perf(runtime): reduce Market frame stalls and Vulkan capture overhead #1553

Merged
HumanBean merged 22 commits from HumanBean/Longshot:perf/market-render-rewrite into main 2026-11-18 07:28:09 +00:00
Owner

Type: perf · Risk: high · Tested on: CachyOS Linux, RTX 3090 · Needs: controlled main comparison, Windows, AMD, Intel and low-VRAM hardware

TL;DR

Market could miss the frame budget while game workers waited for a virtual core, and a recording diagnostic could stall other workers for hundreds of milliseconds. This series changes how Longshot schedules CPU work, captures submitted memory and reuses Vulkan resources. The player reported smoother gameplay on the final build. Two Market visits are measured below.

Breakdown

  • Who it helps: players seeing uneven frame times in busy areas or pressure on renderer memory.
  • What was wrong: worker wakeups, recording locks and copying data during replay added work to the frame. The host-import path also depended on the range a driver accepted.
  • What changes: workers can make progress during large decodes and slow logging. The renderer reuses captures, image allocations and submitted data.
  • What does not change: existing saves and options remain usable.
  • How it was checked: local game-free regressions and a 14-minute interactive Linux playtest across four areas.
  • What is still open: repeatable comparisons with upstream main and coverage on more hardware.
  • Risk: high. Queue ordering, stale GPU data and renderer memory use need coverage across drivers.

Why

In a Market playtest, a recorded frame took 717 ms. While a recording worker held its table lock and a virtual core inside a log write, audio waited 321 ms for that core. Other slow frames coincided with resource decompression and waits for game workers. An earlier renderer path could also reject an otherwise usable host-memory import range. Related work includes #155, #952, #977 and #1402.

How to reproduce

Load child Market and traverse the busy area. Record presents through the local profiling queue, including area entry separately. For a fixed-route comparison, use the same save, camera path, warmed caches, GPU driver and graphics settings on both revisions.

What changed

  • Publish event readiness atomically, wake registered sleepers, avoid uncontended scheduling locks and skip empty Linux condition-variable wakeups.
  • Release the recording table and the guest core around recording diagnostics. Hand off large whole-buffer asset decodes at 128 KiB and retain the existing small-call path.
  • Reuse capture ranges until membership or expiry changes. Bound spare and in-flight allocations, preserve useful buffer sizes for scene loads and release spares under pressure.
  • Read validated single-page data from its submission snapshot, skip the redundant live read, and translate discontiguous virtual ranges page by page. Bound uniform page-generation lookups.
  • Track GPU writes, reuse render targets and staging resources, batch ASTC conversion work within scratch limits, and retry a distinct valid host import range when the driver rejects the preferred span.
  • Add or extend game-free regression coverage for wakeups, recording locks, decode output, capture ownership, boundary reads, imports and renderer resource reuse.

The review follow-up at fdee2857 broadcasts an event when multiple registered sleepers may need different guest cores. Auto-clear still permits one consumer. Pending and completed GPU buffer writes each retain at most 65,536 exact ranges. Excess writes retain conservative completed-timeline evidence for guest-backed textures. GPU-drawn textures require a real ordered byte overlap before their pixels can be replaced, and an upload acknowledges a write only after it succeeds.

Measurements

Verdict: Interactive results support further testing. A controlled comparison against main is pending. Runs below used different player routes, and the queue detected external build activity in the final session.

Hardware: Ryzen 9 7900X, RTX 3090, NVIDIA 620.70.06, CachyOS Linux, 32 GB RAM. Settings included 2560×1440 configured output, fullscreen, V-Sync off and frame generation off. Timings use consecutive displayed-frame intervals from the built-in profiler.

Revision and sample FPS Median frame p99 Worst
Intermediate 5d6590e2, Market, 60 s 50.4 18.3 ms 32.8 ms 716.7 ms
Intermediate 28fb02e2, Market, 60 s 58.0 16.3 ms 28.8 ms 51.1 ms
PR 1820ed9b, first Market visit, 20 s 65.2 14.8 ms 24.8 ms 51.3 ms
PR 1820ed9b, return to Market, 20 s 67.1 15.5 ms 21.5 ms 68.3 ms

The final windows start at the first periodic present-count log following each Market marker and end before the next area transition. They exclude entry and loading. The final build visited Hyrule Field, Death Mountain Crater and Ganon's Castle as well.

The rebased Linux build with the two review fixes (65cf2a90) ran headed in Market and exited normally. A roughly 50-second interactive sample measured 56.9 FPS and a 27.1 ms p99. A separate native smoke run built from the final integration source exited normally after 8,136 presents. Its 900 settled Market frames measured 75.0 FPS and a 17.3 ms p99. The pack builder recorded the final smoke source as a working copy on d87dd600, tree fingerprint 03d9b04d. The two runs followed different routes and do not establish a speedup.

Flags and settings

The profile used HOS_PROFILE=1 and HOS_RESERVE_CORE=0 on each build, with saved player settings and warmed pipeline caches. No new player-facing switch was added.

Testing

Tested: Linux native game build and interactive playtest, normal exit. The focused capture, late-read and uniform-cache checks passed. Both changed translation units from the last commit passed a Windows syntax check. The Linux full suite during the last development pass produced 711 passes, 43 failures and 19 skips. All 43 failures also appeared in the preceding rewrite suite. The affected checks were rerun after final boundary fixes.

Review verification: The new disjoint-core event test and pending-allocation test both reproduced the findings at d87dd600 and passed after the fixes. The write-history fixture covers 196,608 disjoint writes, many outstanding timeline values, peak publication allocations, neighboring GPU-owned images, and writes on either side of a draw in one submission. Related event, multiwait, virtual-core, Tracy, Linux condition-variable, drawn-page and readback checks passed. An integration-suite run with the default tool search reported 638 passed, 35 failed and 104 skipped. The dependency-enabled complete suite at fdee2857 reported 715 passed, 43 failed and 19 skipped. Running all 43 failed checks on upstream 68d7757e reproduced 42. The remaining check, test_astc_reuse.py, found its cleanup call outside a hard-coded 200-character excerpt. Test-only commit cbedca6c uses the full function and the check passed on rerun. The runtime source matches fdee2857.

42 checks that failed on both revisions

test_bug_report_defaults, test_capture_readback_visibility, test_compute_warm_apart, test_cpu_report, test_crt_options, test_damage_debug_menu, test_dev_packs, test_display_startup_failure, test_dlss_feature_size, test_draw_stream_visibility, test_failed_compile_keeps_objects, test_fsr_image_retirement, test_fsr_uniform_ownership, test_guest_imported, test_hud_layout_row, test_invalidate_quick, test_invalidate_vcore, test_libc_hooks, test_linux_preflight, test_linux_pressure, test_linux_update, test_log_open_failure, test_mirror_budget, test_missing_nup, test_mods_size_table, test_nonuniform_image_arrays, test_parallel_init_order, test_pending_guest_import, test_pipeline_play_cache, test_present_source_crop, test_present_thread, test_profiling_mode, test_psychov35_fsr3_fg, test_readback_timeout_source, test_replay_write_order, test_run_all_changed, test_slow_frames, test_staging_burst, test_switch_table, test_upscaler_rows, test_vk_occlusion_queries, test_walk_key

Not tested: Final runtime on Windows, non-NVIDIA GPUs or low-VRAM cards. Controlled performance comparisons against current main remain open.

Must be tested:

  • By hand on this Linux GPU, run interleaved main and branch comparisons on the same Market route, reporting median, p99, long-frame counts and entry time.
  • By hand on Windows and Linux AMD or Intel hardware, including a 4–6 GB card, traverse Market and switch areas repeatedly. Check for missing textures, corruption, allocation failures, VRAM growth and hangs at exit.

Risks

What could break: Guest event ordering, texture snapshots, import fallback and resource retirement are sensitive to thread timing and driver memory behavior.

Review follow-up: With opt-in parallel replay, a later worker may record a buffer write before an earlier worker first creates a texture copy destination at the same address. The destination may miss that write. The ordered-worker fixture covers images already registered with the renderer. The default serial path creates these images in stream order. Excess ranges can also cause extra uploads of guest-backed textures. The CPU cost of the live image index under heavy aliasing still needs measurement.

Trace interpretation: Large native Zstandard decodes contribute to the virtual-core-away interval counted in blocked time. Repeated event signals can update the recorded timestamp when the event is already ready, so the last reported signal does not always identify the producer that woke the waiter.

Turning it off: The work spans host and renderer changes. Revert the series for a full rollback.

Compatibility: The renderer ABI and save format are unchanged. The updated compute shader has a regenerated checked-in header. This PR contains source and tests only.

Checklist

Everyone

  • One topic.
  • The title is a Conventional Commit of the status line's type.
  • Why gives the reason plainly and links related work.
  • Tested on my own PC where it runs.
  • Measurements has a verdict.
  • Performance and memory costs across hardware still need controlled measurements.
  • Testing names what was tested, what was not, and what remains.
  • Rebased onto 79d4a143 before the review fixes. Main then advanced. A local merge of d1a307cb and the published head cbedca6c has no source conflicts; Forgejo reports the WIP PR as non-mergeable.
  • All remaining full-suite failures reproduced on upstream main 68d7757e. Testing lists the 42 checks and the corrected integration-specific check.
  • No game files, dumps or local build artifacts.
  • Third-party sources untouched.
  • Changes use the project's license.

When it applies

  • AI-assisted development disclosed. Assisted-by trailers are present in the recent commits.
  • Two interleaved runs per revision against main.
  • Regression tests added or extended.
  • The changed shader's SPIR-V header is included.
  • Full native Windows build and playtest.
**Type:** perf · **Risk:** high · **Tested on:** CachyOS Linux, RTX 3090 · **Needs:** controlled main comparison, Windows, AMD, Intel and low-VRAM hardware ## TL;DR Market could miss the frame budget while game workers waited for a virtual core, and a recording diagnostic could stall other workers for hundreds of milliseconds. This series changes how Longshot schedules CPU work, captures submitted memory and reuses Vulkan resources. The player reported smoother gameplay on the final build. Two Market visits are measured below. ## Breakdown - **Who it helps:** players seeing uneven frame times in busy areas or pressure on renderer memory. - **What was wrong:** worker wakeups, recording locks and copying data during replay added work to the frame. The host-import path also depended on the range a driver accepted. - **What changes:** workers can make progress during large decodes and slow logging. The renderer reuses captures, image allocations and submitted data. - **What does not change:** existing saves and options remain usable. - **How it was checked:** local game-free regressions and a 14-minute interactive Linux playtest across four areas. - **What is still open:** repeatable comparisons with upstream main and coverage on more hardware. - **Risk:** high. Queue ordering, stale GPU data and renderer memory use need coverage across drivers. ## Why In a Market playtest, a recorded frame took 717 ms. While a recording worker held its table lock and a virtual core inside a log write, audio waited 321 ms for that core. Other slow frames coincided with resource decompression and waits for game workers. An earlier renderer path could also reject an otherwise usable host-memory import range. Related work includes #155, #952, #977 and #1402. ## How to reproduce Load child Market and traverse the busy area. Record presents through the local profiling queue, including area entry separately. For a fixed-route comparison, use the same save, camera path, warmed caches, GPU driver and graphics settings on both revisions. ## What changed - Publish event readiness atomically, wake registered sleepers, avoid uncontended scheduling locks and skip empty Linux condition-variable wakeups. - Release the recording table and the guest core around recording diagnostics. Hand off large whole-buffer asset decodes at 128 KiB and retain the existing small-call path. - Reuse capture ranges until membership or expiry changes. Bound spare and in-flight allocations, preserve useful buffer sizes for scene loads and release spares under pressure. - Read validated single-page data from its submission snapshot, skip the redundant live read, and translate discontiguous virtual ranges page by page. Bound uniform page-generation lookups. - Track GPU writes, reuse render targets and staging resources, batch ASTC conversion work within scratch limits, and retry a distinct valid host import range when the driver rejects the preferred span. - Add or extend game-free regression coverage for wakeups, recording locks, decode output, capture ownership, boundary reads, imports and renderer resource reuse. The review follow-up at `fdee2857` broadcasts an event when multiple registered sleepers may need different guest cores. Auto-clear still permits one consumer. Pending and completed GPU buffer writes each retain at most 65,536 exact ranges. Excess writes retain conservative completed-timeline evidence for guest-backed textures. GPU-drawn textures require a real ordered byte overlap before their pixels can be replaced, and an upload acknowledges a write only after it succeeds. ## Measurements **Verdict:** Interactive results support further testing. A controlled comparison against main is pending. Runs below used different player routes, and the queue detected external build activity in the final session. Hardware: Ryzen 9 7900X, RTX 3090, NVIDIA 620.70.06, CachyOS Linux, 32 GB RAM. Settings included 2560×1440 configured output, fullscreen, V-Sync off and frame generation off. Timings use consecutive displayed-frame intervals from the built-in profiler. | Revision and sample | FPS | Median frame | p99 | Worst | |---|---:|---:|---:|---:| | Intermediate 5d6590e2, Market, 60 s | 50.4 | 18.3 ms | 32.8 ms | 716.7 ms | | Intermediate 28fb02e2, Market, 60 s | 58.0 | 16.3 ms | 28.8 ms | 51.1 ms | | PR 1820ed9b, first Market visit, 20 s | 65.2 | 14.8 ms | 24.8 ms | 51.3 ms | | PR 1820ed9b, return to Market, 20 s | 67.1 | 15.5 ms | 21.5 ms | 68.3 ms | The final windows start at the first periodic present-count log following each Market marker and end before the next area transition. They exclude entry and loading. The final build visited Hyrule Field, Death Mountain Crater and Ganon's Castle as well. The rebased Linux build with the two review fixes (`65cf2a90`) ran headed in Market and exited normally. A roughly 50-second interactive sample measured 56.9 FPS and a 27.1 ms p99. A separate native smoke run built from the final integration source exited normally after 8,136 presents. Its 900 settled Market frames measured 75.0 FPS and a 17.3 ms p99. The pack builder recorded the final smoke source as a working copy on `d87dd600`, tree fingerprint `03d9b04d`. The two runs followed different routes and do not establish a speedup. ### Flags and settings The profile used HOS_PROFILE=1 and HOS_RESERVE_CORE=0 on each build, with saved player settings and warmed pipeline caches. No new player-facing switch was added. ## Testing **Tested:** Linux native game build and interactive playtest, normal exit. The focused capture, late-read and uniform-cache checks passed. Both changed translation units from the last commit passed a Windows syntax check. The Linux full suite during the last development pass produced 711 passes, 43 failures and 19 skips. All 43 failures also appeared in the preceding rewrite suite. The affected checks were rerun after final boundary fixes. **Review verification:** The new disjoint-core event test and pending-allocation test both reproduced the findings at `d87dd600` and passed after the fixes. The write-history fixture covers 196,608 disjoint writes, many outstanding timeline values, peak publication allocations, neighboring GPU-owned images, and writes on either side of a draw in one submission. Related event, multiwait, virtual-core, Tracy, Linux condition-variable, drawn-page and readback checks passed. An integration-suite run with the default tool search reported 638 passed, 35 failed and 104 skipped. The dependency-enabled complete suite at `fdee2857` reported 715 passed, 43 failed and 19 skipped. Running all 43 failed checks on upstream `68d7757e` reproduced 42. The remaining check, `test_astc_reuse.py`, found its cleanup call outside a hard-coded 200-character excerpt. Test-only commit `cbedca6c` uses the full function and the check passed on rerun. The runtime source matches `fdee2857`. <details><summary>42 checks that failed on both revisions</summary> `test_bug_report_defaults`, `test_capture_readback_visibility`, `test_compute_warm_apart`, `test_cpu_report`, `test_crt_options`, `test_damage_debug_menu`, `test_dev_packs`, `test_display_startup_failure`, `test_dlss_feature_size`, `test_draw_stream_visibility`, `test_failed_compile_keeps_objects`, `test_fsr_image_retirement`, `test_fsr_uniform_ownership`, `test_guest_imported`, `test_hud_layout_row`, `test_invalidate_quick`, `test_invalidate_vcore`, `test_libc_hooks`, `test_linux_preflight`, `test_linux_pressure`, `test_linux_update`, `test_log_open_failure`, `test_mirror_budget`, `test_missing_nup`, `test_mods_size_table`, `test_nonuniform_image_arrays`, `test_parallel_init_order`, `test_pending_guest_import`, `test_pipeline_play_cache`, `test_present_source_crop`, `test_present_thread`, `test_profiling_mode`, `test_psychov35_fsr3_fg`, `test_readback_timeout_source`, `test_replay_write_order`, `test_run_all_changed`, `test_slow_frames`, `test_staging_burst`, `test_switch_table`, `test_upscaler_rows`, `test_vk_occlusion_queries`, `test_walk_key` </details> **Not tested:** Final runtime on Windows, non-NVIDIA GPUs or low-VRAM cards. Controlled performance comparisons against current main remain open. **Must be tested:** - By hand on this Linux GPU, run interleaved main and branch comparisons on the same Market route, reporting median, p99, long-frame counts and entry time. - By hand on Windows and Linux AMD or Intel hardware, including a 4–6 GB card, traverse Market and switch areas repeatedly. Check for missing textures, corruption, allocation failures, VRAM growth and hangs at exit. ## Risks **What could break:** Guest event ordering, texture snapshots, import fallback and resource retirement are sensitive to thread timing and driver memory behavior. **Review follow-up:** With opt-in parallel replay, a later worker may record a buffer write before an earlier worker first creates a texture copy destination at the same address. The destination may miss that write. The ordered-worker fixture covers images already registered with the renderer. The default serial path creates these images in stream order. Excess ranges can also cause extra uploads of guest-backed textures. The CPU cost of the live image index under heavy aliasing still needs measurement. **Trace interpretation:** Large native Zstandard decodes contribute to the virtual-core-away interval counted in blocked time. Repeated event signals can update the recorded timestamp when the event is already ready, so the last reported signal does not always identify the producer that woke the waiter. **Turning it off:** The work spans host and renderer changes. Revert the series for a full rollback. **Compatibility:** The renderer ABI and save format are unchanged. The updated compute shader has a regenerated checked-in header. This PR contains source and tests only. ## Checklist ### Everyone - [x] One topic. - [x] The title is a Conventional Commit of the status line's type. - [x] Why gives the reason plainly and links related work. - [x] Tested on my own PC where it runs. - [x] Measurements has a verdict. - [ ] Performance and memory costs across hardware still need controlled measurements. - [x] Testing names what was tested, what was not, and what remains. - [ ] Rebased onto `79d4a143` before the review fixes. Main then advanced. A local merge of `d1a307cb` and the published head `cbedca6c` has no source conflicts; Forgejo reports the WIP PR as non-mergeable. - [x] All remaining full-suite failures reproduced on upstream main `68d7757e`. Testing lists the 42 checks and the corrected integration-specific check. - [x] No game files, dumps or local build artifacts. - [x] Third-party sources untouched. - [x] Changes use the project's license. ### When it applies - [x] AI-assisted development disclosed. Assisted-by trailers are present in the recent commits. - [ ] Two interleaved runs per revision against main. - [x] Regression tests added or extended. - [x] The changed shader's SPIR-V header is included. - [ ] Full native Windows build and playtest.
Assisted-by: Codex
Assisted-by: Codex
Assisted-by: Codex
Assisted-by: Codex
Assisted-by: Codex
Assisted-by: Codex
Hand off large asset decodes and read captured uniform bytes once
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 7s
PR description / Description follows the template (pull_request_target) Successful in 9s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 9s
Third-party parts / As their notes say (pull_request) Successful in 11s
CI / Workflow lint (actionlint) (pull_request) Successful in 12s
Website / Website on Cloudflare (pull_request_target) Has been skipped
beanstalk/any 0/1 pass, 0 running, 0 queued
beanstalk/approval approved by HumanBean (reviewed)
beanstalk/windows 0/1 pass, 2 running, 0 queued
beanstalk/amd 0/1 pass, 2 running, 0 queued
beanstalk/steamdeck 0/1 pass, 1 running, 1 queued
1820ed9b3d
Assisted-by: Codex
Author
Owner

Tested in game: CachyOS Linux, Ryzen 9 7900X, RTX 3090, NVIDIA 620.70.06. The final build ran for 14 minutes, visited child Market twice, Hyrule Field, Death Mountain Crater and Ganon’s Castle, and exited normally. The player reported smoother gameplay. The two 20-second Market samples measured 65.2 and 67.1 FPS.

Tested in game: CachyOS Linux, Ryzen 9 7900X, RTX 3090, NVIDIA 620.70.06. The final build ran for 14 minutes, visited child Market twice, Hyrule Field, Death Mountain Crater and Ganon’s Castle, and exited normally. The player reported smoother gameplay. The two 20-second Market samples measured 65.2 and 67.1 FPS.
Collaborator

Possibly related, for context:

  • PR #759 WIP: fix(vk): seal capture repairs and prove exact CPU visibility — Overlapping Vulkan capture visibility and lifetime changes
  • PR #1284 WIP: fix(runtime): the log writer's flush no longer deadlocks with the writer; the writer runs on Linux too — Logging writer changes overlap runtime recording/log handoff work
  • issue #402 Deck: the frame is CPU-bound in the submission path, not GPU-bound (16 fps at 50% internal, GPU-bound wait 0.4 ms) — Open issue reports CPU-bound submission stalls; possible performance touchpoint
Possibly related, for context: - PR #759 WIP: fix(vk): seal capture repairs and prove exact CPU visibility — Overlapping Vulkan capture visibility and lifetime changes - PR #1284 WIP: fix(runtime): the log writer's flush no longer deadlocks with the writer; the writer runs on Linux too — Logging writer changes overlap runtime recording/log handoff work - issue #402 Deck: the frame is CPU-bound in the submission path, not GPU-bound (16 fps at 50% internal, GPU-bound wait 0.4 ms) — Open issue reports CPU-bound submission stalls; possible performance touchpoint
Author
Owner

@Beanstalk

@Beanstalk
Member
Beanstalk test farm · an earlier run: commit 1820ed9 (the newer results are in a comment below)

Commit 1820ed9 · tier reviewed · approved by HumanBean · dashboard

What will be tested · AI plan (gpt-6.1-terra)

Two interleaved runs per revision compare Market entry, a fixed movement route, and a return visit after Hyrule Field, taking about 26 minutes per tester. The plan measures frame times, hitches, load times and VRAM, and compares images for rendering regressions. Crashes, significant performance or memory regressions, and substantial screenshot differences fail the plan.

  • Where: any (any PC, 1-2 reports).
  • market-return: from a new save (settings vsync=2, frame_generation=0), then teleport to Market, move the stick, take the picture market-first to compare with main, measure market-first for 20 s (after 5 s warm-up), teleport to Hyrule Field, take the picture field to compare with main, take the picture market-return to compare with main, measure market-return for 20 s (after 5 s warm-up); 2 runs on each side.
  • Measured: crashes, frame times, stutters and hitches, VRAM use, load times, the game's log.
  • The PR fails if: it crashes; or a picture differs from main by more than 5%; or peak VRAM is more than 15% above main; or longest load is more than 25% above main; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0.
  • Time: about 28 min of game runs per tester (4 game starts), plus the two builds.

Started at 05:28 UTC.

Estimate: done in about 60 min, from the queue and the testers online now.

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
any 0/1 — — — running
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>1820ed9</code> (the newer results are in a comment below)</summary> Commit `1820ed9` · tier **reviewed** · approved by HumanBean · [dashboard](https://beanstalk.magicbean.dev/prs/1553) **What will be tested** · AI plan (`gpt-6.1-terra`) Two interleaved runs per revision compare Market entry, a fixed movement route, and a return visit after Hyrule Field, taking about 26 minutes per tester. The plan measures frame times, hitches, load times and VRAM, and compares images for rendering regressions. Crashes, significant performance or memory regressions, and substantial screenshot differences fail the plan. - **Where:** any (any PC, 1-2 reports). - **market-return:** from a new save (settings vsync=2, frame_generation=0), then teleport to Market, move the stick, take the picture market-first to compare with main, measure market-first for 20 s (after 5 s warm-up), teleport to Hyrule Field, take the picture field to compare with main, take the picture market-return to compare with main, measure market-return for 20 s (after 5 s warm-up); 2 runs on each side. - **Measured:** crashes, frame times, stutters and hitches, VRAM use, load times, the game's log. - **The PR fails if:** it crashes; or a picture differs from main by more than 5%; or peak VRAM is more than 15% above main; or longest load is more than 25% above main; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0. - **Time:** about 28 min of game runs per tester (4 game starts), plus the two builds. Started at 05:28 UTC. **Estimate:** done in about 60 min, from the queue and the testers online now. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | any | 0/1 | — | — | — | running | </details>
Author
Owner

@Beanstalk I want a windows tester, an amd tester, a steam deck tester

@Beanstalk I want a windows tester, an amd tester, a steam deck tester
Member
Beanstalk test farm · an earlier run: commit 1820ed9, run 2 (the newer results are in a comment below)

Commit 1820ed9 · tier reviewed · approved by HumanBean · dashboard

What will be tested · AI plan (gpt-6.1-terra)

The plan runs on Windows, AMD and Steam Deck targets, comparing two interleaved runs per revision through child Market, Hyrule Field and Death Mountain Crater before returning to Market. Each target takes about 28 minutes of game runs, measuring frame times, hitches, load times and memory use and comparing screenshots with main. Crashes, timeouts, device-loss or out-of-memory logs, substantial frame-time, load-time or memory regressions, and large screenshot differences fail the plan.

  • Where: windows (1-2 reports), amd (1-2 reports), steamdeck (1-2 reports).
  • market-round-trip: from a new save (settings vsync=2, frame_generation=0), then teleport to Market, move the stick, take the picture market-first to compare with main, measure market-first for 30 s (after 5 s warm-up), teleport to Hyrule Field, take the picture field to compare with main, teleport to Death Mountain Crater, take the picture crater to compare with main, take the picture market-return to compare with main, measure market-return for 30 s (after 5 s warm-up); 2 runs on each side.
  • Measured: crashes, frame times, stutters and hitches, VRAM use, memory and CPU time, load times, the game's log.
  • The PR fails if: it crashes; or a picture differs from main by more than 10%; or peak memory is more than 20% above main; or peak VRAM is more than 15% above main; or longest load is more than 25% above main; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0.
  • Time: about 29 min of game runs per tester (4 game starts), plus the two builds.

Started at 05:30 UTC. Run 2: re-planned by HumanBean.

Estimate: done in about 55 min, from the queue and the testers online now; some jobs can't start yet.

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
windows 0/1 — — — running
amd 0/1 — — — running
steamdeck 0/1 — — — running
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>1820ed9</code>, run 2 (the newer results are in a comment below)</summary> Commit `1820ed9` · tier **reviewed** · approved by HumanBean · [dashboard](https://beanstalk.magicbean.dev/prs/1553) **What will be tested** · AI plan (`gpt-6.1-terra`) The plan runs on Windows, AMD and Steam Deck targets, comparing two interleaved runs per revision through child Market, Hyrule Field and Death Mountain Crater before returning to Market. Each target takes about 28 minutes of game runs, measuring frame times, hitches, load times and memory use and comparing screenshots with main. Crashes, timeouts, device-loss or out-of-memory logs, substantial frame-time, load-time or memory regressions, and large screenshot differences fail the plan. - **Where:** windows (1-2 reports), amd (1-2 reports), steamdeck (1-2 reports). - **market-round-trip:** from a new save (settings vsync=2, frame_generation=0), then teleport to Market, move the stick, take the picture market-first to compare with main, measure market-first for 30 s (after 5 s warm-up), teleport to Hyrule Field, take the picture field to compare with main, teleport to Death Mountain Crater, take the picture crater to compare with main, take the picture market-return to compare with main, measure market-return for 30 s (after 5 s warm-up); 2 runs on each side. - **Measured:** crashes, frame times, stutters and hitches, VRAM use, memory and CPU time, load times, the game's log. - **The PR fails if:** it crashes; or a picture differs from main by more than 10%; or peak memory is more than 20% above main; or peak VRAM is more than 15% above main; or longest load is more than 25% above main; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0. - **Time:** about 29 min of game runs per tester (4 game starts), plus the two builds. Started at 05:30 UTC. Run 2: re-planned by HumanBean. **Estimate:** done in about 55 min, from the queue and the testers online now; some jobs can't start yet. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | windows | 0/1 | — | — | — | running | | amd | 0/1 | — | — | — | running | | steamdeck | 0/1 | — | — | — | running | </details>
Contributor

Testing this now on two machines. Each compares the PR head against its base, so only this series differs. That's now cbedca6c (with fdee2857's fixes) against main 79d4a143.

  • Steam Deck OLED (SteamOS, RADV), handheld at 1280×800, fixed settings: paired runs standing in Kokiri and turning in Hyrule Field, then a Market block. A picture-safety check runs first.
  • Windows, RTX 5090: Market and Kokiri, three interleaved pairs. The PR's game-free tests also run on Windows.

Both report p95/p99, the worst frame and long-frame counts alongside FPS, since this targets stalls. Results will follow here.

Edited: retargeted from 1820ed9b/310e7c9d, then from d87dd600, to the current head.

Testing this now on two machines. Each compares the PR head against its base, so only this series differs. That's now `cbedca6c` (with `fdee2857`'s fixes) against main `79d4a143`. - **Steam Deck OLED** (SteamOS, RADV), handheld at 1280×800, fixed settings: paired runs standing in Kokiri and turning in Hyrule Field, then a Market block. A picture-safety check runs first. - **Windows, RTX 5090:** Market and Kokiri, three interleaved pairs. The PR's game-free tests also run on Windows. Both report p95/p99, the worst frame and long-frame counts alongside FPS, since this targets stalls. Results will follow here. *Edited: retargeted from `1820ed9b`/`310e7c9d`, then from `d87dd600`, to the current head.*
Contributor

A code-review note on the scheduling part at 1820ed9b, from reading the source; it hasn't been reproduced yet:

An auto-clear event now wakes one sleeper, chosen by the host, but that sleeper must get a guest core back before it can claim the event.

  • host/nn_os_sync.c:680 wakes a single sleeper with WakeConditionVariable.
  • event_wait (:743) can only take the event after hos_cv_sleep returns.
  • host/hos_thread.c:1989–1992 reacquires the guest core first.

Say sleeper A may only run on busy core 0 and sleeper B may run on free core 1. The host can wake A and leave B asleep, while the event stays ready=1. A higher-priority holder of core 0 can then delay A until the starvation/escape handling (hos_thread.c:1817–1820, 1878–1885). That's a progress/priority-inversion risk, not a lost wake-up or a proven deadlock. Main's broadcast let both sleepers compete.

A possible fix: broadcast when more than one sleeper is registered (the CAS still lets only one consume it), or hand the event to an eligible sleeper explicitly. tests/test_event_handoff.py:53–57 waits on a plain condition_variable_any without hos_vcore_back, so it can't catch this. A case with two sleepers on disjoint core masks would.

For anyone profiling this:

  • hos_zstd.c:406–410 now runs the CPU-bound decode between away and back, and hos_thread.c:1956,1967 count that time as blocked. So a rise in main_blocked_ms doesn't necessarily mean more waiting.
  • HOS_CHAIN SIGNAL records and sig_ns are still overwritten when the event is already ready. That's old behaviour, but now that path wakes nobody, so treat "last SIGNAL" as the waking producer with care.

No problem found so far in capture-range reuse or the one-page snapshot read. The Deck and Windows A/B runs mentioned above are still going ahead.

A code-review note on the scheduling part at `1820ed9b`, from reading the source; it hasn't been reproduced yet: **An auto-clear event now wakes one sleeper, chosen by the host, but that sleeper must get a guest core back before it can claim the event.** - `host/nn_os_sync.c:680` wakes a single sleeper with `WakeConditionVariable`. - `event_wait` (`:743`) can only take the event after `hos_cv_sleep` returns. - `host/hos_thread.c:1989–1992` reacquires the guest core first. Say sleeper A may only run on busy core 0 and sleeper B may run on free core 1. The host can wake A and leave B asleep, while the event stays `ready=1`. A higher-priority holder of core 0 can then delay A until the starvation/escape handling (`hos_thread.c:1817–1820`, `1878–1885`). That's a progress/priority-inversion risk, not a lost wake-up or a proven deadlock. Main's broadcast let both sleepers compete. **A possible fix:** broadcast when more than one sleeper is registered (the CAS still lets only one consume it), or hand the event to an eligible sleeper explicitly. `tests/test_event_handoff.py:53–57` waits on a plain `condition_variable_any` without `hos_vcore_back`, so it can't catch this. A case with two sleepers on disjoint core masks would. **For anyone profiling this:** - `hos_zstd.c:406–410` now runs the CPU-bound decode between away and back, and `hos_thread.c:1956,1967` count that time as blocked. So a rise in `main_blocked_ms` doesn't necessarily mean more waiting. - `HOS_CHAIN` SIGNAL records and `sig_ns` are still overwritten when the event is already ready. That's old behaviour, but now that path wakes nobody, so treat "last SIGNAL" as the waking producer with care. No problem found so far in capture-range reuse or the one-page snapshot read. The Deck and Windows A/B runs mentioned above are still going ahead.
Contributor

A second note from reading 1820ed9b (a static finding, not seen in game): the new GPU write history has no bound on unfinished writes.

  • gpu/vk/gpu_write_history.h:49–65 puts every disjoint write interval into pending[value] with no node or byte limit.
  • :68–75 caps only finished ranges, and only after a whole completed batch has been published.
  • The old texture_gpu_wrote in vk_texture.cpp capped the retained map at 65,536 on each insert.

So one long recording or load with N disjoint SSBO or texel-buffer writes at the same rec_value keeps N map nodes. complete(value) can build the second representation before its final trim. The periodic completion call (vk_replay.cpp:837, every 32 parts) doesn't bound one unfinished batch or a GPU backlog.

Please don't fix this by dropping unfinished records: that would bring back the stale-texture invalidation this history exists to prevent. A conservative overflow policy for pending entries and the publication peak would do instead, for example a coarse dirty-epoch/range fallback; your choice. A demonstrated upstream bound on how many there can be would also do.

A test: test_wrote_regions currently uses a few tiny ranges. A case with more than 65,536 disjoint writes under one pending value, plus overlapping finished and unfinished writes, would cover this.

Otherwise: no stale-capture problem found in the capture-range reuse, the snapshot fast paths or the capture-spare reservations.

A second note from reading `1820ed9b` (a static finding, not seen in game): **the new GPU write history has no bound on unfinished writes.** - `gpu/vk/gpu_write_history.h:49–65` puts every disjoint write interval into `pending[value]` with no node or byte limit. - `:68–75` caps only *finished* ranges, and only after a whole completed batch has been published. - The old `texture_gpu_wrote` in `vk_texture.cpp` capped the retained map at 65,536 on each insert. So one long recording or load with N disjoint SSBO or texel-buffer writes at the same `rec_value` keeps N map nodes. `complete(value)` can build the second representation before its final trim. The periodic completion call (`vk_replay.cpp:837`, every 32 parts) doesn't bound one unfinished batch or a GPU backlog. **Please don't fix this by dropping unfinished records:** that would bring back the stale-texture invalidation this history exists to prevent. A conservative overflow policy for pending entries and the publication peak would do instead, for example a coarse dirty-epoch/range fallback; your choice. A demonstrated upstream bound on how many there can be would also do. **A test:** `test_wrote_regions` currently uses a few tiny ranges. A case with more than 65,536 disjoint writes under one pending value, plus overlapping finished and unfinished writes, would cover this. **Otherwise:** no stale-capture problem found in the capture-range reuse, the snapshot fast paths or the capture-spare reservations.
HumanBean force-pushed perf/market-render-rewrite from 1820ed9b3d
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 7s
PR description / Description follows the template (pull_request_target) Successful in 9s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 9s
Third-party parts / As their notes say (pull_request) Successful in 11s
CI / Workflow lint (actionlint) (pull_request) Successful in 12s
Website / Website on Cloudflare (pull_request_target) Has been skipped
beanstalk/any 0/1 pass, 0 running, 0 queued
beanstalk/approval approved by HumanBean (reviewed)
beanstalk/windows 0/1 pass, 2 running, 0 queued
beanstalk/amd 0/1 pass, 2 running, 0 queued
beanstalk/steamdeck 0/1 pass, 1 running, 1 queued
to d87dd6000f
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 13s
PR description / Description follows the template (pull_request_target) Successful in 14s
CI / Workflow lint (actionlint) (pull_request) Successful in 15s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 12s
Third-party parts / As their notes say (pull_request) Successful in 12s
Website / Website on Cloudflare (pull_request_target) Has been skipped
beanstalk/approval approved by HumanBean (reviewed)
beanstalk/any 0/1 pass, 2 running, 0 queued
2026-11-18 05:35:15 +00:00
Compare
Member
Beanstalk test farm · an earlier run: commit d87dd60 (the newer results are in a comment below)

Commit d87dd60 · tier reviewed · approved by HumanBean · dashboard

What will be tested · AI plan (gpt-6.1-terra)

Two alternating runs compare main and the PR in child Market, Hyrule Field and Death Mountain Crater, then return to Market to exercise resource reuse. The automated plan takes about 27 minutes per PC and measures frame times, hitches, load times, VRAM and process memory while comparing pictures. Crashes, timeouts, substantial performance or memory regressions, and significant picture differences fail the plan.

  • Where: any (any PC, 1-2 reports).
  • market-scene-reuse: from a new save (settings vsync=2, frame_generation=0), then teleport to Market, move the stick, take the picture market-first to compare with main, measure market for 30 s (after 5 s warm-up), teleport to Hyrule Field, take the picture field to compare with main, measure field for 15 s (after 5 s warm-up), teleport to Death Mountain Crater, take the picture crater to compare with main, measure crater for 15 s (after 5 s warm-up), take the picture market-return to compare with main, measure return for 20 s (after 5 s warm-up); 2 runs on each side.
  • Measured: crashes, frame times, stutters and hitches, VRAM use, memory and CPU time, load times, the game's log.
  • The PR fails if: it crashes; or a picture differs from main by more than 5%; or peak memory is more than 20% above main; or peak VRAM is more than 15% above main; or longest load is more than 25% above main; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0.
  • Time: about 31 min of game runs per tester (4 game starts), plus the two builds.

Started at 05:37 UTC.

Estimate: done in about 45 min, from the queue and the testers online now.

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
any 0/1 — — — running
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>d87dd60</code> (the newer results are in a comment below)</summary> Commit `d87dd60` · tier **reviewed** · approved by HumanBean · [dashboard](https://beanstalk.magicbean.dev/prs/1553) **What will be tested** · AI plan (`gpt-6.1-terra`) Two alternating runs compare main and the PR in child Market, Hyrule Field and Death Mountain Crater, then return to Market to exercise resource reuse. The automated plan takes about 27 minutes per PC and measures frame times, hitches, load times, VRAM and process memory while comparing pictures. Crashes, timeouts, substantial performance or memory regressions, and significant picture differences fail the plan. - **Where:** any (any PC, 1-2 reports). - **market-scene-reuse:** from a new save (settings vsync=2, frame_generation=0), then teleport to Market, move the stick, take the picture market-first to compare with main, measure market for 30 s (after 5 s warm-up), teleport to Hyrule Field, take the picture field to compare with main, measure field for 15 s (after 5 s warm-up), teleport to Death Mountain Crater, take the picture crater to compare with main, measure crater for 15 s (after 5 s warm-up), take the picture market-return to compare with main, measure return for 20 s (after 5 s warm-up); 2 runs on each side. - **Measured:** crashes, frame times, stutters and hitches, VRAM use, memory and CPU time, load times, the game's log. - **The PR fails if:** it crashes; or a picture differs from main by more than 5%; or peak memory is more than 20% above main; or peak VRAM is more than 15% above main; or longest load is more than 25% above main; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0. - **Time:** about 31 min of game runs per tester (4 game starts), plus the two builds. Started at 05:37 UTC. **Estimate:** done in about 45 min, from the queue and the testers online now. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | any | 0/1 | — | — | — | running | </details>
Author
Owner

@Beanstalk do broad test

@Beanstalk do broad test
Contributor

Both notes above still apply at the rebased head d87dd600:

  • The single wake: now at host/nn_os_sync.c:716, inside event_signal starting at :704. The lines moved with the rebase onto current main.
  • The write history: gpu/vk/gpu_write_history.h is byte-identical to 1820ed9b, so the line numbers in the second note are unchanged.
Both notes above still apply at the rebased head `d87dd600`: - **The single wake:** now at `host/nn_os_sync.c:716`, inside `event_signal` starting at `:704`. The lines moved with the rebase onto current main. - **The write history:** `gpu/vk/gpu_write_history.h` is byte-identical to `1820ed9b`, so the line numbers in the second note are unchanged.
Preserve guest event progress across core masks and bound GPU write history
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 8s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 10s
CI / Workflow lint (actionlint) (pull_request) Successful in 10s
Third-party parts / As their notes say (pull_request) Successful in 12s
beanstalk/approval not approved yet
PR description / Description follows the template (pull_request_target) Successful in 5s
fdee285794
Assisted-by: OpenAI Codex
Member

Beanstalk test farm

Commit cbedca6 · tier reviewed · approved by HumanBean · dashboard

What will be tested · AI plan (gpt-6.1-terra)

The plan compares main and the PR across Market, Hyrule Field, Death Mountain Crater and Ganon’s Castle, including a return to Market to exercise resource reuse. It takes about 15 minutes per tester and measures frame times, memory and loading, with screenshots for visual regressions. Crashes, timeouts, substantial performance or memory regressions, and excessive screenshot differences fail the run.

  • Where: any (any PC, 1-2 reports).
  • market-scene-reuse: from a new save (settings vsync=2, frame_generation=0), then teleport to Market, move the stick, take the picture market-first to compare with main, measure market-first for 30 s (after 5 s warm-up), teleport to Hyrule Field, take the picture field to compare with main, measure field for 20 s (after 5 s warm-up), teleport to Death Mountain Crater, take the picture crater to compare with main, measure crater for 20 s (after 5 s warm-up), teleport to Ganon's Castle, take the picture castle to compare with main, measure castle for 20 s (after 5 s warm-up), take the picture market-return to compare with main, measure market-return for 30 s (after 5 s warm-up); 1 run on each side.
  • Measured: crashes, frame times, stutters and hitches, VRAM use, memory and CPU time, load times, the game's log.
  • The PR fails if: it crashes; or a picture differs from main by more than 5%; or peak memory is more than 20% above main; or peak VRAM is more than 15% above main; or longest load is more than 30% above main; or frame time (p99) is more than 20% above main; or forbidden log lines is above 0.
  • Time: about 17 min of game runs per tester (2 game starts), plus the two builds.

Done (started 06:14 UTC, last report 06:43 UTC). Comment @Beanstalk to run it again.

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
any · 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 2060, 621.24.0 1/1 1 none — — error

Measurements · any

Verdict: could not be judged on any (1/1 report).

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 2060, 621.24.0 AMD Ryzen 9 5900XT 16-Core Processor, 32 GB RAM
Scene: market-scene-reuse, from a new save (vsync=2, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: main and this PR built and run on the same PC in one session, game starts alternating (ABBA); market-scene-reuse: 1 game start a side, market-first 30 s after 5 s warm-up, field 20 s after 5 s warm-up, crater 20 s after 5 s warm-up, castle 20 s after 5 s warm-up, market-return 30 s after 5 s warm-up; each number the median of the runs, then of 1 report
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Nothing was measured: no metric came back.

Flags and settings

None: the plan varied no setting, switch or build option.

Markdown for the PR description
## Measurements

**Verdict:** could not be judged on any (1/1 report).

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 2060, 621.24.0` `AMD Ryzen 9 5900XT 16-Core Processor, 32 GB RAM`  
Scene: market-scene-reuse, from a new save (vsync=2, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: main and this PR built and run on the same PC in one session, game starts alternating (ABBA); market-scene-reuse: 1 game start a side, market-first 30 s after 5 s warm-up, field 20 s after 5 s warm-up, crater 20 s after 5 s warm-up, castle 20 s after 5 s warm-up, market-return 30 s after 5 s warm-up; each number the median of the runs, then of 1 report  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

Nothing was measured: no metric came back.

### Flags and settings

None: the plan varied no setting, switch or build option.
<!-- beanstalk:sticky --> ### Beanstalk test farm Commit `cbedca6` · tier **reviewed** · approved by HumanBean · [dashboard](https://beanstalk.magicbean.dev/prs/1553) **What will be tested** · AI plan (`gpt-6.1-terra`) The plan compares main and the PR across Market, Hyrule Field, Death Mountain Crater and Ganon’s Castle, including a return to Market to exercise resource reuse. It takes about 15 minutes per tester and measures frame times, memory and loading, with screenshots for visual regressions. Crashes, timeouts, substantial performance or memory regressions, and excessive screenshot differences fail the run. - **Where:** any (any PC, 1-2 reports). - **market-scene-reuse:** from a new save (settings vsync=2, frame_generation=0), then teleport to Market, move the stick, take the picture market-first to compare with main, measure market-first for 30 s (after 5 s warm-up), teleport to Hyrule Field, take the picture field to compare with main, measure field for 20 s (after 5 s warm-up), teleport to Death Mountain Crater, take the picture crater to compare with main, measure crater for 20 s (after 5 s warm-up), teleport to Ganon's Castle, take the picture castle to compare with main, measure castle for 20 s (after 5 s warm-up), take the picture market-return to compare with main, measure market-return for 30 s (after 5 s warm-up); 1 run on each side. - **Measured:** crashes, frame times, stutters and hitches, VRAM use, memory and CPU time, load times, the game's log. - **The PR fails if:** it crashes; or a picture differs from main by more than 5%; or peak memory is more than 20% above main; or peak VRAM is more than 15% above main; or longest load is more than 30% above main; or frame time (p99) is more than 20% above main; or forbidden log lines is above 0. - **Time:** about 17 min of game runs per tester (2 game starts), plus the two builds. Done (started 06:14 UTC, last report 06:43 UTC). Comment `@Beanstalk` to run it again. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | any · 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 2060, 621.24.0` | 1/1 [1](https://beanstalk.magicbean.dev/reports/rp_0ab48b35993f1bb9) | none | — | — | error | #### Measurements · any **Verdict:** could not be judged on any (1/1 report). Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 2060, 621.24.0` `AMD Ryzen 9 5900XT 16-Core Processor, 32 GB RAM` Scene: market-scene-reuse, from a new save (vsync=2, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: main and this PR built and run on the same PC in one session, game starts alternating (ABBA); market-scene-reuse: 1 game start a side, market-first 30 s after 5 s warm-up, field 20 s after 5 s warm-up, crater 20 s after 5 s warm-up, castle 20 s after 5 s warm-up, market-return 30 s after 5 s warm-up; each number the median of the runs, then of 1 report How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) Nothing was measured: no metric came back. ### Flags and settings None: the plan varied no setting, switch or build option. <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** could not be judged on any (1/1 report). Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 2060, 621.24.0` `AMD Ryzen 9 5900XT 16-Core Processor, 32 GB RAM` Scene: market-scene-reuse, from a new save (vsync=2, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: main and this PR built and run on the same PC in one session, game starts alternating (ABBA); market-scene-reuse: 1 game start a side, market-first 30 s after 5 s warm-up, field 20 s after 5 s warm-up, crater 20 s after 5 s warm-up, castle 20 s after 5 s warm-up, market-return 30 s after 5 s warm-up; each number the median of the runs, then of 1 report How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) Nothing was measured: no metric came back. ### Flags and settings None: the plan varied no setting, switch or build option. ``` </details>
Author
Owner

Both review findings reproduced on the rebased head d87dd600 and are addressed in fdee2857.

  • A signal wakes all registered event sleepers when several guest cores may be involved. The auto-clear CAS admits one consumer. The regression forces the host's wake-one choice onto a busy core while an eligible worker waits on another.
  • The GPU history caps pending and completed exact spans, including during publication. Excess writes become visible only as the timeline completes. GPU-owned images track actual byte overlaps in submission and segment order. Failed uploads preserve the write for retry. The fixture exercises 196,608 writes, a GPU backlog, a full publication map and neighboring rendered images.

The description now distinguishes the original playtest, the headed review build and the final integration smoke. It also records the scope of the profiler's blocked-time and SIGNAL timestamps. One follow-up remains in opt-in parallel replay when an earlier segment first creates a destination after a later worker has already recorded an aliased buffer write.

The branch was rebased on 79d4a143 and combines with current main 68d7757e without source conflicts. It remains WIP for measurement and wider hardware coverage.

Both review findings reproduced on the rebased head `d87dd600` and are addressed in `fdee2857`. * A signal wakes all registered event sleepers when several guest cores may be involved. The auto-clear CAS admits one consumer. The regression forces the host's wake-one choice onto a busy core while an eligible worker waits on another. * The GPU history caps pending and completed exact spans, including during publication. Excess writes become visible only as the timeline completes. GPU-owned images track actual byte overlaps in submission and segment order. Failed uploads preserve the write for retry. The fixture exercises 196,608 writes, a GPU backlog, a full publication map and neighboring rendered images. The description now distinguishes the original playtest, the headed review build and the final integration smoke. It also records the scope of the profiler's blocked-time and SIGNAL timestamps. One follow-up remains in opt-in parallel replay when an earlier segment first creates a destination after a later worker has already recorded an aliased buffer write. The branch was rebased on `79d4a143` and combines with current main `68d7757e` without source conflicts. It remains WIP for measurement and wider hardware coverage.
Read the full texture retirement function in the ASTC reuse check
Some checks reported errors
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 9s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 12s
CI / Workflow lint (actionlint) (pull_request) Successful in 14s
Third-party parts / As their notes say (pull_request) Successful in 14s
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Failing after 6s
beanstalk/approval approved by HumanBean (reviewed)
beanstalk/any 0/1 pass, 1 error
cbedca6c6d
Assisted-by: OpenAI Codex
Author
Owner

The complete dependency-enabled suite on fdee2857 reported 715 passed, 43 failed and 19 skipped. All 43 failed checks were rerun on upstream 68d7757e and 42 failed there too. I corrected the ASTC reuse check to inspect the full retirement function, then reran it successfully. The PR description lists the common failures. The new head cbedca6c changes only the test, so the Market smoke still covers the current runtime source.

The complete dependency-enabled suite on `fdee2857` reported 715 passed, 43 failed and 19 skipped. All 43 failed checks were rerun on upstream `68d7757e` and 42 failed there too. I corrected the ASTC reuse check to inspect the full retirement function, then reran it successfully. The PR description lists the common failures. The new head `cbedca6c` changes only the test, so the Market smoke still covers the current runtime source.
Author
Owner

@Beanstalk broad test

@Beanstalk broad test
Contributor

Thanks. I read fdee2857 against both notes, and both look addressed. This is a code-reading check of those two fixes only, not a review of the whole PR; nothing was run.

  • Events: the waiter count is read under e->lk, and the signal wakes one sleeper only when exactly one is registered, otherwise all of them. The auto-clear CAS still admits one consumer. The revised test_event_handoff.py forces the wake-one choice onto the busy core and would fail if that came back.
  • Write history: pending exact ranges are capped at 65,536, and excess writes go to bounded overflow state. complete() only advances a finished dirty floor, and trimming happens per publish. Nothing is dropped, and neighbouring rendered images aren't dirtied just because the history overflowed. The upload-failure retry is checked by a source assertion rather than a real failed upload in the renderer, as far as I can see.
  • The parallel-replay follow-up: agreed it's real. An aliased write recorded before the destination is watched leaves no per-image write. Our Deck and Windows runs therefore use the default path, with RX_VK_PARALLEL checked unset in both arms.
Thanks. I read `fdee2857` against both notes, and both look addressed. This is a code-reading check of those two fixes only, not a review of the whole PR; nothing was run. - **Events:** the waiter count is read under `e->lk`, and the signal wakes one sleeper only when exactly one is registered, otherwise all of them. The auto-clear CAS still admits one consumer. The revised `test_event_handoff.py` forces the wake-one choice onto the busy core and would fail if that came back. - **Write history:** pending exact ranges are capped at 65,536, and excess writes go to bounded overflow state. `complete()` only advances a finished dirty floor, and trimming happens per publish. Nothing is dropped, and neighbouring rendered images aren't dirtied just because the history overflowed. The upload-failure retry is checked by a source assertion rather than a real failed upload in the renderer, as far as I can see. - **The parallel-replay follow-up:** agreed it's real. An aliased write recorded before the destination is watched leaves no per-image write. Our Deck and Windows runs therefore use the default path, with `RX_VK_PARALLEL` checked unset in both arms.
HumanBean changed title from WIP: perf(runtime): reduce Market frame stalls and Vulkan capture overhead to perf(runtime): reduce Market frame stalls and Vulkan capture overhead 2026-11-18 07:28:02 +00:00
HumanBean deleted branch perf/market-render-rewrite 2026-11-18 07:28:10 +00:00
Contributor

Steam Deck OLED, the child Market on a fixed route: no difference resolved between main before this PR and main with it, and no regression. One run a side, so read it as a bound, not a measurement of the change.

Three visits of the Market, walking with camera swings Before: main @ d1a307cb After: main @ 430eef4f (this PR in it)
frames measured 1,602 1,665
median frame 51 ms (19.6 fps) 50 ms (20.0 fps)
mean 17.7 fps 17.9 fps
95th / 99th percentile 88 / 144 ms 84 / 175 ms
longest frame 485 ms 489 ms
frames of 60 ms or more 404 (33.8 s) 418 (34.6 s)
frames of 100 ms or more 47 (7.9 s) 44 (8.2 s)
the same after each visit's first 5 s: median, 99th, 100 ms or more 50 ms, 98 ms, 12 (1.4 s) 49 ms, 91 ms, 6 (0.9 s)
each visit's first 5 s: median; longest 69, 85, 86 ms; 440, 485, 483 ms 62, 91, 79 ms; 382, 489, 428 ms
the teleport into the Market, three visits 13.7, 10.8, 10.2 s 13.3, 10.4, 11.7 s
  • What it says. Every difference is smaller than the spread between two visits of one run (the 99th percentile of a visit: 135, 164, 132 ms before; 106, 212, 173 ms after). The one line that leans the PR's way is the walk after the first 5 s (12 frames of 100 ms or more against 6), too few frames to call.
  • Why it may not show here. At this resolution the Market is a 50 ms frame with about 25 ms of GPU time (the log's GPU time line, both sides, about 2,100 to 2,250 draws), a long way from the 65 to 75 fps of the PR's own numbers. A wait of a millisecond or two for a virtual core is a small part of such a frame.
  • Where the long frames are on this Deck. Almost all the time spent in frames of 100 ms or more is in the 5 s after each arrival, on both sides: a median of 62 to 91 ms there, with one frame of 380 to 490 ms a visit.

Hardware: Steam Deck OLED (AMD Custom APU 0932, 4 cores / 8 threads, RADV VANGOGH, Mesa 26.2.0-devel), SteamOS 3.9.5, 16 GB, on the charger, the GPU at a manual 1600 MHz.

Builds: both built on the Deck by the Linux builder (scripts/linux/appimage.sh, then AppRun --cli --update, --jobs 4), with LONGSHOT_CHUNK_OPT=all and a local hot list of 918 functions, the same on both sides, so not the default build. The update from one to the other compiled 107 files, none of the lifted code, and prepared no shader again.

Settings, the same on both sides: the handheld profile, a fixed 3D resolution of 1536x864 (HOS_RES_LOG=1: vi: res: fixed 1 (scale 1.000) ... 3D scale 1.000 in both logs), the game's own upscaler, headless, HOS_FPS_MAX=1000, and the player's switches: RX_VK_READBACK_LATE=newest,3980, RX_VK_LATE_DEFER=0, RX_VK_READBACK_EARLY_GAP=120, HOS_RESERVE_CORE=0, RX_VK_VRAM_MB=2800, RX_VK_TEX_MAX_DIM=1024, RX_VK_TEX_SKIP_MB=4, RX_VK_LOAD=create, RX_VK_LOW_SPEC=1, RX_VK_TEX_AHEAD=1, HOS_NATIVE_ZSTD=0.

Route: from a save in Kokiri Forest, through the control bridge: the debug teleport to Market_Child three times, Hyrule Field between two visits; in each visit 30 s of a walk that comes back to its start, with camera swings (longshot_ctl.py stick: left stick forward for 90 frames, right stick for 60, back for 90, right stick the other way for 60, left for 60, right for 60, again until the time is up). Every present is taken from the bridge's present events with its time of arrival; a visit's frames are the presents of 200 draws or more between the teleport's answer and the end of the walk.

Limits:

  • One run a side (three visits each), and the two mains are four commits apart (#1562, #1564, this PR, #1567), not this PR alone.
  • HOS_NATIVE_ZSTD=0 is in the player's settings, so the game's own decoder took the streams in both runs: what this PR changes around the host's decode during a load is not measured here.
  • No picture was checked (headless), and no long session was played on it yet.

The route is three small scripts; I can run it again on other settings (the game's dynamic resolution, a default build, HOS_NATIVE_ZSTD on) if one of them would help.

**Steam Deck OLED, the child Market on a fixed route: no difference resolved between main before this PR and main with it, and no regression.** One run a side, so read it as a bound, not a measurement of the change. | Three visits of the Market, walking with camera swings | Before: main @ d1a307cb | After: main @ 430eef4f (this PR in it) | |---|---|---| | frames measured | 1,602 | 1,665 | | median frame | 51 ms (19.6 fps) | 50 ms (20.0 fps) | | mean | 17.7 fps | 17.9 fps | | 95th / 99th percentile | 88 / 144 ms | 84 / 175 ms | | longest frame | 485 ms | 489 ms | | frames of 60 ms or more | 404 (33.8 s) | 418 (34.6 s) | | frames of 100 ms or more | 47 (7.9 s) | 44 (8.2 s) | | the same after each visit's first 5 s: median, 99th, 100 ms or more | 50 ms, 98 ms, 12 (1.4 s) | 49 ms, 91 ms, 6 (0.9 s) | | each visit's first 5 s: median; longest | 69, 85, 86 ms; 440, 485, 483 ms | 62, 91, 79 ms; 382, 489, 428 ms | | the teleport into the Market, three visits | 13.7, 10.8, 10.2 s | 13.3, 10.4, 11.7 s | - **What it says.** Every difference is smaller than the spread between two visits of one run (the 99th percentile of a visit: 135, 164, 132 ms before; 106, 212, 173 ms after). The one line that leans the PR's way is the walk after the first 5 s (12 frames of 100 ms or more against 6), too few frames to call. - **Why it may not show here.** At this resolution the Market is a 50 ms frame with about 25 ms of GPU time (the log's `GPU time` line, both sides, about 2,100 to 2,250 draws), a long way from the 65 to 75 fps of the PR's own numbers. A wait of a millisecond or two for a virtual core is a small part of such a frame. - **Where the long frames are on this Deck.** Almost all the time spent in frames of 100 ms or more is in the 5 s after each arrival, on both sides: a median of 62 to 91 ms there, with one frame of 380 to 490 ms a visit. **Hardware:** Steam Deck OLED (AMD Custom APU 0932, 4 cores / 8 threads, RADV VANGOGH, Mesa 26.2.0-devel), SteamOS 3.9.5, 16 GB, on the charger, the GPU at a manual 1600 MHz. **Builds:** both built on the Deck by the Linux builder (`scripts/linux/appimage.sh`, then `AppRun --cli --update`, `--jobs 4`), with `LONGSHOT_CHUNK_OPT=all` and a local hot list of 918 functions, the same on both sides, so not the default build. The update from one to the other compiled 107 files, none of the lifted code, and prepared no shader again. **Settings, the same on both sides:** the handheld profile, a fixed 3D resolution of 1536x864 (`HOS_RES_LOG=1`: `vi: res: fixed 1 (scale 1.000) ... 3D scale 1.000` in both logs), the game's own upscaler, headless, `HOS_FPS_MAX=1000`, and the player's switches: `RX_VK_READBACK_LATE=newest,3980`, `RX_VK_LATE_DEFER=0`, `RX_VK_READBACK_EARLY_GAP=120`, `HOS_RESERVE_CORE=0`, `RX_VK_VRAM_MB=2800`, `RX_VK_TEX_MAX_DIM=1024`, `RX_VK_TEX_SKIP_MB=4`, `RX_VK_LOAD=create`, `RX_VK_LOW_SPEC=1`, `RX_VK_TEX_AHEAD=1`, `HOS_NATIVE_ZSTD=0`. **Route:** from a save in Kokiri Forest, through the control bridge: the debug teleport to `Market_Child` three times, Hyrule Field between two visits; in each visit 30 s of a walk that comes back to its start, with camera swings (`longshot_ctl.py stick`: left stick forward for 90 frames, right stick for 60, back for 90, right stick the other way for 60, left for 60, right for 60, again until the time is up). Every present is taken from the bridge's `present` events with its time of arrival; a visit's frames are the presents of 200 draws or more between the teleport's answer and the end of the walk. **Limits:** - One run a side (three visits each), and the two mains are four commits apart (#1562, #1564, this PR, #1567), not this PR alone. - `HOS_NATIVE_ZSTD=0` is in the player's settings, so the game's own decoder took the streams in both runs: what this PR changes around the host's decode during a load is not measured here. - No picture was checked (headless), and no long session was played on it yet. The route is three small scripts; I can run it again on other settings (the game's dynamic resolution, a default build, `HOS_NATIVE_ZSTD` on) if one of them would help.
Contributor

Results, following up our testing notice. This PR was merged before our runs finished, so the planned PR-only comparison was replaced. These results compare main 79d4a143 with 430eef4f: a nine-commit bundle that includes this PR, #1564 and #1567. They are not this PR in isolation. The planned Deck Market block wasn't run in this series.

Steam Deck OLED

  • Setup: SteamOS, RADV (Mesa 26.2.0-devel), the built-in 1280×800 display, Minimum preset with a fixed 50% render, frame generation off, default core reservation, native zstd on, 15 W and main's clock policy.
  • Kokiri standing, two reverse-order pairs:
    • fps 25.60 → 25.64 (arm medians): no meaningful FPS gain resolved.
    • p99 rose 49.26 → 52.62 and 48.97 → 50.13 ms.
    • Frames over 50 ms rose 11 → 18 and 10 → 13 (about 14.8 → 23.1 and 13.5 → 16.7 a minute).
    • The longest frame fell 136.67 → 128.44 and 132.98 → 127.73 ms.
    • Two pairs are descriptive: not evidence of equivalence, and not a settled regression.
  • Hyrule Field: no comparison. Neither arm had an admitted measured window, because the steady-state checks saw background work and program-census changes. We haven't diagnosed those refusals as first-use shader translation.
  • Faults and pictures: no GPU fault or reset in this block. An earlier start-up hang on old main is still unexplained. The covered safety windows had zero flash-detector flags, and the sampled views showed no obvious new artifact.

Windows, RTX 5090: three interleaved pairs, warm caches

  • Market: fps rose +1.99, +5.95 and +12.86; p99 fell 0.77, 2.62 and 11.94 ms.
    • All three pairs are valid. The third pair's old-main window ran with 30.7% other CPU on the PC.
    • The two unflagged pairs go the same way, but they stay unresolved at n < 3.
  • Kokiri: fps and p99 were mixed. The longest frame fell in all three pairs.
  • First settled Market window after each launch (all ten launches, including warm-ups and the display-cost runs): nine had no frame over 50 ms. The exception was that CPU-flagged old-main window.
    • Start-up and teleport-settle hitches are a separate matter.
    • With warm driver caches, this doesn't test a fresh install on Most or the first-dispatch risk for unlisted programs.

p0lux's Market traversal (comment 48525) used different builds and settings, with native zstd off. It complements these results; we haven't pooled the two.

Results, following up [our testing notice](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1553#issuecomment-48013). This PR was merged before our runs finished, so the planned PR-only comparison was replaced. These results compare main `79d4a143` with `430eef4f`: a nine-commit bundle that includes this PR, [#1564](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1564) and [#1567](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1567). They are not this PR in isolation. The planned Deck Market block wasn't run in this series. **Steam Deck OLED** - **Setup:** SteamOS, RADV (Mesa 26.2.0-devel), the built-in 1280×800 display, Minimum preset with a fixed 50% render, frame generation off, default core reservation, native zstd on, 15 W and main's clock policy. - **Kokiri standing, two reverse-order pairs:** - fps 25.60 → 25.64 (arm medians): no meaningful FPS gain resolved. - p99 rose 49.26 → 52.62 and 48.97 → 50.13 ms. - Frames over 50 ms rose 11 → 18 and 10 → 13 (about 14.8 → 23.1 and 13.5 → 16.7 a minute). - The longest frame fell 136.67 → 128.44 and 132.98 → 127.73 ms. - Two pairs are descriptive: not evidence of equivalence, and not a settled regression. - **Hyrule Field:** no comparison. Neither arm had an admitted measured window, because the steady-state checks saw background work and program-census changes. We haven't diagnosed those refusals as first-use shader translation. - **Faults and pictures:** no GPU fault or reset in this block. An earlier start-up hang on old main is still unexplained. The covered safety windows had zero flash-detector flags, and the sampled views showed no obvious new artifact. **Windows, RTX 5090: three interleaved pairs, warm caches** - **Market:** fps rose +1.99, +5.95 and +12.86; p99 fell 0.77, 2.62 and 11.94 ms. - All three pairs are valid. The third pair's old-main window ran with 30.7% other CPU on the PC. - The two unflagged pairs go the same way, but they stay unresolved at n < 3. - **Kokiri:** fps and p99 were mixed. The longest frame fell in all three pairs. - **First settled Market window after each launch** (all ten launches, including warm-ups and the display-cost runs): nine had no frame over 50 ms. The exception was that CPU-flagged old-main window. - Start-up and teleport-settle hitches are a separate matter. - With warm driver caches, this doesn't test a fresh install on Most or the first-dispatch risk for unlisted programs. p0lux's Market traversal ([comment 48525](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1553#issuecomment-48525)) used different builds and settings, with native zstd off. It complements these results; we haven't pooled the two.
Contributor

Follow-up on the Field admission refusals: the recurring “1 jobs queued” pattern aligns with the renderer’s scheduled glibc heap check/trim (mallinfo2/malloc_trim), which also exists on 544229a2; window alignment explains why it was sampled in some runs and not others. It is not evidence of a newly translated Field shader. Our original admission decisions and exclusions are unchanged; separate program-census refusals remain, so there is still no admitted Field comparison pair.

Follow-up on the Field admission refusals: the recurring “1 jobs queued” pattern aligns with the renderer’s scheduled glibc heap check/trim (`mallinfo2`/`malloc_trim`), which also exists on `544229a2`; window alignment explains why it was sampled in some runs and not others. It is not evidence of a newly translated Field shader. Our original admission decisions and exclusions are unchanged; separate program-census refusals remain, so there is still no admitted Field comparison pair.
Contributor

Testing note from the Steam Deck LCD campaign (VanGogh iGPU, no VRAM mirrors — the opposite regime from the RTX 3090 route in the description): our campaign overlay branch (perf/1477-bc1-packed-export, PR #1561) is based on pre-1553 main, and #1553 lands under every campaign measurement made in the last two days. The Deck campaign therefore cannot treat post-1553 main as an interchangeable control without one matched pair first (0ffbb8b3 vs 7daafa7a, same Deck, same route). We will run that pair when the campaign reaches its next rebase; flagging it now so nobody compares across the squash by accident. No defect claimed — just regime coverage: the snapshot-read + late-page path and the ASTC upload repartition both run differently on UMA than on the 3090.

Testing note from the Steam Deck LCD campaign (VanGogh iGPU, no VRAM mirrors — the opposite regime from the RTX 3090 route in the description): our campaign overlay branch (perf/1477-bc1-packed-export, PR #1561) is based on pre-1553 main, and #1553 lands under every campaign measurement made in the last two days. The Deck campaign therefore cannot treat post-1553 main as an interchangeable control without one matched pair first (0ffbb8b3 vs 7daafa7a, same Deck, same route). We will run that pair when the campaign reaches its next rebase; flagging it now so nobody compares across the squash by accident. No defect claimed — just regime coverage: the snapshot-read + late-page path and the ASTC upload repartition both run differently on UMA than on the 3090.
Contributor

Instrumentation caveat for the Steam Deck numbers: recurring long frames have nearly the same cadence as our /proc memory sampler. We are investigating an observer effect; no sampler-off control has established its size or whether it changes the arm contrasts. The Deck p99, long-frame counts, maxima and FPS comparisons above include that instrumentation and must not yet be treated as unsampled player experience. The raw results and exclusions are unchanged. This caveat does not concern the separate Windows runs.

Instrumentation caveat for the Steam Deck numbers: recurring long frames have nearly the same cadence as our /proc memory sampler. We are investigating an observer effect; no sampler-off control has established its size or whether it changes the arm contrasts. The Deck p99, long-frame counts, maxima and FPS comparisons above include that instrumentation and must not yet be treated as unsampled player experience. The raw results and exclusions are unchanged. This caveat does not concern the separate Windows runs.
Contributor

One more data point from the Windows side, from a profile on main 430eef4f (RTX 5090, the child Market). It's descriptive and isn't an FPS result.

Five complete 600-present blocks inside the marked Market window averaged 6.72 ms a frame of timestamp gap before the first draw-bearing recording, against 1.56 ms after it. The former includes the output copy; upload times were logged separately. The main-vcore wait was about 0.02 ms a frame.

This points further investigation at the interval before the first draw-bearing recording, not at vcore arbitration. It doesn't identify the signalling dependency or show reclaimable GPU idle time, and it isn't a Deck result. The capture was headless, sampled every 2 ms and warm-cache, with 15.2% other CPU on the PC. No wait chain was obtained.

One more data point from the Windows side, from a profile on main `430eef4f` (RTX 5090, the child Market). It's descriptive and isn't an FPS result. Five complete 600-present blocks inside the marked Market window averaged 6.72 ms a frame of timestamp gap before the first draw-bearing recording, against 1.56 ms after it. The former includes the output copy; upload times were logged separately. The main-vcore wait was about 0.02 ms a frame. This points further investigation at the interval before the first draw-bearing recording, not at vcore arbitration. It doesn't identify the signalling dependency or show reclaimable GPU idle time, and it isn't a Deck result. The capture was headless, sampled every 2 ms and warm-cache, with 15.2% other CPU on the PC. No wait chain was obtained.
Contributor

Follow-up to the instrumentation caveat above: a sampler-cadence control on the same Deck moved the recurring long frames with the memory sampler's period (5.8 → 17.8 → 5.8 s), with every Kokiri interval over 100 ms intersecting its smaps_rollup read. That strengthens the observer-effect caveat for our Deck tail numbers; it doesn't estimate unsampled FPS or show that the arm contrasts cancel. Details: #1477 (comment)

Follow-up to the instrumentation caveat above: a sampler-cadence control on the same Deck moved the recurring long frames with the memory sampler's period (5.8 → 17.8 → 5.8 s), with every Kokiri interval over 100 ms intersecting its `smaps_rollup` read. That strengthens the observer-effect caveat for our Deck tail numbers; it doesn't estimate unsampled FPS or show that the arm contrasts cancel. Details: https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1477#issuecomment-49657
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
6 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!1553
No description provided.