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
No reviewers
Labels
No labels
area/accessibility
area/audio
area/input
area/install
area/menu
area/renderer
area/saves
area/tooling
area/upscaling
beanstalk: approved
beanstalk: failed
beanstalk: needs approval
beanstalk: running
beanstalk: tested
ci: approved
good first issue
gpu/amd
gpu/igpu
gpu/intel
gpu/nvidia
help wanted
kind
bug
kind
chore
kind
docs
kind
feature
kind
performance
kind
question
needs measurements
platform/linux
platform/macos
platform/steam-deck
platform/windows
preview
priority
critical
priority
high
priority
low
regression
risk
high
risk
low
risk
medium
status
blocked
status
confirmed
status
duplicate
status
invalid
status
needs-info
status
wontfix
ci: approved
No milestone
No project
No assignees
4 participants
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
MagicBeanDev/Longshot!1574
Loading…
Reference in a new issue
No description provided.
Delete branch "klimovich008/Longshot:perf/acquire-ahead"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
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:
RX_VK_ACQUIRE_AHEAD=0turns it off (#1458's order: each image asked for at its own present);=1forces it on, for A/B runs.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()andacquire_ahead_wanted(), the end ofpresenter_loop(),present_hand_off()andpresent_thread_drain(); thenheld_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 isacquire_aheadingpu/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 main89c3d21e) over main's game build, then the checks again on this head (ef200041, mained9495bbmerged):=0. The default logs once at the first present that it is on by AMD's driver. At each V-Sync On it logsnot now, the swapchain is FIFO, and back at Auto it is on again. No error-line kind that the=0run lacks; nonot given back,not made in 5 s, device lost or out-of-date line. Game clock 0.99-1.01 after the load.=1and=0(HDR on and off too), and one=1session under Vulkan validation: no message naming acquire, present, swapchain or a fence, noSYNC-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 withoutpresenter.muheld, 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 mained9495bbthey pass again, and so do main's present and recorder tests that changed since (#1866's among them).tests/run_all.py --jobs 4, Windows, llvm-mingw) on this headef200041: 763 passed, 69 failed, 54 skipped. Clean mained9495bb: 761 / 70 / 54. Every failure here also fails on main: the 68 test files below, plus the auto-profile checkAuto-controlled shadow_res missing(the list below; most need tools or a build this PC's run lacks);test_recording_admissionfailed on main only.The failing tests, the same on main
ed9495bbtest_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.pyvk_replay.cppcompiles 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 whereRX_VK_ACQUIRE_AHEADacts. 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:
RX_VK_ACQUIRE_AHEAD=0against 3 with=1, expecting no lower fps and no higher p99 before it could be on there (by hand: the farm runs headless).=1against=0in Hyrule Field, expecting no change (by hand).not nowline and a picture as with=0(by hand).the GPU has finished nothingline 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 at95bdfd06. "Before" isRX_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=0in this PR's own build, not main's build. With=0the 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.=0(main's order) @95bdfd0695bdfd06=0The 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=0against=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.=0(main's order)=1(acquire ahead)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 mergesed9495bb, 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):
presenter.muthere. A zero-timeoutvkAcquireNextImageKHRthat 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.=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 acrossvkQueuePresentKHR; this adds a zero-timeout window of the same kind.How to turn it off:
RX_VK_ACQUIRE_AHEAD=0inlongshot_env.txt; a revert is also enough. What a player notices after updating: nothing in saves,longshot_options.inior the shader and pipeline caches (no translator file orvk_api.htouched); 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
main; the title is a Conventional Commit.mise run testpasses (any failure that also fails onmainis named).main, or Measurements says why there is nothing to measure.third_party/untouched; nothing GPL-incompatible.When it applies
gpu/vk/switches.def.tests/that reads changed source is updated, not weakened.Assisted-by:/Co-Authored-By:trailers.Ready to merge
main, measured again or a comment says why the numbers still hold.🤖 Generated with Claude Code
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.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)@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=1inlongshot_env.txt, and post both runs' fps, your Threaded rendering setting, the switch run'svk: 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: onin 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.@klimovich008 only members of
BigBeanscan start the farm. One of them can approve this request by reacting 👍 to it or to this comment.@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_AHEADunset vs=1, interleaved, in Kokiri standing and Hyrule Field turning. We'll check engagement fromacquire ahead: onand report fps, p99, frames over 50 ms and thevk: 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.
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) · dashboardWhat 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.
1(PR only).Started at 2026-11-18 13:08 UTC.
NVIDIA GeForce RTX 3090, 621.24.0; 2: linux+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 4070, 615.71.9NVIDIA GeForce RTX 4070, 615.71.9; 2: linux+otherunknown, unknownAMD Custom GPU 0405 (RADV VANGOGH), 26.1.99Measurements · 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.0AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 4070, 615.71.9AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)430eef42f24a49RX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)Flags and settings
RX_VK_ACQUIRE_AHEAD1Markdown for the PR description
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.9AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM; 2: linux+otherunknown, unknownAMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)430eef42f24a49RX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)Flags and settings
RX_VK_ACQUIRE_AHEAD1Markdown for the PR description
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.99AMD Custom APU 0405, 16 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)430eef42f24a49RX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)Flags and settings
RX_VK_ACQUIRE_AHEAD1Markdown for the PR description
@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, withRX_VK_ACQUIRE_AHEADunset (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:
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:
No GPU fault or reset in any run.
No default recommendation from this.
@dukenheimer, thank you: that is the case I could not run here (gamescope's mailbox swapchain, threaded rendering off). How I read it:
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.
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.
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 whereverRX_VK_ACQUIRE_AHEAD=1reached the game.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.
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).@Beanstalk
@HumanBean
2f24a49is already running: see the dashboard.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 setRX_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:What would fix it: make the default automatic, at least on
dev.driver_id == VK_DRIVER_ID_AMD_PROPRIETARYon_WIN32. That is exactly the "image back at once, wait in the fence" case you measured. Keep=0as the off switch and=1to 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
vk: the window's image (600 presents)counter for an explicit=1only. That way players' logs don't get a new line every 600 presents.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:
@ -229,6 +229,7 @@ SW(RX_NVN_WATCH_ALL, diag, bool, "off: the Resource Memory thread's writes are nSW(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.")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/=1as the override.@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 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) · dashboardWhat 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.
0or1(PR only).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).Done (started 07:57 UTC, last report 08:55 UTC). Run 2: re-planned by HumanBean. Comment
@Beanstalkto run it again.NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0; 2: linux+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 4070, 615.71.9RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)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.0AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 4070, 615.71.9AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)430eef42f24a49RX_VK_ACQUIRE_AHEAD=0 (PR only)· hitches over 50 ms in the whole runRX_VK_ACQUIRE_AHEAD=0 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=0 (PR only)· worst frame time in the whole run (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· vsync-on · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· vsync-off · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· vsync-restored · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· hitches over 50 ms in the whole runRX_VK_ACQUIRE_AHEAD=1 (PR only)· vsync-on · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· vsync-off · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· vsync-restored · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· worst frame time in the whole run (ms)Flags and settings
RX_VK_ACQUIRE_AHEAD0,1Markdown for the PR description
@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) andframe_generation = 0in every cell, windowed (fullscreen = 0), with no live V-Sync toggle this time. JudgeRX_VK_ACQUIRE_AHEAD=1against=0in the PR's own build with[[pass.compare]]onfps_meanandframetime_p99_ms, alongside the usual comparison with main. Use Hyrule Field fromkokiri-start, a 10 s warm-up, then measure 30 s, 3 runs a side, so one game start can't decide it. Addrun_hitch_countandrun_frametime_max_msas 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 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) · dashboardWhat 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.
0or1(PR only).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).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.
NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0; 2: windows+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 3090, 621.24.0NVIDIA GeForce RTX 5070, 620.70.6AMD Radeon(TM) 880M Graphics, 2.0.416; 2: windows+amd+amd-proprietary+dgpuAMD Radeon RX 7900 XTX, 2.0.416AMD Radeon RX 7900 XTX (RADV NAVI31), 26.2.7; 2: linux+amd+radv+dgpuAMD Radeon RX 9070 XT (RADV GFX1201), 26.2.6AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99Run by hand on PCs that don't match their target (not counted toward it):
NVIDIA GeForce RTX 4070 Ti, 621.14.0)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)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.0AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM; 2: windows+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 3090, 621.24.0AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)430eef42f24a49RX_VK_ACQUIRE_AHEAD=0 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesFlags and settings
RX_VK_ACQUIRE_AHEAD0,1Markdown for the PR description
Measurements · linux+nvidia
Verdict: queued on linux+nvidia (1/1 report).
Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu
NVIDIA GeForce RTX 5070, 620.70.6AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)430eef42f24a49RX_VK_ACQUIRE_AHEAD=0 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesFlags and settings
RX_VK_ACQUIRE_AHEAD0,1Markdown for the PR description
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.416AMD Ryzen AI 9 365 w/ Radeon 880M, 32 GB RAM; 2: windows+amd+amd-proprietary+dgpuAMD Radeon RX 7900 XTX, 2.0.416AMD Ryzen 7 5800X3D 8-Core Processor, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)Nothing was measured: no metric came back.
Flags and settings
RX_VK_ACQUIRE_AHEAD0,1Markdown for the PR description
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.7AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAM; 2: linux+amd+radv+dgpuAMD Radeon RX 9070 XT (RADV GFX1201), 26.2.611th Gen Intel(R) Core(TM) i9-11900KB @ 3.30GHz, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)430eef42f24a49RX_VK_ACQUIRE_AHEAD=0 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesFlags and settings
RX_VK_ACQUIRE_AHEAD0,1Markdown for the PR description
Measurements · steamdeck
Verdict: queued on steamdeck (1/1 report).
Hardware: 1: linux+amd+radv+igpu+handheld
AMD Custom GPU 0405 (RADV VANGOGH), 26.1.99AMD Custom APU 0405, 12 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)430eef42f24a49RX_VK_ACQUIRE_AHEAD=0 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesFlags and settings
RX_VK_ACQUIRE_AHEAD0,1Markdown for the PR description
HumanBean referenced this pull request2026-11-19 17:34:44 +00:00
@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=0cell never ran and nothing compared=1with=0. One Windows NVIDIA tester also failed before building:git -C Z:\longshot diff --name-only HEADexited 128 indev_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 fromkokiri-start, 10 s warm-up, 30 s measured, 2 runs a side. JudgeRX_VK_ACQUIRE_AHEAD=1against=0in the PR's own build with[[pass.compare]]onfps_meanandframetime_p99_ms; run the=0cell before the=1cell so the comparison exists even if time runs short, and drop the comparison with main if that is what fits.run_hitch_countandrun_frametime_max_msstay report-only.What came back from round 3,
=1vs 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 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) · dashboardWhat 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.
RX_VK_ACQUIRE_AHEAD) and off; main is not built or run.0or1(PR only).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).Started at 2026-11-19 18:45 UTC. Run 4: re-planned by klimovich008.
NVIDIA GeForce RTX 3050 Ti Laptop GPU, 621.24.0; 2: windows+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 3090, 621.24.0NVIDIA GeForce RTX 5070, 620.70.6; 2: linux+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce GTX 1070, 580.196.7RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)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.0AMD Ryzen 7 5800H with Radeon Graphics, 16 GB RAM; 2: windows+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 3090, 621.24.0AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)Nothing was measured: no metric came back.
Flags and settings
RX_VK_ACQUIRE_AHEAD0,1Markdown for the PR description
Measurements · linux+nvidia
Verdict: fail on linux+nvidia (2/1 report):
hyrule-field crashfailed.Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu
NVIDIA GeForce RTX 5070, 620.70.6AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce GTX 1070, 580.196.7Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)2f24a49, switch off2f24a49, switch onRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)Flags and settings
RX_VK_ACQUIRE_AHEAD0,1Markdown for the PR description
@Beanstalk plan Again, smaller and with two fixes for problems the farm has on many PRs. Round 4: one
=1start on the Linux RTX 5070 counted as a hang, the=0cell ran out of time, and both Windows NVIDIA testers errored.wait_s) after the save loads, and give the wait forHyruleField_Child120 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".vram_gb = ">= 6". The RTX 3050 Ti Laptop tester fails before building on every PR (git -C Z:\longshot diff --name-only HEADexits 128 indev_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=0cell before=1, 2 runs a side, uncapped and windowed (frame_rate_cap = 6,vsync = 2,frame_generation = 0,fullscreen = 0), Hyrule Field fromkokiri-start, 10 s warm-up, 30 s measured. Judge=1against=0with[[pass.compare]]onfps_meanandframetime_p99_ms;run_hitch_countandrun_frametime_max_msreport-only.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) · dashboardStarted at 04:45 UTC. Run 5: re-planned by klimovich008.
linux+nvidiawindows+nvidia+vram-ge6gb(6 GB VRAM or more)intelWhy 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.1What 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.
RX_VK_ACQUIRE_AHEAD) and off; main is not built or run.0or1(PR only).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).Every scenario and matrix cell
RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=0 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)RX_VK_ACQUIRE_AHEAD=1 (PR only)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.6AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 4070, 615.71.9AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)2f24a49, switch off2f24a49, switch onRX_VK_ACQUIRE_AHEAD=0 (PR only)· field · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)Flags and settings
RX_VK_ACQUIRE_AHEAD0,1As Markdown for the PR description:
Measurements on `windows+nvidia+vram-ge6gb`, for the PR description
Verdict: fail on windows+nvidia+vram-ge6gb (2/1 report):
hyrule-field screenshot.max_difffailed.Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu
NVIDIA GeForce RTX 3090, 621.1.0AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAM; 2: windows+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 3070, 621.24.0AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)2f24a49, switch off2f24a49, switch onRX_VK_ACQUIRE_AHEAD=0 (PR only)· field · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)Flags and settings
RX_VK_ACQUIRE_AHEAD0,1As Markdown for the PR description:
The testers' hardware
linux+nvidiaNVIDIA GeForce RTX 5070, 620.70.6AMD Ryzen 5 9600X 6-Core Processor, 32 GB RAMlinux+nvidiaNVIDIA GeForce RTX 4070, 615.71.9AMD Ryzen 7 5800X3D 8-Core Processor, 64 GB RAMwindows+nvidia+vram-ge6gbNVIDIA GeForce RTX 3090, 621.1.0AMD Ryzen 9 5900X 12-Core Processor, 128 GB RAMwindows+nvidia+vram-ge6gbNVIDIA GeForce RTX 3070, 621.24.0AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAM🤖 A correction to what I wrote here about the Test Farm: none of the farm's rounds on this PR tested the switch.
HOS_HEADLESS=1(no window), and a plan cannot change that. Headless,do_presentreturns beforepresent_image(vk_replay.cpp:5549), andpresent_imageis the only placeRX_VK_ACQUIRE_AHEADis read or acts. So every round,=1against=0, unset, or main, compared the same renderer code.present_imageprintsvk: the window's image (600 presents)every 600 presents. The=1PR-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.=0/unset runs, two=0cells timed out, and on #1763 it did not load a save within 900 s.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.@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=1against unset, same build, and report fps, p99 and frames over 20 ms, with thevk: acquire aheadandvk: the window's imagelog 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.868f6be8into perf/acquire-ahead 494f01bbc289c3d21einto perf/acquire-ahead 8ed75093ed7d5fcb28into perf/acquire-ahead a3f8824224ed9495bbinto perf/acquire-aheadperf(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)🤖 @HumanBean, thank you for the review. Round 3 is pushed (head
ef200041, mained9495bbmerged in). Your points one by one:Blocking: the switch's default. Done as you described.
RX_VK_ACQUIRE_AHEADnow comes from the device policy (acquire_aheadingpu/vk/device_policy.h): on whendev.driver_id == VK_DRIVER_ID_AMD_PROPRIETARYon_WIN32, off with every other driver, which keeps #1458's order.=0turns it off and=1forces it on anywhere, for A/B runs. The first present logs once which way it went and why, for exampleacquire 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.pyand the new test check the choice on both_WIN32sides, 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)", with0and1as the override.Suggestion: the 600-present counter for
=1only. 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:
presenter_loop(), after the presenter's ownvkQueuePresentKHR.presenter.busy), underpresenter.muand the swapchain's lock.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.
=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.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:=1against=0, in a window, uncapped, no lower fps and no higher p99.Also changed since your review:
docs/tested/files are gone (#1856).docs/dev/reference/switches.mdandthreads.md.A second review of the round found no defect. It listed four minor limits, which are now under Risks in the description:
=1;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, our comments crossed. Two things about your test request:
ef200041, which merges mained9495bb, and Forgejo shows it mergeable. Youracquire-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.=1against unset compares on with on.RX_VK_ACQUIRE_AHEAD=0against unset (or against=1) is the comparison that shows the effect. On every other driver, unset is off, so=1against 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, thevk: acquire ahead: ...line at the first present will show it. Thevk: the window's image (600 presents)counter prints only with an explicit=1.@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 test farm · an earlier run: commit
ef20004(the newer results are in a comment below)Commit
ef20004· approved by HumanBean (reviewed) · dashboardStarted 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.
windows+amdwindows+nvidiawindows+intellinux+amdlinux+nvidiasteamdeckWhy 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.0windows+amd:field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)screenshot.max_diff:limit 0.1windows+amd:field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)log_expected_missing.max:2.0 → 2.0; limit 0.0windows+nvidia:field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)screenshot.max_diff:limit 0.1windows+nvidia:field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)log_expected_missing.max:2.0 → 2.0; limit 0.0linux+amd:field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)log_expected_missing.max:2.0 → 2.0; limit 0.0linux+amd:field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)screenshot.max_diff:limit 0.1linux+nvidia:field-and-market · RX_VK_ACQUIRE_AHEAD=1 (PR only)screenshot.max_diff:limit 0.1What 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.
RX_VK_ACQUIRE_AHEAD) and off; main is not built or run.1(PR only).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.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.maxfailed.Hardware: 1: windows+amd+amd-proprietary+dgpu
AMD Radeon RX 9070 XT, 2.0.416AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)ef20004, switch offef20004, switch onRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· market · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· market · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· expected log lines missingFlags and settings
RX_VK_ACQUIRE_AHEAD1As Markdown for the PR description:
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.maxfailed.Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu
NVIDIA GeForce RTX 3070, 621.24.0AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)ef20004, switch offef20004, switch onRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· market · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· market · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· expected log lines missingFlags and settings
RX_VK_ACQUIRE_AHEAD1As Markdown for the PR description:
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_difffailed.Hardware: 1: linux+amd+radv+dgpu
AMD Radeon RX 6600 (RADV NAVI23), 26.2.6AMD Ryzen 5 5600X 6-Core Processor, 64 GB RAM; 2: linux+amd+radv+igpuAMD Radeon 890M Graphics (RADV STRIX1), 26.1.99AMD Ryzen Z2 Extreme, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)ef20004, switch offef20004, switch onRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· market · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· market · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· expected log lines missingFlags and settings
RX_VK_ACQUIRE_AHEAD1As Markdown for the PR description:
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.maxfailed.Hardware: 1: linux+nvidia+nvidia-proprietary+dgpu
NVIDIA GeForce GTX 1070, 580.196.7Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAM; 2: linux+nvidia+nvidia-proprietary+dgpuNVIDIA GeForce RTX 5080, 620.73.4AMD Ryzen 7 7800X3D 8-Core Processor, 32 GB RAMScene: 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 (
@Beanstalkon this PR runs it again)ef20004, switch offef20004, switch onRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· market · frame rateRX_VK_ACQUIRE_AHEAD=1 (PR only)· field · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· market · frame time (p99) (ms)RX_VK_ACQUIRE_AHEAD=1 (PR only)· forbidden log linesRX_VK_ACQUIRE_AHEAD=1 (PR only)· expected log lines missingFlags and settings
RX_VK_ACQUIRE_AHEAD1As Markdown for the PR description:
The testers' hardware
windows+amdAMD Radeon RX 9070 XT, 2.0.416AMD Ryzen 9 5900X 12-Core Processor, 32 GB RAMwindows+nvidiaNVIDIA GeForce RTX 3070, 621.24.0AMD Ryzen 5 5600X3D 6-Core Processor, 32 GB RAMlinux+amdAMD Radeon RX 6600 (RADV NAVI23), 26.2.6AMD Ryzen 5 5600X 6-Core Processor, 64 GB RAMlinux+amdAMD Radeon 890M Graphics (RADV STRIX1), 26.1.99AMD Ryzen Z2 Extreme, 32 GB RAMlinux+nvidiaNVIDIA GeForce GTX 1070, 580.196.7Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz, 32 GB RAMlinux+nvidiaNVIDIA GeForce RTX 5080, 620.73.4AMD Ryzen 7 7800X3D 8-Core Processor, 32 GB RAMLinux 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 withRX_VK_ACQUIRE_AHEAD=0against=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):=0(main's order)=1(acquire ahead)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.
Beanstalk test farm
Commit
623740d· approved by nobody yet · dashboardA member of
BigBeanscan review this commit and comment@Beanstalkto test it.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 itApprove. 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,
623740dturns 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 in623740dhave not been run either.