fix(vk): no more storms of texture re-uploads, gigabytes in seconds with slow frames (a GPU buffer write no longer re-uploads a texture from memory its data never reached) #2164
No reviewers
Labels
No labels
area/accessibility
area/audio
area/input
area/install
area/menu
area/renderer
area/saves
area/tooling
area/upscaling
beanstalk: approved
beanstalk: failed
beanstalk: needs approval
beanstalk: running
beanstalk: tested
ci: approved
good first issue
gpu/amd
gpu/igpu
gpu/intel
gpu/nvidia
help wanted
kind
bug
kind
chore
kind
docs
kind
feature
kind
performance
kind
question
needs measurements
platform/linux
platform/macos
platform/steam-deck
platform/windows
preview
priority
critical
priority
high
priority
low
regression
risk
high
risk
low
risk
medium
status
blocked
status
confirmed
status
duplicate
status
invalid
status
needs-info
status
wontfix
ci: approved
No milestone
No project
No assignees
6 participants
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
MagicBeanDev/Longshot!2164
Loading…
Reference in a new issue
No description provided.
Delete branch "Veix/Longshot:fix/upload-only-arrived"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Summary
The renderer uploads textures again and again from the game's memory although nothing new is there: 7 to 14 GB in the seconds after the pause menu closes, one render target every 5 presents in Castle Town, a steady stream in Hyrule Field. This stops it. The easiest place to see it is the pause menu, but it is not a menu bug: it happens wherever the GPU writes a buffer over memory that a texture also uses.
What goes wrong. The game draws into render targets that share guest memory with other things, among them buffers its compute programs write every frame. When the GPU writes such a buffer, the renderer notes "the GPU wrote here" for every texture over that memory and, at the texture's next use, uploads the whole texture again from guest memory. But a written binding over 1024 KB that the CPU does not read is never copied down into guest memory (
RX_VK_WB_MAX_KB,wb_learn.h). So the upload brings back the bytes the memory had before, over what the GPU has drawn since. The copy down is skipped, the copy up happens anyway: a re-upload that can have no new data.Where it sits in
main:gpu_buffer_bind(gpu/vk/vk_memory.cpp) tells the textures of the whole binding (texture_gpu_wrote) in its first line, about 120 lines before it decides whether the binding is written back (wb_leave_out).memory_stamp_gpustamps the write's pages, and a texture's check for CPU writes reads those stamps as a CPU write.texture_touch(gpu/vk/vk_texture.cpp) uploads the whole texture for any such notice and takes it for memory's.How to see it on
main. Load a save in Kokiri Forest, run for a few seconds so the area streams in, open the pause menu for a few seconds and close it. The log then repeats, every frame or two:and the status line reads 27 to 31 MB uploaded a frame at about 47 fps where the same view runs at 75. A fresh load that only stands still does not show it: the 4096x4096 picture it hits exists only once more of the area is in.
What this changes. One rule: a texture is uploaded from guest memory only where memory holds newer data of its own. - newer only where the write reached memory: the textures are told of a written binding when
gpu_buffer_bindreturns, after its write-back is decided: of the whole binding where it is written back or written in place, or of the kept ranges alone where the rest is left out, including any kept edge range. Those ranges and any CPU-dirty ranges are uploaded for single-level, single-layer, uncompressed, non-sparse textures; other textures are uploaded whole as before. A drawn picture refreshed in part stays marked as drawn.On by default;
RX_VK_UPLOAD_ARRIVED=0givesmain's behaviour. The log'svk: upload arrivedline reports bindings not told whole, part and whole refreshes, and part refreshes that kept a drawn picture every 600 presents.Read first: the comment above
upload_arrived_oningpu/vk/vk_texture.cpp(the rule), thengpu_buffer_bind'sNoticeingpu/vk/vk_memory.cpp, thentexture_touch.Related work, none of which this replaces:
GpuWriteHistory, and first asks whether the data arrived at all.This PR was written with AI assistance (Claude Code); the measurements and the play testing are from my own PC.
Testing
Tested: Windows 11, Ryzen 9 9900X, 64 GB, RTX 4070 SUPER 12 GB (NVIDIA 621.24). Everything in the game ran on
main@e7579b0a; the branch was then rebased onto8f02906b(one conflict invk_texture.cpp, with #1987's diagnostics and its moved log line, both kept asmainhas them), and after it the checks and the renderer's build ran again, the game did not.maindoes not show), no device loss. The storm after the menu thatmainshows at the same spot did not come once.tests/test_direct_buffer_writes.py(extended) runs the realgpu_buffer_bindin every case with the rule off and on, including a binding whose write-back is partly left out. The previously reported 24 of 24 passes were before the latest changes; the updated check still needs to run.tests/test_upload_arrived.py(new) checks notification and dirty-scan ordering, then runs a game-free fixture using the renderer's page scan and write history. The updated check still needs to run.python -I -B tests/run_all.py --changed origin/mainon Windows with the pinned llvm-mingw, after the rebase: 133 passed, 14 failed, 36 skipped. All 14 fail onmain@8f02906bon this PC too, run in the same environment:test_capture_read_once,test_crash_dialog,test_dev_ab,test_frame_overlap,test_guest_imported,test_input_movie,test_intel_prepare_side_by_side,test_linux_pressure,test_pending_guest_import,test_prepare_stall,test_readback_timeout_source,test_sparse_mirror,test_submit_oom,test_switch_table(the table is out of order onmainsince #2093). None is new. The whole suite did not finish on this PC (it stopped making progress after 319 checks): CI runs it.RX_VK_ONLY=1, llvm-mingw clang) at this head, and built in the game at the measured commit.Still to test:
main, with attention to textures the game fills through buffers (terrain, effects, the HUD's labels) and to anything that updates late or not at all, expecting no difference (the Test Farm, no request posted yet: Kokiri Forest, Castle Town, Hyrule Field and Kakariko with a pause menu opened and closed in each, pictures against main, the log'suploaded againandupload over a drawn imagelines counted on both sides)upload over a drawn image ... a GPU buffer wrote itlines with the rule on andRX_VK_UPLOAD_ARRIVED=0, expecting fewer; this is the case that may be unchanged, since the written buffer is small enough there to be copied down (by hand)--cxx g++, and the renderer's build on Linux (by hand or CI; only clang on Windows ran here)Measurements
Earlier measurements: the upload storm after the pause menu and its slow frames were gone with the earlier rule: 7.3 GB uploaded in the 15 seconds after three menu closings without the rule (the median of three runs; 7.2 to 13.7), 0.28 GB with it; frames over 16.7 ms in those seconds from 32 % to 1.4 %. VRAM is the same.
Setup: Windows 11, RTX 4070 SUPER 12 GB (NVIDIA 621.24), Ryzen 9 9900X, 64 GB. 3840x2160 output, DLAA, frame rate uncapped, V-Sync on (a 180 Hz screen), Threaded rendering on. A scripted routine through the control bridge on one save: Kokiri Forest, teleport to Castle Town and run forward 10 s, teleport to Hyrule Field and run forward 10 s, teleport back to Kokiri Forest, then three times the pause menu open 4 s and closed 5 s. Measured from the frame trace (
RX_VK_FRAME_TRACE=1): the 5 seconds after each of the three closings, pooled per run. Six runs, alternating: off, on, off, on, on, off.Both sides are this PR's build on
main@e7579b0a, a switch against a switch: "before" isRX_VK_UPLOAD_ARRIVED=0, which ismain's path. No separate build ofmainwas run for these numbers, and they are from before the rebase onto8f02906b. The first four runs were made at an earlier commit of this branch where the rule was off unless set (so "on" was=1); the last two with the rule on by default, and with=0. The rule's code was the same in both, but has since changed; these measurements need to be repeated at this head.e7579b0a(its path in this PR's build:RX_VK_UPLOAD_ARRIVED=0)upload over a drawn imagelines a runvk: VRAM:line)The worst single frame is not better: those are textures arriving. The one
upload over a drawn imageline with the earlier rule is a 960x540 picture uploaded once for a write that covered all of it.What the earlier rule's own line counted in one run with it on (10,800 presents): 146,979 written bindings not written back and so not told to the textures whole; 787 checks that found only the GPU's own page stamps and uploaded nothing (1,262 MB named as written), none of which had a page the CPU wrote; 14 textures refreshed in part (28 MB of 157 MB); 4 times a drawn picture left as it is (98 MB).
By hand, in play with the earlier rule without the routine (one session each way, 3840x2160 DLAA): without the rule one 1920x1080 target in Castle Town was uploaded again every 5 presents, 146 times (1.2 GB), and 4.4 and 4.7 GB were uploaded after two menu closings; with it, over 75,600 presents through four areas, no drawn picture was uploaded over, and the line counted 4,391 echo checks (6.1 GB named), 154 drawn pictures left (4.8 GB) and 46 part refreshes (97 MB of 552 MB). In Hyrule Field the echo alone ran at about 0.8 MB a present.
VRAM: the drawn textures' total, which is the only kind the rule could hold longer, is equal within 30 MB across the four runs it was read from, and the log's list of drawn textures unused for 120 presents holds the same three in all of them. Not measured on a card where VRAM is short.
Risks
RX_VK_UPLOAD_ARRIVED=0turns the rule off without a rebuild; a revert also undoes it.longshot_options.inior the caches. The renderer is compiled again.Checklist
Ready for review
main; the title is a Conventional Commit.mise run testpasses (any failure that also fails onmainis named). (The checks that read the changed files ran, with the 14 that also fail onmainnamed; the whole suite did not finish on this PC: CI.)main, or Measurements says why there is nothing to measure. (Against this build with the rule off, which ismain's path: a switch against a switch, not a build ofmain.)third_party/untouched; nothing GPL-incompatible.When it applies
mainand passes here. (The updated tests still need to run.)gpu/vk/switches.def.tests/that reads changed source is updated, not weakened. (The updated tests still need to run.)Assisted-by:/Co-Authored-By:trailers.Ready to merge
main, measured again or a comment says why the numbers still hold.🤖 Generated with Claude Code
Tested in game: Windows 11, RTX 4070 SUPER 12 GB, NVIDIA 621.24. About 25 minutes by hand at 3840x2160 DLAA in Kokiri Forest, Kakariko Village, Castle Town and Hyrule Field with many pause menus: no wrong picture seen, and no upload storm after a menu closes, where the same build with RX_VK_UPLOAD_ARRIVED=0 shows it every time. A scripted routine, three runs each way, is in Measurements. The game ran on main
e7579b0a, before the rebase onto8f02906b.Possibly related, for context:
@Beanstalk Renderer change (gpu/vk): textures are no longer uploaded again for GPU buffer writes whose data never reached memory. On by default, RX_VK_UPLOAD_ARRIVED=0 is main's way. The risk is a stale or wrong texture.
Please run it against main on Windows and Linux, NVIDIA and AMD, and a Steam Deck, with no upscaling: Render resolution 100% and the game's own upscaler, at 4K output where the tester's screen has it. From the save kokiri-start: hold the left stick forward 10 s, teleport to Market_Child and hold it 10 s, to HyruleField_Child and hold it 10 s, back to KokiriForest_Child. Then three times: press PLUS, wait 4 s, press PLUS, measure 5 s with no warm-up.
Please count the log lines "upload over a drawn image" and "uploaded again" on both sides without failing on them: main shows dozens after the menus, the PR few or none.
@Veix only members of
BigBeanscan start the farm. One of them can approve this request by reacting 👍 to it or to this comment.@Beanstalk
Beanstalk test farm · an earlier run: commit
0572e84(the newer results are in a comment below)Commit
0572e84· approved by llun (reviewed) · dashboard⚠️ Note: The farm runs at a fixed 1920x1080 output, so the requested 4K output cannot be tested; render resolution is left at the tester's default because its 100% value is not specified.
⚠️ Note: The log counts cover each whole run, not just the post-menu intervals, and the diagnostic lines may be capped; they do not by themselves prove the upload storm is gone.
⚠️ Note: This general renderer change uses one unrestricted target rather than guaranteeing separate Windows, Linux, NVIDIA, AMD and Steam Deck reports.
Started at 00:02 UTC.
Estimate: done in about 45 min, from the queue and the testers online now.
anyWhat was tested
What will be tested · AI plan (
gpt-6.1-terra)The plan compares main and the PR through Kokiri Forest, Market, Hyrule Field and Kakariko, including repeated pause-menu cycles in Kokiri. It captures pictures, measures post-menu frame times and counts texture re-upload log lines on both sides without requiring a particular count. It takes about 25 minutes per tester; crashes, a material screenshot difference or a post-menu p99 frame-time regression over 20% fail the plan.
kokiri-start(settings dlss=0), then move the stick, teleport to Market, take the picture market to compare with main, teleport to Hyrule Field, take the picture field to compare with main, teleport to Kakariko Village, take the picture kakariko to compare with main, teleport to Kokiri Forest, press buttons, take the picture pause-menu to compare with main, measure after-pause-1 for 5 s (after 0 s warm-up), take the picture kokiri-after-pause to compare with main, measure after-pause-2 for 5 s (after 0 s warm-up), measure after-pause-3 for 5 s (after 0 s warm-up); 2 runs on each side.@review
Recommendation: Request changes. The change can permanently miss real CPU and GPU texture updates, leaving stale pictures. The reported pause-menu improvement is substantial, but it was measured against a switch-off build before the rebase, and the current head still needs comparison with its base.
Avoids texture uploads caused by GPU buffer writes that did not reach guest memory, and limits some refreshes to written ranges. It reduces the reported upload storm at the cost of 8 MB for stamp tracking and new ownership and range-tracking logic; several of those shortcuts can discard real updates.
@fixwill do (6)gpu/vk/vk_texture.cpp:4867: A GPU stamp hides an earlier CPU write on the same page. (more on the line)gpu/vk/vk_texture.cpp:3679: The empty-dirty path reads memory_generation after scanning and filtering the pages. (more on the line)gpu/vk/vk_texture.cpp:3650: Coverage does not establish ownership: a compute operation can intentionally update only part of a texture previously drawn by the GPU. (more on the line)gpu/vk/vk_memory.cpp:5488: A kept range at a binding edge is not necessarily unrelated data. (more on the line)gpu/vk/gpu_write_history.h:92: The drawn image's range list includes writes as soon as they are recorded, including submissions that have not completed. (more on the line)tests/test_upload_arrived.py:140: The new test defaults to g++ instead of honoring CXX or the project's selected compiler. (more on the line)Before merging: testing (3) (runs on the systems it can change; it doesn't hold the recommendation)
Checks: Failing on this head, which is behind its base, where it passes:
PR description / Description follows the template (pull_request_target).@rebase(or@fix) brings it up to date and runs it again; not held against it. Still running:CI / Conventional Commit title (pull_request),CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request),CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request),CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request),CI / Workflow lint (actionlint) (pull_request),CI / Website build and checks (pull_request),Guide screenshots / Guide images and local UI source review (pull_request),Third-party parts / As their notes say (pull_request),Third-party parts / The same as upstream (pull_request).More: does it help, other systems, switches, what was read
Does it help: Unproven against the base at this head. On the author's pre-rebase Windows RTX 4070 SUPER build, three interleaved runs with the switch off versus on reduced median uploads after three menu closings from 7,304 MB to 278 MB and frames over 16.7 ms from 32% to 1.4%. Neither side was a separate base build, and the game was not rerun after the rebase.
Other systems: The texture ownership and page-stamp changes affect all GPUs and both Windows and Linux, including compressed textures and render targets. The reported play test covers Windows and NVIDIA before the rebase; AMD, Intel, Linux, Steam Deck, low-VRAM behavior and systematic image comparisons remain untested.
Switches: RX_VK_UPLOAD_ARRIVED is added as a kill switch, default on; 0 restores the earlier path. It has a switches.def row, but the default is unsafe with the missed-update cases below and has not been validated on the other affected systems.
Reviewed:
0572e848adagainst8f02906b5a: Read the repository rules, PR template, standards, commit messages, production diff, gpu_write_history.h, wb_learn.h, and the changed test scripts and upload-arrived fixture. Read the changed sections and relevant callers in vk_memory.cpp and vk_texture.cpp; the large production files and direct-buffer fixture were not read in full. No recorded runs, translations or generated files were changed. docs/review-checklist.md and the adjacent Tooling checkout were absent.; nothing run (a code review).Checked and fine:
Testing: Read-only review; no builds, tests, scripts or game runs were executed.
Overlaps and merge order: The PR identifies related work in #332, #282 and #1223; no merge order is established by the supplied information.
Automated code review by BeanBot (gpt-6.1-terra), asked for by HumanBean. Nothing was run; a maintainer decides.
@ -64,6 +89,7 @@ class GpuWriteHistory {const auto value = std::get<0>(write);if (image.draw < write && (!image.first_write || value < image.first_write))image.first_write = value;if (parts_on && image.draw < write) add_part(image.wr, std::max(lo, it->first.first), std::min(hi, image.end));L5: The drawn image's range list includes writes as soon as they are recorded, including submissions that have not completed. If a completed write covers one half and a later unfinished write covers the other, parts_since reports full coverage and texture_touch can upload the unfinished half from old guest memory, then mark the image no longer GPU-owned. Keep ranges by submission and expose only completed writes, with a test that checks the returned ranges before the second submission completes.
@ -5443,0 +5485,4 @@notice_parts.clear();for (const auto& [klo, khi] : keep) {// (the binding's edge page, kept for what shares it: not a texture's data)if (khi - klo <= (1ull << kPageShift) && (klo == wlo || khi == whi)) continue;L4: A kept range at a binding edge is not necessarily unrelated data. wb_learn also keeps CPU-read or CPU-written ranges, which may be a page or less at that edge; the GPU's bytes within that range are actually written back, yet this skips their texture notification. A texture located there can remain stale. Notify the intersection of every kept range with the binding, including edge ranges, and cover a genuinely used edge range in the fixture.
@ -3635,6 +3647,13 @@ Texture* texture_touch(Texture* tex, bool for_sampling) {// and stayed the flat placeholder they were made with)const uint64_t seen_before = tex->gpu_wrote_seen; // (put back if the upload fails: the write is still to be taken)uint64_t gpu_dirty_found = tex->uploaded ? gpu_wrote_into(*tex) : 0;if (upload_arrived_on() && gpu_dirty_found && tex->gpu_written && arrived_over_part(*tex, seen_before)) {L3: Coverage does not establish ownership: a compute operation can intentionally update only part of a texture previously drawn by the GPU. This branch marks that real write seen without uploading it, and separate partial updates in later submissions are discarded individually, so the texture remains stale. Preserve and apply the written ranges unless ownership can be established from actual resource information; test a drawn texture intentionally updated in parts across submissions.
@ -3653,0 +3676,4 @@for (const auto& r : dirty) named += r.second - r.first;const uint64_t dropped = arrived_drop_echo(*tex, dirty);if (dirty.empty()) {arrived_stats.echo_n++, arrived_stats.echo_bytes += named;L2: The empty-dirty path reads memory_generation after scanning and filtering the pages. A CPU write arriving between that scan and this read is included in upload_gen although it was never uploaded, so the next check misses it. Capture a safe generation before the scan and only advance to that generation, with synchronization consistent with the page tracker.
@ -4756,0 +4864,4 @@const uint64_t end = std::min<uint64_t>(r.second, off + (0x1000 - ((g ? g : tex.gpu + off) & 0xFFF)));if (g && memory_page_gpu_last(g)) {if (in) out.push_back({run, off}), in = false;dropped += end - off;L1: A GPU stamp hides an earlier CPU write on the same page. For example, the CPU changes texture bytes, then a GPU buffer write stamps another part of that page before the texture is checked: this removes the entire page from dirty and can advance upload_gen past the CPU change, leaving stale pixels indefinitely. Track CPU and GPU generations separately, or otherwise retain any CPU write since the texture's last upload; add a test for CPU then GPU on one page.
@ -0,0 +137,4 @@@OVER_PART@@TAKEN@#include "@ROOT@/tests/test_upload_arrived.cpp""""L6 (minor): The new test defaults to g++ instead of honoring CXX or the project's selected compiler. A Windows llvm-mingw setup with clang++ but no g++ cannot run it directly. Choose the configured C++ compiler by default while retaining --cxx.
@fix
0572e848adc670586ecbRecommendation: Approve. The code is ready: only testing is left. The revised rule has not yet been measured against the merge base or tested in play across the affected systems. Earlier results showed a large reduction in uploads and slow frames, but they used an earlier version of the rule. Recommend approval; not approved on the forge.
What
@fixchangedI changed this pull request: the new head is
c670586ecb. I rebased it ontomain(a053f9e121). I edited its description to match the change.Changed
Nothing was built or run: the checks run again on the new head.
The change limits texture refreshes to GPU buffer writes that reach guest memory and preserves partial updates to drawn textures. It aims to reduce redundant uploads, at the cost of additional write-range tracking and a risk of stale or incorrect textures.
Before merging: testing (3) (runs on the systems it can change; it doesn't hold the recommendation)
Checks: they run again on this head (
PR description / Description follows the template (pull_request_target)failed on the last one); a failure shows on the pull request.Also noticed (2; not asked for, not blocking)
More: does it help, other systems, switches, what was read
Does it help: Unproven at this head. Earlier switch-on versus switch-off runs reported median uploads falling from 7,304 MB to 278 MB and frames over 16.7 ms falling from 32% to 1.4% after pause-menu closings; the rule has since changed and those runs did not compare separate base and head builds.
Other systems: The renderer change can affect texture updates and frame pacing on Windows, Linux, NVIDIA, AMD, Intel and Steam Deck. Cross-platform picture comparisons and low-VRAM behavior remain unreported.
Switches: RX_VK_UPLOAD_ARRIVED is added, default on; 0 restores the earlier notification behavior. The default's benefit and correctness at this head remain unverified.
Reviewed:
c670586ecbagainsta053f9e121: Read AGENTS.md, CONTRIBUTING.md, gpu/vk/gpu_write_history.h, tests/test_upload_arrived.cpp and tests/test_upload_arrived.py; inspected the fix commit and relevant texture and buffer paths. The remaining changed files and full base diff were not read in full.; nothing run (a code review).Checked and fine:
Testing: No tests or builds were run. CI has not yet run on this head; the updated game-free checks and Linux build are also reported as pending.
Overlaps and merge order: The description identifies related work in #332 and #282; neither is presented as a replacement for this change.
Automated code review by BeanBot (gpt-6.1-terra), asked for by BeanBot, after its fix. Nothing was run; a maintainer decides.
@Beanstalk
Beanstalk test farm · ⚠️ couldn't be judged on any
Commit
c670586· approved by HumanBean, llun (double-reviewed) · dashboard⚠️ Note: Upload log counts are diagnostic, not a required reduction: the messages can be capped and the affected write-back path may not occur on every run.
⚠️ Note: The single general-hardware target does not guarantee coverage of every requested GPU, operating system, Steam Deck, or low-VRAM configuration; the farm plan also cannot run the standalone C++ fixtures.
Done (started 00:32 UTC, last report 01:04 UTC). Comment
@Beanstalkto run it again.anyCouldn't be judged: the tester's PC could not finish the test. The farm tries another PC, or the same one after a fix; it says nothing about the PR on its own.
any, report 1:Insufficient frame-time evidence for 4 required comparison(s). See rule results. the game refused a step: bad_request: not a button: STARTany, report 2:Insufficient frame-time evidence for 4 required comparison(s). See rule results. the game refused a step: bad_request: not a button: STARTWhat was tested
What will be tested · AI plan (
gpt-6.1-terra)Compare the pull request with main over roughly 35 minutes per tester, opening and closing the pause menu in Kokiri Forest, Castle Town, Hyrule Field, and Kakariko Village. The plan compares pictures, frame times, VRAM, and logged texture re-uploads; crashes, substantial picture differences, or frame-time and VRAM regressions fail it.
kokiri-start, then teleport to Kokiri Forest, move the stick, press buttons, take the picture kokiri-menu to compare with main, measure kokiri-after-menu for 15 s (after 0 s warm-up), take the picture kokiri-after to compare with main, teleport to Market, measure market-after-menu for 15 s (after 0 s warm-up), take the picture market-after to compare with main, teleport to Hyrule Field, measure field-after-menu for 15 s (after 0 s warm-up), take the picture field-after to compare with main, teleport to Kakariko Village, measure kakariko-after-menu for 15 s (after 0 s warm-up), take the picture kakariko-after to compare with main; 3 runs on each side.Measurements on `any`, for the PR description
Verdict: could not be judged on any (2 reports): required frame-time comparison inconclusive (fewer than two usable starts per side).
Hardware: 1: windows+nvidia+nvidia-proprietary+dgpu
NVIDIA GeForce RTX 4070, 621.24.0AMD Ryzen 9 7900X 12-Core Processor, 64 GB RAM; 2: linux+amd+radv+dgpuAMD Radeon RX 9070 XT (RADV GFX1201), 26.1.99AMD Ryzen 7 5700X3D 8-Core Processor, 32 GB RAMScene: texture-refresh, 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); texture-refresh: 3 game starts a side, kokiri-after-menu 15 s after 0 s warm-up, market-after-menu 15 s after 0 s warm-up, field-after-menu 15 s after 0 s warm-up, kakariko-after-menu 15 s after 0 s warm-up; each number the median of the runs, then of 2 reports
How to reproduce: the farm's plan above (
@Beanstalkon this PR runs it again)Nothing was measured: no metric came back.
Flags and settings
None: the plan varied no setting, switch or build option.
As Markdown for the PR description:
The testers' hardware
anyNVIDIA GeForce RTX 4070, 621.24.0AMD Ryzen 9 7900X 12-Core Processor, 64 GB RAManyAMD Radeon RX 9070 XT (RADV GFX1201), 26.1.99AMD Ryzen 7 5700X3D 8-Core Processor, 32 GB RAM@Beanstalk
@llun
c670586is already running: see the dashboard.Write-back overlap with a local shadow-floor branch — two questions, no competing change
We have a local branch (not a PR) for the write-back's remaining bytes:
RX_VK_WB_SHADOW_KB, default off, gives a pool whose small runs keep copying back whole a VRAM shadow sowb_diff.compdiffs those runs instead of copying them whole. It changes thep->shadowdecision and the path counters inmemory_end_submission; it does not touchwb_leave_out()or thekeepranges.We read #2164's
Noticeas:keepis decided bywb_leave_out(wlo, whi, keep)before the copy path is chosen, and the textures are told of those kept ranges (less the edge page), whether the copy ends up whole or diffed. If that is right, our branch composes: a diffed run is still a written-back run, and notifying the whole kept range is conservative — it may upload a few unchanged bytes, never stale ones.Two questions only:
keep? If not, which ranges should be notified when the write-back is diffed?We are not opening a competing PR and are not asking for a design change. We will rebase onto yours if it merges first. No machine time or game data is needed for either answer.
View command line instructions
Checkout
From your project repository, check out a new branch and test the changes.