Reseed the synthetic Present target window when compositor MSC advances
outside the queued range. This prevents a long compositor stall from
permanently exhausting JIT cadence callbacks.
Mark the recovery sample as discontinuous so calibration does not treat the
MSC jump or completion burst as renderer skipping.
Restore client and test files that were already staged when the OBS
cadence commit was created. Keep that work out of the scheduler series
while leaving its working-tree contents untouched.
Track the LGMP serial for each accepted frame-schedule message and wait
for its acknowledgement before sending another. Preserve pending RESET,
IMMEDIATE, and feedback state after definite enqueue failures.
Use bounded retry polling and request one fresh immediate frame after an
ambiguous pointer-queue fault recovers.
Keep one accepted frame-schedule control in flight until LGMP reports
that its serial has been consumed. Retain ambiguous tokens across pointer
queue recovery instead of retransmitting RESET or IMMEDIATE messages.
Back off acknowledgement polling and definite enqueue failures. Use modular
serial comparison so acknowledgement remains correct across rollover.
Permit retained-buffer reuse when both private queues are occupied by a
previous timing owner, even if the new owner has no pending deliveries.
Use the shared fallback when possible. Otherwise retain the fresh frame
locally and republish it instead of waiting for stale private deliveries.
Replace the oldest provisional schedule entry when the bounded client
table has no empty slot. Never evict a client whose frame subscription has
already been observed.
This prevents rapid failed reconnects from filling every scheduler slot
before a real frame subscriber can be registered.
Keep preparing the newest frame when both private owner lanes remain
referenced by a non-consuming timing client. Reuse only an unreferenced
completed buffer and continue serving eligible shared subscribers.
Track owner delivery separately from local retention so cadence advances
without acknowledging owner delivery or accepting phase feedback. Republish
the newest completed frame as soon as an owner lane becomes available.
Record every requested recipient after LGMP posts to at least one live
subscriber. Targets that disappeared during the post are harmless, while
surviving targets must advance instead of remaining perpetually due.
Consume subscription notifications from the private owner queues. When
any lane gains a subscriber, request a retained-frame publication for
the current timing owner so a static desktop cannot leave it waiting.
Renew frame scheduling only while the source is active and OBS is
delivering video ticks. Release ownership after deactivation or a stale
tick stream.
Reacquire with a new generation and an immediate frame when ticking
resumes.
Renew the frame-schedule lease only while the display server is
producing real cadence callbacks. Release ownership after the cadence
stalls, and reacquire with an immediate reset when it resumes.
For non-JIT rendering, treat only a successful presentation as live
cadence.
Track cadence, interruption, and calibration wake reasons independently
across X11 and Wayland. Feed phase correction back only when a pure
cadence wake renders the exact frame that was queued at that wake.
Propagate EGL swap results through the display-server boundary. Reject
failed presentations and keep pending Wayland HDR descriptions inactive
until the preceding surface commit succeeds.
Bump KVMFR to version 28 and attach generation, epoch, and deadline
identities to cadence deliveries and their timing records.
Accept phase corrections only for the exact completed publication. Keep
VM and client clocks independent by exchanging relative phase errors.
Make submission, completion, and work-estimate accounting best effort
so scheduler state cannot delay GPU submission or frame publication.
Advance past cadence deadlines whose publication targets have already
expired after a completed periodic frame.
Use the same slack, work, and safety lead as target selection so the next
publisher wait cannot immediately expire again.
Request one static-desktop re-encode and inspect repeated presentation
numbers for its empty dirty-rectangle marker.
Prepare every marker in a free candidate without superseding retained
damage, so the last desktop update survives a late copy failure.
Replace the shared force and republish booleans with request tickets.
A completed publication now acknowledges only requests captured when it
began, so a concurrent immediate or cadence-break request survives.
Copy imported IVSHMEM frames into renderer-owned textures before
acknowledging their LGMP messages. Hold each lease until its copy fence
signals, and protect selected snapshots until rendering completes.
Track independent delivery lanes, drain acknowledgements on the frame
thread, and recover stale queue subscriptions after host timeouts.
Track the newest submitted and completed frame independently. Only
retain or replay a frame after its copy callback succeeds.
Keep the prior completed frame when a newer copy fails, and compare
publication sequences so out-of-order callbacks cannot move backward.
Treat a forced publication as periodic once the normal pre-deadline
send point is due. This prevents an immediate forced copy from being
followed by another copy for the same cadence slot.
Check a busy slot fence before waiting for its thread-pool callback.
This lets the caller complete finished GPU work inline and avoids a
scheduler delay before the allocator and command list can be reused.
Do not freeze the spare retained candidate while a frame is copied to
IVSHMEM. Allow newer source frames to replace that candidate and retain
any frame prepared after the published sequence for the next deadline.
Take the pipeline lock before selecting the publication candidate so its
transport copy is submitted before any newly admitted preparation.
Retire candidate damage before submitting its publication copy. A fast
completion callback can otherwise release and reuse the candidate while
the publisher is still reading its fields and damage tail.
Keep the client schedule floor at 2 ms while accepting shorter guest
frame intervals for cadence tracking. This lets sources above 500 Hz
trigger immediate final-frame delivery when their cadence breaks.
Signal the shared D3D11 source only after a retained candidate and its
command slots have been acquired. Superseded source frames no longer queue
a fence that no Direct3D 12 work will consume.
Signal a per-slot event after callbacks finish and the command slot has
returned to the free state. This removes the one millisecond polling delay
when candidate state becomes visible just before its slot is reusable.
Drop an acquired frame immediately when both retained candidate slots are
unavailable. Waiting for up to 2 ms held the IddCx surface and
backpressured sources whose frame period was shorter than the wait.
Derive the source rate from unique frames observed over the actual log
interval. The old EWMA discarded intervals below 2 ms, capping the
reported rate at 500 Hz and understating high-rate sources.
Allow the timing owner to keep one delivery pending on each independent
owner queue instead of waiting for the client to release every frame.
Count shared fallback deliveries against the same two-frame limit and
match republished frames across all active lanes. This hides the client
release round trip without allowing a third delivery for the owner.
Store retained frame candidates in the final linear transport layout.
Prepare texture output in local DEFAULT buffers before cadence holding.
Then publish full frames with a single buffer copy.
Keep partial damage on matching pitched layouts and leave effect-owned
buffer copies unchanged. This moves detiling out of the
deadline-critical IVSHMEM or readback transfer.
Ignore allocation alignment when matching retained candidate resources.
D3D12 may resolve automatic alignment requests in GetDesc.
Comparing that value recreated the candidate for every benchmark sample.
Measure native and packed over matching wall-clock intervals.
Use preparation and publication intervals, excluding the cadence hold.
This avoids mixing GPU timestamps with fallback timing. The CPU IVSHMEM
copy is included only on indirect systems.
Track damage received after each retained candidate snapshot. When a
candidate is submitted successfully, replace the global pending set
with its trailing damage instead of requiring the source generation
to remain unchanged.
This lets published full-frame damage retire while preserving newer
partial or full updates.
Run effect timing samples only when the retained candidate pipeline is idle
and force each completed sample to publish immediately. This prevents work
from superseded candidates from being charged to a surviving sample.
Include the indirect CPU copy to IVSHMEM in the measured copy stage while
preserving the wall-clock fallback when GPU timestamps are unavailable.
Treat a failed desktop texture bind as an incomplete render so full target
restoration remains latched until a frame can actually be drawn.
Carry retired damage into the pending record when the drawable texture does
not contain it, closing the publication gap between texture slots and their
matching damage metadata.
