perf(vk): the vegetation's indirect mesh draws keep their passes: their arguments converted at the game's barriers (RX_VK_MESH_CONV) #1846

Merged
HumanBean merged 1 commit from GummiNaomi/Longshot:perf/mesh-conv-batch into main 2026-11-20 15:29:18 +00:00
Member

Summary

Most of the game's grass, ferns and leaves are indirect mesh draws (41 a frame in Kokiri Forest, 49 in Hyrule Field), and each one ended its render pass, recorded four barriers (three of them drains), a fill and a copy, and began its pass again. This fills the argument ring with 1s once, so a draw's copy writes only its counts, and converts the draws after each barrier of the game's together, right there, so they keep their passes (RX_VK_MESH_CONV). In in-run A/Bs on my PC the old way's mean frame time was 0.166 ms longer in Hyrule Field (+1.7 %), 0.113 ms in the Market and 0.094 ms in Kokiri Forest's stand, with 0.12-0.17 ms less GPU time a frame; two interleaved runs a side in Hyrule Field went 10.08 -> 9.87 ms. On by default; RX_VK_MESH_CONV=0 is the old way.

Why: NVN's indirect mesh records are {count, first} and Vulkan's {x, y, z}, so each count is copied into a ring of {count, 1, 1} on the GPU before its draw (mesh_indirect_convert, gpu/vk/vk_draw.cpp). That copy was recorded at the draw itself: end_pass, a drain to transfer, a fill of 1s, a barrier, the copy, a barrier to indirect reads, then the pass begun again with its own full barrier. The game's culling writes the counts before one of its barriers, so they can be read at that barrier instead, as long as nothing between it and the draw may write buffer memory. The ring's slots were 16 bytes apart, which put a draw's x words on an earlier draw's y and z words, so a ring filled once needs slots 48 bytes apart (the least common multiple of 12 and 16).

What changes: the ring is filled with 1s once, by a submission of its own that is waited for, and its slots are 48-byte aligned (gpu/vk/mesh_conv.h take); a slot is used only while the ring has not come round onto it (still_holds). With RX_VK_MESH_CONV=2 (the default), right after each barrier of the game's the replay scans the stream up to the next barrier, the first op that may write buffer memory (a dispatch, a copy, a buffer or texture clear, an event, a counter's report, any op not known) or the segment's end, and converts the indirect mesh draws it finds there together, one full barrier after their copies (mesh_conv_at_barrier, gpu/vk/vk_replay.cpp; mesh_conv_batch). The scan starts again after the op that cut it. A dispatch, or a draw whose program writes memory, drops the rest of the batch, and those draws convert one by one as with 1: the ring's fill alone, each draw's copy between two full barriers. No conversion on a GPU without mesh shaders, whose compute fallback reads the game's own records. The switch is read at each recording's start through a new MkwVkHost.ab_value (host API version 36, host/rx_backend.c), so HOS_AB=RX_VK_MESH_CONV=0 compares the two ways within one run, and the log counts the conversions and each A/B side's GPU time. Unchanged: what is drawn, RX_VK_MESH_ARGS's rewrite, the compute fallback.

Read first: gpu/vk/mesh_conv.h, then mesh_conv_batch and mesh_indirect_convert in gpu/vk/vk_draw.cpp, mesh_conv_at_barrier in gpu/vk/vk_replay.cpp, and tests/test_mesh_conv.py.

Testing

Tested: Windows 11, RTX 4070 SUPER (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB, on a build of main @ f505340b with this change: in-run A/Bs in Kokiri Forest, Hyrule Field and the Market, and four separate runs in Hyrule Field; the log's line counts every indirect mesh draw converted from a batch in Kokiri Forest (41 a frame from 25 batches) and Hyrule Field (49 from 30), none dropped after a write and the ring never came round onto one; the grass, ferns and leaves drawn in every shot, and the shots with it on against off differing no more than two shots of the same side (mean pixel difference 3.5-5.4 against 4.0-7.0).
At this head 27dc8499 (on main @ 1780fbe0), on the same PC: the builder's Windows (llvm-mingw) build, and one headless run of it from kokiri-start with every switch at its default (the control tool's test profile, 1920x1080, uncapped) and the in-run A/B HOS_AB=RX_VK_MESH_CONV=0,3,60: it started, stood in Kokiri Forest for 30 s, teleported to the Market (40 s) and to Hyrule Field (150 s), and quit normally (exit code 0); no FATAL, no device loss and no crash in the log; the grass, ferns and leaves drawn in its shots. The log's line with the default 2: 47.8 indirect mesh draws a frame converted from 29.5 batches at the game's barriers, 0.8 one by one, none dropped after a write, the ring never came round. In Hyrule Field the old way (0) was 0.163 ms a frame slower (+1.67 %), as on f505340b (Measurements, the second table).
No Linux build was done: on Linux only the checks below ran, in WSL.
Checks: tests/test_mesh_conv.py (mesh_conv.h on a model of the stream, slots, scan and batch, with four broken variants it catches; the wiring in the source) passes on this head on Windows (clang) and Linux (g++ 13.3, WSL Ubuntu 24.04) and fails on main; tests/test_hos_ab.py (the host's table with host_ab_value after the Mods tab's functions, the version check), tests/test_switch_table.py, tests/test_draw_side_effects.py, tests/test_mesh_args_cleanup.py, tests/test_mesh_fallback.py and tests/test_split_before_draw.py pass.
Suite: tests/run_all.py with every check on main @ 068fb8eb in WSL Ubuntu 24.04 (740 pass, 61 fail, 69 skipped: no clang or spirv-val there), then this head's --changed checks in WSL (265 pass, 23 fail, 8 skipped) and on Windows (291 run, 52 fail). Every failure also fails on main @ 068fb8eb on the same OS: in WSL and on Windows test_capture_readback_visibility, test_crash_dialog, test_dev_ab, test_dev_packs, test_draw_stream_visibility, test_frame_overlap, test_fsr_image_retirement, test_fsr_uniform_ownership, test_host_guest_writes, test_hud_layout_row, test_linux_pressure, test_parallel_init_order, test_pipeline_play_cache, test_prepare_cache_save, test_present_queue_default, test_present_source_crop, test_present_thread, test_profiling_mode, test_replay_write_order, test_slow_frames, test_upscaler_rows, test_vk_occlusion_queries, test_walk_key; on Windows only test_audio_output_devices, test_audio_volume, test_collect_wide, test_crash_record, test_dev_build, test_draw_binds, test_driver_env_choose, test_hud_layout, test_image_arrays, test_invalidate_vcore, test_linux_driver_fault_guard, test_mesh_fallback_layout, test_oot_fov, test_pads_after_menu, test_pass_hazard, test_pipeline_tour, test_precompile_compute_guard, test_present_aspect_vulkan, test_prompt_font_bind, test_push_state, test_readback_wait_bounded, test_same_draw, test_same_dyn, test_shader_module_guard, test_table_track, test_text_size, test_tracy_funcs, test_vertex_bind, test_wide_ui. (On Windows the changed checks ran on the head before its last fixes: host_ab_value moved above the text fields' code in host/rx_backend.c, which tests/test_menu_text_field.py compiles as C, and two tests' fixtures; test_menu_text_field, test_readback_early, test_recording_admission were run again on this head and passed, as in WSL.) (On Windows most of them are compile errors with this PC's compiler wrapper, on main as here.) These ran on the head as it was on main @ 068fb8eb. It has since been rebased onto main @ 1780fbe0 (after the renderer's threads rewrite: the rescan no longer checks the parallel replay's dry pass, which is gone); there its own checks pass on Windows and in WSL, and every one of its --changed failures in WSL (257 pass, 30 fail) also fails on that main but tests/test_prepare_stall.py, a timed watchdog check that failed once among eight at once and passed twice run alone. The 29 that fail on main @ 1780fbe0 in WSL as here: test_capture_readback_visibility, test_crash_dialog, test_dev_ab, test_dev_packs, test_draw_binds, test_draw_stream_visibility, test_early_split_before_draw, test_frame_overlap, test_fsr_image_retirement, test_fsr_uniform_ownership, test_hold_gpu, test_host_guest_writes, test_hud_layout_row, test_linux_pressure, test_pipeline_play_cache, test_prepare_cache_save, test_present_queue_default, test_present_source_crop, test_profiling_mode, test_readback_early, test_readback_late, test_replay_write_order, test_sampler_admission, test_slow_frames, test_split_before_draw, test_ub_update_batch, test_upscaler_rows, test_vk_occlusion_queries, test_walk_key.

Still to test:

  • steamdeck (RADV): an in-run A/B in Hyrule Field, HOS_AB=RX_VK_MESH_CONV=0,3,60 RX_VK_FRAME_TRACE=1, then scripts/perf.py ab, expecting a larger gain than on this PC (a drain costs more there) and the vegetation drawn (@Beanstalk steamdeck, Hyrule Field 3 minutes with HOS_AB=RX_VK_MESH_CONV=0,3,60 and RX_VK_FRAME_TRACE=1, and a screenshot)
  • A GPU without mesh shaders (the compute fallback): a run in Kokiri Forest, expecting "left as they are (no mesh shaders)" in the log's line, the vegetation drawn and no change in frame time (@Beanstalk a GPU without mesh shaders, Kokiri Forest 2 minutes, the log's indirect mesh draws line and a screenshot)
  • Windows, NVIDIA, at 2560x1440 with the Quality preset Auto picks: an in-run A/B in Hyrule Field, expecting the old way slower as above (@Beanstalk windows nvidia at 2560x1440, Hyrule Field 3 minutes with HOS_AB=RX_VK_MESH_CONV=0,3,60 and RX_VK_FRAME_TRACE=1)

Measurements

Rebased: this head, 2125e5b5, is 27dc8499 rebased onto main 89c3d21e with no conflicts; the numbers below are from 27dc8499 on its old base. At 2125e5b5, tests/test_mesh_conv.py, test_hos_ab.py and test_switch_table.py pass on Windows (clang); test_readback_early.py fails the same way on main 89c3d21e; vk_draw.cpp, vk_replay.cpp and host/rx_backend.c compile syntax-only with the builder's flags.

Verdict: a small, steady gain where the vegetation is: the old way was 1.7 % slower in Hyrule Field, 1.0 % in the Market and about 1 % in Kokiri Forest's stand, by mean frame time, with 0.12-0.17 ms less GPU time a frame; two interleaved runs a side in Hyrule Field agree (median 10.07 / 9.98 -> 9.86 / 9.80 ms). These are from a build on main @ f505340b; at this head 27dc8499, one in-run A/B with default settings agrees: the old way 1.67 % slower in Hyrule Field and 1.33 % in the Market.

Setup: Windows 11 Pro 26200, RTX 4070 SUPER 12 GB (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB; from kokiri-start, a stand in Kokiri Forest, and a teleport to Hyrule Field and to the Market; 1920x1080, no window (HOS_HEADLESS=1), uncapped, 16 cores; the in-run A/B HOS_AB=RX_VK_MESH_CONV=0,3,60 (3 s periods after 60 s of warm-up, scripts/perf.py ab on the frame trace for each side's numbers and the interval), and the separate runs 100 s each, in the order off, on, on, off; in all runs RX_VK_LOAD=create RX_VK_ASTC_BC_ALL=1 RX_VK_IMAGE_BLOCK_MB=32 RX_VK_BC_LAYERS=8 RX_VK_LATE_FIX=1 RX_VK_TEX_MOVE=1 RX_VK_FRAME_TRACE=1 (and two switches this build does not have).

Baseline: one build of main @ f505340b (before the tooling revamp 068fb8eb, which changes none of this code) with this change: RX_VK_MESH_CONV=0, main's conversion, against the default 2, in the same run (A/B) or in separate runs; the host API's number on that build was 35.

Before: RX_VK_MESH_CONV=0 (as main) @ f505340b After: 2 (this PR) @ f505340b
Hyrule Field A/B: mean / median / p99 (ms) 9.919 / 9.850 / 12.290 9.753 / 9.690 / 11.860
Hyrule Field A/B: fps 100.8 102.5
Market A/B: mean / median / p99 (ms) 11.275 / 11.200 / 13.755 11.163 / 11.090 / 13.674
Market A/B: fps 88.7 89.6
Kokiri Forest A/B, the stand: mean (ms) +0.094 (95 %: +0.073 to +0.115)
GPU time a frame, Kokiri Forest / Hyrule Field / Market (ms) 5.922 / 8.296 / 8.222 5.760 / 8.130 / 8.101
Hyrule Field, separate runs: mean (ms) 10.12 / 10.04 9.90 / 9.84
Hyrule Field, separate runs: median / p99 (ms) 10.07 / 11.80, 9.98 / 12.00 9.86 / 11.52, 9.80 / 11.45
Hyrule Field, separate runs: fps / 1 % low 98.8 / 79.3, 99.6 / 76.9 101.0 / 81.1, 101.6 / 79.7
frames of 16.7 ms or more (A/Bs) 0.0-0.2 % 0.0-0.1 %

The A/B intervals of the mean's difference (old less new): Hyrule Field +0.137 to +0.197 ms, the Market +0.061 to +0.167 ms. Kokiri Forest's A/B covered its teleport's frames too: over the whole trace the interval holds 0 (-2.37 to +2.60 ms, the means +1.2 % apart), so its row is the stand alone.

The host's A/B lines and the log's conversion counts (Kokiri Forest, Hyrule Field, the Market):

ab: RX_VK_MESH_CONV=0 against its normal value, 3.0 s periods after 60 s: side 0 (normal) 14381 frames, 7.109 ms a frame (140.7 fps); side 1 (the A/B's value) 14142 frames, 7.221 ms a frame (138.5 fps); side 1 +1.57 % frame time
ab: RX_VK_MESH_CONV=0 against its normal value, 3.0 s periods after 60 s: side 0 (normal) 8448 frames, 9.758 ms a frame (102.5 fps); side 1 (the A/B's value) 8165 frames, 9.922 ms a frame (100.8 fps); side 1 +1.68 % frame time
ab: RX_VK_MESH_CONV=0 against its normal value, 3.0 s periods after 60 s: side 0 (normal) 7338 frames, 11.161 ms a frame (89.6 fps); side 1 (the A/B's value) 7182 frames, 11.278 ms a frame (88.7 fps); side 1 +1.05 % frame time
vk: GPU time by RX_VK_MESH_CONV in the A/B so far: 0: 5.922 ms a frame (15488 frames); 1: 0.000 ms a frame (0 frames); 2: 5.760 ms a frame (15952 frames)
vk: GPU time by RX_VK_MESH_CONV in the A/B so far: 0: 8.296 ms a frame (9073 frames); 1: 0.000 ms a frame (0 frames); 2: 8.130 ms a frame (9304 frames)
vk: GPU time by RX_VK_MESH_CONV in the A/B so far: 0: 8.222 ms a frame (7983 frames); 1: 0.000 ms a frame (0 frames); 2: 8.101 ms a frame (8136 frames)
vk: a frame: indirect mesh draws' arguments (RX_VK_MESH_CONV=2): 0.0 converted one by one, 48.9 from 30.0 batches at the game's barriers (49.0 converted in them; 0.0 dropped after a write, 0.0 the ring came round), 0.0 left as they are (no mesh shaders); scans ended at a barrier 120.5, an op 551.0, the end 7.0, full 0.0

At this head, 27dc8499: one build, one run, the in-run A/B as above but with every other switch at its default (1920x1080, uncapped, 16 cores), scripts/perf.py ab on the frame trace cut to each scene's frames (from 300 frames after the arrival):

RX_VK_MESH_CONV=0 (as main) @ 27dc8499 2 (this PR) @ 27dc8499
Hyrule Field, 150 s: mean / median / p99 (ms) 9.931 / 9.870 / 12.195 9.769 / 9.710 / 11.963
Hyrule Field: fps 100.7 102.4
Hyrule Field: the old way less the new, mean (95 %) +0.163 ms (+0.131 to +0.195), +1.67 %
the Market, 40 s (11 periods): mean / median / p99 (ms) 11.372 / 11.310 / 13.941 11.222 / 11.130 / 14.180
the Market: the old way less the new, mean (95 %) +0.150 ms (+0.072 to +0.228), +1.33 %

Over the whole run (Kokiri Forest's high frame rates, the two teleports and both scenes mixed) the host's ab: line says side 1 -0.24 % and the interval holds 0, and the log's GPU time line, also over the whole run, says 5.912 ms a frame for 0 and 5.985 ms for 2: neither is split by scene, so the scene rows above are the comparison. The GPU time by scene was not measured at this head.

RX_VK_MESH_CONV (new, a kill switch) ships at 2, chosen by the table above; 0 is the conversion as on main, 1 the ring's fill alone.

Risks

What could break: the batch reads a draw's counts at the barrier before it instead of at the draw, so a write to them between the two that the scan does not know of would be missed; every op not known to record no buffer write ends the scan, a dispatch or a draw whose program writes memory drops the batch, and the shots matched in all three scenes, but the scan's list of ops is the thing to review. Not run here: RADV, a GPU without mesh shaders. (The parallel workers, RX_VK_PARALLEL, are gone from main since the threads rewrite, so there is no such case left to run.) The host API goes to version 36, which #1034, #1358 and #1811 also take: whichever lands second renumbers. #1763 (the renderer's threads rewritten) touches the same neighbourhood of vk_replay.cpp (the frame stats' log, do_present, gpu_time_end) without overlapping lines, and its lighter pass-start barrier agrees with this change: the copies end with a full barrier, so the pass that starts after them adds none under either. Turning it off: RX_VK_MESH_CONV=0. After updating, a player sees slightly faster frames where there is grass and foliage; nothing changes for saves, longshot_options.ini or the caches.

Checklist

Ready for review

  • One topic, on current main; the title is a Conventional Commit. (Rebased onto main 89c3d21e as 2125e5b5, no conflicts.)
  • 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.
  • MKWVK_API_VERSION bumped (MkwVkHost or MkwVkRenderer in gpu/vk/vk_api.h changed).
  • Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. (Built on Windows: the builder's llvm-mingw build of this head 27dc8499, run in the game as Testing says, and of the measured build on f505340b. On Linux only checks: tests/test_mesh_conv.py (mesh_conv.h with g++ 13.3) and the --changed suite in WSL Ubuntu 24.04. No Linux build was done.)
  • 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 Most of the game's grass, ferns and leaves are indirect mesh draws (41 a frame in Kokiri Forest, 49 in Hyrule Field), and each one ended its render pass, recorded four barriers (three of them drains), a fill and a copy, and began its pass again. This fills the argument ring with 1s once, so a draw's copy writes only its counts, and converts the draws after each barrier of the game's together, right there, so they keep their passes (`RX_VK_MESH_CONV`). In in-run A/Bs on my PC the old way's mean frame time was 0.166 ms longer in Hyrule Field (+1.7 %), 0.113 ms in the Market and 0.094 ms in Kokiri Forest's stand, with 0.12-0.17 ms less GPU time a frame; two interleaved runs a side in Hyrule Field went 10.08 -> 9.87 ms. On by default; `RX_VK_MESH_CONV=0` is the old way. Why: NVN's indirect mesh records are {count, first} and Vulkan's {x, y, z}, so each count is copied into a ring of {count, 1, 1} on the GPU before its draw (`mesh_indirect_convert`, `gpu/vk/vk_draw.cpp`). That copy was recorded at the draw itself: `end_pass`, a drain to transfer, a fill of 1s, a barrier, the copy, a barrier to indirect reads, then the pass begun again with its own full barrier. The game's culling writes the counts before one of its barriers, so they can be read at that barrier instead, as long as nothing between it and the draw may write buffer memory. The ring's slots were 16 bytes apart, which put a draw's x words on an earlier draw's y and z words, so a ring filled once needs slots 48 bytes apart (the least common multiple of 12 and 16). What changes: the ring is filled with 1s once, by a submission of its own that is waited for, and its slots are 48-byte aligned (`gpu/vk/mesh_conv.h` `take`); a slot is used only while the ring has not come round onto it (`still_holds`). With `RX_VK_MESH_CONV=2` (the default), right after each barrier of the game's the replay scans the stream up to the next barrier, the first op that may write buffer memory (a dispatch, a copy, a buffer or texture clear, an event, a counter's report, any op not known) or the segment's end, and converts the indirect mesh draws it finds there together, one full barrier after their copies (`mesh_conv_at_barrier`, `gpu/vk/vk_replay.cpp`; `mesh_conv_batch`). The scan starts again after the op that cut it. A dispatch, or a draw whose program writes memory, drops the rest of the batch, and those draws convert one by one as with `1`: the ring's fill alone, each draw's copy between two full barriers. No conversion on a GPU without mesh shaders, whose compute fallback reads the game's own records. The switch is read at each recording's start through a new `MkwVkHost.ab_value` (host API version 36, `host/rx_backend.c`), so `HOS_AB=RX_VK_MESH_CONV=0` compares the two ways within one run, and the log counts the conversions and each A/B side's GPU time. Unchanged: what is drawn, `RX_VK_MESH_ARGS`'s rewrite, the compute fallback. Read first: `gpu/vk/mesh_conv.h`, then `mesh_conv_batch` and `mesh_indirect_convert` in `gpu/vk/vk_draw.cpp`, `mesh_conv_at_barrier` in `gpu/vk/vk_replay.cpp`, and `tests/test_mesh_conv.py`. ## Testing **Tested:** Windows 11, RTX 4070 SUPER (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB, on a build of main @ f505340b with this change: in-run A/Bs in Kokiri Forest, Hyrule Field and the Market, and four separate runs in Hyrule Field; the log's line counts every indirect mesh draw converted from a batch in Kokiri Forest (41 a frame from 25 batches) and Hyrule Field (49 from 30), none dropped after a write and the ring never came round onto one; the grass, ferns and leaves drawn in every shot, and the shots with it on against off differing no more than two shots of the same side (mean pixel difference 3.5-5.4 against 4.0-7.0). At this head 27dc8499 (on main @ 1780fbe0), on the same PC: the builder's Windows (llvm-mingw) build, and one headless run of it from `kokiri-start` with every switch at its default (the control tool's `test` profile, 1920x1080, uncapped) and the in-run A/B `HOS_AB=RX_VK_MESH_CONV=0,3,60`: it started, stood in Kokiri Forest for 30 s, teleported to the Market (40 s) and to Hyrule Field (150 s), and quit normally (exit code 0); no FATAL, no device loss and no crash in the log; the grass, ferns and leaves drawn in its shots. The log's line with the default 2: 47.8 indirect mesh draws a frame converted from 29.5 batches at the game's barriers, 0.8 one by one, none dropped after a write, the ring never came round. In Hyrule Field the old way (`0`) was 0.163 ms a frame slower (+1.67 %), as on f505340b (Measurements, the second table). No Linux build was done: on Linux only the checks below ran, in WSL. Checks: `tests/test_mesh_conv.py` (`mesh_conv.h` on a model of the stream, slots, scan and batch, with four broken variants it catches; the wiring in the source) passes on this head on Windows (clang) and Linux (g++ 13.3, WSL Ubuntu 24.04) and fails on main; `tests/test_hos_ab.py` (the host's table with `host_ab_value` after the Mods tab's functions, the version check), `tests/test_switch_table.py`, `tests/test_draw_side_effects.py`, `tests/test_mesh_args_cleanup.py`, `tests/test_mesh_fallback.py` and `tests/test_split_before_draw.py` pass. Suite: `tests/run_all.py` with every check on main @ 068fb8eb in WSL Ubuntu 24.04 (740 pass, 61 fail, 69 skipped: no clang or spirv-val there), then this head's `--changed` checks in WSL (265 pass, 23 fail, 8 skipped) and on Windows (291 run, 52 fail). Every failure also fails on main @ 068fb8eb on the same OS: in WSL and on Windows `test_capture_readback_visibility`, `test_crash_dialog`, `test_dev_ab`, `test_dev_packs`, `test_draw_stream_visibility`, `test_frame_overlap`, `test_fsr_image_retirement`, `test_fsr_uniform_ownership`, `test_host_guest_writes`, `test_hud_layout_row`, `test_linux_pressure`, `test_parallel_init_order`, `test_pipeline_play_cache`, `test_prepare_cache_save`, `test_present_queue_default`, `test_present_source_crop`, `test_present_thread`, `test_profiling_mode`, `test_replay_write_order`, `test_slow_frames`, `test_upscaler_rows`, `test_vk_occlusion_queries`, `test_walk_key`; on Windows only `test_audio_output_devices`, `test_audio_volume`, `test_collect_wide`, `test_crash_record`, `test_dev_build`, `test_draw_binds`, `test_driver_env_choose`, `test_hud_layout`, `test_image_arrays`, `test_invalidate_vcore`, `test_linux_driver_fault_guard`, `test_mesh_fallback_layout`, `test_oot_fov`, `test_pads_after_menu`, `test_pass_hazard`, `test_pipeline_tour`, `test_precompile_compute_guard`, `test_present_aspect_vulkan`, `test_prompt_font_bind`, `test_push_state`, `test_readback_wait_bounded`, `test_same_draw`, `test_same_dyn`, `test_shader_module_guard`, `test_table_track`, `test_text_size`, `test_tracy_funcs`, `test_vertex_bind`, `test_wide_ui`. (On Windows the changed checks ran on the head before its last fixes: `host_ab_value` moved above the text fields' code in `host/rx_backend.c`, which `tests/test_menu_text_field.py` compiles as C, and two tests' fixtures; `test_menu_text_field`, `test_readback_early`, `test_recording_admission` were run again on this head and passed, as in WSL.) (On Windows most of them are compile errors with this PC's compiler wrapper, on main as here.) These ran on the head as it was on main @ 068fb8eb. It has since been rebased onto main @ 1780fbe0 (after the renderer's threads rewrite: the rescan no longer checks the parallel replay's dry pass, which is gone); there its own checks pass on Windows and in WSL, and every one of its `--changed` failures in WSL (257 pass, 30 fail) also fails on that main but `tests/test_prepare_stall.py`, a timed watchdog check that failed once among eight at once and passed twice run alone. The 29 that fail on main @ 1780fbe0 in WSL as here: `test_capture_readback_visibility`, `test_crash_dialog`, `test_dev_ab`, `test_dev_packs`, `test_draw_binds`, `test_draw_stream_visibility`, `test_early_split_before_draw`, `test_frame_overlap`, `test_fsr_image_retirement`, `test_fsr_uniform_ownership`, `test_hold_gpu`, `test_host_guest_writes`, `test_hud_layout_row`, `test_linux_pressure`, `test_pipeline_play_cache`, `test_prepare_cache_save`, `test_present_queue_default`, `test_present_source_crop`, `test_profiling_mode`, `test_readback_early`, `test_readback_late`, `test_replay_write_order`, `test_sampler_admission`, `test_slow_frames`, `test_split_before_draw`, `test_ub_update_batch`, `test_upscaler_rows`, `test_vk_occlusion_queries`, `test_walk_key`. **Still to test:** - steamdeck (RADV): an in-run A/B in Hyrule Field, `HOS_AB=RX_VK_MESH_CONV=0,3,60 RX_VK_FRAME_TRACE=1`, then `scripts/perf.py ab`, expecting a larger gain than on this PC (a drain costs more there) and the vegetation drawn (@Beanstalk steamdeck, Hyrule Field 3 minutes with HOS_AB=RX_VK_MESH_CONV=0,3,60 and RX_VK_FRAME_TRACE=1, and a screenshot) - A GPU without mesh shaders (the compute fallback): a run in Kokiri Forest, expecting "left as they are (no mesh shaders)" in the log's line, the vegetation drawn and no change in frame time (@Beanstalk a GPU without mesh shaders, Kokiri Forest 2 minutes, the log's indirect mesh draws line and a screenshot) - Windows, NVIDIA, at 2560x1440 with the Quality preset Auto picks: an in-run A/B in Hyrule Field, expecting the old way slower as above (@Beanstalk windows nvidia at 2560x1440, Hyrule Field 3 minutes with HOS_AB=RX_VK_MESH_CONV=0,3,60 and RX_VK_FRAME_TRACE=1) ## Measurements **Rebased:** this head, 2125e5b5, is 27dc8499 rebased onto main 89c3d21e with no conflicts; the numbers below are from 27dc8499 on its old base. At 2125e5b5, `tests/test_mesh_conv.py`, `test_hos_ab.py` and `test_switch_table.py` pass on Windows (clang); `test_readback_early.py` fails the same way on main 89c3d21e; `vk_draw.cpp`, `vk_replay.cpp` and `host/rx_backend.c` compile syntax-only with the builder's flags. **Verdict:** a small, steady gain where the vegetation is: the old way was 1.7 % slower in Hyrule Field, 1.0 % in the Market and about 1 % in Kokiri Forest's stand, by mean frame time, with 0.12-0.17 ms less GPU time a frame; two interleaved runs a side in Hyrule Field agree (median 10.07 / 9.98 -> 9.86 / 9.80 ms). These are from a build on main @ f505340b; at this head 27dc8499, one in-run A/B with default settings agrees: the old way 1.67 % slower in Hyrule Field and 1.33 % in the Market. Setup: Windows 11 Pro 26200, RTX 4070 SUPER 12 GB (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB; from `kokiri-start`, a stand in Kokiri Forest, and a teleport to Hyrule Field and to the Market; 1920x1080, no window (`HOS_HEADLESS=1`), uncapped, 16 cores; the in-run A/B `HOS_AB=RX_VK_MESH_CONV=0,3,60` (3 s periods after 60 s of warm-up, `scripts/perf.py ab` on the frame trace for each side's numbers and the interval), and the separate runs 100 s each, in the order off, on, on, off; in all runs `RX_VK_LOAD=create RX_VK_ASTC_BC_ALL=1 RX_VK_IMAGE_BLOCK_MB=32 RX_VK_BC_LAYERS=8 RX_VK_LATE_FIX=1 RX_VK_TEX_MOVE=1 RX_VK_FRAME_TRACE=1` (and two switches this build does not have). Baseline: one build of main @ f505340b (before the tooling revamp 068fb8eb, which changes none of this code) with this change: `RX_VK_MESH_CONV=0`, main's conversion, against the default 2, in the same run (A/B) or in separate runs; the host API's number on that build was 35. | | Before: `RX_VK_MESH_CONV=0` (as main) @ f505340b | After: 2 (this PR) @ f505340b | |---|---|---| | Hyrule Field A/B: mean / median / p99 (ms) | 9.919 / 9.850 / 12.290 | 9.753 / 9.690 / 11.860 | | Hyrule Field A/B: fps | 100.8 | 102.5 | | Market A/B: mean / median / p99 (ms) | 11.275 / 11.200 / 13.755 | 11.163 / 11.090 / 13.674 | | Market A/B: fps | 88.7 | 89.6 | | Kokiri Forest A/B, the stand: mean (ms) | +0.094 (95 %: +0.073 to +0.115) | | | GPU time a frame, Kokiri Forest / Hyrule Field / Market (ms) | 5.922 / 8.296 / 8.222 | 5.760 / 8.130 / 8.101 | | Hyrule Field, separate runs: mean (ms) | 10.12 / 10.04 | 9.90 / 9.84 | | Hyrule Field, separate runs: median / p99 (ms) | 10.07 / 11.80, 9.98 / 12.00 | 9.86 / 11.52, 9.80 / 11.45 | | Hyrule Field, separate runs: fps / 1 % low | 98.8 / 79.3, 99.6 / 76.9 | 101.0 / 81.1, 101.6 / 79.7 | | frames of 16.7 ms or more (A/Bs) | 0.0-0.2 % | 0.0-0.1 % | The A/B intervals of the mean's difference (old less new): Hyrule Field +0.137 to +0.197 ms, the Market +0.061 to +0.167 ms. Kokiri Forest's A/B covered its teleport's frames too: over the whole trace the interval holds 0 (-2.37 to +2.60 ms, the means +1.2 % apart), so its row is the stand alone. The host's A/B lines and the log's conversion counts (Kokiri Forest, Hyrule Field, the Market): ``` ab: RX_VK_MESH_CONV=0 against its normal value, 3.0 s periods after 60 s: side 0 (normal) 14381 frames, 7.109 ms a frame (140.7 fps); side 1 (the A/B's value) 14142 frames, 7.221 ms a frame (138.5 fps); side 1 +1.57 % frame time ab: RX_VK_MESH_CONV=0 against its normal value, 3.0 s periods after 60 s: side 0 (normal) 8448 frames, 9.758 ms a frame (102.5 fps); side 1 (the A/B's value) 8165 frames, 9.922 ms a frame (100.8 fps); side 1 +1.68 % frame time ab: RX_VK_MESH_CONV=0 against its normal value, 3.0 s periods after 60 s: side 0 (normal) 7338 frames, 11.161 ms a frame (89.6 fps); side 1 (the A/B's value) 7182 frames, 11.278 ms a frame (88.7 fps); side 1 +1.05 % frame time vk: GPU time by RX_VK_MESH_CONV in the A/B so far: 0: 5.922 ms a frame (15488 frames); 1: 0.000 ms a frame (0 frames); 2: 5.760 ms a frame (15952 frames) vk: GPU time by RX_VK_MESH_CONV in the A/B so far: 0: 8.296 ms a frame (9073 frames); 1: 0.000 ms a frame (0 frames); 2: 8.130 ms a frame (9304 frames) vk: GPU time by RX_VK_MESH_CONV in the A/B so far: 0: 8.222 ms a frame (7983 frames); 1: 0.000 ms a frame (0 frames); 2: 8.101 ms a frame (8136 frames) vk: a frame: indirect mesh draws' arguments (RX_VK_MESH_CONV=2): 0.0 converted one by one, 48.9 from 30.0 batches at the game's barriers (49.0 converted in them; 0.0 dropped after a write, 0.0 the ring came round), 0.0 left as they are (no mesh shaders); scans ended at a barrier 120.5, an op 551.0, the end 7.0, full 0.0 ``` At this head, 27dc8499: one build, one run, the in-run A/B as above but with every other switch at its default (1920x1080, uncapped, 16 cores), `scripts/perf.py ab` on the frame trace cut to each scene's frames (from 300 frames after the arrival): | | `RX_VK_MESH_CONV=0` (as main) @ 27dc8499 | 2 (this PR) @ 27dc8499 | |---|---|---| | Hyrule Field, 150 s: mean / median / p99 (ms) | 9.931 / 9.870 / 12.195 | 9.769 / 9.710 / 11.963 | | Hyrule Field: fps | 100.7 | 102.4 | | Hyrule Field: the old way less the new, mean (95 %) | +0.163 ms (+0.131 to +0.195), +1.67 % | | | the Market, 40 s (11 periods): mean / median / p99 (ms) | 11.372 / 11.310 / 13.941 | 11.222 / 11.130 / 14.180 | | the Market: the old way less the new, mean (95 %) | +0.150 ms (+0.072 to +0.228), +1.33 % | | Over the whole run (Kokiri Forest's high frame rates, the two teleports and both scenes mixed) the host's `ab:` line says side 1 -0.24 % and the interval holds 0, and the log's GPU time line, also over the whole run, says 5.912 ms a frame for `0` and 5.985 ms for 2: neither is split by scene, so the scene rows above are the comparison. The GPU time by scene was not measured at this head. `RX_VK_MESH_CONV` (new, a kill switch) ships at 2, chosen by the table above; `0` is the conversion as on main, `1` the ring's fill alone. ## Risks What could break: the batch reads a draw's counts at the barrier before it instead of at the draw, so a write to them between the two that the scan does not know of would be missed; every op not known to record no buffer write ends the scan, a dispatch or a draw whose program writes memory drops the batch, and the shots matched in all three scenes, but the scan's list of ops is the thing to review. Not run here: RADV, a GPU without mesh shaders. (The parallel workers, `RX_VK_PARALLEL`, are gone from main since the threads rewrite, so there is no such case left to run.) The host API goes to version 36, which #1034, #1358 and #1811 also take: whichever lands second renumbers. #1763 (the renderer's threads rewritten) touches the same neighbourhood of `vk_replay.cpp` (the frame stats' log, `do_present`, `gpu_time_end`) without overlapping lines, and its lighter pass-start barrier agrees with this change: the copies end with a full barrier, so the pass that starts after them adds none under either. Turning it off: `RX_VK_MESH_CONV=0`. After updating, a player sees slightly faster frames where there is grass and foliage; nothing changes for saves, `longshot_options.ini` or the caches. ## Checklist ### Ready for review - [x] One topic, on current `main`; the title is a Conventional Commit. (Rebased onto main 89c3d21e as 2125e5b5, no conflicts.) - [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] `MKWVK_API_VERSION` bumped (`MkwVkHost` or `MkwVkRenderer` in `gpu/vk/vk_api.h` changed). - [ ] Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. (Built on Windows: the builder's llvm-mingw build of this head 27dc8499, run in the game as Testing says, and of the measured build on f505340b. On Linux only checks: `tests/test_mesh_conv.py` (`mesh_conv.h` with g++ 13.3) and the `--changed` suite in WSL Ubuntu 24.04. No Linux build was done.) - [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)
perf(vk): the vegetation's indirect mesh draws keep their passes: their arguments converted at the game's barriers (RX_VK_MESH_CONV)
Some checks failed
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
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
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 16s
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 24s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 25s
CI / Workflow lint (actionlint) (pull_request) Successful in 27s
Third-party parts / As their notes say (pull_request) Successful in 31s
CI / Website build and checks (pull_request) Has been cancelled
e992631ed3
Each indirect mesh draw (most of the game's grass, ferns and leaves: 41 to 49 a frame in Kokiri Forest and Hyrule Field)
ended its render pass, recorded a drain barrier, a fill of 1s, a barrier, the copy of its counts and a barrier, and began
the pass again with a full barrier: four barriers, three of them drains, and a pass split a draw.

- The 4 MB ring is filled with 1s once, when it is made, and its slots are 48 bytes apart (16 put a draw's x words on an
  earlier draw's y and z words): a draw's copy writes only its x words.
- RX_VK_MESH_CONV=2 (the default): right after each barrier of the game's, the replay scans the stream up to the next
  barrier, the first op that may write buffer memory or the segment's end, and converts the indirect mesh draws it finds
  there at once, one full barrier after their copies (mesh_conv.h, vk_replay.cpp mesh_conv_at_barrier); the scan starts
  again after the op that cut it. A dispatch, or a draw whose program writes memory, drops the rest of the batch: those
  draws convert one by one. 1: the ring's fill alone, a draw's copy between two full barriers. 0: as before.
- No conversion on a GPU without mesh shaders (the compute fallback reads the game's own records).
- The switch is read at each recording's start through MkwVkHost.ab_value (host API version 36, host/rx_backend.c), so
  HOS_AB=RX_VK_MESH_CONV=0 compares the two ways within one run; the log counts the conversions and each side's GPU time.

In-run A/Bs on 16 cores (HOS_AB=RX_VK_MESH_CONV=0,3,60), the old way's mean frame time against the new: Hyrule Field
+0.166 ms (95 % interval +0.137 to +0.197), the Market +0.113 ms (+0.061 to +0.167), Kokiri Forest's stand +0.094 ms;
GPU time 0.12-0.17 ms a frame lower. Two interleaved runs a side at Hyrule Field: 10.08 -> 9.87 ms.
tests/test_mesh_conv.py runs mesh_conv.h on a model of the stream and checks the wiring; tests/test_hos_ab.py checks the
host table with ab_value after the Mods tab's functions;
tests/recording_admission_test.cpp gets a stand-in for mesh_conv_begin_recording, and tests/test_readback_early.py
lets only the rescan come between a part's end and the next op.

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

Possibly related, for context:

  • PR #1460 perf(vk): one map reservation per task workgroup, not per meshlet (#2245) — Open vegetation mesh-shader work touches task/mesh rendering, but distinct shader-stage optimization
  • issue #1836 Game: Hair and foliage render as sparkling artifacts with severe frame-rate drops on Radeon Pro 580 — Open foliage rendering/performance report is an affected symptom area; Radeon-specific issue
  • issue #402 Deck: the frame is CPU-bound in the submission path, not GPU-bound (16 fps at 50% internal, GPU-bound wait 0.4 ms) — Open Deck replay-cost investigation includes vegetation conversion overhead in its measurements
  • PR #1243 fix(vk): keep mesh indirect argument ranges from overlapping — Merged fix established non-overlapping mesh argument ring allocation, relevant background for this ring change
  • PR #864 fix(vk): RX_VK_PASS_TIMING names the mesh fallback's compute and the indirect mesh argument conversion — Merged profiling change in mesh_indirect_convert; adjacent code may conflict
Possibly related, for context: - PR #1460 perf(vk): one map reservation per task workgroup, not per meshlet (#2245) — Open vegetation mesh-shader work touches task/mesh rendering, but distinct shader-stage optimization - issue #1836 Game: Hair and foliage render as sparkling artifacts with severe frame-rate drops on Radeon Pro 580 — Open foliage rendering/performance report is an affected symptom area; Radeon-specific issue - issue #402 Deck: the frame is CPU-bound in the submission path, not GPU-bound (16 fps at 50% internal, GPU-bound wait 0.4 ms) — Open Deck replay-cost investigation includes vegetation conversion overhead in its measurements - PR #1243 fix(vk): keep mesh indirect argument ranges from overlapping — Merged fix established non-overlapping mesh argument ring allocation, relevant background for this ring change - PR #864 fix(vk): RX_VK_PASS_TIMING names the mesh fallback's compute and the indirect mesh argument conversion — Merged profiling change in mesh_indirect_convert; adjacent code may conflict
HumanBean added this to the WIP project 2026-11-20 06:44:06 +00:00
GummiNaomi force-pushed perf/mesh-conv-batch from e992631ed3
Some checks failed
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
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
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 16s
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 24s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 25s
CI / Workflow lint (actionlint) (pull_request) Successful in 27s
Third-party parts / As their notes say (pull_request) Successful in 31s
CI / Website build and checks (pull_request) Has been cancelled
to 27dc849964
Some checks reported errors
Website / Website on Cloudflare (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
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
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 22s
CI / Conventional Commit title (pull_request) Successful in 13s
CI / Workflow lint (actionlint) (pull_request) Successful in 24s
Third-party parts / As their notes say (pull_request) Successful in 25s
Website / Website on Cloudflare (pull_request_target) Has been skipped
beanstalk/windows 0/2 pass, 3 error
beanstalk/approval approved by HumanBean (reviewed)
PR description / Description follows the template (pull_request_target) Failing after 6s
beanstalk/linux 0/2 pass, 3 error
beanstalk/steamdeck 0/1 pass, 0 running, 2 queued
CI / Website build and checks (pull_request) Has been cancelled
2026-11-20 07:46:24 +00:00
Compare
Owner

@Beanstalk let's test widely

@Beanstalk let's test widely
Member
Beanstalk test farm · an earlier run: commit 27dc849 (the newer results are in a comment below)

Commit 27dc849 · tier reviewed · approved by HumanBean · dashboard

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

The plan tests vegetation rendering in Kokiri Forest, Hyrule Field and the Market on Linux, Windows and Steam Deck. It compares main with the PR with parallel replay both off and on, because batching must also work across worker segments. Each target takes roughly 22 minutes; screenshots, frame times, GPU time and load times are compared. Crashes, device loss, substantial visual differences or performance regressions fail the plan.

  • Where: linux (2-3 reports), windows (2-3 reports), steamdeck (1-2 reports).
  • Matrix: 2 cells, each on main and the PR: RX_VK_PARALLEL 0 or 1.
  • vegetation-tour: from the repository's save kokiri-start, then teleport to Kokiri Forest, measure forest for 20 s (after 5 s warm-up), take the picture forest to compare with main, teleport to Hyrule Field, measure field for 20 s (after 5 s warm-up), take the picture field to compare with main, teleport to Market, measure market for 20 s (after 5 s warm-up), take the picture market 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, GPU time per pass, load times, the game's log.
  • The PR fails if: it crashes; or a picture differs from main by more than 10%; or GPU time a frame is more than 15% above main; or longest load is more than 30% above main; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0.
  • Time: about 25 min of game runs per tester (4 game starts), plus the two builds.

Started at 08:01 UTC.

Estimate: done in about 2 h 45 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
linux 0/2 — — — error
windows · 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 4080, 621.1.0 2/2 1 2 none — — error
steamdeck 0/1 — — — queued
Scenario · matrix cell Target Frame p99 (ms) vs main Result
vegetation-tour · RX_VK_PARALLEL=0 linux — —
vegetation-tour · RX_VK_PARALLEL=0 windows — not judged
vegetation-tour · RX_VK_PARALLEL=0 steamdeck — —
vegetation-tour · RX_VK_PARALLEL=1 linux — —
vegetation-tour · RX_VK_PARALLEL=1 windows — not judged
vegetation-tour · RX_VK_PARALLEL=1 steamdeck — —

Measurements · windows

Verdict: could not be judged on windows (2/2 reports).

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 4080, 621.1.0 AMD Ryzen 7 9800X3D 8-Core Processor, 32 GB RAM
Scene: vegetation-tour, from the repository's save kokiri-start; 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); vegetation-tour: 1 game start a side, forest 20 s after 5 s warm-up, 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)

Nothing was measured: no metric came back.

Flags and settings

Flag What it is Values tried Before this PR After this PR Effect (GPU time a frame) Helps / doesn't help / untested
RX_VK_PARALLEL switch 0, 1 main's default the PR's default vegetation-tour, the PR at 0 → at 1: not measured untested
Markdown for the PR description
## Measurements

**Verdict:** could not be judged on windows (2/2 reports).

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 4080, 621.1.0` `AMD Ryzen 7 9800X3D 8-Core Processor, 32 GB RAM`  
Scene: vegetation-tour, from the repository's save kokiri-start; 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); vegetation-tour: 1 game start a side, forest 20 s after 5 s warm-up, 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)

Nothing was measured: no metric came back.

### Flags and settings

| Flag | What it is | Values tried | Before this PR | After this PR | Effect (GPU time a frame) | Helps / doesn't help / untested |
|---|---|---|---|---|---|---|
| `RX_VK_PARALLEL` | switch | `0`, `1` | main's default | the PR's default | vegetation-tour, the PR at 0 → at 1: not measured | untested |
<!-- beanstalk:previous --> <details><summary>Beanstalk test farm · an earlier run: commit <code>27dc849</code> (the newer results are in a comment below)</summary> Commit `27dc849` · tier **reviewed** · approved by HumanBean · [dashboard](https://beanstalk.magicbean.dev/prs/1846) **What will be tested** · AI plan (`gpt-6.1-terra`) The plan tests vegetation rendering in Kokiri Forest, Hyrule Field and the Market on Linux, Windows and Steam Deck. It compares main with the PR with parallel replay both off and on, because batching must also work across worker segments. Each target takes roughly 22 minutes; screenshots, frame times, GPU time and load times are compared. Crashes, device loss, substantial visual differences or performance regressions fail the plan. - **Where:** linux (2-3 reports), windows (2-3 reports), steamdeck (1-2 reports). - **Matrix:** 2 cells, each on main and the PR: RX_VK_PARALLEL `0` or `1`. - **vegetation-tour:** from the repository's save `kokiri-start`, then teleport to Kokiri Forest, measure forest for 20 s (after 5 s warm-up), take the picture forest to compare with main, teleport to Hyrule Field, measure field for 20 s (after 5 s warm-up), take the picture field to compare with main, teleport to Market, measure market for 20 s (after 5 s warm-up), take the picture market 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, GPU time per pass, load times, the game's log. - **The PR fails if:** it crashes; or a picture differs from main by more than 10%; or GPU time a frame is more than 15% above main; or longest load is more than 30% above main; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0. - **Time:** about 25 min of game runs per tester (4 game starts), plus the two builds. Started at 08:01 UTC. **Estimate:** done in about 2 h 45 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 | | --- | --- | --- | --- | --- | --- | | linux | 0/2 | — | — | — | error | | windows · 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 4080, 621.1.0` | 2/2 [1](https://beanstalk.magicbean.dev/reports/rp_5dbb3b1eaa40f216) [2](https://beanstalk.magicbean.dev/reports/rp_8f87cc5a02ce7238) | none | — | — | error | | steamdeck | 0/1 | — | — | — | queued | | Scenario · matrix cell | Target | Frame p99 (ms) vs main | Result | | --- | --- | --- | --- | | vegetation-tour · `RX_VK_PARALLEL=0` | linux | — | — | | vegetation-tour · `RX_VK_PARALLEL=0` | windows | — | not judged | | vegetation-tour · `RX_VK_PARALLEL=0` | steamdeck | — | — | | vegetation-tour · `RX_VK_PARALLEL=1` | linux | — | — | | vegetation-tour · `RX_VK_PARALLEL=1` | windows | — | not judged | | vegetation-tour · `RX_VK_PARALLEL=1` | steamdeck | — | — | #### Measurements · windows **Verdict:** could not be judged on windows (2/2 reports). 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 4080, 621.1.0` `AMD Ryzen 7 9800X3D 8-Core Processor, 32 GB RAM` Scene: vegetation-tour, from the repository's save kokiri-start; 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); vegetation-tour: 1 game start a side, forest 20 s after 5 s warm-up, 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) Nothing was measured: no metric came back. ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (GPU time a frame) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_PARALLEL` | switch | `0`, `1` | main's default | the PR's default | vegetation-tour, the PR at 0 → at 1: not measured | untested | <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** could not be judged on windows (2/2 reports). 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 4080, 621.1.0` `AMD Ryzen 7 9800X3D 8-Core Processor, 32 GB RAM` Scene: vegetation-tour, from the repository's save kokiri-start; 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); vegetation-tour: 1 game start a side, forest 20 s after 5 s warm-up, 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) Nothing was measured: no metric came back. ### Flags and settings | Flag | What it is | Values tried | Before this PR | After this PR | Effect (GPU time a frame) | Helps / doesn't help / untested | |---|---|---|---|---|---|---| | `RX_VK_PARALLEL` | switch | `0`, `1` | main's default | the PR's default | vegetation-tour, the PR at 0 → at 1: not measured | untested | ``` </details> </details>
GummiNaomi changed title from WIP: perf(vk): the vegetation's indirect mesh draws keep their passes: their arguments converted at the game's barriers (RX_VK_MESH_CONV) to perf(vk): the vegetation's indirect mesh draws keep their passes: their arguments converted at the game's barriers (RX_VK_MESH_CONV) 2026-11-20 08:04:43 +00:00
GummiNaomi force-pushed perf/mesh-conv-batch from 27dc849964
Some checks reported errors
Website / Website on Cloudflare (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
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
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 22s
CI / Conventional Commit title (pull_request) Successful in 13s
CI / Workflow lint (actionlint) (pull_request) Successful in 24s
Third-party parts / As their notes say (pull_request) Successful in 25s
Website / Website on Cloudflare (pull_request_target) Has been skipped
beanstalk/windows 0/2 pass, 3 error
beanstalk/approval approved by HumanBean (reviewed)
PR description / Description follows the template (pull_request_target) Failing after 6s
beanstalk/linux 0/2 pass, 3 error
beanstalk/steamdeck 0/1 pass, 0 running, 2 queued
CI / Website build and checks (pull_request) Has been cancelled
to 2125e5b5a9
Some checks reported errors
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request) Has been skipped
PR description / Description follows the template (pull_request_target) Failing after 12s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 12s
Third-party parts / As their notes say (pull_request) Successful in 13s
CI / Conventional Commit title (pull_request) Successful in 11s
CI / Workflow lint (actionlint) (pull_request) Successful in 16s
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Website build and checks (pull_request) Failing after 4m35s
beanstalk/approval approved by GummiNaomi (reviewed)
beanstalk/steamdeck 0/1 pass, 0 running, 0 queued
beanstalk/linux 0/1 pass, 1 error
beanstalk/windows+nvidia 0/1 pass, 2 error
2026-11-20 14:08:18 +00:00
Compare
Member

Beanstalk test farm

Commit 2125e5b · tier reviewed · approved by GummiNaomi · dashboard

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

From kokiri-start, this plan runs the in-game mesh-conversion A/B for two minutes each in Hyrule Field and the Market on Steam Deck, Linux, and Windows with NVIDIA. It compares vegetation screenshots and frame times with main, failing on crashes, device loss, substantial visual differences, or a 15% p99 frame-time regression. Each tester’s game runs take about 15 minutes. The farm cannot set the requested 2560x1440 output or target GPUs by mesh-shader capability, so the no-mesh fallback and its log cannot be guaranteed; the requested frame-trace switch is also unavailable to plans.

  • Where: steamdeck (1-2 reports), linux (1-2 reports), windows+nvidia (1-2 reports).
  • vegetation-ab: from the repository's save kokiri-start (switches HOS_AB=RX_VK_MESH_CONV=0,3,60), then teleport to Hyrule Field, take the picture field-vegetation to compare with main, measure field for 2 min (after 10 s warm-up), teleport to Market, take the picture market-vegetation to compare with main, measure market for 2 min (after 10 s warm-up); 1 run on each side.
  • Measured: crashes, frame times, stutters and hitches, the game's log.
  • The PR fails if: it crashes; or a picture differs from main by more than 10%; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0.
  • Time: about 19 min of game runs per tester (2 game starts), plus the two builds.

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

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
steamdeck 0/1 — — — queued
linux · 1: linux+other unknown, unknown 1/1 1 none — — error
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 4070 Ti, 621.14.0 2/1 1 2 none — — error

Measurements · linux

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

Hardware: 1: linux+other unknown, unknown AMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAM
Scene: vegetation-ab, from the repository's save kokiri-start (HOS_AB=RX_VK_MESH_CONV=0,3,60); 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); vegetation-ab: 1 game start a side, field 120 s after 10 s warm-up, market 120 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)

Nothing was measured: no metric came back.

Flags and settings

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

Markdown for the PR description
## Measurements

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

Hardware: 1: linux+other `unknown, unknown` `AMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAM`  
Scene: vegetation-ab, from the repository's save kokiri-start (HOS_AB=RX_VK_MESH_CONV=0,3,60); 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); vegetation-ab: 1 game start a side, field 120 s after 10 s warm-up, market 120 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)

Nothing was measured: no metric came back.

### Flags and settings

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

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 4070 Ti, 621.14.0 AMD Ryzen 9 5900X 12-Core Processor, 64 GB RAM
Scene: vegetation-ab, from the repository's save kokiri-start (HOS_AB=RX_VK_MESH_CONV=0,3,60); 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); vegetation-ab: 1 game start a side, field 120 s after 10 s warm-up, market 120 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

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

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 4070 Ti, 621.14.0` `AMD Ryzen 9 5900X 12-Core Processor, 64 GB RAM`  
Scene: vegetation-ab, from the repository's save kokiri-start (HOS_AB=RX_VK_MESH_CONV=0,3,60); 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); vegetation-ab: 1 game start a side, field 120 s after 10 s warm-up, market 120 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

None: the plan varied no setting, switch or build option.
<!-- beanstalk:sticky --> ### Beanstalk test farm Commit `2125e5b` · tier **reviewed** · approved by GummiNaomi · [dashboard](https://beanstalk.magicbean.dev/prs/1846) **What will be tested** · AI plan (`gpt-6.1-terra`) From kokiri-start, this plan runs the in-game mesh-conversion A/B for two minutes each in Hyrule Field and the Market on Steam Deck, Linux, and Windows with NVIDIA. It compares vegetation screenshots and frame times with main, failing on crashes, device loss, substantial visual differences, or a 15% p99 frame-time regression. Each tester’s game runs take about 15 minutes. The farm cannot set the requested 2560x1440 output or target GPUs by mesh-shader capability, so the no-mesh fallback and its log cannot be guaranteed; the requested frame-trace switch is also unavailable to plans. - **Where:** steamdeck (1-2 reports), linux (1-2 reports), windows+nvidia (1-2 reports). - **vegetation-ab:** from the repository's save `kokiri-start` (switches `HOS_AB=RX_VK_MESH_CONV=0,3,60`), then teleport to Hyrule Field, take the picture field-vegetation to compare with main, measure field for 2 min (after 10 s warm-up), teleport to Market, take the picture market-vegetation to compare with main, measure market for 2 min (after 10 s warm-up); 1 run on each side. - **Measured:** crashes, frame times, stutters and hitches, the game's log. - **The PR fails if:** it crashes; or a picture differs from main by more than 10%; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0. - **Time:** about 19 min of game runs per tester (2 game starts), plus the two builds. Done (started 14:36 UTC, last report 14:57 UTC). Comment `@Beanstalk` to run it again. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | steamdeck | 0/1 | — | — | — | queued | | linux · 1: linux+other `unknown, unknown` | 1/1 [1](https://beanstalk.magicbean.dev/reports/rp_811ee7b0654fbc1d) | none | — | — | error | | 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 4070 Ti, 621.14.0` | 2/1 [1](https://beanstalk.magicbean.dev/reports/rp_d7f479dc6ee4cd04) [2](https://beanstalk.magicbean.dev/reports/rp_be198a2427ecd495) | none | — | — | error | #### Measurements · linux **Verdict:** could not be judged on linux (1/1 report). Hardware: 1: linux+other `unknown, unknown` `AMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAM` Scene: vegetation-ab, from the repository's save kokiri-start (HOS_AB=RX_VK_MESH_CONV=0,3,60); 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); vegetation-ab: 1 game start a side, field 120 s after 10 s warm-up, market 120 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) Nothing was measured: no metric came back. ### Flags and settings None: the plan varied no setting, switch or build option. <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** could not be judged on linux (1/1 report). Hardware: 1: linux+other `unknown, unknown` `AMD Ryzen 7 5700X3D 8-Core Processor, 128 GB RAM` Scene: vegetation-ab, from the repository's save kokiri-start (HOS_AB=RX_VK_MESH_CONV=0,3,60); 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); vegetation-ab: 1 game start a side, field 120 s after 10 s warm-up, market 120 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) Nothing was measured: no metric came back. ### Flags and settings None: the plan varied no setting, switch or build option. ``` </details> #### 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 4070 Ti, 621.14.0` `AMD Ryzen 9 5900X 12-Core Processor, 64 GB RAM` Scene: vegetation-ab, from the repository's save kokiri-start (HOS_AB=RX_VK_MESH_CONV=0,3,60); 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); vegetation-ab: 1 game start a side, field 120 s after 10 s warm-up, market 120 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 None: the plan varied no setting, switch or build option. <details><summary>Markdown for the PR description</summary> ```markdown ## Measurements **Verdict:** could not be judged on 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 4070 Ti, 621.14.0` `AMD Ryzen 9 5900X 12-Core Processor, 64 GB RAM` Scene: vegetation-ab, from the repository's save kokiri-start (HOS_AB=RX_VK_MESH_CONV=0,3,60); 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); vegetation-ab: 1 game start a side, field 120 s after 10 s warm-up, market 120 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 None: the plan varied no setting, switch or build option. ``` </details>
Author
Member

@Beanstalk steamdeck, linux and windows (an NVIDIA card at 2560x1440, and a GPU without mesh shaders if there is one): from kokiri-start, Hyrule Field and Castle Town's market, 2 minutes each, HOS_AB=RX_VK_MESH_CONV=0,3,60 RX_VK_FRAME_TRACE=1. Expecting the old way (side 1) slower, as here (+1.7 % in Hyrule Field, +1.3 % in the Market at 2125e5b5's code), the vegetation drawn, and on a GPU without mesh shaders "left as they are (no mesh shaders)" in the log with no change in frame time. This replaces today's run, which ended in error before building (the farm's checkout of main failed git rev-parse --verify HEAD^{commit} in packs.py's cmd_base) and whose plan also tested RX_VK_PARALLEL, which main has removed.

@Beanstalk steamdeck, linux and windows (an NVIDIA card at 2560x1440, and a GPU without mesh shaders if there is one): from kokiri-start, Hyrule Field and Castle Town's market, 2 minutes each, `HOS_AB=RX_VK_MESH_CONV=0,3,60 RX_VK_FRAME_TRACE=1`. Expecting the old way (side 1) slower, as here (+1.7 % in Hyrule Field, +1.3 % in the Market at 2125e5b5's code), the vegetation drawn, and on a GPU without mesh shaders "left as they are (no mesh shaders)" in the log with no change in frame time. This replaces today's run, which ended in `error` before building (the farm's checkout of main failed `git rev-parse --verify HEAD^{commit}` in packs.py's cmd_base) and whose plan also tested `RX_VK_PARALLEL`, which main has removed.
HumanBean deleted branch perf/mesh-conv-batch 2026-11-20 15:29:18 +00:00
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!1846
No description provided.