Repository navigation
perf(render): park the render loop while nothing consumes frames - #445
Open
hyperb1iss wants to merge 9 commits into
Open
hyperb1iss wants to merge 9 commits into
hyperb1iss wants to merge 9 commits into
Conversation
Watch channels never announce a new subscriber, so a producer that wants to idle while nothing consumes its output has no way to learn that a consumer arrived short of polling receiver counts. The bus now owns an OutputDemandSignal: every lane subscription, every OutputDemandHold, and every published event notifies it, and output_receiver_count sums the receivers on every latest-value output stream, per-zone canvases included. Holds cover consumers that read published frames by borrowing a sender instead of holding a receiver. The device registry gains a change notification that fires whenever its generation moves, and the backend manager exposes its routed devices with their backend ids. Together these let the render loop sleep on real signals and wake the instant a device or consumer appears. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
A Servo page keeps working after the render loop stops asking for frames: its script thread schedules its own animation ticks every 30 ms while requestAnimationFrame callbacks are live, and its timers keep firing, so an unobserved WebGL effect keeps the WebGL thread and the GPU driver busy. EffectRenderer::park lets the render loop quiesce that work. Servo and web viewport renderers queue a fire-and-forget SetThrottled command, which throttles the webview (no self-scheduled ticks, timers clamped to the minimum duration); the next render command unthrottles it as it always has, so resume needs no counterpart. EffectRenderer::is_warming reports a renderer that has not yet shown its current content. Servo tracks a page from load start to its first completed frame, so the render loop can keep a freshly applied effect rendering until it is warm instead of parking on a placeholder. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
With an HTML effect active the loop rendered at its full tier whether or not anything received the frames: a Mac with no devices and no client spent about 5 ms of CPU per frame, 31% of a core at 60 fps, on output no one saw. The idle throttle only engaged when no effect ran. The contended resource is CPU and GPU time spent on unobserved frames; no observable cadence changes, because the moment anything can observe a frame the loop renders at its full tier again. This is not a nerf. Before each frame the output gate counts consumers: renderable devices in the registry or routed by the backend manager (simulated displays only while display output holds demand for a preview), receivers on any bus output stream (WebSocket streams, display backdrops, and canvas captures all hold one), stream subscribers to republished host input events, and explicit demand holds. With none, and once every producer is warm for the current scene, effects, and canvas, the loop parks: it withdraws its input capture demand, parks the producers so Servo pages throttle, and sleeps on the bus demand signal, the registry, input demand revisions, and the scene transaction queue, with a one second safety tick. Rigs with a connected device never park. On wake the frame clock restarts one interval back, so effect time steps by a single frame across the park with no catch-up burst. A canvas capture skips the wake frame, whose asynchronous producers still show output requested before the park, and returns the next one. Status and diagnose report render_loop.output_demand with the park state, idle reason, consumer counts, and last wake reason; delivered and actual FPS read zero while parked and frame_liveness passes instead of failing. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
A daemon with nothing consuming its frames now parks its render loop, so the render line reads 0 fps on an idle machine. Without a note that looks like a stall. The status table adds one line when the loop is parked saying that nothing consumes frames and that a device, preview, or capture resumes rendering. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The render pipeline page gains a section on what counts as a consumer, how a parked loop wakes, how producers settle before parking, and how effect time and capture freshness carry across a park. The SparkleFlinger design notes record the gate next to the existing sleep and idle throttles, the REST status example shows render_loop.output_demand, and the performance troubleshooting page explains a parked render_loop check so 0 fps on an idle daemon reads as expected rather than as a stall. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The daemon's status and diagnose contracts gained output_demand, which reports whether the render loop parked because nothing consumes its frames. Both fields are optional in the schema, so this client still parses responses from daemons that predate them. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
RenderLoop::park excludes parked time from elapsed the way a pause does without leaving the Running state, so media layers and time bindings that read render time continue where they stopped instead of jumping by the parked span. A pause and a park that overlap are excluded once. RenderLoop::abandon_frame drops a ticked frame without recording it, so a park feeds no timing into tier decisions and does not advance the frame number. OutputDemandSignal now notifies its waiter list only while a producer has armed a wait, with full fences on both sides so a waiter armed before a state change always sees it or is woken. Every event publication notifies the signal and tokio's notify_waiters takes a lock on each call, so the armed check keeps the publish path free of that cost while nothing is parked. MediaProducer::is_live_stream lets the renderer drop live streams, whose decoder runs on its own worker, while it renders nothing. Servo comments now say what throttling does here: it stops the page's self-scheduled requestAnimationFrame ticks, while timers keep the 4 ms minimum Hypercolor configures. Coverage lands for every park and pause interleaving, the abandoned frame, routed device targets, live stream detection, effect pool park and warming, and Servo warming from load start to the first completed frame. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
…etry A crossfade advances only as frames render, so parking mid transition froze it with the outgoing scene's producers alive; the loop now keeps rendering until a transition finishes or the settle limit passes, and until loading media has a frame. Live media streams kept decoding on their own worker while parked; parking now drops them, on a short-lived thread because dropping one joins a decoder that waits on its network source. Parking also calls RenderLoop::park and abandon_frame, so render time stops and the parked frame feeds no tier statistics. The parked flag cleared only when a frame was recorded, so a loop woken into the idle or sleep throttle, or paused while parked, kept reporting a park. The gate now clears it whenever it decides to render and when the loop leaves the running state. Status and diagnose measure frame age on render time, the clock frame timestamps use, rather than daemon uptime, which also stops pauses inflating frame_age_ms. One-off frame and spectrum reads borrow the lane instead of subscribing, so they no longer wake a parked loop, and the backend manager is locked only when nothing else proves demand. Tests cover a device routed without a registry entry, input event streams, pausing while parked, render time across a park, a transition finishing before the park, the display output hold, and the consumer counting helpers. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Bus events make a parked loop re-check its work rather than wake it to render. Throttled pages stop their self-scheduled requestAnimationFrame loops but keep their timers, so an effect that animates from timers keeps running while parked. Parking waits for transitions within the settle limit and drops live media streams, and render time stops while parked, so media layers and time bindings continue where they left off. The architecture page and the SparkleFlinger notes now say so. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
|
Warning Review limit reached
This review includes 55 billable files and costs up to $13.75. Or wait 33 minutes for your next included review. View limit details
Comment |
This branch has not been deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
On a Mac with no lights and the desktop app closed, the daemon running one HTML effect at 60 fps used 31% of a core rendering frames that nothing received. The idle throttle in
frame_executor.rsonly engaged when no effect ran (effect_running || has_active_input_demand), so with an effect active the loop rendered at its full tier whether or not any device, preview, display, or capture consumed the result. With this PR the render loop parks when nothing consumes its frames and wakes at full tier the moment something does.This is not a lowered baseline. The contended resource is CPU and GPU spent on frames no one receives, and no observable cadence changes: whenever anything can observe a frame, the loop renders at the rate it does today.
💡 What counts as demand
Demand is defined once, in
crates/hypercolor-daemon/src/output_demand.rs:OutputDemandHold. Display output takes one while it has targets, which is how a previewed simulator counts.🛠️ How it parks and wakes
The gate (
render_thread/output_gate.rs) runs before every frame, after scene transactions are serviced. With no consumers it parks only once every producer has shown its content, any scene transition has finished, and loading media has a frame, capped at 10 s, so an effect applied while nobody watches is already loaded when a client or capture arrives.On park it withdraws audio, screen, and interaction capture demand (screen capture stops through its existing demand path), throttles Servo pages, drops live media streams on a teardown thread, discards the frame so the FPS controller sees nothing, and holds render time the way a pause does. Servo needed the explicit throttle: its script thread schedules
requestAnimationFrameticks every 30 ms on its own, so an unobserved WebGL page kept drawing even when the daemon stopped asking for frames. The next render unthrottles as before.The parked loop sleeps on the bus demand signal, which fires on every subscription, hold, and published event, and also listens for device registry changes, input-demand changes, and scene transactions, with a 1 s safety tick. On resume the frame clock restarts one interval back, so effect time steps by exactly one frame, and media layers and time bindings continue from where they paused.
render_loop.output_demandin/api/v1/systemand the diagnose snapshot reports the parked state, the idle reason (no_output_consumers), parked time, consumer counts, and the last wake reason;frame_livenesspasses while parked, andhypercolor statusprints a parked line.🧪 Validation
Measured on an isolated Linux daemon (
unshare -Urnm, a private/devwith no GPU, USB, HID, or input nodes, private XDG, HOME, and TMPDIR, discovery, audio, capture, and input off), Arc Storm at 60 fps, CPU from/proc/<pid>/statover 20 s windows. With/devhidden, Servo WebGL ran on llvmpipe, so absolute numbers are far above the Mac's; the ratio is what carries over.ce477c8d8)GET /api/v1/canvas/frameX-Canvas-Fresh: 1A capture skips the first frame after a wake, so it costs about two frames. Device connect, preview subscriptions, display backdrops, and input-event streams are covered by tests asserting a wake under 500 ms; with a 1 s safety tick, passing them proves the wake is event-driven.
cargo fmt --all -- --check,cargo check --workspace-D warnings: daemon default,--no-default-features --lib,wgpu,persistence-test-hooks; core default andmedia-video; CLI and TUIoutput_demand_tests(new)render_thread_tests, canvas capture, display output, simulator, API, and MCP suites, plus the core suitesAn independent reviewer returned FAIL on the first pass; every finding is fixed (transitions and media now settle before parking, telemetry is exact while parked, render time holds while parked), and the re-review passed.
spectrumtopic.requestAnimationFramebut not timers, because Servo's timer minimum is 4 ms. A third-party effect that animates fromsetTimeoutorsetIntervalkeeps running while parked; every bundled effect usesrequestAnimationFrame.OutputDemandHold. A simulator preview wakes the loop on display output's next 16 ms tick.🤖 Generated with Claude Code