fix(vk): GPUs on the compute fallback load programs when the game makes them, not all 32,645 pipelines before the title #975

Merged
HumanBean merged 2 commits from HumanBean/Longshot:fix/fallback-load-create into main 2026-11-16 01:09:28 +00:00
Owner

Type: fix · Risk: medium · Tested on: not yet in the game · Needs: Windows, AMD without native mesh shaders (RX 6600 / Navi 23), any compute-fallback GPU

Why

Since rc.4, the RX 6600 (and the other Navi 23 cards) on Windows drops to 1-15 fps in Hyrule Field, Lake Hylia and elsewhere, where rc.3 ran at 30-60. The logs show the PC at its commit limit before play has started.

Two merges between rc.3 and rc.4 add up to that:

  • #219 put Navi 23 on Windows on the compute fallback for task + mesh draws, to stop device losses on the native path (#583, #130). On rc.3 the RX 6600 drew mesh programs itself. The load default (gpu/vk/load_default.h) is RX_VK_LOAD=start on any GPU without native mesh, so the RX 6600 went from loading programs when the game makes them (create) to keeping every listed program and pipeline ready before the title.
  • #563 added 22,987 pipelines to the shipped list, so that start now keeps 27,262 programs and 32,645 graphics pipelines ready. #563 was measured on an RTX 4070 SUPER, which loads at create, so the cost on fallback cards wasn't seen.

From the reporters' rc.4 logs (source b784a40c):

  • #933 (16 GB PC), at the title before any play: memory: working set 8328 MB (peak 11393), private 19227 MB, then commit limit near: 279 MB of commit left (reserve 2560 MB); the textures' budget down to 0 MB of their 72 MB (RX_VK_COMMIT_RESERVE_MB). The texture budget is 0 because of the commit rule, not VRAM: the same title shows VRAM: 5237 MB used of 6564 MB allowed (1304 MB of it free in the blocks).
  • #933 in play: the same draw counts take about 4 times the GPU time of #869's 32 GB PC with the same card and path (about 66 ms against 17 ms at 500-999 draws a frame), with textures retired and their ASTC decoded again. That fits memory pressure, not the fallback's own shaders.
  • #869 (32 GB), in play: private 29379 MB, VRAM: 6826 MB used of 6826 MB allowed, render target images: ... 138690 made new ... VRAM short: given back, and the game's threads waiting on the render thread (timelines 513.73 ms a frame summed across threads) at 1.9 fps.

#805 had already measured RX_VK_LOAD=create on two other fallback cards. On the RX 5600 XT and the GTX 1060 it gave the same fps or better, 4-5 GB less private memory and no commit limit near lines. That issue also suspected #563 of the growth.

This PR keeps #219's fallback, which reporters say stopped the device losses, and removes the start-mode memory it brought. What it doesn't remove:

  • The compute programs #563 keeps ready (2,199 keys, about 1.3 GB), which are kept in create too: a follow-up.
  • The fallback's own cost per mesh draw on the render thread. #869's worst frames are the replay on the CPU (its jobs 168.64 ms a frame), and some of that may be the fallback's recording.
  • About 3.5 GB of device memory in use outside the renderer's blocks at the title on #933. It isn't attributed; the driver's pipelines are a guess.

Fixes #869. See #933, #805, #563, #219.

How to reproduce

Seen on: Windows 11, RX 6600 8 GB (Adrenalin 26.8.1 and 26.10.1), Ryzen 5 3600 / 4650G, 16-32 GB (#869, #933)
Settings and switches: defaults (Auto: task + mesh compute fallback, threaded rendering)
Steps: start rc.4 and look at the vk: precompile: and vk: memory heaps: lines at the title, then play in Hyrule Field for a while
Expected: VRAM left for textures and render targets; fps as on rc.3
Actual: programs are loaded before the title (start): this GPU draws mesh programs through the compute fallback, 32,645 pipelines kept, the texture budget at 0, the commit limit near, and fps falling to 1-15

What changed

Auto now loads programs when the game makes them (create) on the compute fallback too, as it already does on GPUs with mesh shaders. The safety net stays as it is: an install whose loads at create wait too long gets longshot_load_start.txt, and from then on loads before the title. That covers the one fallback PC where create waited seconds (an RX 580 with 16 GB). RX_VK_LOAD=start still gives the old behaviour.

  • vk: load_default::choose in gpu/vk/load_default.h no longer returns start for !native_mesh. native_mesh now only picks the reason the log gives. The comment says why, with the numbers.
  • vk: the comment above programs_load_decide in gpu/vk/vk_programs.cpp.
  • tests: tests/load_default_test.cpp expects create on the fallback without the marker (its own commit, which fails on main at CHECK(choose(nullptr, false, false).create)); tests/test_load_default.py's docstring.
  • docs: RX_VK_LOAD and RX_VK_DROP_MODULES in docs/development.md.

Measurements

Verdict: not measured yet. A run on an AMD compute-fallback PC is coming: main against this PR, Hyrule Field over a long session, fps, VRAM at the title and in play, private memory, commit limit near lines.

Hardware: -
Scene: -
Method: -
How to reproduce: -

Before: main @ dbad7d12 After: this PR @ 3aff78a2
fps, Hyrule Field
VRAM used at the title
private memory in play
commit limit near lines
(to come)

Flags and settings

No new switch. The default of RX_VK_LOAD changes on compute-fallback GPUs.

Flag What it is Before this PR After this PR Effect Helps / doesn't help / untested Recommendation
RX_VK_LOAD (unset) on a compute-fallback GPU when kept programs and pipelines are loaded start create (start once the safety net's marker is there) 4-5 GB less private memory and the driver's VRAM for the pipelines no longer held (#805); loads in the background as the game makes programs helps on RX 5600 XT and GTX 1060 (#805); RX 6600 untested; an RX 580 with 16 GB waited seconds at create (the marker takes such a PC back) create for everyone, as shipped here

Testing

Tested: nothing in the game yet; runs on an RX 580 (Linux, RADV, 16 GB) are under way, with the renderer built from this change before its comments were reworded (same code). I read the code: create mode already handles the compute fallback's programs (precompile_at_create makes the fallback programs' compute pipelines, tests/test_fallback_loaded.py), and players have run RX_VK_LOAD=create on fallback cards (#805: RX 5600 XT, GTX 1060). The game-free checks were not run on this PC.

Not tested: any GPU in the game with this build; Linux fallback GPUs (Steam Deck, which has run RX_VK_LOAD=create in docs/tested runs); Intel GPUs before Arc.

Must be tested:

  • Windows, AMD compute fallback (RX 6600 or another Navi 23): a cold start, then about 20 minutes through Hyrule Field and two other areas, on main and on this PR. Expected: the log says programs are loaded when the game makes them (create): the default, on the compute fallback too, VRAM used at the title well under the allowance, no commit limit near lines on a 32 GB PC, Hyrule Field fps as on rc.3 (by hand: the AMD lab PC)
  • python -I -B tests/run_all.py, expecting tests/test_load_default.py to fail on main at the first commit's check and pass here (the author's PC can't run the checks)

Risks

What could break: on a fallback PC where loads at create are slow (the RX 580 case), the first visits to areas wait on loads until the safety net puts that install back on start (one session over 2 s of long waits, or two over 500 ms). Draws whose pipelines aren't loaded yet are left out for a frame, as they already are on GPUs with mesh shaders.

Turning it off: RX_VK_LOAD=start in longshot_env.txt, or revert the commit.

Compatibility: nothing to rebuild: the shader and pipeline caches stay as they are. The first start after updating loads at create; an install whose folder already has longshot_load_start.txt keeps loading at start.

Issues

Fixes #869
See #933
See #805

Checklist

Everyone

  • One topic.
  • The title is a Conventional Commit (type(scope): description) of the status line's type.
  • Why gives the reason plainly and links the issues that fit (the tracker searched).
  • Measurements has a verdict, or one line saying why there is nothing to measure. (the AMD run is to come)
  • Testing names what was tested, what wasn't, and what must still be tested, where and how.
  • Rebased on current main.
  • python -I -B tests/run_all.py passes (any failure that also fails on main is named). (not run on this PC)
  • No game files, dumps, build output or generated files.
  • third_party/ untouched (a new folder with a PROVENANCE.md instead).
  • The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled.

When it applies

  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.
  • Numbers from the same PC, scene and settings, at least 2 interleaved runs each, the median reported. (to come)
  • Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value.
  • A game-free test added for the fix, failing on main and passing here. (not run here: see Must be tested)
  • A check under tests/ that reads changed source updated in this PR, not weakened.
  • Docs updated.

🤖 Generated with Claude Code

**Type:** fix · **Risk:** medium · **Tested on:** not yet in the game · **Needs:** Windows, AMD without native mesh shaders (RX 6600 / Navi 23), any compute-fallback GPU ## Why Since rc.4, the RX 6600 (and the other Navi 23 cards) on Windows drops to 1-15 fps in Hyrule Field, Lake Hylia and elsewhere, where rc.3 ran at 30-60. The logs show the PC at its commit limit before play has started. Two merges between rc.3 and rc.4 add up to that: - **#219** put Navi 23 on Windows on the compute fallback for task + mesh draws, to stop device losses on the native path (#583, #130). On rc.3 the RX 6600 drew mesh programs itself. The load default (`gpu/vk/load_default.h`) is `RX_VK_LOAD=start` on any GPU without native mesh, so the RX 6600 went from loading programs when the game makes them (`create`) to keeping every listed program and pipeline ready before the title. - **#563** added 22,987 pipelines to the shipped list, so that start now keeps 27,262 programs and 32,645 graphics pipelines ready. #563 was measured on an RTX 4070 SUPER, which loads at create, so the cost on fallback cards wasn't seen. From the reporters' rc.4 logs (source b784a40c): - #933 (16 GB PC), at the title before any play: `memory: working set 8328 MB (peak 11393), private 19227 MB`, then `commit limit near: 279 MB of commit left (reserve 2560 MB); the textures' budget down to 0 MB of their 72 MB (RX_VK_COMMIT_RESERVE_MB)`. The texture budget is 0 because of the commit rule, not VRAM: the same title shows `VRAM: 5237 MB used of 6564 MB allowed (1304 MB of it free in the blocks)`. - #933 in play: the same draw counts take about 4 times the GPU time of #869's 32 GB PC with the same card and path (about 66 ms against 17 ms at 500-999 draws a frame), with textures retired and their ASTC decoded again. That fits memory pressure, not the fallback's own shaders. - #869 (32 GB), in play: `private 29379 MB`, `VRAM: 6826 MB used of 6826 MB allowed`, `render target images: ... 138690 made new ... VRAM short: given back`, and the game's threads waiting on the render thread (`timelines 513.73` ms a frame summed across threads) at 1.9 fps. #805 had already measured `RX_VK_LOAD=create` on two other fallback cards. On the RX 5600 XT and the GTX 1060 it gave the same fps or better, 4-5 GB less private memory and no `commit limit near` lines. That issue also suspected #563 of the growth. This PR keeps #219's fallback, which reporters say stopped the device losses, and removes the start-mode memory it brought. What it doesn't remove: - The compute programs #563 keeps ready (2,199 keys, about 1.3 GB), which are kept in `create` too: a follow-up. - The fallback's own cost per mesh draw on the render thread. #869's worst frames are the replay on the CPU (`its jobs 168.64 ms a frame`), and some of that may be the fallback's recording. - About 3.5 GB of device memory in use outside the renderer's blocks at the title on #933. It isn't attributed; the driver's pipelines are a guess. Fixes #869. See #933, #805, #563, #219. ## How to reproduce **Seen on:** Windows 11, RX 6600 8 GB (Adrenalin 26.8.1 and 26.10.1), Ryzen 5 3600 / 4650G, 16-32 GB (#869, #933) **Settings and switches:** defaults (Auto: task + mesh compute fallback, threaded rendering) **Steps:** start rc.4 and look at the `vk: precompile:` and `vk: memory heaps:` lines at the title, then play in Hyrule Field for a while **Expected:** VRAM left for textures and render targets; fps as on rc.3 **Actual:** `programs are loaded before the title (start): this GPU draws mesh programs through the compute fallback`, 32,645 pipelines kept, the texture budget at 0, the commit limit near, and fps falling to 1-15 ## What changed Auto now loads programs when the game makes them (`create`) on the compute fallback too, as it already does on GPUs with mesh shaders. The safety net stays as it is: an install whose loads at create wait too long gets `longshot_load_start.txt`, and from then on loads before the title. That covers the one fallback PC where `create` waited seconds (an RX 580 with 16 GB). `RX_VK_LOAD=start` still gives the old behaviour. - vk: `load_default::choose` in `gpu/vk/load_default.h` no longer returns start for `!native_mesh`. `native_mesh` now only picks the reason the log gives. The comment says why, with the numbers. - vk: the comment above `programs_load_decide` in `gpu/vk/vk_programs.cpp`. - tests: `tests/load_default_test.cpp` expects create on the fallback without the marker (its own commit, which fails on `main` at `CHECK(choose(nullptr, false, false).create)`); `tests/test_load_default.py`'s docstring. - docs: `RX_VK_LOAD` and `RX_VK_DROP_MODULES` in `docs/development.md`. ## Measurements **Verdict:** not measured yet. A run on an AMD compute-fallback PC is coming: main against this PR, Hyrule Field over a long session, fps, VRAM at the title and in play, private memory, `commit limit near` lines. Hardware: - Scene: - Method: - How to reproduce: - | | Before: main @ dbad7d12 | After: this PR @ 3aff78a2 | |---|---|---| | fps, Hyrule Field | | | | VRAM used at the title | | | | private memory in play | | | | `commit limit near` lines | | | ``` (to come) ``` ### Flags and settings No new switch. The default of `RX_VK_LOAD` changes on compute-fallback GPUs. | Flag | What it is | Before this PR | After this PR | Effect | Helps / doesn't help / untested | Recommendation | |---|---|---|---|---|---|---| | `RX_VK_LOAD` (unset) on a compute-fallback GPU | when kept programs and pipelines are loaded | `start` | `create` (`start` once the safety net's marker is there) | 4-5 GB less private memory and the driver's VRAM for the pipelines no longer held (#805); loads in the background as the game makes programs | helps on RX 5600 XT and GTX 1060 (#805); RX 6600 untested; an RX 580 with 16 GB waited seconds at create (the marker takes such a PC back) | `create` for everyone, as shipped here | ## Testing **Tested:** nothing in the game yet; runs on an RX 580 (Linux, RADV, 16 GB) are under way, with the renderer built from this change before its comments were reworded (same code). I read the code: create mode already handles the compute fallback's programs (`precompile_at_create` makes the fallback programs' compute pipelines, `tests/test_fallback_loaded.py`), and players have run `RX_VK_LOAD=create` on fallback cards (#805: RX 5600 XT, GTX 1060). The game-free checks were not run on this PC. **Not tested:** any GPU in the game with this build; Linux fallback GPUs (Steam Deck, which has run `RX_VK_LOAD=create` in docs/tested runs); Intel GPUs before Arc. **Must be tested:** - Windows, AMD compute fallback (RX 6600 or another Navi 23): a cold start, then about 20 minutes through Hyrule Field and two other areas, on main and on this PR. Expected: the log says `programs are loaded when the game makes them (create): the default, on the compute fallback too`, VRAM used at the title well under the allowance, no `commit limit near` lines on a 32 GB PC, Hyrule Field fps as on rc.3 (by hand: the AMD lab PC) - `python -I -B tests/run_all.py`, expecting `tests/test_load_default.py` to fail on `main` at the first commit's check and pass here (the author's PC can't run the checks) ## Risks **What could break:** on a fallback PC where loads at create are slow (the RX 580 case), the first visits to areas wait on loads until the safety net puts that install back on `start` (one session over 2 s of long waits, or two over 500 ms). Draws whose pipelines aren't loaded yet are left out for a frame, as they already are on GPUs with mesh shaders. **Turning it off:** `RX_VK_LOAD=start` in `longshot_env.txt`, or revert the commit. **Compatibility:** nothing to rebuild: the shader and pipeline caches stay as they are. The first start after updating loads at create; an install whose folder already has `longshot_load_start.txt` keeps loading at start. ## Issues Fixes #869 See #933 See #805 ## Checklist ### Everyone - [x] One topic. - [x] The title is a Conventional Commit (`type(scope): description`) of the status line's type. - [x] Why gives the reason plainly and links the issues that fit (the tracker searched). - [ ] Measurements has a verdict, or one line saying why there is nothing to measure. (the AMD run is to come) - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [ ] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). (not run on this PC) - [x] No game files, dumps, build output or generated files. - [x] `third_party/` untouched (a new folder with a `PROVENANCE.md` instead). - [x] The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. ### When it applies - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. - [ ] Numbers from the same PC, scene and settings, at least 2 interleaved runs each, the median reported. (to come) - [x] Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value. - [x] A game-free test added for the fix, failing on `main` and passing here. (not run here: see Must be tested) - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. - [x] Docs updated. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
On main a GPU that draws mesh programs through the compute fallback loads every listed program and pipeline before the
title. tests/load_default_test.cpp now expects create there unless the marker is there, and fails on main at
CHECK(choose(nullptr, false, false).create).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
fix(vk): GPUs on the compute fallback load programs when the game makes them, not all 32,645 pipelines before the title (#869, #933)
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 4s
CI / Conventional Commit title (pull_request) Successful in 3s
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Workflow lint (actionlint) (pull_request) Successful in 5s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 5s
Third-party parts / As their notes say (pull_request) Successful in 8s
beanstalk/approval approved by HumanBean (reviewed)
beanstalk/windows+amd 0/1 pass, 0 running, 1 queued
3632ac007b
Since #563's list a start on the compute fallback (RX 6600 and other cards without usable mesh shaders) kept 27,262 programs
and 32,645 graphics pipelines ready before the title: 5.2 GB of an 8 GB card's VRAM used at the title with the textures'
budget at 0, and 25-29 GB of private memory, at the commit limit. rc.4 fell to 1-15 fps there. Auto now picks create on the
fallback as with mesh shaders; the safety net (longshot_load_start.txt) still takes a PC whose loads wait back to start, and
RX_VK_LOAD=start gives the old behaviour.

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

@Beanstalk

@Beanstalk
Member

Beanstalk test farm

Commit 3aff78a · tier untrusted · approved by nobody yet · dashboard

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

<!-- beanstalk:sticky --> ### Beanstalk test farm Commit `3aff78a` · tier **untrusted** · approved by nobody yet · [dashboard](https://beanstalk.magicbean.dev/prs/975) A member of `BigBeans` can review this commit and comment `@Beanstalk` to test it.
HumanBean force-pushed fix/fallback-load-create from 3632ac007b
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 4s
CI / Conventional Commit title (pull_request) Successful in 3s
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Workflow lint (actionlint) (pull_request) Successful in 5s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 5s
Third-party parts / As their notes say (pull_request) Successful in 8s
beanstalk/approval approved by HumanBean (reviewed)
beanstalk/windows+amd 0/1 pass, 0 running, 1 queued
to 3aff78a24d
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 3s
CI / Workflow lint (actionlint) (pull_request) Successful in 5s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 5s
Third-party parts / As their notes say (pull_request) Successful in 8s
beanstalk/approval not approved yet
PR description / Description follows the template (pull_request_target) Failing after 4s
2026-11-16 01:03:00 +00:00
Compare
Author
Owner

Reworded, no change to the code: the description, the comment in load_default.h, the docs row and the fix commit's message now say the texture budget reached 0 by the commit rule (system RAM and page file), not by VRAM, and that #219 is what put the RX 6600 on the compute fallback and so on start-mode loading; #563 made that start costlier. The description also names what this PR doesn't remove (the compute programs #563 keeps ready, the fallback's per-draw cost). Force-pushed as 3aff78a2. No tests were run on this PC.

Reworded, no change to the code: the description, the comment in load_default.h, the docs row and the fix commit's message now say the texture budget reached 0 by the commit rule (system RAM and page file), not by VRAM, and that #219 is what put the RX 6600 on the compute fallback and so on start-mode loading; #563 made that start costlier. The description also names what this PR doesn't remove (the compute programs #563 keeps ready, the fallback's per-draw cost). Force-pushed as 3aff78a2. No tests were run on this PC.
HumanBean changed title from WIP: fix(vk): GPUs on the compute fallback load programs when the game makes them, not all 32,645 pipelines before the title to fix(vk): GPUs on the compute fallback load programs when the game makes them, not all 32,645 pipelines before the title 2026-11-16 01:09:23 +00:00
HumanBean deleted branch fix/fallback-load-create 2026-11-16 01:09:28 +00:00
Author
Owner

Measured after the merge, on an RX 580 8 GB (RADV POLARIS10, Mesa 26.2.6, 8 logical processors, 16 GB, CachyOS, KDE Wayland, fullscreen). This is the one card where loads at create were known to be slow. The Windows RX 6600 case this PR is for is still unmeasured.

Verdict: no fps cost. On this card create made first uses wait 0.5-2.2 s a session, so the safety net put the install back on start after its second session, as designed.

Method: one dev_packs.py base of main dbad7d12, with main's runtime and this PR's longshot_vk.so (same code as 3aff78a2; the build predates the comment rewording), both prepared. The route: the pristine Kokiri save, Kokiri Forest, then teleports to Hyrule Field, the Market and Hyrule Field again, 40 s standing and 30 s turning in each. Cap 240, default options. Arms: M = main (start on this fallback GPU), P = this PR, C = main + RX_VK_LOAD=create. Order: warm-ups M, P, then M P C P M C M P C. fps is 1000 / the median frame time (RX_VK_FRAME_LOG), and each value is the median of the arm's runs.

fps / p99 frame ms M: main @ dbad7d12 P: this PR C: main + create
Kokiri, standing / turning 20.9 / 22.4 (54.6 / 65.8) 20.9 / 22.5 (54.7 / 70.6) 21.0 / 22.5 (54.7 / 62.3)
Hyrule Field, standing / turning 28.0 / 33.7 (39.1 / 41.8) 27.5 / 34.0 (39.7 / 41.6) 27.6 / 33.4 (39.5 / 43.2)
Market, standing / turning 24.2 / 38.1 (83.3 / 130.6) 24.3 / 36.8 (79.5 / 131.7) 24.5 / 38.5 (79.6 / 124.9)
Hyrule Field again, standing / turning 27.3 / 32.7 (52.6 / 59.5) 27.6 / 32.6 (57.5 / 64.8) 27.2 / 33.2 (53.5 / 64.7)
Load mode start ×3 create (warm-up, ab-2), then start (ab-4, ab-8: the marker) create ×3 (the switch wins)
First-use waits the safety net counted - 503 ms, 1,236 ms 505, 566, 2,178 ms
Worst single load - 550, 885 ms 782, 771, 1,109 ms
Private memory, highest 1.87-1.93 GB 2.44 GB (create) 2.45-2.53 GB
commit limit near lines 0 0 0
  • fps: every difference is inside the spread between runs of the same arm.
  • Memory: on this Linux PC, create holds about 0.6 GB more than start, not less. That's probably start letting go of the shader modules on Linux with 20 GB of RAM or less (RX_VK_DROP_MODULES); not checked. #805's Windows numbers go the other way.
warm-P: vk: first uses waited for loads for 503 ms in this session (the longest 222 ms; waits over 20 ms counted): over 500 ms. Once is let pass; if the next session does the same, starts load every listed program before the title again
warm-P: vk: program loads at create (close): 5511 queued, 5511 loaded (median 0.46 ms, 99th percentile 192.66 ms, worst 549.97 ms, 105721 ms and 1152.0 MB read in all); ... 9591 graphics pipelines (0 not in a cache), ...
ab-4-P: vk: programs are loaded before the title (start): in an earlier session first uses waited too long for loads (longshot_load_start.txt)

Still to run: a Windows RX 6600, on the same save and spot, with each of the default, RX_VK_LOAD=create and RX_VK_TASK_MESH_FALLBACK=0. Read the commit limit near lines, the memory: working set ... private lines, the GPU time against draws, and fps. No tests were run on the author's PC.

**Measured after the merge, on an RX 580 8 GB** (RADV POLARIS10, Mesa 26.2.6, 8 logical processors, 16 GB, CachyOS, KDE Wayland, fullscreen). This is the one card where loads at create were known to be slow. The Windows RX 6600 case this PR is for is still unmeasured. **Verdict:** no fps cost. On this card create made first uses wait 0.5-2.2 s a session, so the safety net put the install back on start after its second session, as designed. Method: one `dev_packs.py` base of main dbad7d12, with main's runtime and this PR's `longshot_vk.so` (same code as 3aff78a2; the build predates the comment rewording), both prepared. The route: the pristine Kokiri save, Kokiri Forest, then teleports to Hyrule Field, the Market and Hyrule Field again, 40 s standing and 30 s turning in each. Cap 240, default options. Arms: M = main (start on this fallback GPU), P = this PR, C = main + `RX_VK_LOAD=create`. Order: warm-ups M, P, then M P C P M C M P C. fps is 1000 / the median frame time (`RX_VK_FRAME_LOG`), and each value is the median of the arm's runs. | fps / p99 frame ms | M: main @ dbad7d12 | P: this PR | C: main + create | |---|---|---|---| | Kokiri, standing / turning | 20.9 / 22.4 (54.6 / 65.8) | 20.9 / 22.5 (54.7 / 70.6) | 21.0 / 22.5 (54.7 / 62.3) | | Hyrule Field, standing / turning | 28.0 / 33.7 (39.1 / 41.8) | 27.5 / 34.0 (39.7 / 41.6) | 27.6 / 33.4 (39.5 / 43.2) | | Market, standing / turning | 24.2 / 38.1 (83.3 / 130.6) | 24.3 / 36.8 (79.5 / 131.7) | 24.5 / 38.5 (79.6 / 124.9) | | Hyrule Field again, standing / turning | 27.3 / 32.7 (52.6 / 59.5) | 27.6 / 32.6 (57.5 / 64.8) | 27.2 / 33.2 (53.5 / 64.7) | | Load mode | start ×3 | create (warm-up, ab-2), then start (ab-4, ab-8: the marker) | create ×3 (the switch wins) | | First-use waits the safety net counted | - | 503 ms, 1,236 ms | 505, 566, 2,178 ms | | Worst single load | - | 550, 885 ms | 782, 771, 1,109 ms | | Private memory, highest | 1.87-1.93 GB | 2.44 GB (create) | 2.45-2.53 GB | | `commit limit near` lines | 0 | 0 | 0 | - **fps:** every difference is inside the spread between runs of the same arm. - **Memory:** on this Linux PC, create holds about 0.6 GB more than start, not less. That's probably start letting go of the shader modules on Linux with 20 GB of RAM or less (`RX_VK_DROP_MODULES`); not checked. #805's Windows numbers go the other way. ``` warm-P: vk: first uses waited for loads for 503 ms in this session (the longest 222 ms; waits over 20 ms counted): over 500 ms. Once is let pass; if the next session does the same, starts load every listed program before the title again warm-P: vk: program loads at create (close): 5511 queued, 5511 loaded (median 0.46 ms, 99th percentile 192.66 ms, worst 549.97 ms, 105721 ms and 1152.0 MB read in all); ... 9591 graphics pipelines (0 not in a cache), ... ab-4-P: vk: programs are loaded before the title (start): in an earlier session first uses waited too long for loads (longshot_load_start.txt) ``` **Still to run:** a Windows RX 6600, on the same save and spot, with each of the default, `RX_VK_LOAD=create` and `RX_VK_TASK_MESH_FALLBACK=0`. Read the `commit limit near` lines, the `memory: working set ... private` lines, the GPU time against draws, and fps. No tests were run on the author's PC.
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
2 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!975
No description provided.