perf(vk): the game's per-frame render targets are reused instead of made and destroyed twice a frame #994

Merged
HumanBean merged 1 commit from GummiNaomi/Longshot:perf/target-pool-every-frame into main 2026-11-16 01:33:04 +00:00
Member

Type: perf · Risk: low · Tested on: Windows 11, RTX 4070 SUPER (NVIDIA 617.42) · Needs: Linux; AMD; Intel; a Steam Deck; an 8 GB card

Why

In busy places the frame rate goes up and down: in Castle Town's market at night, frames over 25 ms come several times a second. One cause is in the renderer: the game makes its per-frame render targets (a 384 x 384 depth target, 1280 x 720, 640 x 360 and 2560 x 1440 ones) at a slightly different place in its memory every frame, and Longshot made a new Vulkan image for each of them and destroyed one, about twice a frame. Destroying and making images was about 20 % of the render thread's time there (vkDestroyImage 15 %, vmaCreateImage 5 %, sampled).

See #995.

What changed

The render target pool, meant to hand last frame's image to this frame's target of the same shape, now gets its dead targets in time and keeps enough of them. Measured in the market at night: of the images made new, 80 % had last frame's one of their shape alive and unused, and the pool destroyed 99 % of what it let go for being over its 256 MB bound (21,879 of 22,000 in 100 s): dead targets came back every 10 presents, three or more presents late, ten frames' worth at once, and went over the bound.

  • vk: the dead transient targets are looked for every present (RX_VK_DEAD_EVERY 10 -> 1) after one present unused (RX_VK_DEAD_MIN_UNUSED 3 -> 1), in texture_frame (gpu/vk/vk_texture.cpp).
  • vk: the pool's bound is a twelfth of what the driver allows, 256 to 768 MB (gpu/vk/target_pool.h, pool_cap), two or three frames of these targets; RX_VK_TARGET_POOL_MB still sets it. Under VRAM pressure the pool is given back as before (pool_pressed), and on a small card the bound stays near the old 256 MB.
  • tests: tests/test_target_pool_cap.py (the bound by allowance), tests/test_target_image_pool.py (the new defaults).
  • docs: the three switches in docs/development.md.

Measurements

Verdict: fewer slow frames and less render thread time, the average frame rate about the same or a little higher. The images made new fall by 62 % on this build, and by 65-79 % in earlier runs with the same settings.

Hardware: Windows 11 Pro 26200, RTX 4070 SUPER 12 GB (NVIDIA 617.42), Ryzen 9 9950X3D (16 cores, SMT off), 32 GB
Scene: Castle Town's market at night (save set "First Step into Hyrule Town", !cheat 121 at 40 s), 2560x1440, DLAA, uncapped, the render thread on (Auto)
Method: headless runs on a wall-clock script (town-market.txt, 100 s), the two sides in turn in one build; fps is the median of the log's 120-present lines with 1,500-2,999 draws; slow frames and 1 % low from the frame trace's last two thirds; images from the log's render target images: line
How to reproduce: the save set above, the walk into the market at night; RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3 against the defaults

Before: old defaults, this PR @ a2cdf4e5 After: this PR @ a2cdf4e5
Render target images made new / destroyed (100 s) 21,501 / 21,229 8,096 / 7,768
Frames over 25 ms / over 50 ms 76 / 14 49 / 10
1 % low 42.1 fps 44.8 fps
Market fps, median 69.7 70.7
Render thread, its jobs a frame 9.9-11.9 ms 9.1-10.7 ms

Baseline: the same build with the old defaults set by switch (run with this change in the working tree on main d9486a08, then rebased cleanly onto a0be15b3); one round, the PC's time being short. The same three settings as switches on main 14e165ab (with the play folder's other switches, RX_VK_MIRROR_SPARSE=0), three rounds in turn, gave:

Before (main 14e165ab) After (the same, with the three settings)
Images made new (100 s) 20,037 / 11,567 / 12,816 4,320 / 4,326 / 4,051
Frames over 25 ms 200 / 437 / 219 52 / 54 / 37
1 % low (fps) 36.4 / 31.6 / 36.1 44.4 / 42.9 / 44.3
Market fps 61.9 / 53.8 / 62.6 66.5 / 63.2 / 61.4
VRAM in use 7.0-7.4 GB 7.3-7.8 GB

Played on the same PC with these settings: no visible change in the picture. A frame-by-frame check (a 320x180 picture of every present, counting one-frame flips over 1 % of the picture) gave 60 and 119 such frames against 17-60 on main's runs, all under 2.2 % of the picture and spread out (motion and lights), none of the concentrated kind a wrong image gives.

pp-main-1 [RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3] pool: 25820 reused from the pool, 21501 made new, 21229 destroyed
pp-new-1  [] pool: 34433 reused from the pool, 8096 made new, 7768 destroyed; vk: render target pool: up to 768 MB

Flags and settings

Three defaults change; no new switch.

Flag What it is Before this PR After this PR Effect Helps / doesn't help / untested Recommendation
RX_VK_DEAD_EVERY how often dead transient targets are looked for 10 1 the pool gets them as they die helps: RTX 4070 SUPER; untested elsewhere the new default
RX_VK_DEAD_MIN_UNUSED presents a dead target must be unused 3 1 the same as above the new default
RX_VK_TARGET_POOL_MB the pool's bound 256 a twelfth of the allowance, 256-768 two or three frames of targets kept as above; on 4-6 GB cards about the old bound the new default

Testing

Tested: Windows 11, RTX 4070 SUPER, NVIDIA 617.42: the runs above; played in Castle Town and Hyrule Field with the same three settings over two sessions ("seems good"); tests/test_target_pool_cap.py and tests/test_target_image_pool.py pass; python -I -B tests/run_all.py: 359 passed, 88 failed, 205 skipped; main d9486a08 on the same PC: 358 passed, 88 failed, the same 88 (this PC's toolchain: Windows line endings, fixtures needing gcc or compiling with -Werror).

Not tested: AMD and Intel GPUs, Linux, a Steam Deck, an 8 GB card (where the bound is ~580 MB and the VRAM tighter).

Must be tested:

  • Linux, any GPU: Castle Town's market at night, walking and turning the camera for a few minutes, the FPS counter on, then the same with RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3, expecting fewer dips with the defaults and no flicker (Test Farm: @Beanstalk linux)
  • AMD, Windows or Linux: the same, expecting the same (Test Farm: @Beanstalk amd)
  • An 8 GB card: the same, expecting no more textures evicted than with the old settings (the log's textures retired lines) (by hand)

Risks

What could break: a render target let go one present after its last use while the game still samples it later: it would come back empty (a flicker). The dead rule is unchanged (another target drawn over its storage since); only the wait and the sweep's interval are shorter. More VRAM held by idle pooled images on cards near their limit: given back under pressure as before.

Turning it off: RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3.

Compatibility: Nothing changes.

Issues

See #995.

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.
  • 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).
  • 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.
  • Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value.
  • A file in docs/tested/ for each new measured run (format in docs/tested-configurations.md).
  • A check under tests/ that reads changed source updated in this PR, not weakened.
  • Docs updated.

🤖 Generated with Claude Code

**Type:** perf · **Risk:** low · **Tested on:** Windows 11, RTX 4070 SUPER (NVIDIA 617.42) · **Needs:** Linux; AMD; Intel; a Steam Deck; an 8 GB card ## Why In busy places the frame rate goes up and down: in Castle Town's market at night, frames over 25 ms come several times a second. One cause is in the renderer: the game makes its per-frame render targets (a 384 x 384 depth target, 1280 x 720, 640 x 360 and 2560 x 1440 ones) at a slightly different place in its memory every frame, and Longshot made a new Vulkan image for each of them and destroyed one, about twice a frame. Destroying and making images was about 20 % of the render thread's time there (vkDestroyImage 15 %, vmaCreateImage 5 %, sampled). See #995. ## What changed The render target pool, meant to hand last frame's image to this frame's target of the same shape, now gets its dead targets in time and keeps enough of them. Measured in the market at night: of the images made new, 80 % had last frame's one of their shape alive and unused, and the pool destroyed 99 % of what it let go for being over its 256 MB bound (21,879 of 22,000 in 100 s): dead targets came back every 10 presents, three or more presents late, ten frames' worth at once, and went over the bound. - vk: the dead transient targets are looked for every present (`RX_VK_DEAD_EVERY` 10 -> 1) after one present unused (`RX_VK_DEAD_MIN_UNUSED` 3 -> 1), in `texture_frame` (`gpu/vk/vk_texture.cpp`). - vk: the pool's bound is a twelfth of what the driver allows, 256 to 768 MB (`gpu/vk/target_pool.h`, `pool_cap`), two or three frames of these targets; `RX_VK_TARGET_POOL_MB` still sets it. Under VRAM pressure the pool is given back as before (`pool_pressed`), and on a small card the bound stays near the old 256 MB. - tests: `tests/test_target_pool_cap.py` (the bound by allowance), `tests/test_target_image_pool.py` (the new defaults). - docs: the three switches in `docs/development.md`. ## Measurements **Verdict:** fewer slow frames and less render thread time, the average frame rate about the same or a little higher. The images made new fall by 62 % on this build, and by 65-79 % in earlier runs with the same settings. Hardware: Windows 11 Pro 26200, RTX 4070 SUPER 12 GB (NVIDIA 617.42), Ryzen 9 9950X3D (16 cores, SMT off), 32 GB Scene: Castle Town's market at night (save set "First Step into Hyrule Town", `!cheat 121` at 40 s), 2560x1440, DLAA, uncapped, the render thread on (Auto) Method: headless runs on a wall-clock script (town-market.txt, 100 s), the two sides in turn in one build; fps is the median of the log's 120-present lines with 1,500-2,999 draws; slow frames and 1 % low from the frame trace's last two thirds; images from the log's `render target images:` line How to reproduce: the save set above, the walk into the market at night; `RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3` against the defaults | | Before: old defaults, this PR @ a2cdf4e5 | After: this PR @ a2cdf4e5 | |---|---|---| | Render target images made new / destroyed (100 s) | 21,501 / 21,229 | 8,096 / 7,768 | | Frames over 25 ms / over 50 ms | 76 / 14 | 49 / 10 | | 1 % low | 42.1 fps | 44.8 fps | | Market fps, median | 69.7 | 70.7 | | Render thread, its jobs a frame | 9.9-11.9 ms | 9.1-10.7 ms | Baseline: the same build with the old defaults set by switch (run with this change in the working tree on main d9486a08, then rebased cleanly onto a0be15b3); one round, the PC's time being short. The same three settings as switches on main 14e165ab (with the play folder's other switches, `RX_VK_MIRROR_SPARSE=0`), three rounds in turn, gave: | | Before (main 14e165ab) | After (the same, with the three settings) | |---|---|---| | Images made new (100 s) | 20,037 / 11,567 / 12,816 | 4,320 / 4,326 / 4,051 | | Frames over 25 ms | 200 / 437 / 219 | 52 / 54 / 37 | | 1 % low (fps) | 36.4 / 31.6 / 36.1 | 44.4 / 42.9 / 44.3 | | Market fps | 61.9 / 53.8 / 62.6 | 66.5 / 63.2 / 61.4 | | VRAM in use | 7.0-7.4 GB | 7.3-7.8 GB | Played on the same PC with these settings: no visible change in the picture. A frame-by-frame check (a 320x180 picture of every present, counting one-frame flips over 1 % of the picture) gave 60 and 119 such frames against 17-60 on main's runs, all under 2.2 % of the picture and spread out (motion and lights), none of the concentrated kind a wrong image gives. ``` pp-main-1 [RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3] pool: 25820 reused from the pool, 21501 made new, 21229 destroyed pp-new-1 [] pool: 34433 reused from the pool, 8096 made new, 7768 destroyed; vk: render target pool: up to 768 MB ``` ### Flags and settings Three defaults change; no new switch. | Flag | What it is | Before this PR | After this PR | Effect | Helps / doesn't help / untested | Recommendation | |---|---|---|---|---|---|---| | `RX_VK_DEAD_EVERY` | how often dead transient targets are looked for | 10 | 1 | the pool gets them as they die | helps: RTX 4070 SUPER; untested elsewhere | the new default | | `RX_VK_DEAD_MIN_UNUSED` | presents a dead target must be unused | 3 | 1 | the same | as above | the new default | | `RX_VK_TARGET_POOL_MB` | the pool's bound | 256 | a twelfth of the allowance, 256-768 | two or three frames of targets kept | as above; on 4-6 GB cards about the old bound | the new default | ## Testing **Tested:** Windows 11, RTX 4070 SUPER, NVIDIA 617.42: the runs above; played in Castle Town and Hyrule Field with the same three settings over two sessions ("seems good"); `tests/test_target_pool_cap.py` and `tests/test_target_image_pool.py` pass; `python -I -B tests/run_all.py`: 359 passed, 88 failed, 205 skipped; main d9486a08 on the same PC: 358 passed, 88 failed, the same 88 (this PC's toolchain: Windows line endings, fixtures needing gcc or compiling with `-Werror`). **Not tested:** AMD and Intel GPUs, Linux, a Steam Deck, an 8 GB card (where the bound is ~580 MB and the VRAM tighter). **Must be tested:** - Linux, any GPU: Castle Town's market at night, walking and turning the camera for a few minutes, the FPS counter on, then the same with `RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3`, expecting fewer dips with the defaults and no flicker (Test Farm: @Beanstalk linux) - AMD, Windows or Linux: the same, expecting the same (Test Farm: @Beanstalk amd) - An 8 GB card: the same, expecting no more textures evicted than with the old settings (the log's `textures retired` lines) (by hand) ## Risks **What could break:** a render target let go one present after its last use while the game still samples it later: it would come back empty (a flicker). The dead rule is unchanged (another target drawn over its storage since); only the wait and the sweep's interval are shorter. More VRAM held by idle pooled images on cards near their limit: given back under pressure as before. **Turning it off:** `RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3`. **Compatibility:** Nothing changes. ## Issues See #995. ## 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). - [x] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [x] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). - [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. - [x] Numbers from the same PC, scene and settings, at least 2 interleaved runs each, the median reported. - [x] Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value. - [x] A file in `docs/tested/` for each new measured run (format in `docs/tested-configurations.md`). - [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)
perf(vk): the game's per-frame render targets are reused instead of made and destroyed twice a frame
Some checks failed
beanstalk/approval approved by GummiNaomi (reviewed)
beanstalk/linux 0/1 pass, 0 running, 0 queued
CI / Conventional Commit title (pull_request) Successful in 8s
CI / Workflow lint (actionlint) (pull_request) Successful in 16s
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
Third-party parts / As their notes say (pull_request) Successful in 19s
Website / Website on Cloudflare (pull_request_target) Has been skipped
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 15s
PR description / Description follows the template (pull_request_target) Successful in 5s
beanstalk/amd 0/1 pass, 0 running, 0 queued
a2cdf4e5dd
OoT makes its transient render targets (a 384 x 384 depth target, 1280 x 720,
640 x 360 and 2560 x 1440 ones) at shifted offsets of a scratch heap every
frame. The render target pool was meant to hand the last frame's image to the
next, but in Castle Town's market at night it made ~22,000 images new in 100 s
and destroyed as many, two a frame: vkDestroyImage and vmaCreateImage were
about 20 % of the render thread. Of the images made new, 80 % had last frame's
one of their shape still alive and unused, and the pool destroyed 99 % of what
it let go for being over its 256 MB bound: the dead targets came back in bursts
every 10 presents, 3+ presents late, and went over the bound.

Now the dead targets are looked for every present after one unused
(RX_VK_DEAD_EVERY 10 -> 1, RX_VK_DEAD_MIN_UNUSED 3 -> 1), and the pool may hold
a twelfth of what the driver allows, 256 to 768 MB (gpu/vk/target_pool.h), two
or three frames of these targets. Under VRAM pressure the pool is still given
back as before.

Measured on Windows 11, RTX 4070 SUPER, Ryzen 9 9950X3D, 2560x1440 DLAA,
uncapped, Castle Town's market at night, old and new defaults in one build:
images made new 21,501 -> 8,096, frames over 25 ms 76 -> 49, over 50 ms
14 -> 10, 1 % low 42.1 -> 44.8 fps, market median 69.7 -> 70.7 fps. With the
same three settings as switches on main 14e165ab, three rounds: frames over
25 ms 200/437/219 -> 52/54/37, 1 % low 36.4/31.6/36.1 -> 44.4/42.9/44.3 fps.
Not run on Linux, AMD, Intel or a Steam Deck.

Tests: tests/test_target_pool_cap.py (the bound by allowance),
tests/test_target_image_pool.py (the new defaults). The switches are in
docs/development.md; the measured runs in docs/tested/.

See #995

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
GummiNaomi changed title from WIP: perf(vk): the game's per-frame render targets are reused instead of made and destroyed twice a frame to perf(vk): the game's per-frame render targets are reused instead of made and destroyed twice a frame 2026-11-16 01:23:13 +00:00
Author
Member

@Beanstalk linux, any GPU: Castle Town's market at night (a save in town, night), walk into the market and turn the camera for a few minutes with the FPS counter on; then the same with RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3 (the old behaviour). Expect fewer dips and slow frames with the defaults and no flicker. Please post both runs' 1 % low or slow-frame counts and whether anything flickered.

@Beanstalk linux, any GPU: Castle Town's market at night (a save in town, night), walk into the market and turn the camera for a few minutes with the FPS counter on; then the same with RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3 (the old behaviour). Expect fewer dips and slow frames with the defaults and no flicker. Please post both runs' 1 % low or slow-frame counts and whether anything flickered.
Author
Member

@Beanstalk amd, Windows or Linux: Castle Town's market at night (a save in town, night), walk into the market and turn the camera for a few minutes with the FPS counter on; then the same with RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3 (the old behaviour). Expect fewer dips and slow frames with the defaults and no flicker. Please post both runs' 1 % low or slow-frame counts and whether anything flickered.

@Beanstalk amd, Windows or Linux: Castle Town's market at night (a save in town, night), walk into the market and turn the camera for a few minutes with the FPS counter on; then the same with RX_VK_TARGET_POOL_MB=256 RX_VK_DEAD_EVERY=10 RX_VK_DEAD_MIN_UNUSED=3 (the old behaviour). Expect fewer dips and slow frames with the defaults and no flicker. Please post both runs' 1 % low or slow-frame counts and whether anything flickered.
Member

Beanstalk test farm

Commit a2cdf4e · tier reviewed · approved by GummiNaomi · dashboard

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

On Linux and AMD PCs, the plan teleports a fresh child save to the market, moves and turns the camera, then measures for 100 seconds with default pool settings and again with the old-behavior switches. The requested nighttime town save is unavailable, so the plan cannot guarantee night or reproduce the walk into the market; the roughly 25-minute run measures 1% low frame time, hitches and VRAM and captures screenshots. Crashes, substantial frame-time regressions, device-loss logs or screenshot differences beyond tolerance fail the plan. The plan cannot automatically compare the two switch configurations against each other or detect flicker between screenshots. Neither requested target is online now, so both will wait for a matching PC. No tester online now matches linux, amd: those targets wait for one.

  • Where: linux (1 report), amd (1 report).
  • market-default: from a new save (settings fps_counter=1, frame_rate_cap=6), then teleport to Market, 4 times: move the stick, take the picture market-first to compare with main, measure market for 100 s (after 10 s warm-up), take the picture market-last to compare with main; 1 run on each side.
  • market-old-settings: from a new save (settings fps_counter=1, frame_rate_cap=6; switches RX_VK_DEAD_EVERY=10, RX_VK_TARGET_POOL_MB=256, RX_VK_DEAD_MIN_UNUSED=3), then teleport to Market, 4 times: move the stick, take the picture market-first to compare with main, measure market for 100 s (after 10 s warm-up), take the picture market-last to compare with main; 1 run on each side.
  • Measured: crashes, frame times, stutters and hitches, VRAM use, the game's log.
  • The PR fails if: it crashes; or a picture differs from main by more than 5%; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0; or frame time (worst 1%) is more than 15% above main.
  • Time: about 32 min of game runs per tester (4 game starts), plus the two builds.

Done. Run 2: re-planned by GummiNaomi. Comment @Beanstalk to run it again.

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
linux 0/1 — — — queued
amd 0/1 — — — queued
<!-- beanstalk:sticky --> ### Beanstalk test farm Commit `a2cdf4e` · tier **reviewed** · approved by GummiNaomi · [dashboard](https://beanstalk.magicbean.dev/prs/994) **What will be tested** · AI plan (`gpt-6.1-terra`) On Linux and AMD PCs, the plan teleports a fresh child save to the market, moves and turns the camera, then measures for 100 seconds with default pool settings and again with the old-behavior switches. The requested nighttime town save is unavailable, so the plan cannot guarantee night or reproduce the walk into the market; the roughly 25-minute run measures 1% low frame time, hitches and VRAM and captures screenshots. Crashes, substantial frame-time regressions, device-loss logs or screenshot differences beyond tolerance fail the plan. The plan cannot automatically compare the two switch configurations against each other or detect flicker between screenshots. Neither requested target is online now, so both will wait for a matching PC. No tester online now matches linux, amd: those targets wait for one. - **Where:** linux (1 report), amd (1 report). - **market-default:** from a new save (settings fps_counter=1, frame_rate_cap=6), then teleport to Market, 4 times: move the stick, take the picture market-first to compare with main, measure market for 100 s (after 10 s warm-up), take the picture market-last to compare with main; 1 run on each side. - **market-old-settings:** from a new save (settings fps_counter=1, frame_rate_cap=6; switches `RX_VK_DEAD_EVERY=10`, `RX_VK_TARGET_POOL_MB=256`, `RX_VK_DEAD_MIN_UNUSED=3`), then teleport to Market, 4 times: move the stick, take the picture market-first to compare with main, measure market for 100 s (after 10 s warm-up), take the picture market-last to compare with main; 1 run on each side. - **Measured:** crashes, frame times, stutters and hitches, VRAM use, the game's log. - **The PR fails if:** it crashes; or a picture differs from main by more than 5%; or frame time (p99) is more than 15% above main; or forbidden log lines is above 0; or frame time (worst 1%) is more than 15% above main. - **Time:** about 32 min of game runs per tester (4 game starts), plus the two builds. Done. Run 2: re-planned by GummiNaomi. Comment `@Beanstalk` to run it again. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | linux | 0/1 | — | — | — | queued | | amd | 0/1 | — | — | — | queued |
HumanBean deleted branch perf/target-pool-every-frame 2026-11-16 01:33:04 +00:00
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!994
No description provided.