perf(vk): ask for the window's next image on the presenter thread right after a present, so the render thread stops waiting for it #1574

Merged
HumanBean merged 17 commits from klimovich008/Longshot:perf/acquire-ahead into main 2026-11-20 22:20:18 +00:00
Member

Summary

Since #1458 the renderer waits on the CPU for the window's next image before it draws into it. With AMD's Windows driver, in a window, the render thread's presents took 2.3-2.7 ms of every frame, most of it that wait, and the render thread is what the frame waits for.

What changes for a player: the window's next image is now asked for on the presenter thread right after each present, so the wait for it overlaps the next frame's work and the render thread stops waiting for it (its presents: 0.23-0.24 ms a frame). On an RX 9070 XT in a 1280x720 window, uncapped, that gave 78.49 -> 84.69 fps (+7.9 %, 3 pairs, higher in every pair) and p99 18.40 -> 16.93 ms. At the default 60 fps cap fps does not change; p99 was lower in each pair.

Where it is on:

  • On by default with every driver (a maintainer's decision, HumanBean, 2026-11-20). Measured gains: AMD's Windows driver (RX 9070 XT, +7.9 % uncapped) and NVIDIA on Linux (RTX 3090, +3.8 % by median, see Measurements). NVIDIA and Intel on Windows, RADV on a desktop and the Steam Deck have not been measured with this design: drivers that wait inside the acquire answer its zero timeout at once, with an image or none, so the presenter never waits there.
  • RX_VK_ACQUIRE_AHEAD=0 turns it off (#1458's order: each image asked for at its own present); =1 forces it on, for A/B runs.
  • Never with frame generation or V-Sync On (FIFO): both keep #1458's order.

Since #1763 the presenter thread runs on every PC, so this round moved the ahead acquire onto that thread: it is made after the presenter's own vkQueuePresentKHR, while the swapchain is still the presenter's (presenter.busy), and before it says it is done. The render thread reads the image's state only after its drain of the presenter, as it already does before every acquire. This also answers the #1702 overlap from review: acquire ahead no longer holds off for the presenter thread.

Read first, in gpu/vk/vk_replay.cpp: acquire_ahead() and acquire_ahead_wanted(), the end of presenter_loop(), present_hand_off() and present_thread_drain(); then held_image_drop() / acquire_fence_ready() (a fence let go with a swapchain is kept and used again once signaled, instead of leaked; this is #1458's path on every GPU). The default is acquire_ahead in gpu/vk/device_policy.h (on for every driver).

See #1458, #1376, #1763.

Testing

Tested: Windows 11, RX 9070 XT, AMD 26.11.2, Ryzen 7 5700X3D, this PR's renderer (95bdfd06, on main 89c3d21e) over main's game build, then the checks again on this head (ef200041, main ed9495bb merged):

  • In the game, two sessions with 99 swapchain remakes each (resize to 1600x900 and back, V-Sync On / Auto / Off / Auto, F11 full screen and back, minimize and restore, a 40-step drag-resize), with the default and with =0. The default logs once at the first present that it is on by AMD's driver. At each V-Sync On it logs not now, the swapchain is FIFO, and back at Auto it is on again. No error-line kind that the =0 run lacks; no not given back, not made in 5 s, device lost or out-of-date line. Game clock 0.99-1.01 after the load.
  • The implementer's sessions: 156 remakes each with the default, =1 and =0 (HDR on and off too), and one =1 session under Vulkan validation: no message naming acquire, present, swapchain or a fence, no SYNC-HAZARD.
  • tests/test_present_acquire_ahead.py (new): 12/12 modes pass (Windows and Linux sides x AMD-Windows default / another driver's default x unset, 0, 1). It fails on main's source and on this PR's older render-thread design. Its 21 broken variants each fail for their own reason (e.g. the ahead acquire without presenter.mu held, an acquire after a drain gave up, a fence reused before it is signaled).
  • test_present_image_free, test_present_device_loss (all ten WSI sites), test_present_thread, test_device_policy, test_switch_table: pass. After merging main ed9495bb they pass again, and so do main's present and recorder tests that changed since (#1866's among them).
  • Full suite (tests/run_all.py --jobs 4, Windows, llvm-mingw) on this head ef200041: 763 passed, 69 failed, 54 skipped. Clean main ed9495bb: 761 / 70 / 54. Every failure here also fails on main: the 68 test files below, plus the auto-profile check Auto-controlled shadow_res missing (the list below; most need tools or a build this PC's run lacks); test_recording_admission failed on main only.
The failing tests, the same on main ed9495bb

test_appimage_player_build.py, test_auto_handheld.py, test_bug_report_defaults.py, test_capture_read_once.py, test_capture_readback_visibility.py, test_crash_dialog.py, test_crash_record.py, test_crt_options.py, test_damage_debug_menu.py, test_dev_ab.py, test_dev_build.py, test_dev_migrate.py, test_dev_packs.py, test_device_lost_exit.py, test_display_startup_failure.py, test_dlss_feature_size.py, test_draw_binds.py, test_draw_stream_visibility.py, test_failed_compile_keeps_objects.py, test_flush_nothing_held.py, test_frame_overlap.py, test_fsr_image_retirement.py, test_fsr_uniform_ownership.py, test_game_menu_mouse_buttons.py, test_gpu_wait_stats.py, test_guest_imported.py, test_high_fps_fixes.py, test_host_guest_writes.py, test_hud_layout_row.py, test_job_queue.py, test_libc_hooks.py, test_lift_cache.py, test_linux_preflight.py, test_linux_pressure.py, test_longshot_ctl.py, test_low_vram_texture_mips.py, test_make_game_ngx.py, test_mise_build.py, test_missing_nup.py, test_mods_list.py, test_ngx_sdk.py, test_pads_after_menu.py, test_pass_barrier.py, test_pending_guest_import.py, test_pipeline_play_cache.py, test_prepare_cache_save.py, test_present_queue_default.py, test_present_semaphores.py, test_present_source_crop.py, test_profiling_mode.py, test_psychov35_fsr3_fg.py, test_readback_timeout_source.py, test_recorder_own_idle.py, test_reflex_swapchain_lifetime.py, test_renderer_new_handler.py, test_replay_write_order.py, test_sampler_admission.py, test_sdiv_overflow.py, test_slow_frames.py, test_song_note_cue.py, test_sparse_mirror.py, test_staging_burst.py, test_texel_buffer_ownership.py, test_ub_update_batch.py, test_upscaler_rows.py, test_vcore_escape.py, test_vk_occlusion_queries.py, test_walk_key.py

  • vk_replay.cpp compiles for Windows (llvm-mingw) and for Linux (clang, WSL).

The Test Farm can't test this switch: Beanstalk starts every game with HOS_HEADLESS=1 (no window, so no swapchain), and headless the renderer never reaches the present path where RX_VK_ACQUIRE_AHEAD acts. Its earlier rounds on this PR compared the same code on both sides.

Now that it is on with every driver, the items below check the default, not an opt-in.

Still to test:

  • NVIDIA on Windows: in a window, uncapped, V-Sync Off, frame generation off, 3 runs with RX_VK_ACQUIRE_AHEAD=0 against 3 with =1, expecting no lower fps and no higher p99 before it could be on there (by hand: the farm runs headless).
  • Intel Arc on Windows: the same, expecting the same (by hand).
  • Linux RADV and NVIDIA, X11 and Wayland: the same, plus the window covered by another for 40 s and uncovered, expecting frames back and no hang (by hand).
  • Steam Deck: =1 against =0 in Hyrule Field, expecting no change (by hand).
  • AMD on Windows: frame generation 2x for a minute, and turning it off mid-play, expecting the log's not now line and a picture as with =0 (by hand).
  • AMD on Windows: #1458's case with the default on, full screen behind another window for 40 s, twice, expecting no the GPU has finished nothing line and frames back (by hand).

Measurements

Verdict: helps on AMD's Windows driver in a window when uncapped: +7.9 % fps by median (78.49 -> 84.69), higher in all 3 pairs (+8.5 / +6.8 / +7.9 %), p99 18.40 -> 16.93 ms. CPU ms a frame moved +0.9 %, under 5 %, so our harness labels the result diagnostic: its rule would want 6 pairs, and we run 3. At the default 60 fps cap: fps unchanged, p99 lower in each pair, CPU ms a frame mixed (by pair -6.1 / +3.5 / +0.1 %). Also measured since: Linux NVIDIA (below). Not measured on any other GPU or system.

Setup: Windows 11, RX 9070 XT (AMD 26.11.2), Ryzen 7 5700X3D, one 5120x1440 144 Hz display. Hyrule Field, the camera turning at full speed, a 1280x720 window (V-Sync Auto, so immediate), frame generation off, threaded rendering on (RX_VK_ASYNC=1), a fixed background GPU load. Uncapped: HOS_FPS_MAX=240; capped: the options file's 60. One build: main 89c3d21e's game with this PR's renderer at 95bdfd06. "Before" is RX_VK_ACQUIRE_AHEAD=0, which is main's order; "After" is the default. 3 alternating pairs a side, 20 s window, no warm-up runs, all 12 runs admitted. Game clock 0.999-1.001 in every run.

Baseline: RX_VK_ACQUIRE_AHEAD=0 in this PR's own build, not main's build. With =0 the present path is main's (#1458's order, each image asked for at its present), and one build in both arms leaves the switch as the only difference. The 3 pairs ran on one runtime, so no second renderer build stood between them.

Uncapped Before: =0 (main's order) @ 95bdfd06 After: the default @ 95bdfd06
fps, median (runs) 78.49 (77.84, 79.84, 78.49) 84.69 (84.44, 85.24, 84.69)
CPU ms a frame, median 51.84 52.30
p99 frame (ms), median 18.40 16.93
worst frame (ms) 52.8, 54.4, 59.4 50.4, 66.2, 45.7
frames over 50 / 100 / 250 ms (sum) 4 / 0 / 0 2 / 0 / 0
render thread's presents, ms a frame 2.32-2.67 0.23-0.24
presenter's wait for the copy's fence, ms a present 0.56-1.00 2.64-2.91
60 fps cap Before: =0 After: the default
fps, median 59.60 59.74
CPU ms a frame, median (runs) 52.09 (51.91, 52.09, 53.72) 53.75 (48.74, 53.90, 53.75)
p99 frame (ms), median 20.19 19.29
frames over 50 / 100 / 250 ms (sum) 3 / 1 / 0 4 / 1 / 0

The wait did not go away: it moved to the presenter thread, which now waits longer for the copy's fence, beside the render thread instead of in front of it. At the cap, each arm's CPU ms spread 48.7-53.9 ms by itself; one sampled run per arm showed equal user-mode CPU per thread.

Linux NVIDIA (HumanBean): Linux (CachyOS, kernel 7.3, Wayland), RTX 3090 (NVIDIA 620.x), Ryzen 9 7900X, this PR @ ef200041, one runtime, RX_VK_ACQUIRE_AHEAD=0 against =1; dev.py ab --scene market --seconds 30, a 2560x1440 window, uncapped, V-Sync Auto (mailbox), frame generation off, interleaved; every clean run of three A/Bs.

Market, 30 s =0 (main's order) =1 (acquire ahead)
fps, each run 96.0, 89.7, 87.8, 98.2 98.1, 88.9, 90.4, 98.4, 96.4
fps, median 92.9 96.4 (+3.8 %)

The runs overlap (87.8-98.2 against 88.9-98.4), so this is a direction, not a settled gain.

These numbers were measured on main 89c3d21e. Main has moved since (this head merges ed9495bb, including #1866's recorder change, which touches the render thread's waits); they were not measured again.

Risks

What could break, with every driver now (all but =0, frame generation and V-Sync On): the window's image is asked for earlier. A swapchain remake (resize, full screen, HDR, V-Sync) lets an image asked for ahead go. Its fence is then kept and used again once the driver signals it, never before.

Known limits (from a second review; none seen in the game):

  1. The presenter's 5 s drain can't give up while the presenter is inside the ahead acquire, because it holds presenter.mu there. A zero-timeout vkAcquireNextImageKHR that blocked (a driver sending a message to a window thread that isn't pumping) would hang the render thread instead of letting it go on after 5 s. Not reached with the default: main's own acquire at the present has the same exposure with no bound at all. Hardening, if wanted: make the acquire with the mutex released and take it again after.
  2. Window close with DLSS-G and =1 (NVIDIA only, not the default): the same message-pump case through DLSS-G's close, which takes the swapchain's lock. Main's presenter already holds that lock across vkQueuePresentKHR; this adds a zero-timeout window of the same kind.
  3. Frame generation turned off in the middle of a set: that frame's present asks for the next image ahead while the last generated frames still go out, so one image more is out for a moment (it takes the held-image path; a timeout of 0, so nothing blocks). Not run in the game.
  4. The pool of fences let go is capped at 8; a 9th pending one is forgotten, as main forgets every one today.

How to turn it off: RX_VK_ACQUIRE_AHEAD=0 in longshot_env.txt; a revert is also enough. What a player notices after updating: nothing in saves, longshot_options.ini or the shader and pipeline caches (no translator file or vk_api.h touched); in a window, uncapped, a higher frame rate with AMD's Windows driver (+7.9 % measured) and likely with others (+3.8 % on a Linux RTX 3090); at a 60 fps cap no change in fps.

Checklist

Ready for review

  • One topic, on current main; the title is a Conventional Commit.
  • Tested on my own PC, in the game for a change the game runs, as Testing says.
  • mise run test passes (any failure that also fails on main is named).
  • Measured against main, or Measurements says why there is nothing to measure.
  • No game files, build output or hand-edited generated files; third_party/ untouched; nothing GPL-incompatible.

When it applies

  • A switch added or changed: it ships at the default the measurements chose, with its row in gpu/vk/switches.def.
  • A check under tests/ that reads changed source is updated, not weakened.
  • Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths.
  • Docs updated.
  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.

Ready to merge

  • Everything in Still to test has run, its results in Tested.
  • Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers").
  • Approved in review, every comment answered.
  • CI passes on the head; on current main, measured again or a comment says why the numbers still hold.

🤖 Generated with Claude Code

## Summary Since #1458 the renderer waits on the CPU for the window's next image before it draws into it. With AMD's Windows driver, in a window, the render thread's presents took 2.3-2.7 ms of every frame, most of it that wait, and the render thread is what the frame waits for. What changes for a player: the window's next image is now asked for on the presenter thread right after each present, so the wait for it overlaps the next frame's work and the render thread stops waiting for it (its presents: 0.23-0.24 ms a frame). On an RX 9070 XT in a 1280x720 window, uncapped, that gave 78.49 -> 84.69 fps (+7.9 %, 3 pairs, higher in every pair) and p99 18.40 -> 16.93 ms. At the default 60 fps cap fps does not change; p99 was lower in each pair. Where it is on: - **On by default with every driver** (a maintainer's decision, HumanBean, 2026-11-20). Measured gains: AMD's Windows driver (RX 9070 XT, +7.9 % uncapped) and NVIDIA on Linux (RTX 3090, +3.8 % by median, see Measurements). NVIDIA and Intel on Windows, RADV on a desktop and the Steam Deck have not been measured with this design: drivers that wait inside the acquire answer its zero timeout at once, with an image or none, so the presenter never waits there. - `RX_VK_ACQUIRE_AHEAD=0` turns it off (#1458's order: each image asked for at its own present); `=1` forces it on, for A/B runs. - Never with frame generation or V-Sync On (FIFO): both keep #1458's order. Since #1763 the presenter thread runs on every PC, so this round moved the ahead acquire onto that thread: it is made after the presenter's own `vkQueuePresentKHR`, while the swapchain is still the presenter's (`presenter.busy`), and before it says it is done. The render thread reads the image's state only after its drain of the presenter, as it already does before every acquire. This also answers the #1702 overlap from review: acquire ahead no longer holds off for the presenter thread. Read first, in `gpu/vk/vk_replay.cpp`: `acquire_ahead()` and `acquire_ahead_wanted()`, the end of `presenter_loop()`, `present_hand_off()` and `present_thread_drain()`; then `held_image_drop()` / `acquire_fence_ready()` (a fence let go with a swapchain is kept and used again once signaled, instead of leaked; this is #1458's path on every GPU). The default is `acquire_ahead` in `gpu/vk/device_policy.h` (on for every driver). See #1458, #1376, #1763. ## Testing **Tested:** Windows 11, RX 9070 XT, AMD 26.11.2, Ryzen 7 5700X3D, this PR's renderer (95bdfd06, on main 89c3d21e) over main's game build, then the checks again on this head (ef200041, main ed9495bb merged): - In the game, two sessions with 99 swapchain remakes each (resize to 1600x900 and back, V-Sync On / Auto / Off / Auto, F11 full screen and back, minimize and restore, a 40-step drag-resize), with the default and with `=0`. The default logs once at the first present that it is on by AMD's driver. At each V-Sync On it logs `not now, the swapchain is FIFO`, and back at Auto it is on again. No error-line kind that the `=0` run lacks; no `not given back`, `not made in 5 s`, device lost or out-of-date line. Game clock 0.99-1.01 after the load. - The implementer's sessions: 156 remakes each with the default, `=1` and `=0` (HDR on and off too), and one `=1` session under Vulkan validation: no message naming acquire, present, swapchain or a fence, no `SYNC-HAZARD`. - `tests/test_present_acquire_ahead.py` (new): 12/12 modes pass (Windows and Linux sides x AMD-Windows default / another driver's default x unset, `0`, `1`). It fails on main's source and on this PR's older render-thread design. Its 21 broken variants each fail for their own reason (e.g. the ahead acquire without `presenter.mu` held, an acquire after a drain gave up, a fence reused before it is signaled). - `test_present_image_free`, `test_present_device_loss` (all ten WSI sites), `test_present_thread`, `test_device_policy`, `test_switch_table`: pass. After merging main ed9495bb they pass again, and so do main's present and recorder tests that changed since (#1866's among them). - Full suite (`tests/run_all.py --jobs 4`, Windows, llvm-mingw) on this head ef200041: 763 passed, 69 failed, 54 skipped. Clean main ed9495bb: 761 / 70 / 54. Every failure here also fails on main: the 68 test files below, plus the auto-profile check `Auto-controlled shadow_res missing` (the list below; most need tools or a build this PC's run lacks); `test_recording_admission` failed on main only. <details><summary>The failing tests, the same on main ed9495bb</summary> `test_appimage_player_build.py`, `test_auto_handheld.py`, `test_bug_report_defaults.py`, `test_capture_read_once.py`, `test_capture_readback_visibility.py`, `test_crash_dialog.py`, `test_crash_record.py`, `test_crt_options.py`, `test_damage_debug_menu.py`, `test_dev_ab.py`, `test_dev_build.py`, `test_dev_migrate.py`, `test_dev_packs.py`, `test_device_lost_exit.py`, `test_display_startup_failure.py`, `test_dlss_feature_size.py`, `test_draw_binds.py`, `test_draw_stream_visibility.py`, `test_failed_compile_keeps_objects.py`, `test_flush_nothing_held.py`, `test_frame_overlap.py`, `test_fsr_image_retirement.py`, `test_fsr_uniform_ownership.py`, `test_game_menu_mouse_buttons.py`, `test_gpu_wait_stats.py`, `test_guest_imported.py`, `test_high_fps_fixes.py`, `test_host_guest_writes.py`, `test_hud_layout_row.py`, `test_job_queue.py`, `test_libc_hooks.py`, `test_lift_cache.py`, `test_linux_preflight.py`, `test_linux_pressure.py`, `test_longshot_ctl.py`, `test_low_vram_texture_mips.py`, `test_make_game_ngx.py`, `test_mise_build.py`, `test_missing_nup.py`, `test_mods_list.py`, `test_ngx_sdk.py`, `test_pads_after_menu.py`, `test_pass_barrier.py`, `test_pending_guest_import.py`, `test_pipeline_play_cache.py`, `test_prepare_cache_save.py`, `test_present_queue_default.py`, `test_present_semaphores.py`, `test_present_source_crop.py`, `test_profiling_mode.py`, `test_psychov35_fsr3_fg.py`, `test_readback_timeout_source.py`, `test_recorder_own_idle.py`, `test_reflex_swapchain_lifetime.py`, `test_renderer_new_handler.py`, `test_replay_write_order.py`, `test_sampler_admission.py`, `test_sdiv_overflow.py`, `test_slow_frames.py`, `test_song_note_cue.py`, `test_sparse_mirror.py`, `test_staging_burst.py`, `test_texel_buffer_ownership.py`, `test_ub_update_batch.py`, `test_upscaler_rows.py`, `test_vcore_escape.py`, `test_vk_occlusion_queries.py`, `test_walk_key.py` </details> - `vk_replay.cpp` compiles for Windows (llvm-mingw) and for Linux (clang, WSL). The Test Farm can't test this switch: Beanstalk starts every game with `HOS_HEADLESS=1` (no window, so no swapchain), and headless the renderer never reaches the present path where `RX_VK_ACQUIRE_AHEAD` acts. Its earlier rounds on this PR compared the same code on both sides. Now that it is on with every driver, the items below check the default, not an opt-in. **Still to test:** - NVIDIA on Windows: in a window, uncapped, V-Sync Off, frame generation off, 3 runs with `RX_VK_ACQUIRE_AHEAD=0` against 3 with `=1`, expecting no lower fps and no higher p99 before it could be on there (by hand: the farm runs headless). - Intel Arc on Windows: the same, expecting the same (by hand). - Linux RADV and NVIDIA, X11 and Wayland: the same, plus the window covered by another for 40 s and uncovered, expecting frames back and no hang (by hand). - Steam Deck: `=1` against `=0` in Hyrule Field, expecting no change (by hand). - AMD on Windows: frame generation 2x for a minute, and turning it off mid-play, expecting the log's `not now` line and a picture as with `=0` (by hand). - AMD on Windows: #1458's case with the default on, full screen behind another window for 40 s, twice, expecting no `the GPU has finished nothing` line and frames back (by hand). ## Measurements **Verdict:** helps on AMD's Windows driver in a window when uncapped: +7.9 % fps by median (78.49 -> 84.69), higher in all 3 pairs (+8.5 / +6.8 / +7.9 %), p99 18.40 -> 16.93 ms. CPU ms a frame moved +0.9 %, under 5 %, so our harness labels the result **diagnostic**: its rule would want 6 pairs, and we run 3. At the default 60 fps cap: fps unchanged, p99 lower in each pair, CPU ms a frame mixed (by pair -6.1 / +3.5 / +0.1 %). Also measured since: Linux NVIDIA (below). Not measured on any other GPU or system. Setup: Windows 11, RX 9070 XT (AMD 26.11.2), Ryzen 7 5700X3D, one 5120x1440 144 Hz display. Hyrule Field, the camera turning at full speed, a 1280x720 window (V-Sync Auto, so immediate), frame generation off, threaded rendering on (`RX_VK_ASYNC=1`), a fixed background GPU load. Uncapped: `HOS_FPS_MAX=240`; capped: the options file's 60. One build: main 89c3d21e's game with this PR's renderer at 95bdfd06. "Before" is `RX_VK_ACQUIRE_AHEAD=0`, which is main's order; "After" is the default. 3 alternating pairs a side, 20 s window, no warm-up runs, all 12 runs admitted. Game clock 0.999-1.001 in every run. Baseline: `RX_VK_ACQUIRE_AHEAD=0` in this PR's own build, not main's build. With `=0` the present path is main's (#1458's order, each image asked for at its present), and one build in both arms leaves the switch as the only difference. The 3 pairs ran on one runtime, so no second renderer build stood between them. | Uncapped | Before: `=0` (main's order) @ 95bdfd06 | After: the default @ 95bdfd06 | |---|---|---| | fps, median (runs) | 78.49 (77.84, 79.84, 78.49) | 84.69 (84.44, 85.24, 84.69) | | CPU ms a frame, median | 51.84 | 52.30 | | p99 frame (ms), median | 18.40 | 16.93 | | worst frame (ms) | 52.8, 54.4, 59.4 | 50.4, 66.2, 45.7 | | frames over 50 / 100 / 250 ms (sum) | 4 / 0 / 0 | 2 / 0 / 0 | | render thread's presents, ms a frame | 2.32-2.67 | 0.23-0.24 | | presenter's wait for the copy's fence, ms a present | 0.56-1.00 | 2.64-2.91 | | 60 fps cap | Before: `=0` | After: the default | |---|---|---| | fps, median | 59.60 | 59.74 | | CPU ms a frame, median (runs) | 52.09 (51.91, 52.09, 53.72) | 53.75 (48.74, 53.90, 53.75) | | p99 frame (ms), median | 20.19 | 19.29 | | frames over 50 / 100 / 250 ms (sum) | 3 / 1 / 0 | 4 / 1 / 0 | The wait did not go away: it moved to the presenter thread, which now waits longer for the copy's fence, beside the render thread instead of in front of it. At the cap, each arm's CPU ms spread 48.7-53.9 ms by itself; one sampled run per arm showed equal user-mode CPU per thread. **Linux NVIDIA** (HumanBean): Linux (CachyOS, kernel 7.3, Wayland), RTX 3090 (NVIDIA 620.x), Ryzen 9 7900X, this PR @ ef200041, one runtime, `RX_VK_ACQUIRE_AHEAD=0` against `=1`; `dev.py ab --scene market --seconds 30`, a 2560x1440 window, uncapped, V-Sync Auto (mailbox), frame generation off, interleaved; every clean run of three A/Bs. | Market, 30 s | `=0` (main's order) | `=1` (acquire ahead) | |---|---|---| | fps, each run | 96.0, 89.7, 87.8, 98.2 | 98.1, 88.9, 90.4, 98.4, 96.4 | | fps, median | 92.9 | 96.4 (+3.8 %) | The runs overlap (87.8-98.2 against 88.9-98.4), so this is a direction, not a settled gain. These numbers were measured on main 89c3d21e. Main has moved since (this head merges ed9495bb, including #1866's recorder change, which touches the render thread's waits); they were not measured again. ## Risks What could break, with every driver now (all but `=0`, frame generation and V-Sync On): the window's image is asked for earlier. A swapchain remake (resize, full screen, HDR, V-Sync) lets an image asked for ahead go. Its fence is then kept and used again once the driver signals it, never before. Known limits (from a second review; none seen in the game): 1. The presenter's 5 s drain can't give up while the presenter is inside the ahead acquire, because it holds `presenter.mu` there. A zero-timeout `vkAcquireNextImageKHR` that blocked (a driver sending a message to a window thread that isn't pumping) would hang the render thread instead of letting it go on after 5 s. Not reached with the default: main's own acquire at the present has the same exposure with no bound at all. Hardening, if wanted: make the acquire with the mutex released and take it again after. 2. Window close with DLSS-G and `=1` (NVIDIA only, not the default): the same message-pump case through DLSS-G's close, which takes the swapchain's lock. Main's presenter already holds that lock across `vkQueuePresentKHR`; this adds a zero-timeout window of the same kind. 3. Frame generation turned off in the middle of a set: that frame's present asks for the next image ahead while the last generated frames still go out, so one image more is out for a moment (it takes the held-image path; a timeout of 0, so nothing blocks). Not run in the game. 4. The pool of fences let go is capped at 8; a 9th pending one is forgotten, as main forgets every one today. How to turn it off: `RX_VK_ACQUIRE_AHEAD=0` in `longshot_env.txt`; a revert is also enough. What a player notices after updating: nothing in saves, `longshot_options.ini` or the shader and pipeline caches (no translator file or `vk_api.h` touched); in a window, uncapped, a higher frame rate with AMD's Windows driver (+7.9 % measured) and likely with others (+3.8 % on a Linux RTX 3090); at a 60 fps cap no change in fps. ## Checklist ### Ready for review - [x] One topic, on current `main`; the title is a Conventional Commit. - [x] Tested on my own PC, in the game for a change the game runs, as Testing says. - [x] `mise run test` passes (any failure that also fails on `main` is named). - [x] Measured against `main`, or Measurements says why there is nothing to measure. - [x] No game files, build output or hand-edited generated files; `third_party/` untouched; nothing GPL-incompatible. ### When it applies - [x] A switch added or changed: it ships at the default the measurements chose, with its row in `gpu/vk/switches.def`. - [x] A check under `tests/` that reads changed source is updated, not weakened. - [x] Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. - [x] Docs updated. - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. ### Ready to merge - [ ] Everything in Still to test has run, its results in Tested. - [ ] Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers"). - [ ] Approved in review, every comment answered. - [ ] CI passes on the head; on current `main`, measured again or a comment says why the numbers still hold. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
Since #1458 the window's image is waited for on the CPU at its present. With the switch the next
present's image is asked for right after each present, with a timeout of 0 and the queue's lock let go,
so it has the next frame's work to come back in. One image out at most; its present still waits up to
kImageFreeNs for it and then holds it, as #1376's path does; a new swapchain lets it go. Not with frame
generation, the presenter thread or FIFO. Unset or 0: the same Vulkan calls in the same order as before;
a counter line every 600 presents says how long the presents waited for the image.

tests/test_present_acquire_ahead.py: the acquire, copy and end of present_image cut from the source and
run against a model presentation engine (AMD-like and NVIDIA-like), with the switch unset, 0 and 1, and
five broken variants that must fail.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
test_present_device_loss routes device loss at the ahead acquire too (ten sites); test_present_thread
reads present_image's end with the present's result kept.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The swapchain out of date at the ahead acquire (switch off: at the present's own): no image is taken from that answer,
the fence is left as it was, the next present makes the swapchain again and the presents after it copy. Broken variants
that must fail, beside the five before: the frame generation gate removed, the presenter thread's gate removed, an
out-of-date answer to the ahead acquire taken as an image, and the switch's value ignored (run with it unset, so the
check that unset keeps #1458's order is shown to see an ahead acquire).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
With the window hidden, the first present waits for the image exactly kImageFreeNs and then goes on (before, its time was
not looked at, so a wait without that bound passed). A broken variant with the bound at 30 s must fail. (The sol review
of ef6038ab..0ceaa6ab, job1118-2-r1.md, point 4.)

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Right after frame generation is turned off its last presents ahead may still hold
images of their own, so the image asked for ahead can be one more out (as the
present's own acquire is without the switch). The comment no longer states an
invariant that transition breaks.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The two admitted pairs of the A/B (control and RX_VK_ACQUIRE_AHEAD=1), one file a run,
Hyrule Field's standard test with the fixed background load.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
CONTRIBUTING.md asks that a switch cost nothing while off. The counter of the window's
image waits (two clock reads a present and a log line every 600 presents) ran for
every player; it now runs with RX_VK_ACQUIRE_AHEAD=1 only, and with the switch unset or
0 present_image makes #1458's calls and nothing else but one read of the switch's
cached value. On Linux the 100 ms acquire that finds the window not shown is now
counted too (the review's point: it returned before the note).

The test checks that unset and =0 log no counter line, with a broken variant that runs
the counter with the switch off.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
test(vk): #1458's image-free check gives its fixture the switch reader the present now calls
Some checks failed
Website / Website on Cloudflare (pull_request_target) Has been skipped
beanstalk/nvidia 0/1 pass, 0 running, 0 queued
beanstalk/linux 0/1 pass, 0 running, 0 queued
beanstalk/any 0/1 pass, 0 running, 0 queued
beanstalk/windows+amd 0/1 pass, 0 running, 0 queued
beanstalk/linux+radv 0/1 pass, 0 running, 0 queued
beanstalk/steamdeck 0/1 pass, 0 running, 0 queued
beanstalk/windows+nvidia 0/1 pass, 0 running, 0 queued
PR description / Description follows the template (pull_request_target) Failing after 6s
beanstalk/approval planning the tests
beanstalk/linux+nvidia 0/1 pass, 0 running, 0 queued
beanstalk/windows+nvidia+vram-ge6gb 0/1 pass, 0 running, 0 queued
beanstalk/intel 0/1 pass, 0 running, 0 queued
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
Guide screenshots / Guide images and local UI source review (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
Website / Website on Cloudflare (pull_request) Has been cancelled
2f24a499ca
present_image reads RX_VK_ACQUIRE_AHEAD (acquire_ahead_set) before its acquire, inside the
helpers the check cuts out; its fixture gets env_on, answering off: #1458's order, which it
checks, unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Author
Member

Tested in game: Windows 11, RX 9070 XT (AMD 26.11.1), Ryzen 7 5700X3D: this PR's renderer (at 0ceaa6ab, before the rebase; same code with the switch set) in Hyrule Field's standard test in a 1280x720 window, 2 pairs against main ef6038ab: 64.6 -> 70.0 fps, game clock 1.000-1.001 both arms, no frame over 100 ms; window resizes, F11 full screen and back, Insert, a Vulkan validation session (no swapchain/acquire/present/fence message), frame generation 2x and V-Sync On (the switch holds off and logs why), and a full-screen window covered for 40 s twice: no error line, no hang.

Tested in game: Windows 11, RX 9070 XT (AMD 26.11.1), Ryzen 7 5700X3D: this PR's renderer (at 0ceaa6ab, before the rebase; same code with the switch set) in Hyrule Field's standard test in a 1280x720 window, 2 pairs against main ef6038ab: 64.6 -> 70.0 fps, game clock 1.000-1.001 both arms, no frame over 100 ms; window resizes, F11 full screen and back, Insert, a Vulkan validation session (no swapchain/acquire/present/fence message), frame generation 2x and V-Sync On (the switch holds off and logs why), and a full-screen window covered for 40 s twice: no error line, no hang.
klimovich008 changed title from WIP: perf(vk): RX_VK_ACQUIRE_AHEAD=1 asks for the window's next image right after a present, so the render thread no longer waits for it (off by default) to perf(vk): RX_VK_ACQUIRE_AHEAD=1 asks for the window's next image right after a present, so the render thread no longer waits for it (off by default) 2026-11-18 10:34:00 +00:00
Author
Member

@Beanstalk nvidia, intel, linux, steamdeck: in Hyrule Field, in a window, with V-Sync Off and frame generation off, play 3 minutes without the switch, then 3 minutes with RX_VK_ACQUIRE_AHEAD=1 in longshot_env.txt, and post both runs' fps, your Threaded rendering setting, the switch run's vk: the window's image (600 presents) lines, and with Threaded rendering on both runs' vk: the render thread (600 presents ...) lines. Expect with the switch: acquire ahead: on in the log, the window's image waited for near 0 ms a present, fps not lower. On Linux, also cover the window with another one for 40 s, then uncover it: frames must come back. Fail on a hang, a crash, a lost device, flashing or repeated frames, lower fps, or error lines in the log.

@Beanstalk nvidia, intel, linux, steamdeck: in Hyrule Field, in a window, with V-Sync Off and frame generation off, play 3 minutes without the switch, then 3 minutes with `RX_VK_ACQUIRE_AHEAD=1` in `longshot_env.txt`, and post both runs' fps, your Threaded rendering setting, the switch run's `vk: the window's image (600 presents)` lines, and with Threaded rendering on both runs' `vk: the render thread (600 presents ...)` lines. Expect with the switch: `acquire ahead: on` in the log, the window's image waited for near 0 ms a present, fps not lower. On Linux, also cover the window with another one for 40 s, then uncover it: frames must come back. Fail on a hang, a crash, a lost device, flashing or repeated frames, lower fps, or error lines in the log.
Member

@klimovich008 only members of BigBeans can start the farm. One of them can approve this request by reacting 👍 to it or to this comment.

@klimovich008 only members of `BigBeans` can start the farm. One of them can approve this request by reacting 👍 to it or to this comment.
Contributor

@klimovich008 Yes, we'll run it on our Steam Deck OLED (SteamOS, RADV, handheld 1280×800, Threaded rendering at Auto, so off). It'll be the same build with RX_VK_ACQUIRE_AHEAD unset vs =1, interleaved, in Kokiri standing and Hyrule Field turning. We'll check engagement from acquire ahead: on and report fps, p99, frames over 50 ms and the vk: the window's image (600 presents) lines.

It's queued after the block that's running on the Deck now, so expect results later today. The Deck presents through gamescope, not a desktop window, so we'll also note the swapchain and present mode from the log, since the acquire wait may look different there.

@klimovich008 Yes, we'll run it on our Steam Deck OLED (SteamOS, RADV, handheld 1280×800, Threaded rendering at Auto, so off). It'll be the same build with `RX_VK_ACQUIRE_AHEAD` unset vs `=1`, interleaved, in Kokiri standing and Hyrule Field turning. We'll check engagement from `acquire ahead: on` and report fps, p99, frames over 50 ms and the `vk: the window's image (600 presents)` lines. It's queued after the block that's running on the Deck now, so expect results later today. The Deck presents through gamescope, not a desktop window, so we'll also note the swapchain and present mode from the log, since the acquire wait may look different there.
Member
Beanstalk test farm · an earlier run: commit 2f24a49 (the newer results are in a comment below)

Commit 2f24a49 · tier double-reviewed · approved by HumanBean, futondestroyer (👍 on klimovich008's request) · dashboard

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

On NVIDIA, Intel, Linux and Steam Deck PCs, the plan compares main and the PR in Hyrule Field for three minutes per run, with acquire-ahead off and on. It measures FPS, frame times and hitches, compares still images, and fails on lower FPS, crashes, device-loss or fatal GPU-hang logs. Intel and Steam Deck targets will wait for matching testers. The headless farm cannot cover and uncover a desktop window, verify repeated frames throughout a run, or enforce the requested per-present wait and threaded-rendering log details. No tester online now matches intel, steamdeck: those targets wait for one.

  • Where: nvidia (1-2 reports), intel (1-2 reports), linux (1-2 reports), steamdeck (1-2 reports).
  • Matrix: 1 cell, each on main and the PR: RX_VK_ACQUIRE_AHEAD 1 (PR only).
  • field-default: from a new save (settings vsync=2, fullscreen=0, frame_generation=0), then teleport to Hyrule Field, take the picture field-default to compare with main, measure field for 3 min (after 10 s warm-up); 1 run on each side.
  • field-acquire-ahead: from a new save (settings vsync=2, fullscreen=0, frame_generation=0), then teleport to Hyrule Field, take the picture field-ahead to compare with main, measure field for 3 min (after 10 s warm-up); 1 run on each side.
  • Measured: crashes, draws and frame rate, frame times, stutters and hitches, the game's log.
  • The PR fails if: it crashes; or frame rate is more than 0% below main; or a picture differs from main by more than 5%; or forbidden log lines is above 0.
  • Time: about 37 min of game runs per tester (4 game starts), plus the two builds.

Started at 2026-11-18 13:08 UTC.

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
nvidia · 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3090, 621.24.0; 2: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070, 615.71.9 2/1 1 2 none 19.8 vs 19.6 (+1%) — fail ⚠ outlier
intel 0/1 — — — queued
linux · 1: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070, 615.71.9; 2: linux+other unknown, unknown 2/1 1 2 none 18.8 vs 19.3 (−3%) — pass
steamdeck · 1: linux+amd+radv+igpu+handheld AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99 1/1 1 none 67.4 vs 56.8 (+19%) — fail

Measurements · nvidia

Verdict: fail on nvidia (2/1 report): field-acquire-ahead field.fps_mean.min_delta_pct (+0.0%) failed.

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3090, 621.24.0 AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070, 615.71.9 AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM
Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: main @ 430eef4 After: this PR @ 2f24a49
field-default · field · frame rate 60.0 60.0 (+0%)
field-default · forbidden log lines 0.0 0.0
field-default · field · frame time (p99) (ms) 19.6 19.8 (+1%)
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 60.0 60.0 (+0%)
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 19.6 22.1 (+13%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 1 not in main the PR's default field-acquire-ahead, main without it → the PR with 1: 60.0 → 60.0 (+0%) no clear effect
Markdown for the PR description
## Measurements

**Verdict:** fail on nvidia (2/1 report): `field-acquire-ahead field.fps_mean.min_delta_pct (+0.0%)` failed.

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`  
Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: main @ 430eef4 | After: this PR @ 2f24a49 |
|---|---|---|
| field-default · field · frame rate | 60.0 | 60.0 (+0%) |
| field-default · forbidden log lines | 0.0 | 0.0 |
| field-default · field · frame time (p99) (ms) | 19.6 | 19.8 (+1%) |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 60.0 | 60.0 (+0%) |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 19.6 | 22.1 (+13%) |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 60.0 → 60.0 (+0%) | no clear effect |

Measurements · linux

Verdict: pass on linux (2/1 report): no rule failed and no PR run crashed.

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070, 615.71.9 AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM; 2: linux+other unknown, unknown AMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAM
Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: main @ 430eef4 After: this PR @ 2f24a49
field-default · field · frame rate 60.0 60.0 (+0%)
field-default · forbidden log lines 0.0 0.0
field-default · field · frame time (p99) (ms) 19.3 18.8 (−3%)
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 60.0 60.0 (+0%)
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 18.9 18.9 (+0%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 1 not in main the PR's default field-acquire-ahead, main without it → the PR with 1: 60.0 → 60.0 (+0%) no clear effect
Markdown for the PR description
## Measurements

**Verdict:** pass on linux (2/1 report): no rule failed and no PR run crashed.

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`; 2: linux+other `unknown, unknown` `AMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAM`  
Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: main @ 430eef4 | After: this PR @ 2f24a49 |
|---|---|---|
| field-default · field · frame rate | 60.0 | 60.0 (+0%) |
| field-default · forbidden log lines | 0.0 | 0.0 |
| field-default · field · frame time (p99) (ms) | 19.3 | 18.8 (−3%) |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 60.0 | 60.0 (+0%) |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 18.9 | 18.9 (+0%) |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 60.0 → 60.0 (+0%) | no clear effect |

Measurements · steamdeck

Verdict: fail on steamdeck (1/1 report): field-default field.fps_mean.min_delta_pct (-1.9%); field-acquire-ahead field.fps_mean.min_delta_pct (-2.4%) failed.

Hardware: 1: linux+amd+radv+igpu+handheld AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99 AMD Custom APU 0405, 16 GB RAM
Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 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)

Before: main @ 430eef4 After: this PR @ 2f24a49
field-default · field · frame rate 20.5 20.2 (−2%)
field-default · forbidden log lines 0.0 0.0
field-default · field · frame time (p99) (ms) 56.8 67.4 (+19%)
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 20.2 19.8 (−2%)
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0
field-acquire-ahead · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 70.5 70.1 (−1%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 1 not in main the PR's default field-acquire-ahead, main without it → the PR with 1: 20.2 → 19.8 (−2%) doesn't help
Markdown for the PR description
## Measurements

**Verdict:** fail on steamdeck (1/1 report): `field-default field.fps_mean.min_delta_pct (-1.9%)`; `field-acquire-ahead field.fps_mean.min_delta_pct (-2.4%)` failed.

Hardware: 1: linux+amd+radv+igpu+handheld `AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99` `AMD Custom APU 0405, 16 GB RAM`  
Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 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)

| | Before: main @ 430eef4 | After: this PR @ 2f24a49 |
|---|---|---|
| field-default · field · frame rate | 20.5 | 20.2 (−2%) |
| field-default · forbidden log lines | 0.0 | 0.0 |
| field-default · field · frame time (p99) (ms) | 56.8 | 67.4 (+19%) |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 20.2 | 19.8 (−2%) |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 70.5 | 70.1 (−1%) |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 20.2 → 19.8 (−2%) | doesn't help |
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>2f24a49</code> (the newer results are in a comment below)</summary> Commit `2f24a49` · tier **double-reviewed** · approved by HumanBean, futondestroyer (👍 on klimovich008's request) · [dashboard](https://beanstalk.magicbean.dev/prs/1574) **What will be tested** · AI plan (`gpt-6.1-terra`) On NVIDIA, Intel, Linux and Steam Deck PCs, the plan compares main and the PR in Hyrule Field for three minutes per run, with acquire-ahead off and on. It measures FPS, frame times and hitches, compares still images, and fails on lower FPS, crashes, device-loss or fatal GPU-hang logs. Intel and Steam Deck targets will wait for matching testers. The headless farm cannot cover and uncover a desktop window, verify repeated frames throughout a run, or enforce the requested per-present wait and threaded-rendering log details. No tester online now matches intel, steamdeck: those targets wait for one. - **Where:** nvidia (1-2 reports), intel (1-2 reports), linux (1-2 reports), steamdeck (1-2 reports). - **Matrix:** 1 cell, each on main and the PR: RX_VK_ACQUIRE_AHEAD `1` (PR only). - **field-default:** from a new save (settings vsync=2, fullscreen=0, frame_generation=0), then teleport to Hyrule Field, take the picture field-default to compare with main, measure field for 3 min (after 10 s warm-up); 1 run on each side. - **field-acquire-ahead:** from a new save (settings vsync=2, fullscreen=0, frame_generation=0), then teleport to Hyrule Field, take the picture field-ahead to compare with main, measure field for 3 min (after 10 s warm-up); 1 run on each side. - **Measured:** crashes, draws and frame rate, frame times, stutters and hitches, the game's log. - **The PR fails if:** it crashes; or frame rate is more than 0% below main; or a picture differs from main by more than 5%; or forbidden log lines is above 0. - **Time:** about 37 min of game runs per tester (4 game starts), plus the two builds. Started at 2026-11-18 13:08 UTC. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | nvidia · 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_8db0f25f3bc6c740) [2](https://beanstalk.magicbean.dev/reports/rp_b854f1dd81aaa143) | none | 19.8 vs 19.6 (+1%) | — | fail ⚠ outlier | | intel | 0/1 | — | — | — | queued | | linux · 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9`; 2: linux+other `unknown, unknown` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_bb166040791326c5) [2](https://beanstalk.magicbean.dev/reports/rp_903bc676955bce4a) | none | 18.8 vs 19.3 (−3%) | — | pass | | steamdeck · 1: linux+amd+radv+igpu+handheld `AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99` | 1/1 [1](https://beanstalk.magicbean.dev/reports/rp_2c4fd85bfc92f26d) | none | 67.4 vs 56.8 (+19%) | — | fail | #### Measurements · nvidia **Verdict:** fail on nvidia (2/1 report): `field-acquire-ahead field.fps_mean.min_delta_pct (+0.0%)` failed. Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM` Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | field-default · field · frame rate | 60.0 | 60.0 (+0%) | | field-default · forbidden log lines | 0.0 | 0.0 | | field-default · field · frame time (p99) (ms) | 19.6 | 19.8 (+1%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 60.0 | 60.0 (+0%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 19.6 | 22.1 (+13%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 60.0 → 60.0 (+0%) | no clear effect | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** fail on nvidia (2/1 report): `field-acquire-ahead field.fps_mean.min_delta_pct (+0.0%)` failed. Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM` Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | field-default · field · frame rate | 60.0 | 60.0 (+0%) | | field-default · forbidden log lines | 0.0 | 0.0 | | field-default · field · frame time (p99) (ms) | 19.6 | 19.8 (+1%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 60.0 | 60.0 (+0%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 19.6 | 22.1 (+13%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 60.0 → 60.0 (+0%) | no clear effect | ``` </details> #### Measurements · linux **Verdict:** pass on linux (2/1 report): no rule failed and no PR run crashed. Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`; 2: linux+other `unknown, unknown` `AMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAM` Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | field-default · field · frame rate | 60.0 | 60.0 (+0%) | | field-default · forbidden log lines | 0.0 | 0.0 | | field-default · field · frame time (p99) (ms) | 19.3 | 18.8 (−3%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 60.0 | 60.0 (+0%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 18.9 | 18.9 (+0%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 60.0 → 60.0 (+0%) | no clear effect | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** pass on linux (2/1 report): no rule failed and no PR run crashed. Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`; 2: linux+other `unknown, unknown` `AMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAM` Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | field-default · field · frame rate | 60.0 | 60.0 (+0%) | | field-default · forbidden log lines | 0.0 | 0.0 | | field-default · field · frame time (p99) (ms) | 19.3 | 18.8 (−3%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 60.0 | 60.0 (+0%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 18.9 | 18.9 (+0%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 60.0 → 60.0 (+0%) | no clear effect | ``` </details> #### Measurements · steamdeck **Verdict:** fail on steamdeck (1/1 report): `field-default field.fps_mean.min_delta_pct (-1.9%)`; `field-acquire-ahead field.fps_mean.min_delta_pct (-2.4%)` failed. Hardware: 1: linux+amd+radv+igpu+handheld `AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99` `AMD Custom APU 0405, 16 GB RAM` Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 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) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | field-default · field · frame rate | 20.5 | 20.2 (−2%) | | field-default · forbidden log lines | 0.0 | 0.0 | | field-default · field · frame time (p99) (ms) | 56.8 | 67.4 (+19%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 20.2 | 19.8 (−2%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 70.5 | 70.1 (−1%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 20.2 → 19.8 (−2%) | doesn't help | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** fail on steamdeck (1/1 report): `field-default field.fps_mean.min_delta_pct (-1.9%)`; `field-acquire-ahead field.fps_mean.min_delta_pct (-2.4%)` failed. Hardware: 1: linux+amd+radv+igpu+handheld `AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99` `AMD Custom APU 0405, 16 GB RAM` Scene: field-default, from a new save (vsync=2, fullscreen=0, frame_generation=0); field-acquire-ahead, from a new save (vsync=2, fullscreen=0, 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); field-default: 1 game start a side, field 180 s after 10 s warm-up; field-acquire-ahead: 1 game start a side, field 180 s after 10 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) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | field-default · field · frame rate | 20.5 | 20.2 (−2%) | | field-default · forbidden log lines | 0.0 | 0.0 | | field-default · field · frame time (p99) (ms) | 56.8 | 67.4 (+19%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 20.2 | 19.8 (−2%) | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-acquire-ahead · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 70.5 | 70.1 (−1%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | not in main | the PR's default | field-acquire-ahead, main without it → the PR with 1: 20.2 → 19.8 (−2%) | doesn't help | ``` </details> </details>
Contributor

@klimovich008 the Steam Deck run you asked for.

Setup: Steam Deck OLED (SteamOS, RADV), built-in 1280×800 display through gamescope's mailbox swapchain, Minimum preset with a fixed 50% render, Threaded rendering at Auto (off). The same build of this PR on main 430eef4f, with RX_VK_ACQUIRE_AHEAD unset (U) vs =1 (A), three interleaved rounds.

  • Engagement: ahead acquisition actually succeeded, and the images were reported ready at their next present. Every A counter line ending inside a measured window read 600 free, 0 waited, 0 dropped, 0 none given.

  • Kokiri standing, three pairs:

    • fps: A was +0.038, +0.171 and +0.071 fps; arm medians 25.42 → 25.53 (about +0.4%, median paired +0.28%);
    • p95: lower by 0.050, 0.559 and 0.791 ms;
    • frames over 50 ms: lower in 2 pairs, tied in 1;
    • p99 and the longest frame: mixed.

    That's a small positive directional signal, not an established practical or general win.

  • Hyrule Field: no admitted measured pair.

  • What this can't show:

    • The U arm's image wait isn't recorded, so there's no before/after wait comparison.
    • Displayed-frame correctness wasn't checked, since the screenshots weren't inspected.
    • An observer effect from our /proc memory sampler is unresolved.
  • No GPU fault or reset in any run.

No default recommendation from this.

@klimovich008 the Steam Deck run you asked for. **Setup:** Steam Deck OLED (SteamOS, RADV), built-in 1280×800 display through gamescope's mailbox swapchain, Minimum preset with a fixed 50% render, Threaded rendering at Auto (off). The same build of this PR on main `430eef4f`, with `RX_VK_ACQUIRE_AHEAD` unset (U) vs `=1` (A), three interleaved rounds. - **Engagement:** ahead acquisition actually succeeded, and the images were reported ready at their next present. Every A counter line ending inside a measured window read 600 free, 0 waited, 0 dropped, 0 none given. - **Kokiri standing, three pairs:** - fps: A was +0.038, +0.171 and +0.071 fps; arm medians 25.42 → 25.53 (about +0.4%, median paired +0.28%); - p95: lower by 0.050, 0.559 and 0.791 ms; - frames over 50 ms: lower in 2 pairs, tied in 1; - p99 and the longest frame: mixed. That's a small positive directional signal, not an established practical or general win. - **Hyrule Field:** no admitted measured pair. - **What this can't show:** - The U arm's image wait isn't recorded, so there's no before/after wait comparison. - Displayed-frame correctness wasn't checked, since the screenshots weren't inspected. - An observer effect from our /proc memory sampler is unresolved. - **No GPU fault or reset** in any run. No default recommendation from this.
Author
Member

@dukenheimer, thank you: that is the case I could not run here (gamescope's mailbox swapchain, threaded rendering off). How I read it:

  • It engages on the Deck: 600 of 600 images free at their present, none waited or dropped.
  • Kokiri: +0.4 % fps with lower p95 in all three pairs, which is within what three pairs can call. So no gain is claimed for the Deck, and it does no harm there. No GPU faults.

I'll add it to Testing. The farm's NVIDIA cell shows p99 19.6 -> 22.1 ms with the switch set (its fps rule fails at +0.0 % because both sides sit at the 60 cap). I'm checking whether the switch was engaged in those runs at all, and I'll report here.

@dukenheimer, thank you: that is the case I could not run here (gamescope's mailbox swapchain, threaded rendering off). How I read it: - **It engages on the Deck:** 600 of 600 images free at their present, none waited or dropped. - **Kokiri:** +0.4 % fps with lower p95 in all three pairs, which is within what three pairs can call. So no gain is claimed for the Deck, and it does no harm there. No GPU faults. I'll add it to Testing. The farm's NVIDIA cell shows p99 19.6 -> 22.1 ms with the switch set (its fps rule fails at +0.0 % because both sides sit at the 60 cap). I'm checking whether the switch was engaged in those runs at all, and I'll report here.
Author
Member

Following up on my comment above about the farm's NVIDIA cell. I went through the four reports.

Did the switch engage? The settings allowed it, but the reports don't show it.

  • The farm ran vsync=2, which is V-Sync Off (the immediate mode), with frame generation off. Threaded rendering was on. The switch holds off only for FIFO (V-Sync On), frame generation and the presenter thread, so from the source it should have engaged wherever RX_VK_ACQUIRE_AHEAD=1 reached the game.
  • The reports publish only the end of one PR-side log. With the switch set, vk: the window's image (600 presents) is printed every 600 presents whether or not it engages, and none of the published log ends has that line. So the reports can't show whether the switch was on in the measured runs, either way.

Is the p99 rise real? It comes from one run on one PC. That run neither proves nor rules out an effect.

  • The cell's 19.6 → 22.1 ms is the median of two reports:
  • The 4070's second report (the Linux cell, rp_bb166040791326c5) has 18.86 → 18.91 ms, with stutters 7 → 0.
  • Each report is one 180 s run a side.
  • The farm marks the 3090 report as disagreeing with its peers. Without the switch, that report's PR run also had the larger longest-frame change (27.2 → 37.0 ms).
  • So the rise is the 3090's single run, and I can't say from it whether the switch caused it. Settling it needs repeat runs on an NVIDIA Windows PC with the switch's log lines visible.
  • The cell's "fail" is the fps rule at the 60 cap: 60.00 → 59.99.

Testing now has the farm's three reports with their p99, stutters and fps, and the Arch Linux report that timed out before play. It also has the Steam Deck run (thank you @dukenheimer): engaged, Kokiri about +0.4 % fps, no GPU faults, Hyrule with no admitted pair. Must be tested lists the NVIDIA repeat as the open question. No code changed (head 2f24a499).

Following up on [my comment above](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1574#issuecomment-49627) about the farm's NVIDIA cell. I went through the four reports. **Did the switch engage?** The settings allowed it, but the reports don't show it. - The farm ran `vsync=2`, which is V-Sync **Off** (the immediate mode), with frame generation off. Threaded rendering was on. The switch holds off only for FIFO (V-Sync On), frame generation and the presenter thread, so from the source it should have engaged wherever `RX_VK_ACQUIRE_AHEAD=1` reached the game. - The reports publish only the end of one PR-side log. With the switch set, `vk: the window's image (600 presents)` is printed every 600 presents whether or not it engages, and none of the published log ends has that line. So the reports can't show whether the switch was on in the measured runs, either way. **Is the p99 rise real?** It comes from one run on one PC. That run neither proves nor rules out an effect. - The cell's 19.6 → 22.1 ms is the median of two reports: - [the Windows RTX 3090](https://beanstalk.magicbean.dev/reports/rp_8db0f25f3bc6c740): 20.54 → 25.33 ms, stutters 1 → 13. - [the Linux RTX 4070](https://beanstalk.magicbean.dev/reports/rp_b854f1dd81aaa143): 18.59 → 18.92 ms. - The 4070's second report (the Linux cell, [rp_bb166040791326c5](https://beanstalk.magicbean.dev/reports/rp_bb166040791326c5)) has 18.86 → 18.91 ms, with stutters 7 → 0. - Each report is one 180 s run a side. - The farm marks the 3090 report as disagreeing with its peers. Without the switch, that report's PR run also had the larger longest-frame change (27.2 → 37.0 ms). - So the rise is the 3090's single run, and I can't say from it whether the switch caused it. Settling it needs repeat runs on an NVIDIA Windows PC with the switch's log lines visible. - The cell's "fail" is the fps rule at the 60 cap: 60.00 → 59.99. **Testing** now has the farm's three reports with their p99, stutters and fps, and the Arch Linux report that timed out before play. It also has the Steam Deck run (thank you @dukenheimer): engaged, Kokiri about +0.4 % fps, no GPU faults, Hyrule with no admitted pair. Must be tested lists the NVIDIA repeat as the open question. No code changed (head `2f24a499`).
Owner

@Beanstalk

@Beanstalk
Member

@HumanBean 2f24a49 is already running: see the dashboard.

@HumanBean `2f24a49` is already running: see the [dashboard](https://beanstalk.magicbean.dev/prs/1574).
HumanBean requested changes 2026-11-19 06:56:12 +00:00
Dismissed
HumanBean left a comment

Thanks, this is careful work. The mechanism is sound, the gates are conservative, and I found nothing wrong in the code. The thing to change is the default.

Blocking

The switch's default (gpu/vk/switches.def:232, gpu/vk/vk_replay.cpp:5794). We want switches to have a default that's right for everyone and that the renderer picks from the hardware. They're for A/B runs and as an off switch, not for players to find. As written, the one setup where this was measured to help, AMD's Windows driver in a window (+8.4 % fps, the render thread's presents 4.1 to 0.75 ms), stays off for every player who has it. Nobody will set RX_VK_ACQUIRE_AHEAD=1, so once merged it is dead code until someone comes back to flip it. The Test Farm runs that the description gave as the condition for that are now in, and they show no harm anywhere they reached:

  • Linux RTX 4070: p99 flat in two reports.
  • Steam Deck: neutral, with the switch engaged 600 of 600.
  • The RTX 3090's p99 rise is one run, with no engagement line.

What would fix it: make the default automatic, at least on dev.driver_id == VK_DRIVER_ID_AMD_PROPRIETARY on _WIN32. That is exactly the "image back at once, wait in the fence" case you measured. Keep =0 as the off switch and =1 to force it on elsewhere for A/B, and log which way the default went at the first present. Every other driver keeps #1458's order until there's evidence for it. If you'd rather keep it off everywhere, the description needs to say exactly what stands between it and default-on: which run, on what hardware, and what result flips it.

Suggestions

  • If it becomes default-on for AMD on Windows, keep the vk: the window's image (600 presents) counter for an explicit =1 only. That way players' logs don't get a new line every 600 presents.
  • Overlap: #1702 (WIP) turns the presenter thread on by default with NVIDIA's driver. This switch holds off whenever the presenter thread is on, so if that lands, acquire-ahead can never engage on NVIDIA. Worth deciding which of the two NVIDIA should get before the NVIDIA Windows repeat runs are spent on this one.

Measurements: on the RX 9070 XT, both switch-on runs (69.84, 70.14 fps) are above both control runs (64.29, 64.89). The gap of about 5.4 fps is roughly ten times the spread within each arm, and the drop in present time explains it, so the gain looks real on that PC. It is only 2 pairs, though, in an uncapped 1280x720 window with a background GPU load, so it's a lab setup. The farm can't confirm or refute a gain: every farm cell sat at the 60 fps cap. The Deck cell also shows the farm's own noise: without the switch, the PR moved fps by -1.9 % and p99 by +19 %, which is larger than any delta with the switch on there. Still missing:

  • Uncapped NVIDIA Windows repeats with the engagement line visible (the open p99 question).
  • Intel.
  • RADV on a desktop (X11 and Wayland), including the covered window.
  • AMD Windows at the default 60 cap, to show what a player there actually gains.
Thanks, this is careful work. The mechanism is sound, the gates are conservative, and I found nothing wrong in the code. The thing to change is the default. ### Blocking **The switch's default (`gpu/vk/switches.def:232`, `gpu/vk/vk_replay.cpp:5794`).** We want switches to have a default that's right for everyone and that the renderer picks from the hardware. They're for A/B runs and as an off switch, not for players to find. As written, the one setup where this was measured to help, AMD's Windows driver in a window (+8.4 % fps, the render thread's presents 4.1 to 0.75 ms), stays off for every player who has it. Nobody will set `RX_VK_ACQUIRE_AHEAD=1`, so once merged it is dead code until someone comes back to flip it. The Test Farm runs that the description gave as the condition for that are now in, and they show no harm anywhere they reached: - Linux RTX 4070: p99 flat in two reports. - Steam Deck: neutral, with the switch engaged 600 of 600. - The RTX 3090's p99 rise is one run, with no engagement line. What would fix it: make the default automatic, at least on `dev.driver_id == VK_DRIVER_ID_AMD_PROPRIETARY` on `_WIN32`. That is exactly the "image back at once, wait in the fence" case you measured. Keep `=0` as the off switch and `=1` to force it on elsewhere for A/B, and log which way the default went at the first present. Every other driver keeps [#1458](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1458)'s order until there's evidence for it. If you'd rather keep it off everywhere, the description needs to say exactly what stands between it and default-on: which run, on what hardware, and what result flips it. ### Suggestions - If it becomes default-on for AMD on Windows, keep the `vk: the window's image (600 presents)` counter for an explicit `=1` only. That way players' logs don't get a new line every 600 presents. - Overlap: https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1702 (WIP) turns the presenter thread on by default with NVIDIA's driver. This switch holds off whenever the presenter thread is on, so if that lands, acquire-ahead can never engage on NVIDIA. Worth deciding which of the two NVIDIA should get before the NVIDIA Windows repeat runs are spent on this one. Measurements: on the RX 9070 XT, both switch-on runs (69.84, 70.14 fps) are above both control runs (64.29, 64.89). The gap of about 5.4 fps is roughly ten times the spread within each arm, and the drop in present time explains it, so the gain looks real on that PC. It is only 2 pairs, though, in an uncapped 1280x720 window with a background GPU load, so it's a lab setup. The farm can't confirm or refute a gain: every farm cell sat at the 60 fps cap. The Deck cell also shows the farm's own noise: without the switch, the PR moved fps by -1.9 % and p99 by +19 %, which is larger than any delta with the switch on there. Still missing: - Uncapped NVIDIA Windows repeats with the engagement line visible (the open p99 question). - Intel. - RADV on a desktop (X11 and Wayland), including the covered window. - AMD Windows at the default 60 cap, to show what a player there actually gains.
@ -229,6 +229,7 @@ SW(RX_NVN_WATCH_ALL, diag, bool, "off: the Resource Memory thread's writes are n
SW(RX_NVN_WATCH_TEX, diag, string, "off", "Page-watches the storage of textures of the given <w>x<h> size and logs who writes it, with call stacks.")
SW(RX_NVN_WATCH_TEXELS_SRC, diag, string, "off", "Page-watches the source data of WriteTexels uploads into textures of the given <w>x<h> size and logs later writes to it.")
SW(RX_VK_9E5_SWAP, diag, bool, "off", "Swaps R and B in sampled views of RGB9E5 textures, for diagnosing a colour-order fault.")
SW(RX_VK_ACQUIRE_AHEAD, attempt, bool, "off on every PC: the window's image asked for at its own present (#1458's order)", "=1 asks for the next present's image right after each present (no wait there), so its fence is signaled while the next frame is made; not with frame generation, the presenter thread or FIFO.")
Owner

If the default becomes automatic (on for AMD's proprietary driver on Windows), this row's default text should say so, e.g. "on with AMD's Windows driver, off elsewhere (#1458's order)", and =0/=1 as the override.

If the default becomes automatic (on for AMD's proprietary driver on Windows), this row's default text should say so, e.g. "on with AMD's Windows driver, off elsewhere (#1458's order)", and `=0`/`=1` as the override.
Owner

@Beanstalk plan Judge RX_VK_ACQUIRE_AHEAD=1 against =0 in the PR's own build with pass.compare on frame times and fps, alongside the usual comparison with main. If the PR logs the per-present wait or acquire timings as numbers, read them with a log_value probe and compare them too, and use run_frametime_max_ms / run_hitch_count to catch hitches outside the measure steps.

@Beanstalk plan Judge RX_VK_ACQUIRE_AHEAD=1 against =0 in the PR's own build with [[pass.compare]] on frame times and fps, alongside the usual comparison with main. If the PR logs the per-present wait or acquire timings as numbers, read them with a log_value probe and compare them too, and use run_frametime_max_ms / run_hitch_count to catch hitches outside the measure steps.
Member
Beanstalk test farm · an earlier run: commit 2f24a49, run 2 (the newer results are in a comment below)

Commit 2f24a49 · tier double-reviewed · approved by HumanBean, futondestroyer (👍 on klimovich008's request) · dashboard

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

The plan compares acquire-ahead on and off in the PR build and against main in Hyrule Field, including a V-Sync toggle that exercises the FIFO fallback. It takes about 22 minutes per tester and measures frame times, FPS, run-wide hitches, screenshots and the logged per-present image wait. Crashes, visual differences, or significant performance regressions fail the plan. The image-wait timing is reported but cannot be compared against switch-off because that mode does not log it.

  • Where: any (any PC, 1-2 reports).
  • Matrix: 2 cells, each on main and the PR: RX_VK_ACQUIRE_AHEAD 0 or 1 (PR only).
  • field-present: from the repository's save kokiri-start (settings vsync=2, fullscreen=0, frame_generation=0), then teleport to Hyrule Field, measure vsync-off for 30 s (after 5 s warm-up), take the picture field-off to compare with main, set vsync to 1, measure vsync-on for 20 s (after 5 s warm-up), set vsync to 2, measure vsync-restored for 20 s (after 5 s warm-up), take the picture field-restored to compare with main; 1 run on each side for each of 2 cells (2 game starts a run).
  • Measured: crashes, frame times, stutters and hitches, draws and frame rate, numbers from the game's log, the game's log.
  • The PR fails if: it crashes; or the PR's frame time (p99) with RX_VK_ACQUIRE_AHEAD=1 is more than 20% above RX_VK_ACQUIRE_AHEAD=0; or the PR's frame rate with RX_VK_ACQUIRE_AHEAD=1 is more than 10% below RX_VK_ACQUIRE_AHEAD=0; or the PR's worst frame time in the whole run with RX_VK_ACQUIRE_AHEAD=1 is more than 50% above RX_VK_ACQUIRE_AHEAD=0; or the PR's hitches over 50 ms in the whole run with RX_VK_ACQUIRE_AHEAD=1 is more than 50% above RX_VK_ACQUIRE_AHEAD=0; or frame rate is more than 10% below main; or a picture differs from main by more than 5%; or hitches over 50 ms in the whole run is more than 50% above main; or frame time (p99) is more than 20% above main; or forbidden log lines is above 0; or worst frame time in the whole run is more than 50% above main.
  • Time: about 26 min of game runs per tester (4 game starts), plus the two builds.

Done (started 07:57 UTC, last report 08:55 UTC). Run 2: re-planned by HumanBean. 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 3050 Ti Laptop GPU, 621.24.0; 2: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070, 615.71.9 2/1 1 2 none 18.5 vs 18.7 (−1%) — fail
Scenario · matrix cell Target Frame p99 (ms) vs main Result
field-present · RX_VK_ACQUIRE_AHEAD=0 (PR only) any — pass
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) any 18.5 vs 18.7 (−1%) fail

Measurements · any

Verdict: fail on any (2/1 report): field-present run_hitch_count: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEA (+300.0%) failed.

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0 AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070, 615.71.9 AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM
Scene: field-present, from the repository's save kokiri-start (vsync=2, fullscreen=0, 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); field-present: 1 game start a side, vsync-off 30 s after 5 s warm-up, vsync-on 20 s after 5 s warm-up, vsync-restored 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: main @ 430eef4 After: this PR @ 2f24a49
field-present · RX_VK_ACQUIRE_AHEAD=0 (PR only) · hitches over 50 ms in the whole run 6.0 3.0 (−50%)
field-present · RX_VK_ACQUIRE_AHEAD=0 (PR only) · forbidden log lines 0.0 0.0
field-present · RX_VK_ACQUIRE_AHEAD=0 (PR only) · worst frame time in the whole run (ms) 704.9 681.7 (−3%)
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · vsync-on · frame rate 60.0 60.0 (−0%)
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · vsync-off · frame rate 59.9 60.0 (+0%)
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · vsync-restored · frame rate 60.0 60.0 (+0%)
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · hitches over 50 ms in the whole run 10.0 12.0 (+20%)
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · vsync-on · frame time (p99) (ms) 18.7 18.5 (−1%)
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · vsync-off · frame time (p99) (ms) 18.8 18.7 (−1%)
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · vsync-restored · frame time (p99) (ms) 18.4 18.6 (+1%)
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0
field-present · RX_VK_ACQUIRE_AHEAD=1 (PR only) · worst frame time in the whole run (ms) 420.6 417.7 (−1%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 not in main the PR's default field-present, main without it → the PR with 0: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** fail on any (2/1 report): `field-present run_hitch_count: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEA (+300.0%)` failed.

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`  
Scene: field-present, from the repository's save kokiri-start (vsync=2, fullscreen=0, 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); field-present: 1 game start a side, vsync-off 30 s after 5 s warm-up, vsync-on 20 s after 5 s warm-up, vsync-restored 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: main @ 430eef4 | After: this PR @ 2f24a49 |
|---|---|---|
| field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · hitches over 50 ms in the whole run | 6.0 | 3.0 (−50%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · worst frame time in the whole run (ms) | 704.9 | 681.7 (−3%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-on · frame rate | 60.0 | 60.0 (−0%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-off · frame rate | 59.9 | 60.0 (+0%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-restored · frame rate | 60.0 | 60.0 (+0%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · hitches over 50 ms in the whole run | 10.0 | 12.0 (+20%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-on · frame time (p99) (ms) | 18.7 | 18.5 (−1%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-off · frame time (p99) (ms) | 18.8 | 18.7 (−1%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-restored · frame time (p99) (ms) | 18.4 | 18.6 (+1%) |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · worst frame time in the whole run (ms) | 420.6 | 417.7 (−1%) |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | field-present, main without it → the PR with 0: not measured | untested |
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>2f24a49</code>, run 2 (the newer results are in a comment below)</summary> Commit `2f24a49` · tier **double-reviewed** · approved by HumanBean, futondestroyer (👍 on klimovich008's request) · [dashboard](https://beanstalk.magicbean.dev/prs/1574) **What will be tested** · AI plan (`gpt-6.1-terra`) The plan compares acquire-ahead on and off in the PR build and against main in Hyrule Field, including a V-Sync toggle that exercises the FIFO fallback. It takes about 22 minutes per tester and measures frame times, FPS, run-wide hitches, screenshots and the logged per-present image wait. Crashes, visual differences, or significant performance regressions fail the plan. The image-wait timing is reported but cannot be compared against switch-off because that mode does not log it. - **Where:** any (any PC, 1-2 reports). - **Matrix:** 2 cells, each on main and the PR: RX_VK_ACQUIRE_AHEAD `0` or `1` (PR only). - **field-present:** from the repository's save `kokiri-start` (settings vsync=2, fullscreen=0, frame_generation=0), then teleport to Hyrule Field, measure vsync-off for 30 s (after 5 s warm-up), take the picture field-off to compare with main, set vsync to 1, measure vsync-on for 20 s (after 5 s warm-up), set vsync to 2, measure vsync-restored for 20 s (after 5 s warm-up), take the picture field-restored to compare with main; 1 run on each side for each of 2 cells (2 game starts a run). - **Measured:** crashes, frame times, stutters and hitches, draws and frame rate, numbers from the game's log, the game's log. - **The PR fails if:** it crashes; or the PR's frame time (p99) with RX_VK_ACQUIRE_AHEAD=1 is more than 20% above RX_VK_ACQUIRE_AHEAD=0; or the PR's frame rate with RX_VK_ACQUIRE_AHEAD=1 is more than 10% below RX_VK_ACQUIRE_AHEAD=0; or the PR's worst frame time in the whole run with RX_VK_ACQUIRE_AHEAD=1 is more than 50% above RX_VK_ACQUIRE_AHEAD=0; or the PR's hitches over 50 ms in the whole run with RX_VK_ACQUIRE_AHEAD=1 is more than 50% above RX_VK_ACQUIRE_AHEAD=0; or frame rate is more than 10% below main; or a picture differs from main by more than 5%; or hitches over 50 ms in the whole run is more than 50% above main; or frame time (p99) is more than 20% above main; or forbidden log lines is above 0; or worst frame time in the whole run is more than 50% above main. - **Time:** about 26 min of game runs per tester (4 game starts), plus the two builds. Done (started 07:57 UTC, last report 08:55 UTC). Run 2: re-planned by HumanBean. 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 3050 Ti Laptop GPU, 621.24.0`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_8ac79f77f159aae4) [2](https://beanstalk.magicbean.dev/reports/rp_9dcffc18a61093bf) | none | 18.5 vs 18.7 (−1%) | — | fail | | Scenario · matrix cell | Target | Frame p99 (ms) vs main | Result | | --- | --- | --- | --- | | field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | any | — | pass | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | any | 18.5 vs 18.7 (−1%) | fail | #### Measurements · any **Verdict:** fail on any (2/1 report): `field-present run_hitch_count: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEA (+300.0%)` failed. Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM` Scene: field-present, from the repository's save kokiri-start (vsync=2, fullscreen=0, 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); field-present: 1 game start a side, vsync-off 30 s after 5 s warm-up, vsync-on 20 s after 5 s warm-up, vsync-restored 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · hitches over 50 ms in the whole run | 6.0 | 3.0 (−50%) | | field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · worst frame time in the whole run (ms) | 704.9 | 681.7 (−3%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-on · frame rate | 60.0 | 60.0 (−0%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-off · frame rate | 59.9 | 60.0 (+0%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-restored · frame rate | 60.0 | 60.0 (+0%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · hitches over 50 ms in the whole run | 10.0 | 12.0 (+20%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-on · frame time (p99) (ms) | 18.7 | 18.5 (−1%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-off · frame time (p99) (ms) | 18.8 | 18.7 (−1%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-restored · frame time (p99) (ms) | 18.4 | 18.6 (+1%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · worst frame time in the whole run (ms) | 420.6 | 417.7 (−1%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | field-present, main without it → the PR with 0: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** fail on any (2/1 report): `field-present run_hitch_count: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEA (+300.0%)` failed. Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM` Scene: field-present, from the repository's save kokiri-start (vsync=2, fullscreen=0, 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); field-present: 1 game start a side, vsync-off 30 s after 5 s warm-up, vsync-on 20 s after 5 s warm-up, vsync-restored 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · hitches over 50 ms in the whole run | 6.0 | 3.0 (−50%) | | field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-present · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · worst frame time in the whole run (ms) | 704.9 | 681.7 (−3%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-on · frame rate | 60.0 | 60.0 (−0%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-off · frame rate | 59.9 | 60.0 (+0%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-restored · frame rate | 60.0 | 60.0 (+0%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · hitches over 50 ms in the whole run | 10.0 | 12.0 (+20%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-on · frame time (p99) (ms) | 18.7 | 18.5 (−1%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-off · frame time (p99) (ms) | 18.8 | 18.7 (−1%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · vsync-restored · frame time (p99) (ms) | 18.4 | 18.6 (+1%) | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-present · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · worst frame time in the whole run (ms) | 420.6 | 417.7 (−1%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | field-present, main without it → the PR with 0: not measured | untested | ``` </details> </details>
Author
Member

@Beanstalk plan Uncapped, so a gain can show. Every earlier cell sat at the 60 fps cap, so no fps difference could appear. Set frame_rate_cap = 6 (Uncapped), vsync = 2 (Off) and frame_generation = 0 in every cell, windowed (fullscreen = 0), with no live V-Sync toggle this time. Judge RX_VK_ACQUIRE_AHEAD=1 against =0 in the PR's own build with [[pass.compare]] on fps_mean and frametime_p99_ms, alongside the usual comparison with main. Use Hyrule Field from kokiri-start, a 10 s warm-up, then measure 30 s, 3 runs a side, so one game start can't decide it. Add run_hitch_count and run_frametime_max_ms as report-only, not as fail rules: run 2 failed on a hitch count of 12 vs 3 from one start a side, and main itself showed 10 vs 6 across those cells. Targets: NVIDIA on Windows, NVIDIA on Linux, Intel, AMD on Windows (AMD's driver), AMD on Linux (RADV), and the Steam Deck, as many as are free. The PR's open question is which drivers gain uncapped. On an RX 9070 XT with AMD's Windows driver it was +1.2 % fps at the same uncapped settings, with presents 3.2 -> 0.8 ms a frame.

@Beanstalk plan Uncapped, so a gain can show. Every earlier cell sat at the 60 fps cap, so no fps difference could appear. Set `frame_rate_cap = 6` (Uncapped), `vsync = 2` (Off) and `frame_generation = 0` in every cell, windowed (`fullscreen = 0`), with no live V-Sync toggle this time. Judge `RX_VK_ACQUIRE_AHEAD=1` against `=0` in the PR's own build with `[[pass.compare]]` on `fps_mean` and `frametime_p99_ms`, alongside the usual comparison with main. Use Hyrule Field from `kokiri-start`, a 10 s warm-up, then measure 30 s, 3 runs a side, so one game start can't decide it. Add `run_hitch_count` and `run_frametime_max_ms` as report-only, not as fail rules: run 2 failed on a hitch count of 12 vs 3 from one start a side, and main itself showed 10 vs 6 across those cells. Targets: NVIDIA on Windows, NVIDIA on Linux, Intel, AMD on Windows (AMD's driver), AMD on Linux (RADV), and the Steam Deck, as many as are free. The PR's open question is which drivers gain uncapped. On an RX 9070 XT with AMD's Windows driver it was +1.2 % fps at the same uncapped settings, with presents 3.2 -> 0.8 ms a frame.
Member
Beanstalk test farm · an earlier run: commit 2f24a49, run 3 (the newer results are in a comment below)

Commit 2f24a49 · tier double-reviewed · approved by HumanBean, futondestroyer (👍 on klimovich008's request) · dashboard

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

The plan compares acquire-ahead off and on in uncapped, windowed Hyrule Field, with V-Sync and frame generation off, across the requested GPU and driver targets. Each cell uses two runs per side, rather than the requested three, to stay within the farm's 60-minute limit; each run warms up for 10 seconds and measures for 30 seconds, for roughly 45 minutes per tester. FPS and p99 frame time are compared both against main and between the PR's switch settings; crashes or substantial performance regressions fail, while whole-run hitch and maximum-frame metrics are report-only. The Intel target will wait for a matching tester to come online. No tester online now matches intel: that target waits for one.

  • Where: windows+nvidia (1-2 reports), linux+nvidia (1-2 reports), intel (1-2 reports), windows+amd (1-2 reports), linux+radv (1-2 reports), steamdeck (1-2 reports).
  • Matrix: 2 cells, each on main and the PR: RX_VK_ACQUIRE_AHEAD 0 or 1 (PR only).
  • hyrule-field: from the repository's save kokiri-start (settings vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0), then teleport to Hyrule Field, measure field for 30 s (after 10 s warm-up); 2 runs on each side for each of 2 cells (2 game starts a run).
  • Measured: crashes, frame times, stutters and hitches, draws and frame rate, numbers from the game's log, the game's log.
  • The PR fails if: it crashes; or the PR's frame rate with RX_VK_ACQUIRE_AHEAD=1 is more than 10% below RX_VK_ACQUIRE_AHEAD=0; or the PR's frame time (p99) with RX_VK_ACQUIRE_AHEAD=1 is more than 20% above RX_VK_ACQUIRE_AHEAD=0; or frame rate is more than 10% below main; or frame time (p99) is more than 20% above main; or forbidden log lines is above 0.
  • Time: about 46 min of game runs per tester (8 game starts), plus the two builds.

Started at 15:56 UTC. Run 3: re-planned by klimovich008.

Estimate: done in about 2 h 30 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+nvidia · 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0; 2: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3090, 621.24.0 2/1 1 2 none — — error
linux+nvidia · 1: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 5070, 620.70.6 1/1 1 none 12.7 vs 12.9 (−2%) — queued
intel 0/1 — — — queued
windows+amd · 1: windows+amd+amd-proprietary+igpu AMD Radeon(TM) 880M Graphics, 2.0.416; 2: windows+amd+amd-proprietary+dgpu AMD Radeon RX 7900 XTX, 2.0.416 2/1 1 2 none — — error
linux+radv · 1: linux+amd+radv+dgpu AMD Radeon RX 7900 XTX (RADV NAVI31), 26.2.7; 2: linux+amd+radv+dgpu AMD Radeon RX 9070 XT (RADV GFX1201), 26.2.6 2/1 1 2 none — — error ⚠ outlier
steamdeck · 1: linux+amd+radv+igpu+handheld AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99 1/1 1 none 59.5 vs 57.2 (+4%) — queued

Run by hand on PCs that don't match their target (not counted toward it):

Target Ran on Result
linux+nvidia off target (ran on windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070 Ti, 621.14.0) error
Scenario · matrix cell Target Frame p99 (ms) vs main Result
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) windows+nvidia — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) linux+nvidia — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) intel — —
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) windows+amd — not judged
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) linux+radv — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) steamdeck — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) windows+nvidia — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) linux+nvidia 12.7 vs 12.9 (−2%) pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) intel — —
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) windows+amd — not judged
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) linux+radv — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) steamdeck 59.5 vs 57.2 (+4%) pass

Measurements · windows+nvidia

Verdict: could not be judged on windows+nvidia (2/1 report).

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0 AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM; 2: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3090, 621.24.0 AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: main @ 430eef4 After: this PR @ 2f24a49
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) · forbidden log lines 0.0 0.0
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 not in main the PR's default hyrule-field, main without it → the PR with 0: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** could not be judged on windows+nvidia (2/1 report).

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: main @ 430eef4 | After: this PR @ 2f24a49 |
|---|---|---|
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested |

Measurements · linux+nvidia

Verdict: queued on linux+nvidia (1/1 report).

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 5070, 620.70.6 AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 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)

Before: main @ 430eef4 After: this PR @ 2f24a49
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) · forbidden log lines 0.0 0.0
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 100.1 100.0 (−0%)
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 12.9 12.7 (−2%)
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 not in main the PR's default hyrule-field, main without it → the PR with 0: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** queued on linux+nvidia (1/1 report).

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 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)

| | Before: main @ 430eef4 | After: this PR @ 2f24a49 |
|---|---|---|
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 100.1 | 100.0 (−0%) |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 12.9 | 12.7 (−2%) |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested |

Measurements · windows+amd

Verdict: could not be judged on windows+amd (2/1 report).

Hardware: 1: windows+amd+amd-proprietary+igpu AMD Radeon(TM) 880M Graphics, 2.0.416 AMD Ryzen AI 9 365 w/ Radeon 880M, 32 GB RAM; 2: windows+amd+amd-proprietary+dgpu AMD Radeon RX 7900 XTX, 2.0.416 AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports
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

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 not in main the PR's default hyrule-field, main without it → the PR with 0: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** could not be judged on windows+amd (2/1 report).

Hardware: 1: windows+amd+amd-proprietary+igpu `AMD Radeon(TM) 880M Graphics, 2.0.416` `AMD Ryzen AI 9 365 w/ Radeon 880M, 32 GB RAM`; 2: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 7900 XTX, 2.0.416` `AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
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

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested |

Measurements · linux+radv

Verdict: could not be judged on linux+radv (2/1 report).

Hardware: 1: linux+amd+radv+dgpu AMD Radeon RX 7900 XTX (RADV NAVI31), 26.2.7 AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM; 2: linux+amd+radv+dgpu AMD Radeon RX 9070 XT (RADV GFX1201), 26.2.6 11th Gen Intel(R) Core(TM) i9-11900KB @ 3.30GHz, 32 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: main @ 430eef4 After: this PR @ 2f24a49
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) · forbidden log lines 0.0 0.0
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 not in main the PR's default hyrule-field, main without it → the PR with 0: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** could not be judged on linux+radv (2/1 report).

Hardware: 1: linux+amd+radv+dgpu `AMD Radeon RX 7900 XTX (RADV NAVI31), 26.2.7` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`; 2: linux+amd+radv+dgpu `AMD Radeon RX 9070 XT (RADV GFX1201), 26.2.6` `11th Gen Intel(R) Core(TM) i9-11900KB @ 3.30GHz, 32 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: main @ 430eef4 | After: this PR @ 2f24a49 |
|---|---|---|
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested |

Measurements · steamdeck

Verdict: queued on steamdeck (1/1 report).

Hardware: 1: linux+amd+radv+igpu+handheld AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99 AMD Custom APU 0405, 12 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 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)

Before: main @ 430eef4 After: this PR @ 2f24a49
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) · forbidden log lines 0.0 0.0
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 20.7 20.7 (−0%)
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 57.2 59.5 (+4%)
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 not in main the PR's default hyrule-field, main without it → the PR with 0: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** queued on steamdeck (1/1 report).

Hardware: 1: linux+amd+radv+igpu+handheld `AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99` `AMD Custom APU 0405, 12 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 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)

| | Before: main @ 430eef4 | After: this PR @ 2f24a49 |
|---|---|---|
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 20.7 | 20.7 (−0%) |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 57.2 | 59.5 (+4%) |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested |
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>2f24a49</code>, run 3 (the newer results are in a comment below)</summary> Commit `2f24a49` · tier **double-reviewed** · approved by HumanBean, futondestroyer (👍 on klimovich008's request) · [dashboard](https://beanstalk.magicbean.dev/prs/1574) **What will be tested** · AI plan (`gpt-6.1-terra`) The plan compares acquire-ahead off and on in uncapped, windowed Hyrule Field, with V-Sync and frame generation off, across the requested GPU and driver targets. Each cell uses two runs per side, rather than the requested three, to stay within the farm's 60-minute limit; each run warms up for 10 seconds and measures for 30 seconds, for roughly 45 minutes per tester. FPS and p99 frame time are compared both against main and between the PR's switch settings; crashes or substantial performance regressions fail, while whole-run hitch and maximum-frame metrics are report-only. The Intel target will wait for a matching tester to come online. No tester online now matches intel: that target waits for one. - **Where:** windows+nvidia (1-2 reports), linux+nvidia (1-2 reports), intel (1-2 reports), windows+amd (1-2 reports), linux+radv (1-2 reports), steamdeck (1-2 reports). - **Matrix:** 2 cells, each on main and the PR: RX_VK_ACQUIRE_AHEAD `0` or `1` (PR only). - **hyrule-field:** from the repository's save `kokiri-start` (settings vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0), then teleport to Hyrule Field, measure field for 30 s (after 10 s warm-up); 2 runs on each side for each of 2 cells (2 game starts a run). - **Measured:** crashes, frame times, stutters and hitches, draws and frame rate, numbers from the game's log, the game's log. - **The PR fails if:** it crashes; or the PR's frame rate with RX_VK_ACQUIRE_AHEAD=1 is more than 10% below RX_VK_ACQUIRE_AHEAD=0; or the PR's frame time (p99) with RX_VK_ACQUIRE_AHEAD=1 is more than 20% above RX_VK_ACQUIRE_AHEAD=0; or frame rate is more than 10% below main; or frame time (p99) is more than 20% above main; or forbidden log lines is above 0. - **Time:** about 46 min of game runs per tester (8 game starts), plus the two builds. Started at 15:56 UTC. Run 3: re-planned by klimovich008. **Estimate:** done in about 2 h 30 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+nvidia · 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_9fc665d5993b6ef4) [2](https://beanstalk.magicbean.dev/reports/rp_405be0c8dd6ca57d) | none | — | — | error | | linux+nvidia · 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` | 1/1 [1](https://beanstalk.magicbean.dev/reports/rp_2d407acdae1ef74f) | none | 12.7 vs 12.9 (−2%) | — | queued | | intel | 0/1 | — | — | — | queued | | windows+amd · 1: windows+amd+amd-proprietary+igpu `AMD Radeon(TM) 880M Graphics, 2.0.416`; 2: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 7900 XTX, 2.0.416` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_7c94eaba62aed18a) [2](https://beanstalk.magicbean.dev/reports/rp_95f4799c37b321d9) | none | — | — | error | | linux+radv · 1: linux+amd+radv+dgpu `AMD Radeon RX 7900 XTX (RADV NAVI31), 26.2.7`; 2: linux+amd+radv+dgpu `AMD Radeon RX 9070 XT (RADV GFX1201), 26.2.6` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_c92e36a77d344f4c) [2](https://beanstalk.magicbean.dev/reports/rp_6d02c4b07b528a43) | none | — | — | error ⚠ outlier | | steamdeck · 1: linux+amd+radv+igpu+handheld `AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99` | 1/1 [1](https://beanstalk.magicbean.dev/reports/rp_e63417936a4c5a35) | none | 59.5 vs 57.2 (+4%) | — | queued | Run by hand on PCs that don't match their target (not counted toward it): | Target | Ran on | Result | | --- | --- | --- | | linux+nvidia | off target (ran on windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070 Ti, 621.14.0`) | [error](https://beanstalk.magicbean.dev/reports/rp_2d2739612ce1748f) | | Scenario · matrix cell | Target | Frame p99 (ms) vs main | Result | | --- | --- | --- | --- | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | windows+nvidia | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | linux+nvidia | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | intel | — | — | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | windows+amd | — | not judged | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | linux+radv | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | steamdeck | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | windows+nvidia | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | linux+nvidia | 12.7 vs 12.9 (−2%) | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | intel | — | — | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | windows+amd | — | not judged | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | linux+radv | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | steamdeck | 59.5 vs 57.2 (+4%) | pass | #### Measurements · windows+nvidia **Verdict:** could not be judged on windows+nvidia (2/1 report). Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** could not be judged on windows+nvidia (2/1 report). Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | ``` </details> #### Measurements · linux+nvidia **Verdict:** queued on linux+nvidia (1/1 report). Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 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) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 100.1 | 100.0 (−0%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 12.9 | 12.7 (−2%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** queued on linux+nvidia (1/1 report). Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 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) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 100.1 | 100.0 (−0%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 12.9 | 12.7 (−2%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | ``` </details> #### Measurements · windows+amd **Verdict:** could not be judged on windows+amd (2/1 report). Hardware: 1: windows+amd+amd-proprietary+igpu `AMD Radeon(TM) 880M Graphics, 2.0.416` `AMD Ryzen AI 9 365 w/ Radeon 880M, 32 GB RAM`; 2: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 7900 XTX, 2.0.416` `AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports 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 | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** could not be judged on windows+amd (2/1 report). Hardware: 1: windows+amd+amd-proprietary+igpu `AMD Radeon(TM) 880M Graphics, 2.0.416` `AMD Ryzen AI 9 365 w/ Radeon 880M, 32 GB RAM`; 2: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 7900 XTX, 2.0.416` `AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports 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 | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | ``` </details> #### Measurements · linux+radv **Verdict:** could not be judged on linux+radv (2/1 report). Hardware: 1: linux+amd+radv+dgpu `AMD Radeon RX 7900 XTX (RADV NAVI31), 26.2.7` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`; 2: linux+amd+radv+dgpu `AMD Radeon RX 9070 XT (RADV GFX1201), 26.2.6` `11th Gen Intel(R) Core(TM) i9-11900KB @ 3.30GHz, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** could not be judged on linux+radv (2/1 report). Hardware: 1: linux+amd+radv+dgpu `AMD Radeon RX 7900 XTX (RADV NAVI31), 26.2.7` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`; 2: linux+amd+radv+dgpu `AMD Radeon RX 9070 XT (RADV GFX1201), 26.2.6` `11th Gen Intel(R) Core(TM) i9-11900KB @ 3.30GHz, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | ``` </details> #### Measurements · steamdeck **Verdict:** queued on steamdeck (1/1 report). Hardware: 1: linux+amd+radv+igpu+handheld `AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99` `AMD Custom APU 0405, 12 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 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) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 20.7 | 20.7 (−0%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 57.2 | 59.5 (+4%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** queued on steamdeck (1/1 report). Hardware: 1: linux+amd+radv+igpu+handheld `AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99` `AMD Custom APU 0405, 12 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, 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); hyrule-field: 2 game starts a side, field 30 s after 10 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) | | Before: main @ 430eef4 | After: this PR @ 2f24a49 | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · forbidden log lines | 0.0 | 0.0 | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 20.7 | 20.7 (−0%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 57.2 | 59.5 (+4%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | not in main | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | ``` </details> </details>
Author
Member

@Beanstalk plan Smaller, so it fits the hour. Round 3 ran out of time on every tester ("a step ran out of time"), so the RX_VK_ACQUIRE_AHEAD=0 cell never ran and nothing compared =1 with =0. One Windows NVIDIA tester also failed before building: git -C Z:\longshot diff --name-only HEAD exited 128 in dev_packs.py (rp_9fc665d5993b6ef4), the same sandbox error the Windows AMD testers hit earlier.

This time: targets NVIDIA on Windows first, then Intel, then NVIDIA on Linux. Still uncapped and windowed (frame_rate_cap = 6, vsync = 2, frame_generation = 0, fullscreen = 0). Hyrule Field from kokiri-start, 10 s warm-up, 30 s measured, 2 runs a side. Judge RX_VK_ACQUIRE_AHEAD=1 against =0 in the PR's own build with [[pass.compare]] on fps_mean and frametime_p99_ms; run the =0 cell before the =1 cell so the comparison exists even if time runs short, and drop the comparison with main if that is what fits. run_hitch_count and run_frametime_max_ms stay report-only.

What came back from round 3, =1 vs main: NVIDIA RTX 5070 on Linux 100.06 → 99.95 fps (−0.1 %), p99 12.86 → 12.66 ms; Steam Deck 20.74 → 20.66 fps, p99 57.21 → 59.55 ms. The open question is still whether any non-AMD Windows driver gains uncapped.

@Beanstalk plan Smaller, so it fits the hour. Round 3 ran out of time on every tester ("a step ran out of time"), so the `RX_VK_ACQUIRE_AHEAD=0` cell never ran and nothing compared `=1` with `=0`. One Windows NVIDIA tester also failed before building: `git -C Z:\longshot diff --name-only HEAD` exited 128 in `dev_packs.py` (rp_9fc665d5993b6ef4), the same sandbox error the Windows AMD testers hit earlier. This time: targets NVIDIA on Windows first, then Intel, then NVIDIA on Linux. Still uncapped and windowed (`frame_rate_cap = 6`, `vsync = 2`, `frame_generation = 0`, `fullscreen = 0`). Hyrule Field from `kokiri-start`, 10 s warm-up, 30 s measured, **2 runs a side**. Judge `RX_VK_ACQUIRE_AHEAD=1` against `=0` in the PR's own build with `[[pass.compare]]` on `fps_mean` and `frametime_p99_ms`; run the `=0` cell before the `=1` cell so the comparison exists even if time runs short, and drop the comparison with main if that is what fits. `run_hitch_count` and `run_frametime_max_ms` stay report-only. What came back from round 3, `=1` vs main: NVIDIA RTX 5070 on Linux 100.06 → 99.95 fps (−0.1 %), p99 12.86 → 12.66 ms; Steam Deck 20.74 → 20.66 fps, p99 57.21 → 59.55 ms. The open question is still whether any non-AMD Windows driver gains uncapped.
Member
Beanstalk test farm · an earlier run: commit 2f24a49, run 4 (the newer results are in a comment below)

Commit 2f24a49 · tier double-reviewed · approved by HumanBean, futondestroyer (👍 on klimovich008's request) · dashboard

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

On Windows NVIDIA, Intel, and Linux NVIDIA PCs, the plan compares acquire-ahead off and on in the PR build in Hyrule Field. Each setting gets two runs with a 10-second warm-up and 30-second measurement, uncapped and windowed; the switch axis isolates its effect without building main. A crash, a frame-rate drop over 5%, a p99 frame-time increase over 15%, or a substantial screenshot difference fails the plan. Whole-run hitch counts and maximum frame times are reported without failing it. Gameplay runs take roughly 30–35 minutes per tester; a target may wait if no matching PC is available.

  • Where: windows+nvidia (1-2 reports), intel (1-2 reports), linux+nvidia (1-2 reports).
  • Against: the PR itself, switch on (RX_VK_ACQUIRE_AHEAD) and off; main is not built or run.
  • Matrix: 2 cells, each with the switch on and off: RX_VK_ACQUIRE_AHEAD 0 or 1 (PR only).
  • hyrule-field: from the repository's save kokiri-start (settings vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0), then teleport to Hyrule Field, measure field for 30 s (after 10 s warm-up), take the picture field to compare with the switch off; 2 runs on each side for each of 2 cells (2 game starts a run).
  • Measured: crashes, frame times, stutters and hitches, draws and frame rate.
  • The PR fails if: it crashes; or the PR's frame rate with RX_VK_ACQUIRE_AHEAD=1 is more than 5% below RX_VK_ACQUIRE_AHEAD=0; or the PR's frame time (p99) with RX_VK_ACQUIRE_AHEAD=1 is more than 15% above RX_VK_ACQUIRE_AHEAD=0; or a picture differs from main by more than 5%.
  • Time: about 46 min of game runs per tester (8 game starts), plus the two builds.

Started at 2026-11-19 18:45 UTC. Run 4: re-planned by klimovich008.

Target Reports Crash Frame p99 (ms) vs switch off VRAM peak (MB) vs switch off Result
windows+nvidia · 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0; 2: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3090, 621.24.0 2/1 1 2 none — — error ⚠ outlier
intel 0/1 — — — queued
linux+nvidia · 1: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 5070, 620.70.6; 2: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce GTX 1070, 580.196.7 2/1 1 2 1 PR run 18.0 vs 15.6 (+15%) — fail ⚠ outlier
Scenario · matrix cell Target Frame p99 (ms) vs switch off Result
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) windows+nvidia — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) intel — —
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) linux+nvidia — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) windows+nvidia — pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) intel — —
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) linux+nvidia 18.0 vs 15.6 (+15%) fail

Measurements · windows+nvidia

Verdict: could not be judged on windows+nvidia (2/1 report).

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0 AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM; 2: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3090, 621.24.0 AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports
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

Flag What it is Values tried Before this PR After this PR Effect (frame time (p99)) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 off (the switch's default) the PR's default hyrule-field, main without it → the PR with 0: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** could not be judged on windows+nvidia (2/1 report).

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
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

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested |

Measurements · linux+nvidia

Verdict: fail on linux+nvidia (2/1 report): hyrule-field crash failed.

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 5070, 620.70.6 AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce GTX 1070, 580.196.7 Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: this PR @ 2f24a49, switch off After: this PR @ 2f24a49, switch on
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 15.6 18.0 (+15%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame time (p99)) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 off (the switch's default) the PR's default hyrule-field, main without it → the PR with 0: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** fail on linux+nvidia (2/1 report): `hyrule-field crash` failed.

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce GTX 1070, 580.196.7` `Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on |
|---|---|---|
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 15.6 | 18.0 (+15%) |

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested |
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>2f24a49</code>, run 4 (the newer results are in a comment below)</summary> Commit `2f24a49` · tier **double-reviewed** · approved by HumanBean, futondestroyer (👍 on klimovich008's request) · [dashboard](https://beanstalk.magicbean.dev/prs/1574) **What will be tested** · AI plan (`gpt-6.1-terra`) On Windows NVIDIA, Intel, and Linux NVIDIA PCs, the plan compares acquire-ahead off and on in the PR build in Hyrule Field. Each setting gets two runs with a 10-second warm-up and 30-second measurement, uncapped and windowed; the switch axis isolates its effect without building main. A crash, a frame-rate drop over 5%, a p99 frame-time increase over 15%, or a substantial screenshot difference fails the plan. Whole-run hitch counts and maximum frame times are reported without failing it. Gameplay runs take roughly 30–35 minutes per tester; a target may wait if no matching PC is available. - **Where:** windows+nvidia (1-2 reports), intel (1-2 reports), linux+nvidia (1-2 reports). - **Against:** the PR itself, switch on (`RX_VK_ACQUIRE_AHEAD`) and off; main is not built or run. - **Matrix:** 2 cells, each with the switch on and off: RX_VK_ACQUIRE_AHEAD `0` or `1` (PR only). - **hyrule-field:** from the repository's save `kokiri-start` (settings vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0), then teleport to Hyrule Field, measure field for 30 s (after 10 s warm-up), take the picture field to compare with the switch off; 2 runs on each side for each of 2 cells (2 game starts a run). - **Measured:** crashes, frame times, stutters and hitches, draws and frame rate. - **The PR fails if:** it crashes; or the PR's frame rate with RX_VK_ACQUIRE_AHEAD=1 is more than 5% below RX_VK_ACQUIRE_AHEAD=0; or the PR's frame time (p99) with RX_VK_ACQUIRE_AHEAD=1 is more than 15% above RX_VK_ACQUIRE_AHEAD=0; or a picture differs from main by more than 5%. - **Time:** about 46 min of game runs per tester (8 game starts), plus the two builds. Started at 2026-11-19 18:45 UTC. Run 4: re-planned by klimovich008. | Target | Reports | Crash | Frame p99 (ms) vs switch off | VRAM peak (MB) vs switch off | Result | | --- | --- | --- | --- | --- | --- | | windows+nvidia · 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_8dde308961538b2e) [2](https://beanstalk.magicbean.dev/reports/rp_eaccf35196d3fd35) | none | — | — | error ⚠ outlier | | intel | 0/1 | — | — | — | queued | | linux+nvidia · 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce GTX 1070, 580.196.7` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_783d4bc2799a36d3) [2](https://beanstalk.magicbean.dev/reports/rp_1d00d428103b113e) | 1 PR run | 18.0 vs 15.6 (+15%) | — | fail ⚠ outlier | | Scenario · matrix cell | Target | Frame p99 (ms) vs switch off | Result | | --- | --- | --- | --- | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | windows+nvidia | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | intel | — | — | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | linux+nvidia | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | windows+nvidia | — | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | intel | — | — | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | linux+nvidia | 18.0 vs 15.6 (+15%) | fail | #### Measurements · windows+nvidia **Verdict:** could not be judged on windows+nvidia (2/1 report). Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports 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 | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** could not be judged on windows+nvidia (2/1 report). Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0` `AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.24.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports 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 | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | ``` </details> #### Measurements · linux+nvidia **Verdict:** fail on linux+nvidia (2/1 report): `hyrule-field crash` failed. Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce GTX 1070, 580.196.7` `Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 15.6 | 18.0 (+15%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** fail on linux+nvidia (2/1 report): `hyrule-field crash` failed. Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce GTX 1070, 580.196.7` `Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 15.6 | 18.0 (+15%) | ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: not measured | untested | ``` </details> </details>
Author
Member

@Beanstalk plan Again, smaller and with two fixes for problems the farm has on many PRs. Round 4: one =1 start on the Linux RTX 5070 counted as a hang, the =0 cell ran out of time, and both Windows NVIDIA testers errored.

  • Before the teleport, wait 10 s (wait_s) after the save loads, and give the wait for HyruleField_Child 120 s. In the timed-out runs the teleport never took (the last picture still shows Kokiri Forest; the same on #1488 and #1755), and #1702's were refused with "an event is playing".
  • Windows NVIDIA target: vram_gb = ">= 6". The RTX 3050 Ti Laptop tester fails before building on every PR (git -C Z:\longshot diff --name-only HEAD exits 128 in dev_packs.py).

The question for this round is whether the Linux NVIDIA hang comes back, so targets in this order: NVIDIA on Linux, NVIDIA on Windows, Intel. The PR's own build only, RX_VK_ACQUIRE_AHEAD=0 cell before =1, 2 runs a side, uncapped and windowed (frame_rate_cap = 6, vsync = 2, frame_generation = 0, fullscreen = 0), Hyrule Field from kokiri-start, 10 s warm-up, 30 s measured. Judge =1 against =0 with [[pass.compare]] on fps_mean and frametime_p99_ms; run_hitch_count and run_frametime_max_ms report-only.

@Beanstalk plan Again, smaller and with two fixes for problems the farm has on many PRs. Round 4: one `=1` start on the Linux RTX 5070 counted as a hang, the `=0` cell ran out of time, and both Windows NVIDIA testers errored. - **Before the teleport, wait 10 s** (`wait_s`) after the save loads, and give the wait for `HyruleField_Child` 120 s. In the timed-out runs the teleport never took (the last picture still shows Kokiri Forest; the same on #1488 and #1755), and #1702's were refused with "an event is playing". - **Windows NVIDIA target: `vram_gb = ">= 6"`.** The RTX 3050 Ti Laptop tester fails before building on every PR (`git -C Z:\longshot diff --name-only HEAD` exits 128 in `dev_packs.py`). The question for this round is whether the Linux NVIDIA hang comes back, so targets in this order: NVIDIA on Linux, NVIDIA on Windows, Intel. The PR's own build only, `RX_VK_ACQUIRE_AHEAD=0` cell before `=1`, 2 runs a side, uncapped and windowed (`frame_rate_cap = 6`, `vsync = 2`, `frame_generation = 0`, `fullscreen = 0`), Hyrule Field from `kokiri-start`, 10 s warm-up, 30 s measured. Judge `=1` against `=0` with `[[pass.compare]]` on `fps_mean` and `frametime_p99_ms`; `run_hitch_count` and `run_frametime_max_ms` report-only.
Member
Beanstalk test farm · an earlier run: commit 2f24a49, run 5 (the newer results are in a comment below)

Commit 2f24a49 · approved by HumanBean, futondestroyer (👍 on klimovich008's request) (double-reviewed) · dashboard

Started at 04:45 UTC. Run 5: re-planned by klimovich008.

Target Result Reports Frame time p99 (ms), switch off → switch on VRAM peak (MB) Crashes
linux+nvidia ❌ fail (an outlier) 2 1 2 13.2 → 13.4 (+2%) — none
windows+nvidia+vram-ge6gb (6 GB VRAM or more) ❌ fail (an outlier) 2 1 2 14.6 → 19.7 (+35%) — none
intel ⏳ queued 0 of 1 — — —

Why it failed

  • linux+nvidia: hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) field.fps_mean: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR): 98.2 → 69.8 (−29.0%); limit 5.0; the PR's own cells: RX_VK_ACQUIRE_AHEAD=1 against RX_VK_ACQUIRE_AHEAD=0 (RX_VK_ACQUIRE_AHEAD=0 (PR only))
  • linux+nvidia: hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) field.frametime_p99_ms: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR): 14.1 → 17.1 (+21.3%); limit 15.0; the PR's own cells: RX_VK_ACQUIRE_AHEAD=1 against RX_VK_ACQUIRE_AHEAD=0 (RX_VK_ACQUIRE_AHEAD=0 (PR only))
  • windows+nvidia+vram-ge6gb: hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) screenshot.max_diff: 0.0 → 0.1; limit 0.1
What was tested

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

The PR build will run windowed, uncapped Hyrule Field tests with acquire-ahead set to 0 and then 1, using two runs per side. Linux NVIDIA, Windows NVIDIA with at least 6 GB of VRAM, and Intel are targeted; the Intel target will wait for a matching tester to come online. Each run waits after loading the Kokiri save, then measures 30 seconds after a 10-second warm-up, for roughly 40–45 minutes per tester. Crashes, hangs, a greater than 5% FPS loss, a greater than 15% p99 frametime increase, or a significant screenshot difference fail the plan; run-wide hitches and maximum frametime are reported without limits. No tester online now matches intel: that target waits for one.

  • Where: linux+nvidia (1-2 reports), windows+nvidia+vram-ge6gb (6 GB VRAM or more, 1-2 reports), intel (1-2 reports).
  • Against: the PR itself, switch on (RX_VK_ACQUIRE_AHEAD) and off; main is not built or run.
  • Matrix: 2 cells, each with the switch on and off: RX_VK_ACQUIRE_AHEAD 0 or 1 (PR only).
  • hyrule-field: from the repository's save kokiri-start (settings vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0), then teleport to Hyrule Field, measure field for 30 s (after 10 s warm-up), take the picture field to compare with the switch off; 2 runs on each side for each of 2 cells (2 game starts a run).
  • Measured: crashes, frame times, stutters and hitches, draws and frame rate.
  • The PR fails if: it crashes; or the PR's frame rate with RX_VK_ACQUIRE_AHEAD=1 is more than 5% below RX_VK_ACQUIRE_AHEAD=0; or the PR's frame time (p99) with RX_VK_ACQUIRE_AHEAD=1 is more than 15% above RX_VK_ACQUIRE_AHEAD=0; or a picture differs from main by more than 5%.
  • Time: about 47 min of game runs per tester (8 game starts), plus the two builds.
Every scenario and matrix cell
Scenario · matrix cell Target Frame time p99 (ms), switch off → switch on Result
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) linux+nvidia 13.2 → 13.4 (+2%) pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) windows+nvidia+vram-ge6gb 14.6 → 19.7 (+35%) pass
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) intel — —
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) linux+nvidia 12.6 → 15.3 (+22%) fail
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) windows+nvidia+vram-ge6gb 15.6 → 15.1 (−3%) fail
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) intel — —
Measurements on `linux+nvidia`, for the PR description

Verdict: fail on linux+nvidia (2/1 report): hyrule-field field.fps_mean: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR) (-29.0%); hyrule-field field.frametime_p99_ms: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR) (+21.3%) failed.

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 5070, 620.70.6 AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070, 615.71.9 AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: this PR @ 2f24a49, switch off After: this PR @ 2f24a49, switch on
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) · field · frame time (p99) (ms) 13.2 13.4 (+2%)
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 12.6 15.3 (+22%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame time (p99)) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 off (the switch's default) the PR's default hyrule-field, main without it → the PR with 0: 13.2 → 13.4 (+2%) no clear effect

As Markdown for the PR description:

## Measurements

**Verdict:** fail on linux+nvidia (2/1 report): `hyrule-field field.fps_mean: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR) (-29.0%)`; `hyrule-field field.frametime_p99_ms: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR) (+21.3%)` failed.

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on |
|---|---|---|
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · field · frame time (p99) (ms) | 13.2 | 13.4 (+2%) |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 12.6 | 15.3 (+22%) |

**Flags and settings**

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: 13.2 → 13.4 (+2%) | no clear effect |
Measurements on `windows+nvidia+vram-ge6gb`, for the PR description

Verdict: fail on windows+nvidia+vram-ge6gb (2/1 report): hyrule-field screenshot.max_diff failed.

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3090, 621.1.0 AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM; 2: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3070, 621.24.0 AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: this PR @ 2f24a49, switch off After: this PR @ 2f24a49, switch on
hyrule-field · RX_VK_ACQUIRE_AHEAD=0 (PR only) · field · frame time (p99) (ms) 14.6 19.7 (+35%)
hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 15.6 15.1 (−3%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame time (p99)) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 0, 1 off (the switch's default) the PR's default hyrule-field, main without it → the PR with 0: 14.6 → 19.7 (+35%) doesn't help

As Markdown for the PR description:

## Measurements

**Verdict:** fail on windows+nvidia+vram-ge6gb (2/1 report): `hyrule-field screenshot.max_diff` failed.

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.1.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3070, 621.24.0` `AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM`  
Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on |
|---|---|---|
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · field · frame time (p99) (ms) | 14.6 | 19.7 (+35%) |
| hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 15.6 | 15.1 (−3%) |

**Flags and settings**

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: 14.6 → 19.7 (+35%) | doesn't help |
The testers' hardware
Target Report Ran on
linux+nvidia 1 linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 5070, 620.70.6 AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM
linux+nvidia 2 linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 4070, 615.71.9 AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM
windows+nvidia+vram-ge6gb 1 windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3090, 621.1.0 AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM
windows+nvidia+vram-ge6gb 2 windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3070, 621.24.0 AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>2f24a49</code>, run 5 (the newer results are in a comment below)</summary> Commit `2f24a49` · approved by HumanBean, futondestroyer (👍 on klimovich008's request) (double-reviewed) · [dashboard](https://beanstalk.magicbean.dev/prs/1574) Started at 04:45 UTC. Run 5: re-planned by klimovich008. | Target | Result | Reports | Frame time p99 (ms), switch off → switch on | VRAM peak (MB) | Crashes | | --- | --- | --- | --- | --- | --- | | `linux+nvidia` | ❌ fail (an outlier) | 2 [1](https://beanstalk.magicbean.dev/reports/rp_a168d2e42dd7b0b4) [2](https://beanstalk.magicbean.dev/reports/rp_7e6b5851db8131b4) | 13.2 → 13.4 (+2%) | — | none | | `windows+nvidia+vram-ge6gb` (6 GB VRAM or more) | ❌ fail (an outlier) | 2 [1](https://beanstalk.magicbean.dev/reports/rp_db63580f0f2f7940) [2](https://beanstalk.magicbean.dev/reports/rp_973afe194d9462e9) | 14.6 → 19.7 (+35%) | — | none | | `intel` | ⏳ queued | 0 of 1 | — | — | — | **Why it failed** - `linux+nvidia`: `hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `field.fps_mean: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR)`: `98.2 → 69.8 (−29.0%); limit 5.0; the PR's own cells: RX_VK_ACQUIRE_AHEAD=1 against RX_VK_ACQUIRE_AHEAD=0 (RX_VK_ACQUIRE_AHEAD=0 (PR only))` - `linux+nvidia`: `hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `field.frametime_p99_ms: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR)`: `14.1 → 17.1 (+21.3%); limit 15.0; the PR's own cells: RX_VK_ACQUIRE_AHEAD=1 against RX_VK_ACQUIRE_AHEAD=0 (RX_VK_ACQUIRE_AHEAD=0 (PR only))` - `windows+nvidia+vram-ge6gb`: `hyrule-field · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `screenshot.max_diff`: `0.0 → 0.1; limit 0.1` <details><summary>What was tested</summary> **What will be tested** · AI plan (`gpt-6.1-terra`) The PR build will run windowed, uncapped Hyrule Field tests with acquire-ahead set to 0 and then 1, using two runs per side. Linux NVIDIA, Windows NVIDIA with at least 6 GB of VRAM, and Intel are targeted; the Intel target will wait for a matching tester to come online. Each run waits after loading the Kokiri save, then measures 30 seconds after a 10-second warm-up, for roughly 40–45 minutes per tester. Crashes, hangs, a greater than 5% FPS loss, a greater than 15% p99 frametime increase, or a significant screenshot difference fail the plan; run-wide hitches and maximum frametime are reported without limits. No tester online now matches intel: that target waits for one. - **Where:** linux+nvidia (1-2 reports), windows+nvidia+vram-ge6gb (6 GB VRAM or more, 1-2 reports), intel (1-2 reports). - **Against:** the PR itself, switch on (`RX_VK_ACQUIRE_AHEAD`) and off; main is not built or run. - **Matrix:** 2 cells, each with the switch on and off: RX_VK_ACQUIRE_AHEAD `0` or `1` (PR only). - **hyrule-field:** from the repository's save `kokiri-start` (settings vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0), then teleport to Hyrule Field, measure field for 30 s (after 10 s warm-up), take the picture field to compare with the switch off; 2 runs on each side for each of 2 cells (2 game starts a run). - **Measured:** crashes, frame times, stutters and hitches, draws and frame rate. - **The PR fails if:** it crashes; or the PR's frame rate with RX_VK_ACQUIRE_AHEAD=1 is more than 5% below RX_VK_ACQUIRE_AHEAD=0; or the PR's frame time (p99) with RX_VK_ACQUIRE_AHEAD=1 is more than 15% above RX_VK_ACQUIRE_AHEAD=0; or a picture differs from main by more than 5%. - **Time:** about 47 min of game runs per tester (8 game starts), plus the two builds. </details> <details><summary>Every scenario and matrix cell</summary> | Scenario · matrix cell | Target | Frame time p99 (ms), switch off → switch on | Result | | --- | --- | --- | --- | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | linux+nvidia | 13.2 → 13.4 (+2%) | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | windows+nvidia+vram-ge6gb | 14.6 → 19.7 (+35%) | pass | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` | intel | — | — | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | linux+nvidia | 12.6 → 15.3 (+22%) | fail | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | windows+nvidia+vram-ge6gb | 15.6 → 15.1 (−3%) | fail | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` | intel | — | — | </details> <details><summary>Measurements on `linux+nvidia`, for the PR description</summary> **Verdict:** fail on linux+nvidia (2/1 report): `hyrule-field field.fps_mean: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR) (-29.0%)`; `hyrule-field field.frametime_p99_ms: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR) (+21.3%)` failed. Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · field · frame time (p99) (ms) | 13.2 | 13.4 (+2%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 12.6 | 15.3 (+22%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: 13.2 → 13.4 (+2%) | no clear effect | As Markdown for the PR description: ```markdown ## Measurements **Verdict:** fail on linux+nvidia (2/1 report): `hyrule-field field.fps_mean: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR) (-29.0%)`; `hyrule-field field.frametime_p99_ms: RX_VK_ACQUIRE_AHEAD=1 vs RX_VK_ACQUIRE_AHEAD=0 (PR) (+21.3%)` failed. Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · field · frame time (p99) (ms) | 13.2 | 13.4 (+2%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 12.6 | 15.3 (+22%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: 13.2 → 13.4 (+2%) | no clear effect | ``` </details> <details><summary>Measurements on `windows+nvidia+vram-ge6gb`, for the PR description</summary> **Verdict:** fail on windows+nvidia+vram-ge6gb (2/1 report): `hyrule-field screenshot.max_diff` failed. Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.1.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3070, 621.24.0` `AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · field · frame time (p99) (ms) | 14.6 | 19.7 (+35%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 15.6 | 15.1 (−3%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: 14.6 → 19.7 (+35%) | doesn't help | As Markdown for the PR description: ```markdown ## Measurements **Verdict:** fail on windows+nvidia+vram-ge6gb (2/1 report): `hyrule-field screenshot.max_diff` failed. Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.1.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM`; 2: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3070, 621.24.0` `AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM` Scene: hyrule-field, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); hyrule-field: 2 game starts a side, field 30 s after 10 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ 2f24a49, switch off | After: this PR @ 2f24a49, switch on | |---|---|---| | hyrule-field · `RX_VK_ACQUIRE_AHEAD=0 (PR only)` · field · frame time (p99) (ms) | 14.6 | 19.7 (+35%) | | hyrule-field · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 15.6 | 15.1 (−3%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame time (p99)) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `0`, `1` | off (the switch's default) | the PR's default | hyrule-field, main without it → the PR with 0: 14.6 → 19.7 (+35%) | doesn't help | ``` </details> <details><summary>The testers' hardware</summary> | Target | Report | Ran on | | --- | --- | --- | | `linux+nvidia` | [1](https://beanstalk.magicbean.dev/reports/rp_a168d2e42dd7b0b4) | linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5070, 620.70.6` `AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM` | | `linux+nvidia` | [2](https://beanstalk.magicbean.dev/reports/rp_7e6b5851db8131b4) | linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 4070, 615.71.9` `AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM` | | `windows+nvidia+vram-ge6gb` | [1](https://beanstalk.magicbean.dev/reports/rp_db63580f0f2f7940) | windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3090, 621.1.0` `AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM` | | `windows+nvidia+vram-ge6gb` | [2](https://beanstalk.magicbean.dev/reports/rp_973afe194d9462e9) | windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3070, 621.24.0` `AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM` | </details> </details>
Author
Member

🤖 A correction to what I wrote here about the Test Farm: none of the farm's rounds on this PR tested the switch.

  • The farm starts every game with HOS_HEADLESS=1 (no window), and a plan cannot change that. Headless, do_present returns before present_image (vk_replay.cpp:5549), and present_image is the only place RX_VK_ACQUIRE_AHEAD is read or acts. So every round, =1 against =0, unset, or main, compared the same renderer code.
  • The farm's own logs agree: with the switch set, present_image prints vk: the window's image (600 presents) every 600 presents. The =1 PR-side logs from rounds 4 and 5 run 960 and 760 presents with no such line (round 3's too). My earlier "the reports can't show the switch's state either way" was wrong: they show it never ran.
  • So the RTX 3090's p99 rise, the Linux RTX 5070 "hang" and round 5's 42.7 fps run are not the switch's. That RTX 5070 tester also stalls with the switch off: 17.4 s and 3.4 s frames in =0/unset runs, two =0 cells timed out, and on #1763 it did not load a save within 900 s.
  • Read on its own, the switch's code adds no wait without a bound (the ahead acquire uses a timeout of 0, and its present waits at most 250 ms, as a fresh acquire does). A second review agreed.

What stands: the windowed numbers from my RX 9070 XT (AMD's Windows driver), +8.4 % fps in the standard test and +1.2 % uncapped, with presents 3.2-4.1 → 0.75-0.8 ms a frame, and the Steam Deck run (which logged the switch engaging).

Still open: whether other drivers gain (NVIDIA, Intel, RADV on a desktop), uncapped and in a window. The farm can't answer that as it runs now, so it needs a windowed run by hand. At this head (2f24a499) the switch is still off by default on every PC. I have edited the description's farm lines to say they don't test the switch; nothing else in it changed.

🤖 A correction to what I wrote here about the Test Farm: **none of the farm's rounds on this PR tested the switch.** - The farm starts every game with `HOS_HEADLESS=1` (no window), and a plan cannot change that. Headless, `do_present` returns before `present_image` (`vk_replay.cpp:5549`), and `present_image` is the only place `RX_VK_ACQUIRE_AHEAD` is read or acts. So every round, `=1` against `=0`, unset, or main, compared the same renderer code. - The farm's own logs agree: with the switch set, `present_image` prints `vk: the window's image (600 presents)` every 600 presents. The `=1` PR-side logs from rounds 4 and 5 run 960 and 760 presents with no such line (round 3's too). My earlier "the reports can't show the switch's state either way" was wrong: they show it never ran. - So the RTX 3090's p99 rise, the Linux RTX 5070 "hang" and round 5's 42.7 fps run are not the switch's. That RTX 5070 tester also stalls with the switch off: 17.4 s and 3.4 s frames in `=0`/unset runs, two `=0` cells timed out, and on #1763 it did not load a save within 900 s. - Read on its own, the switch's code adds no wait without a bound (the ahead acquire uses a timeout of 0, and its present waits at most 250 ms, as a fresh acquire does). A second review agreed. What stands: the windowed numbers from my RX 9070 XT (AMD's Windows driver), +8.4 % fps in the standard test and +1.2 % uncapped, with presents 3.2-4.1 → 0.75-0.8 ms a frame, and the Steam Deck run (which logged the switch engaging). Still open: whether other drivers gain (NVIDIA, Intel, RADV on a desktop), uncapped and in a window. The farm can't answer that as it runs now, so it needs a windowed run by hand. At this head (`2f24a499`) the switch is still off by default on every PC. I have edited the description's farm lines to say they don't test the switch; nothing else in it changed.
Owner

@Beanstalk please test this on windows+amd, windows+nvidia, windows+intel, linux+amd, linux+nvidia and the Steam Deck, in a window (not full screen) with V-Sync Off and frame generation off, not headless: Hyrule Field with the camera turning, then the Castle Town market standing. Compare RX_VK_ACQUIRE_AHEAD=1 against unset, same build, and report fps, p99 and frames over 20 ms, with the vk: acquire ahead and vk: the window's image log lines. We want to know whether the switch should be on by default for everyone. Note: this branch has a conflict with main; a rebase is on HumanBean:acquire-ahead-rebased.

@Beanstalk please test this on windows+amd, windows+nvidia, windows+intel, linux+amd, linux+nvidia and the Steam Deck, in a window (not full screen) with V-Sync Off and frame generation off, not headless: Hyrule Field with the camera turning, then the Castle Town market standing. Compare `RX_VK_ACQUIRE_AHEAD=1` against unset, same build, and report fps, p99 and frames over 20 ms, with the `vk: acquire ahead` and `vk: the window's image` log lines. We want to know whether the switch should be on by default for everyone. Note: this branch has a conflict with main; a rebase is on HumanBean:acquire-ahead-rebased.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
The device policy decides it (acquire_ahead: VK_DRIVER_ID_AMD_PROPRIETARY on Windows, the driver that hands the image
back at once and leaves the wait to the acquire's fence); every other driver keeps #1458's order. RX_VK_ACQUIRE_AHEAD is
read over it by device_policy_env's one rule: 0 off, 1 on with any driver for A/B runs. The first present logs which way
it went and why; the image-wait counter's line every 600 presents is kept for an explicit RX_VK_ACQUIRE_AHEAD=1 only.

Tests: test_device_policy.py pins the field on its 19 PCs (on for the four with AMD's Windows driver), the switch over it,
and the rule at its edges (AMD's Linux driver, AMDVLK, RADV, NVIDIA, Intel, Dozen off); test_present_acquire_ahead.py
runs both defaults with the switch unset, 0 and 1, the first present's line and the counter, with five new broken variants.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Conflicts:
- gpu/vk/vk_replay.cpp: one comment hunk at present_image's image_free; the branch's text kept (it names the ahead image).
- gpu/vk/device_policy.h: main removed presenter_queue (#1763) and added readback_late_newest; main's kept, acquire_ahead
  added after it (field, rule line, log flag).
- tests/test_device_policy.py: main's field list, 7900X row and occ_copy needle kept, acquire_ahead added to each.
- docs/development.md, docs/development/device-policy.md: deleted on main (#1802); the switch's row moves to
  docs/dev/reference/switches.md in the next commit.

After this merge acquire ahead never runs: #1763 runs the presenter thread on every PC and acquire_ahead_wanted() is off
with it. The next commit moves the ahead acquire onto the presenter thread.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Since #1763 the presenter thread makes every present on every PC, and acquire ahead was off whenever it ran: after the merge
of main it never engaged. With the presenter on, present_out only hands the present over, so an acquire on the render thread
right after it would run beside the presenter's vkQueuePresentKHR on the same swapchain.

Now the presenter asks for the next present's image itself, right after its own present of a game frame came back
VK_SUCCESS, while the swapchain is still its own (presenter.busy):
- present_image decides (acquire_ahead_wanted: the device policy, frame generation, FIFO, the start-up screen) and passes it
  with the hand-over (present_acquire_ahead -> presenter.ahead, with the swapchain's generation);
- the acquire is made with presenter.mu held and the swapchain's lock (presenter_queue_mu), a timeout of 0, the queue's
  lock not held; present_image reads the image only after its drain of the presenter, as before;
- a drain that gives up after its 5 s clears presenter.ahead, so no image is asked for ahead after the render thread went on
  without the presenter;
- held_image_drop's fence left pending (#1458's path, reached by a resize with an ahead image out, or a held image while the
  window is hidden) is kept and used again once signaled, before a new one is made (at most 8 kept): the fence leak listed
  as a follow-up on #1574.

The default is unchanged: on with AMD's own driver on Windows, off with every other driver; RX_VK_ACQUIRE_AHEAD=0 off, =1 on.
The switch's row moves to docs/dev/reference/switches.md (#1802), with a note in threads.md.

tests/test_present_acquire_ahead.py runs the presenter's real code (its state, wait, hand-over, drain, and presenter_loop's
take and end of a present) against the model engine, with the presenter on time, late and stuck; 21 broken variants fail.
On main 89c3d21e's source, and on this branch's merge commit, it fails.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Merge main ed9495bb into perf/acquire-ahead
Some checks failed
beanstalk/windows+intel 0/1 pass, 0 running, 2 queued
beanstalk/linux+amd 2/1 fail
beanstalk/linux+nvidia 2/1 fail
beanstalk/steamdeck 0/1 pass, 0 running, 2 queued
beanstalk/approval approved by HumanBean (reviewed)
beanstalk/windows+amd 1/1 fail
beanstalk/windows+nvidia 1/1 fail
CI / Website build and checks (pull_request) Has been cancelled
CI / Conventional Commit title (pull_request) Successful in 22s
PR description / Description follows the template (pull_request_target) Successful in 27s
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 / Workflow lint (actionlint) (pull_request) Successful in 34s
Website / Website on Cloudflare (pull_request) Has been skipped
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 31s
Third-party parts / As their notes say (pull_request) Successful in 41s
Website / Website on Cloudflare (pull_request_target) Has been skipped
ef200041a7
One conflict in gpu/vk/vk_replay.cpp: present_out's declaration takes main's
lock type (#1866's QueueMutex); acquire ahead's two declarations kept after it.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
klimovich008 changed title from perf(vk): RX_VK_ACQUIRE_AHEAD=1 asks for the window's next image right after a present, so the render thread no longer waits for it (off by default) to perf(vk): ask for the window's next image on the presenter thread right after a present, so the render thread stops waiting for it (on with AMD's Windows driver) 2026-11-20 17:54:23 +00:00
Author
Member

🤖 @HumanBean, thank you for the review. Round 3 is pushed (head ef200041, main ed9495bb merged in). Your points one by one:

Blocking: the switch's default. Done as you described. RX_VK_ACQUIRE_AHEAD now comes from the device policy (acquire_ahead in gpu/vk/device_policy.h): on when dev.driver_id == VK_DRIVER_ID_AMD_PROPRIETARY on _WIN32, off with every other driver, which keeps #1458's order. =0 turns it off and =1 forces it on anywhere, for A/B runs. The first present logs once which way it went and why, for example acquire ahead: on by default with AMD's Windows driver ... (RX_VK_ACQUIRE_AHEAD=0: off). NVIDIA, Intel and Linux stay off: nothing has been measured there with this design. tests/test_device_policy.py and the new test check the choice on both _WIN32 sides, with broken variants (on with every driver; off with AMD's).

Inline, switches.def's default text. The row now reads "on with AMD's own driver on Windows, off elsewhere (each image asked for at its present, #1458's order)", with 0 and 1 as the override.

Suggestion: the 600-present counter for =1 only. Done. With the default (on with AMD's driver) or =0, nothing is counted and no line is printed beyond the one first-present line. The test checks both.

Suggestion: the overlap with #1702. Since then #1763 put the presenter thread on every PC. That made the old gate ("not while the presenter thread is on") turn this off everywhere. So round 3 moved the ahead acquire onto the presenter thread:

  • It is made at the end of presenter_loop(), after the presenter's own vkQueuePresentKHR.
  • It runs while the presenter still owns the swapchain (presenter.busy), under presenter.mu and the swapchain's lock.
  • The render thread reads that state only after its drain of the presenter.
  • If the drain gives up after 5 s, it clears the request under presenter.mu, so no image is asked for ahead after the render thread went on.

The presenter thread and acquire ahead no longer compete, so there is no choice to make for NVIDIA between them. It stays off on NVIDIA by default.

Measurements you asked for.

  • AMD Windows at the default 60 cap (3 pairs, default against =0): fps 59.60 → 59.74, no change. p99 was lower in each pair (median 20.19 → 19.29 ms). CPU ms a frame was mixed: by pair −6.1 / +3.5 / +0.1 %, median +3.2 %, mean −0.8 %, inside each arm's own 48.7-53.9 ms spread. So a capped player there gains no fps, at most smoother frame times.
  • Uncapped, the same PC, for comparison: 78.49 → 84.69 fps (+7.9 %), higher in all 3 pairs, p99 18.40 → 16.93 ms. CPU ms moved under 5 %, so our harness calls 3 pairs "diagnostic".
  • NVIDIA Windows uncapped, Intel, RADV on a desktop (X11, Wayland, a covered window): not run. As my earlier comment said, the Test Farm can't test this switch. It starts every game with HOS_HEADLESS=1, so there is no window and no swapchain, and the renderer never reaches the present path. Those cells need someone to run them by hand. Until then the default is off there, and the description says what would change that: =1 against =0, in a window, uncapped, no lower fps and no higher p99.

Also changed since your review:

  • The fence that #1458's path could leak at a swapchain remake (an image held or asked for ahead, its fence still pending) is now kept and reused once it is signaled, never before. That is #1458's path on every GPU; the test covers both.
  • The docs/tested/ files are gone (#1856).
  • The docs rows moved to docs/dev/reference/switches.md and threads.md.

A second review of the round found no defect. It listed four minor limits, which are now under Risks in the description:

  • the 5 s drain can't give up while the presenter is inside the zero-timeout acquire;
  • the same message-pump case at window close with DLSS-G and =1;
  • frame generation turned off mid-set briefly leaves one more image out;
  • the pool of let-go fences is capped at 8.

The numbers were measured on main 89c3d21e. Main's newer commits (#1866 among them) were merged after the measurement and were not measured again.

🤖 @HumanBean, thank you for the review. Round 3 is pushed (head `ef200041`, main `ed9495bb` merged in). Your points one by one: **Blocking: the switch's default.** Done as you described. `RX_VK_ACQUIRE_AHEAD` now comes from the device policy (`acquire_ahead` in `gpu/vk/device_policy.h`): on when `dev.driver_id == VK_DRIVER_ID_AMD_PROPRIETARY` on `_WIN32`, off with every other driver, which keeps #1458's order. `=0` turns it off and `=1` forces it on anywhere, for A/B runs. The first present logs once which way it went and why, for example `acquire ahead: on by default with AMD's Windows driver ... (RX_VK_ACQUIRE_AHEAD=0: off)`. NVIDIA, Intel and Linux stay off: nothing has been measured there with this design. `tests/test_device_policy.py` and the new test check the choice on both `_WIN32` sides, with broken variants (on with every driver; off with AMD's). **Inline, `switches.def`'s default text.** The row now reads "on with AMD's own driver on Windows, off elsewhere (each image asked for at its present, #1458's order)", with `0` and `1` as the override. **Suggestion: the 600-present counter for `=1` only.** Done. With the default (on with AMD's driver) or `=0`, nothing is counted and no line is printed beyond the one first-present line. The test checks both. **Suggestion: the overlap with #1702.** Since then #1763 put the presenter thread on every PC. That made the old gate ("not while the presenter thread is on") turn this off everywhere. So round 3 moved the ahead acquire onto the presenter thread: - It is made at the end of `presenter_loop()`, after the presenter's own `vkQueuePresentKHR`. - It runs while the presenter still owns the swapchain (`presenter.busy`), under `presenter.mu` and the swapchain's lock. - The render thread reads that state only after its drain of the presenter. - If the drain gives up after 5 s, it clears the request under `presenter.mu`, so no image is asked for ahead after the render thread went on. The presenter thread and acquire ahead no longer compete, so there is no choice to make for NVIDIA between them. It stays off on NVIDIA by default. **Measurements you asked for.** - **AMD Windows at the default 60 cap** (3 pairs, default against `=0`): fps 59.60 → 59.74, no change. p99 was lower in each pair (median 20.19 → 19.29 ms). CPU ms a frame was mixed: by pair −6.1 / +3.5 / +0.1 %, median +3.2 %, mean −0.8 %, inside each arm's own 48.7-53.9 ms spread. So a capped player there gains no fps, at most smoother frame times. - **Uncapped, the same PC, for comparison:** 78.49 → 84.69 fps (+7.9 %), higher in all 3 pairs, p99 18.40 → 16.93 ms. CPU ms moved under 5 %, so our harness calls 3 pairs "diagnostic". - **NVIDIA Windows uncapped, Intel, RADV on a desktop (X11, Wayland, a covered window):** not run. As my earlier comment said, the Test Farm can't test this switch. It starts every game with `HOS_HEADLESS=1`, so there is no window and no swapchain, and the renderer never reaches the present path. Those cells need someone to run them by hand. Until then the default is off there, and the description says what would change that: `=1` against `=0`, in a window, uncapped, no lower fps and no higher p99. **Also changed since your review:** - The fence that #1458's path could leak at a swapchain remake (an image held or asked for ahead, its fence still pending) is now kept and reused once it is signaled, never before. That is #1458's path on every GPU; the test covers both. - The `docs/tested/` files are gone (#1856). - The docs rows moved to `docs/dev/reference/switches.md` and `threads.md`. A second review of the round found no defect. It listed four minor limits, which are now under Risks in the description: - the 5 s drain can't give up while the presenter is inside the zero-timeout acquire; - the same message-pump case at window close with DLSS-G and `=1`; - frame generation turned off mid-set briefly leaves one more image out; - the pool of let-go fences is capped at 8. The numbers were measured on main 89c3d21e. Main's newer commits (#1866 among them) were merged after the measurement and were not measured again.
Author
Member

🤖 @HumanBean, our comments crossed. Two things about your test request:

  • The conflict is gone. The head is now ef200041, which merges main ed9495bb, and Forgejo shows it mergeable. Your acquire-ahead-rebased (cb9c503c) is a rebase of the round-1 commits: the render-thread acquire, off by default, which never engages now that #1763 runs the presenter everywhere. Round 3 replaces those, so the rebase isn't needed unless you'd rather we take it.
  • How to compare on AMD Windows. Since round 3, "unset" is on there by default. So with AMD's Windows driver, =1 against unset compares on with on. RX_VK_ACQUIRE_AHEAD=0 against unset (or against =1) is the comparison that shows the effect. On every other driver, unset is off, so =1 against unset works as you wrote it.

On "not headless": every farm round so far ran with HOS_HEADLESS=1, and headless the switch's code is never reached. If the farm can now run in a window, the vk: acquire ahead: ... line at the first present will show it. The vk: the window's image (600 presents) counter prints only with an explicit =1.

🤖 @HumanBean, our comments crossed. Two things about your test request: - **The conflict is gone.** The head is now `ef200041`, which merges main `ed9495bb`, and Forgejo shows it mergeable. Your `acquire-ahead-rebased` (cb9c503c) is a rebase of the round-1 commits: the render-thread acquire, off by default, which never engages now that #1763 runs the presenter everywhere. Round 3 replaces those, so the rebase isn't needed unless you'd rather we take it. - **How to compare on AMD Windows.** Since round 3, "unset" is on there by default. So with AMD's Windows driver, `=1` against unset compares on with on. `RX_VK_ACQUIRE_AHEAD=0` against unset (or against `=1`) is the comparison that shows the effect. On every other driver, unset is off, so `=1` against unset works as you wrote it. On "not headless": every farm round so far ran with `HOS_HEADLESS=1`, and headless the switch's code is never reached. If the farm can now run in a window, the `vk: acquire ahead: ...` line at the first present will show it. The `vk: the window's image (600 presents)` counter prints only with an explicit `=1`.
Owner

@Beanstalk please test this on windows+amd, windows+nvidia, windows+intel, linux+amd, linux+nvidia and the Steam Deck, in a window (not full screen) with V-Sync Off and frame generation off, not headless: Hyrule Field with the camera turning, then the Castle Town market standing. Compare RX_VK_ACQUIRE_AHEAD=1 against unset, same build, and report fps, p99 and frames over 20 ms, with the vk: acquire ahead and vk: the window's image log lines. We want to know whether the switch should be on by default for everyone. Note: this branch has a conflict with main; a rebase is on HumanBean:acquire-ahead-rebased.

@Beanstalk please test this on windows+amd, windows+nvidia, windows+intel, linux+amd, linux+nvidia and the Steam Deck, in a window (not full screen) with V-Sync Off and frame generation off, not headless: Hyrule Field with the camera turning, then the Castle Town market standing. Compare RX_VK_ACQUIRE_AHEAD=1 against unset, same build, and report fps, p99 and frames over 20 ms, with the vk: acquire ahead and vk: the window's image log lines. We want to know whether the switch should be on by default for everyone. Note: this branch has a conflict with main; a rebase is on HumanBean:acquire-ahead-rebased.
Member
Beanstalk test farm · an earlier run: commit ef20004 (the newer results are in a comment below)

Commit ef20004 · approved by HumanBean (reviewed) · dashboard

Started at 18:22 UTC.

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

Target Result Reports Frame time p99 (ms), switch off → switch on VRAM peak (MB) Crashes
windows+amd ❌ fail 1 1 16.9 → 17.2 (+2%) — none
windows+nvidia ❌ fail 1 1 16.2 → 15.3 (−5%) — none
windows+intel ⏳ queued 0 of 1 — — —
linux+amd ❌ fail (an outlier) 2 1 2 18.3 → 19.5 (+7%) — none
linux+nvidia ❌ fail (an outlier) 2 1 2 13.8 → 13.3 (−4%) — none
steamdeck ⏳ queued 0 of 1 — — —

Why it failed

  • windows+amd: field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) market.fps_mean.min_delta_pct: 53.8 → 41.6 (−22.7%); limit 10.0
  • windows+amd: field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) screenshot.max_diff: limit 0.1
  • windows+amd: field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) log_expected_missing.max: 2.0 → 2.0; limit 0.0
  • windows+nvidia: field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) screenshot.max_diff: limit 0.1
  • windows+nvidia: field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) log_expected_missing.max: 2.0 → 2.0; limit 0.0
  • linux+amd: field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) log_expected_missing.max: 2.0 → 2.0; limit 0.0
  • linux+amd: field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) screenshot.max_diff: limit 0.1
  • linux+nvidia: field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) screenshot.max_diff: limit 0.1
  • and 1 more, in the reports
What was tested

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

This headless diagnostic runs Hyrule Field and the Market on the six requested hardware targets, comparing the PR build with acquire-ahead forced on against its default in about 12 minutes per tester. It records FPS and p99, with a camera turn before the Field measurement, but cannot count frames over 20 ms. The farm cannot exercise the window-present path, so the required present-path logs will be missing and fail the test; the results cannot establish whether the switch should be on by default. Windows Intel has no tester listed online and will wait for one; on AMD Windows, forced-on versus unset may compare on against on. No tester online now matches windows+intel: that target waits for one.

  • Where: windows+amd (1-2 reports), windows+nvidia (1-2 reports), windows+intel (1-2 reports), linux+amd (1-2 reports), linux+nvidia (1-2 reports), steamdeck (1-2 reports).
  • Against: the PR itself, switch on (RX_VK_ACQUIRE_AHEAD) and off; main is not built or run.
  • Matrix: 1 cell, each with the switch on and off: RX_VK_ACQUIRE_AHEAD 1 (PR only).
  • field-and-market: from the repository's save kokiri-start (settings vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0), then teleport to Hyrule Field, move the stick, take the picture field to compare with the switch off, measure field for 20 s (after 5 s warm-up), teleport to Market, take the picture market to compare with the switch off, measure market for 20 s (after 5 s warm-up); 1 run on each side.
  • Measured: crashes, frame times, stutters and hitches, draws and frame rate, the game's log.
  • The PR fails if: it crashes; or frame rate is more than 10% below main; or a picture differs from main by more than 5%; or frame time (p99) is more than 10% above main; or forbidden log lines is above 0; or expected log lines missing is above 0.
  • Time: about 12 min of game runs per tester (2 game starts), plus the two builds.
Measurements on `windows+amd`, for the PR description

Verdict: fail on windows+amd (1 report): field-and-market market.fps_mean.min_delta_pct (-22.7%); field-and-market screenshot.max_diff; field-and-market log_expected_missing.max failed.

Hardware: 1: windows+amd+amd-proprietary+dgpu AMD Radeon RX 9070 XT, 2.0.416 AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM
Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 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)

Before: this PR @ ef20004, switch off After: this PR @ ef20004, switch on
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 80.9 84.1 (+4%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · market · frame rate 53.8 41.6 (−23%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 16.9 17.2 (+2%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · market · frame time (p99) (ms) 29.9 36.5 (+22%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · expected log lines missing 2.0 2.0 (+0%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 1 off (the switch's default) the PR's default field-and-market, main without it → the PR with 1: 80.9 → 84.1 (+4%) helps

As Markdown for the PR description:

## Measurements

**Verdict:** fail on windows+amd (1 report): `field-and-market market.fps_mean.min_delta_pct (-22.7%)`; `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed.

Hardware: 1: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM`  
Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 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)

| | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on |
|---|---|---|
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 80.9 | 84.1 (+4%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 53.8 | 41.6 (−23%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 16.9 | 17.2 (+2%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 29.9 | 36.5 (+22%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) |

**Flags and settings**

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 80.9 → 84.1 (+4%) | helps |
Measurements on `windows+nvidia`, for the PR description

Verdict: fail on windows+nvidia (1 report): field-and-market screenshot.max_diff; field-and-market log_expected_missing.max failed.

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3070, 621.24.0 AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM
Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 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)

Before: this PR @ ef20004, switch off After: this PR @ ef20004, switch on
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 86.7 85.5 (−1%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · market · frame rate 60.7 60.4 (−1%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 16.2 15.3 (−5%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · market · frame time (p99) (ms) 21.5 22.5 (+4%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · expected log lines missing 2.0 2.0 (+0%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 1 off (the switch's default) the PR's default field-and-market, main without it → the PR with 1: 86.7 → 85.5 (−1%) no clear effect

As Markdown for the PR description:

## Measurements

**Verdict:** fail on windows+nvidia (1 report): `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed.

Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3070, 621.24.0` `AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM`  
Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 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)

| | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on |
|---|---|---|
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 86.7 | 85.5 (−1%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 60.7 | 60.4 (−1%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 16.2 | 15.3 (−5%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 21.5 | 22.5 (+4%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) |

**Flags and settings**

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 86.7 → 85.5 (−1%) | no clear effect |
Measurements on `linux+amd`, for the PR description

Verdict: fail on linux+amd (2 reports): field-and-market log_expected_missing.max; field-and-market screenshot.max_diff failed.

Hardware: 1: linux+amd+radv+dgpu AMD Radeon RX 6600 (RADV NAVI23), 26.2.6 AMD Ryzen 5 5600X 6-Core Processor, 64 GB RAM; 2: linux+amd+radv+igpu AMD Radeon 890M Graphics (RADV STRIX1), 26.1.99 AMD Ryzen Z2 Extreme, 32 GB RAM
Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: this PR @ ef20004, switch off After: this PR @ ef20004, switch on
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 73.0 70.6 (−3%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · market · frame rate 35.3 38.0 (+8%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 18.3 19.5 (+7%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · market · frame time (p99) (ms) 72.8 64.0 (−12%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · expected log lines missing 2.0 2.0 (+0%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 1 off (the switch's default) the PR's default field-and-market, main without it → the PR with 1: 73.0 → 70.6 (−3%) doesn't help

As Markdown for the PR description:

## Measurements

**Verdict:** fail on linux+amd (2 reports): `field-and-market log_expected_missing.max`; `field-and-market screenshot.max_diff` failed.

Hardware: 1: linux+amd+radv+dgpu `AMD Radeon RX 6600 (RADV NAVI23), 26.2.6` `AMD Ryzen 5 5600X 6-Core Processor, 64 GB RAM`; 2: linux+amd+radv+igpu `AMD Radeon 890M Graphics (RADV STRIX1), 26.1.99` `AMD Ryzen Z2 Extreme, 32 GB RAM`  
Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on |
|---|---|---|
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 73.0 | 70.6 (−3%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 35.3 | 38.0 (+8%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 18.3 | 19.5 (+7%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 72.8 | 64.0 (−12%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) |

**Flags and settings**

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 73.0 → 70.6 (−3%) | doesn't help |
Measurements on `linux+nvidia`, for the PR description

Verdict: fail on linux+nvidia (2 reports): field-and-market screenshot.max_diff; field-and-market log_expected_missing.max failed.

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce GTX 1070, 580.196.7 Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 5080, 620.73.4 AMD Ryzen 7 7800X3D 8-Core Processor, 32 GB RAM
Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (@Beanstalk on this PR runs it again)

Before: this PR @ ef20004, switch off After: this PR @ ef20004, switch on
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame rate 111.2 115.7 (+4%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · market · frame rate 78.5 77.5 (−1%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · field · frame time (p99) (ms) 13.8 13.3 (−4%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · market · frame time (p99) (ms) 20.0 21.1 (+6%)
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · forbidden log lines 0.0 0.0
field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only) · expected log lines missing 2.0 2.0 (+0%)

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (frame rate) Helps / doesn't help / untested
RX_VK_ACQUIRE_AHEAD switch the PR adds (set on the PR side only) 1 off (the switch's default) the PR's default field-and-market, main without it → the PR with 1: 111.2 → 115.7 (+4%) helps

As Markdown for the PR description:

## Measurements

**Verdict:** fail on linux+nvidia (2 reports): `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed.

Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce GTX 1070, 580.196.7` `Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5080, 620.73.4` `AMD Ryzen 7 7800X3D 8-Core Processor, 32 GB RAM`  
Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them  
Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports  
How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again)

| | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on |
|---|---|---|
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 111.2 | 115.7 (+4%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 78.5 | 77.5 (−1%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 13.8 | 13.3 (−4%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 20.0 | 21.1 (+6%) |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 |
| field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) |

**Flags and settings**

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 111.2 → 115.7 (+4%) | helps |
The testers' hardware
Target Report Ran on
windows+amd 1 windows+amd+amd-proprietary+dgpu AMD Radeon RX 9070 XT, 2.0.416 AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM
windows+nvidia 1 windows+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 3070, 621.24.0 AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM
linux+amd 1 linux+amd+radv+dgpu AMD Radeon RX 6600 (RADV NAVI23), 26.2.6 AMD Ryzen 5 5600X 6-Core Processor, 64 GB RAM
linux+amd 2 linux+amd+radv+igpu AMD Radeon 890M Graphics (RADV STRIX1), 26.1.99 AMD Ryzen Z2 Extreme, 32 GB RAM
linux+nvidia 1 linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce GTX 1070, 580.196.7 Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM
linux+nvidia 2 linux+nvidia+nvidia-proprietary+dgpu NVIDIA GeForce RTX 5080, 620.73.4 AMD Ryzen 7 7800X3D 8-Core Processor, 32 GB RAM
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>ef20004</code> (the newer results are in a comment below)</summary> Commit `ef20004` · approved by HumanBean (reviewed) · [dashboard](https://beanstalk.magicbean.dev/prs/1574) Started at 18:22 UTC. **Estimate:** done in about 5 h 30 min, from the queue and the testers online now; some jobs can't start yet. | Target | Result | Reports | Frame time p99 (ms), switch off → switch on | VRAM peak (MB) | Crashes | | --- | --- | --- | --- | --- | --- | | `windows+amd` | ❌ fail | 1 [1](https://beanstalk.magicbean.dev/reports/rp_6af627e4dfcef5f5) | 16.9 → 17.2 (+2%) | — | none | | `windows+nvidia` | ❌ fail | 1 [1](https://beanstalk.magicbean.dev/reports/rp_d16809a10e31f72a) | 16.2 → 15.3 (−5%) | — | none | | `windows+intel` | ⏳ queued | 0 of 1 | — | — | — | | `linux+amd` | ❌ fail (an outlier) | 2 [1](https://beanstalk.magicbean.dev/reports/rp_f6c52862f071f12f) [2](https://beanstalk.magicbean.dev/reports/rp_16f6aed5b5728fa1) | 18.3 → 19.5 (+7%) | — | none | | `linux+nvidia` | ❌ fail (an outlier) | 2 [1](https://beanstalk.magicbean.dev/reports/rp_9b9c5c333b3da1d9) [2](https://beanstalk.magicbean.dev/reports/rp_72c9a7fa004d23aa) | 13.8 → 13.3 (−4%) | — | none | | `steamdeck` | ⏳ queued | 0 of 1 | — | — | — | **Why it failed** - `windows+amd`: `field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `market.fps_mean.min_delta_pct`: `53.8 → 41.6 (−22.7%); limit 10.0` - `windows+amd`: `field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `screenshot.max_diff`: `limit 0.1` - `windows+amd`: `field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `log_expected_missing.max`: `2.0 → 2.0; limit 0.0` - `windows+nvidia`: `field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `screenshot.max_diff`: `limit 0.1` - `windows+nvidia`: `field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `log_expected_missing.max`: `2.0 → 2.0; limit 0.0` - `linux+amd`: `field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `log_expected_missing.max`: `2.0 → 2.0; limit 0.0` - `linux+amd`: `field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `screenshot.max_diff`: `limit 0.1` - `linux+nvidia`: `field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)` `screenshot.max_diff`: `limit 0.1` - and 1 more, in the reports <details><summary>What was tested</summary> **What will be tested** · AI plan (`gpt-6.1-terra`) This headless diagnostic runs Hyrule Field and the Market on the six requested hardware targets, comparing the PR build with acquire-ahead forced on against its default in about 12 minutes per tester. It records FPS and p99, with a camera turn before the Field measurement, but cannot count frames over 20 ms. The farm cannot exercise the window-present path, so the required present-path logs will be missing and fail the test; the results cannot establish whether the switch should be on by default. Windows Intel has no tester listed online and will wait for one; on AMD Windows, forced-on versus unset may compare on against on. No tester online now matches windows+intel: that target waits for one. - **Where:** windows+amd (1-2 reports), windows+nvidia (1-2 reports), windows+intel (1-2 reports), linux+amd (1-2 reports), linux+nvidia (1-2 reports), steamdeck (1-2 reports). - **Against:** the PR itself, switch on (`RX_VK_ACQUIRE_AHEAD`) and off; main is not built or run. - **Matrix:** 1 cell, each with the switch on and off: RX_VK_ACQUIRE_AHEAD `1` (PR only). - **field-and-market:** from the repository's save `kokiri-start` (settings vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0), then teleport to Hyrule Field, move the stick, take the picture field to compare with the switch off, measure field for 20 s (after 5 s warm-up), teleport to Market, take the picture market to compare with the switch off, measure market for 20 s (after 5 s warm-up); 1 run on each side. - **Measured:** crashes, frame times, stutters and hitches, draws and frame rate, the game's log. - **The PR fails if:** it crashes; or frame rate is more than 10% below main; or a picture differs from main by more than 5%; or frame time (p99) is more than 10% above main; or forbidden log lines is above 0; or expected log lines missing is above 0. - **Time:** about 12 min of game runs per tester (2 game starts), plus the two builds. </details> <details><summary>Measurements on `windows+amd`, for the PR description</summary> **Verdict:** fail on windows+amd (1 report): `field-and-market market.fps_mean.min_delta_pct (-22.7%)`; `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed. Hardware: 1: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM` Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 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) | | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on | |---|---|---| | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 80.9 | 84.1 (+4%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 53.8 | 41.6 (−23%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 16.9 | 17.2 (+2%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 29.9 | 36.5 (+22%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 80.9 → 84.1 (+4%) | helps | As Markdown for the PR description: ```markdown ## Measurements **Verdict:** fail on windows+amd (1 report): `field-and-market market.fps_mean.min_delta_pct (-22.7%)`; `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed. Hardware: 1: windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM` Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 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) | | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on | |---|---|---| | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 80.9 | 84.1 (+4%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 53.8 | 41.6 (−23%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 16.9 | 17.2 (+2%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 29.9 | 36.5 (+22%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 80.9 → 84.1 (+4%) | helps | ``` </details> <details><summary>Measurements on `windows+nvidia`, for the PR description</summary> **Verdict:** fail on windows+nvidia (1 report): `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed. Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3070, 621.24.0` `AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM` Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 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) | | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on | |---|---|---| | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 86.7 | 85.5 (−1%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 60.7 | 60.4 (−1%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 16.2 | 15.3 (−5%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 21.5 | 22.5 (+4%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 86.7 → 85.5 (−1%) | no clear effect | As Markdown for the PR description: ```markdown ## Measurements **Verdict:** fail on windows+nvidia (1 report): `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed. Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3070, 621.24.0` `AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM` Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 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) | | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on | |---|---|---| | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 86.7 | 85.5 (−1%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 60.7 | 60.4 (−1%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 16.2 | 15.3 (−5%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 21.5 | 22.5 (+4%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 86.7 → 85.5 (−1%) | no clear effect | ``` </details> <details><summary>Measurements on `linux+amd`, for the PR description</summary> **Verdict:** fail on linux+amd (2 reports): `field-and-market log_expected_missing.max`; `field-and-market screenshot.max_diff` failed. Hardware: 1: linux+amd+radv+dgpu `AMD Radeon RX 6600 (RADV NAVI23), 26.2.6` `AMD Ryzen 5 5600X 6-Core Processor, 64 GB RAM`; 2: linux+amd+radv+igpu `AMD Radeon 890M Graphics (RADV STRIX1), 26.1.99` `AMD Ryzen Z2 Extreme, 32 GB RAM` Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on | |---|---|---| | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 73.0 | 70.6 (−3%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 35.3 | 38.0 (+8%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 18.3 | 19.5 (+7%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 72.8 | 64.0 (−12%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 73.0 → 70.6 (−3%) | doesn't help | As Markdown for the PR description: ```markdown ## Measurements **Verdict:** fail on linux+amd (2 reports): `field-and-market log_expected_missing.max`; `field-and-market screenshot.max_diff` failed. Hardware: 1: linux+amd+radv+dgpu `AMD Radeon RX 6600 (RADV NAVI23), 26.2.6` `AMD Ryzen 5 5600X 6-Core Processor, 64 GB RAM`; 2: linux+amd+radv+igpu `AMD Radeon 890M Graphics (RADV STRIX1), 26.1.99` `AMD Ryzen Z2 Extreme, 32 GB RAM` Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on | |---|---|---| | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 73.0 | 70.6 (−3%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 35.3 | 38.0 (+8%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 18.3 | 19.5 (+7%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 72.8 | 64.0 (−12%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 73.0 → 70.6 (−3%) | doesn't help | ``` </details> <details><summary>Measurements on `linux+nvidia`, for the PR description</summary> **Verdict:** fail on linux+nvidia (2 reports): `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed. Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce GTX 1070, 580.196.7` `Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5080, 620.73.4` `AMD Ryzen 7 7800X3D 8-Core Processor, 32 GB RAM` Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on | |---|---|---| | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 111.2 | 115.7 (+4%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 78.5 | 77.5 (−1%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 13.8 | 13.3 (−4%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 20.0 | 21.1 (+6%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 111.2 → 115.7 (+4%) | helps | As Markdown for the PR description: ```markdown ## Measurements **Verdict:** fail on linux+nvidia (2 reports): `field-and-market screenshot.max_diff`; `field-and-market log_expected_missing.max` failed. Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce GTX 1070, 580.196.7` `Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM`; 2: linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5080, 620.73.4` `AMD Ryzen 7 7800X3D 8-Core Processor, 32 GB RAM` Scene: field-and-market, from the repository's save kokiri-start (vsync=2, fullscreen=0, frame_rate_cap=6, frame_generation=0); each cell's settings and switches as the table names them Method: the Beanstalk test farm: this PR built once and run with its PR-only switches on and off on the same PC in one session, game starts alternating (ABBA); field-and-market: 1 game start a side, field 20 s after 5 s warm-up, market 20 s after 5 s warm-up; each number the median of the runs, then of 2 reports How to reproduce: the farm's plan above (`@Beanstalk` on this PR runs it again) | | Before: this PR @ ef20004, switch off | After: this PR @ ef20004, switch on | |---|---|---| | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame rate | 111.2 | 115.7 (+4%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame rate | 78.5 | 77.5 (−1%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · field · frame time (p99) (ms) | 13.8 | 13.3 (−4%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · market · frame time (p99) (ms) | 20.0 | 21.1 (+6%) | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · forbidden log lines | 0.0 | 0.0 | | field-and-market · `RX_VK_ACQUIRE_AHEAD=1 (PR only)` · expected log lines missing | 2.0 | 2.0 (+0%) | **Flags and settings** | Flag | What it is | Values tried | Before this PR | After this PR | Effect (frame rate) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_ACQUIRE_AHEAD` | switch the PR adds (set on the PR side only) | `1` | off (the switch's default) | the PR's default | field-and-market, main without it → the PR with 1: 111.2 → 115.7 (+4%) | helps | ``` </details> <details><summary>The testers' hardware</summary> | Target | Report | Ran on | | --- | --- | --- | | `windows+amd` | [1](https://beanstalk.magicbean.dev/reports/rp_6af627e4dfcef5f5) | windows+amd+amd-proprietary+dgpu `AMD Radeon RX 9070 XT, 2.0.416` `AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAM` | | `windows+nvidia` | [1](https://beanstalk.magicbean.dev/reports/rp_d16809a10e31f72a) | windows+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 3070, 621.24.0` `AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM` | | `linux+amd` | [1](https://beanstalk.magicbean.dev/reports/rp_f6c52862f071f12f) | linux+amd+radv+dgpu `AMD Radeon RX 6600 (RADV NAVI23), 26.2.6` `AMD Ryzen 5 5600X 6-Core Processor, 64 GB RAM` | | `linux+amd` | [2](https://beanstalk.magicbean.dev/reports/rp_16f6aed5b5728fa1) | linux+amd+radv+igpu `AMD Radeon 890M Graphics (RADV STRIX1), 26.1.99` `AMD Ryzen Z2 Extreme, 32 GB RAM` | | `linux+nvidia` | [1](https://beanstalk.magicbean.dev/reports/rp_9b9c5c333b3da1d9) | linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce GTX 1070, 580.196.7` `Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM` | | `linux+nvidia` | [2](https://beanstalk.magicbean.dev/reports/rp_72c9a7fa004d23aa) | linux+nvidia+nvidia-proprietary+dgpu `NVIDIA GeForce RTX 5080, 620.73.4` `AMD Ryzen 7 7800X3D 8-Core Processor, 32 GB RAM` | </details> </details>
Owner

Linux NVIDIA results, for the "Linux RADV and NVIDIA" item in Still to test (the NVIDIA half): Linux (CachyOS, kernel 7.3, Wayland), RTX 3090 (NVIDIA 620.x), Ryzen 9 7900X, this PR @ ef200041, one runtime with RX_VK_ACQUIRE_AHEAD=0 against =1. dev.py ab --scene market --seconds 30, a 2560x1440 window, uncapped, V-Sync Auto (mailbox), frame generation off; every clean run of three A/Bs (A, B interleaved; 3 runs failed at the teleport, a test-driver issue fixed in #1922, not this PR):

Market, 30 s =0 (main's order) =1 (acquire ahead)
fps, each run 96.0, 89.7, 87.8, 98.2 98.1, 88.9, 90.4, 98.4, 96.4
fps, median 92.9 96.4 (+3.8%)
p99 ms, each run 13.5, 18.3, 19.6, 11.9 12.4, 15.3, 25.5, 12.0, 14.0
the render thread's presents, ms a frame (a 10 min session each) 1.27 1.20

No crash, hang or Vulkan error; the swapchain was remade at every start. The fps spread between runs (88-98) is larger than the difference, so this is even to slightly better on NVIDIA's Linux driver, not a measured gain: unlike AMD's Windows driver (2.3-2.7 ms of presents a frame down to 0.24), NVIDIA here hardly makes the render thread wait for the next image, so there is little for the acquire ahead to take off.

Linux NVIDIA results, for the "Linux RADV and NVIDIA" item in Still to test (the NVIDIA half): Linux (CachyOS, kernel 7.3, Wayland), RTX 3090 (NVIDIA 620.x), Ryzen 9 7900X, this PR @ ef200041, one runtime with `RX_VK_ACQUIRE_AHEAD=0` against `=1`. `dev.py ab --scene market --seconds 30`, a 2560x1440 window, uncapped, V-Sync Auto (mailbox), frame generation off; every clean run of three A/Bs (A, B interleaved; 3 runs failed at the teleport, a test-driver issue fixed in #1922, not this PR): | Market, 30 s | `=0` (main's order) | `=1` (acquire ahead) | |---|---|---| | fps, each run | 96.0, 89.7, 87.8, 98.2 | 98.1, 88.9, 90.4, 98.4, 96.4 | | fps, median | 92.9 | 96.4 (+3.8%) | | p99 ms, each run | 13.5, 18.3, 19.6, 11.9 | 12.4, 15.3, 25.5, 12.0, 14.0 | | the render thread's presents, ms a frame (a 10 min session each) | 1.27 | 1.20 | No crash, hang or Vulkan error; the swapchain was remade at every start. The fps spread between runs (88-98) is larger than the difference, so this is even to slightly better on NVIDIA's Linux driver, not a measured gain: unlike AMD's Windows driver (2.3-2.7 ms of presents a frame down to 0.24), NVIDIA here hardly makes the render thread wait for the next image, so there is little for the acquire ahead to take off.
perf(vk): acquire ahead on by default with every driver, not only AMD's on Windows
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 23s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 35s
CI / Workflow lint (actionlint) (pull_request) Successful in 36s
Third-party parts / As their notes say (pull_request) Successful in 41s
PR description / Description follows the template (pull_request_target) Successful in 21s
beanstalk/approval not approved yet
CI / Website build and checks (pull_request) Failing after 2m10s
623740d540
RX_VK_ACQUIRE_AHEAD's default moves from AMD's Windows driver only to every
driver: the presenter thread asks for the window's next image right after each
present everywhere, still never under frame generation or FIFO (V-Sync On).
RX_VK_ACQUIRE_AHEAD=0 keeps #1458's order as the off switch.

device_policy.h's acquire_ahead_default rule is gone; the first present's line
says "on by default"; the switch row, the docs and both checks follow.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Member

Beanstalk test farm

Commit 623740d · approved by nobody yet · dashboard

A member of BigBeans can review this commit and comment @Beanstalk to test it.

<!-- beanstalk:sticky --> ### Beanstalk test farm Commit `623740d` · approved by nobody yet · [dashboard](https://beanstalk.magicbean.dev/prs/1574) A member of `BigBeans` can review this commit and comment `@Beanstalk` to test it.
HumanBean changed title from perf(vk): ask for the window's next image on the presenter thread right after a present, so the render thread stops waiting for it (on with AMD's Windows driver) to perf(vk): ask for the window's next image on the presenter thread right after a present, so the render thread stops waiting for it 2026-11-20 22:10:52 +00:00
HumanBean approved these changes 2026-11-20 22:17:57 +00:00
HumanBean left a comment

Approve. Round 3 settles my earlier review: the default comes from the device policy, the counter prints only with =1, and the ahead acquire moved onto the presenter thread, under presenter.mu while it owns the swapchain, with a drain that gave up clearing the request. On top of it, 623740d turns it on by default with every driver (still never under frame generation or FIFO); RX_VK_ACQUIRE_AHEAD=0 stays the off switch. That is a maintainer's call on thin evidence: +7.9% uncapped on one RX 9070 XT with AMD's Windows driver, +3.8% by median on a Linux RTX 3090 in a window (overlapping runs). The farm can't check it (its runs are headless), so the by-hand items in Still to test now check the default. Nothing was run for this review; the policy and fixture edits in 623740d have not been run either.

Approve. Round 3 settles my earlier review: the default comes from the device policy, the counter prints only with =1, and the ahead acquire moved onto the presenter thread, under presenter.mu while it owns the swapchain, with a drain that gave up clearing the request. On top of it, 623740d turns it on by default with every driver (still never under frame generation or FIFO); RX_VK_ACQUIRE_AHEAD=0 stays the off switch. That is a maintainer's call on thin evidence: +7.9% uncapped on one RX 9070 XT with AMD's Windows driver, +3.8% by median on a Linux RTX 3090 in a window (overlapping runs). The farm can't check it (its runs are headless), so the by-hand items in Still to test now check the default. Nothing was run for this review; the policy and fixture edits in 623740d have not been run either.
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
4 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!1574
No description provided.