Commit Graph

644 Commits

Author SHA1 Message Date
epicmeme546
7b201d868e Drop only stale released textures under VRAM pressure, let textures give way only when the system's commit runs low, and count the heightmap slots a finalize now leaves current.
Above the VRAM pressure threshold the released textures that come back intact were dropped oldest first, however recently released. The game releases and takes back hundreds a frame in towns, so the list is mostly those, and each drop was made and uploaded again within frames and freed nothing. With the budget taken as 7.5 GiB (NX2NAVI_VRAM_BUDGET_MB), seven minutes of teleports between Hyrule Field, Kakariko Village, the Graveyard, Death Mountain Trail and Kokiri Forest dropped 82,288 and stayed over the budget throughout; with 11 GiB, 178 draws met a texture that was gone. They now go by the rule drop_stale keeps (released STALE_FRAMES ago and idle): on the same tour 34,699 drops, a fifth fewer textures made again, a third less time the render thread waited on textures, 4 draws of a missing texture instead of 11, and the slowest 1 % of frames in Hyrule Field afterwards at 32 fps instead of 22.

Past the process's own commit bound (tex_proc_commit_mb), textures were dropped and idle live ones evicted as under a low system commit. The bound compares the commit less the video memory in use, and a dropped texture lowers both sides alike, so nothing a drop did could bring the process back under it: textures went one after the other for as long as the rest of the process stayed large, and the ground flickered white with the system's commit to spare (#434). The bound now only writes its line into the log.

The perf trace's texture origins line counts the slots a finalize leaves current because another texture of the same parameters was registered at the storage since (the terrain heightmaps of pull request #535): 173 at the load of a Hyrule Field save, and between 40 and 365 every 60 frames while Link runs through the field, each of which the old rule left stale.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 12:53:58 -05:00
epicmeme546
b5789c6bec Keep one FSR 4 and one FSR 3.1 context per output size, free the ones no upscale used for 90 seconds, and let FSR 4 recover from failed creations.
Each upscaling mode made a context of its own (about 217 MiB of video memory for FSR 4 at 3440x1440, 50 to 70 ms each), up to six were kept beside FSR 3.1's, and three FSR 4 creations that failed in a row turned FSR 4 off for the run: the menu then showed FSR 3.1 and no longer listed FSR 4. A player's log had the third failure (error 3) right after stepping through the modes with ten contexts alive. A context now takes every render size up to its output size, which the API allows at each dispatch; a creation that fails frees every context not in use, FSR 3.1's idle ones too, and is tried again; FSR 3.1 serves the frames between tries two seconds apart; only four failures in a row turn FSR 4 off, and choosing it in the menu again tries it anew.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 12:33:36 -05:00
epicmeme546
8afca0922a Merge the fix for sunken terrain chunks from pull request #535: a finalize marks stale only the slots its own texture object registered, so a streamed heightmap registered at the storage of the one before it keeps its slot.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 11:28:41 -05:00
chrg6
d55f7e763d Make co-op a hidden beta in 0.8.0: the menu shows its Co-op tab only with coop_beta = 1.
No menu row sets coop_beta; it lives in nx2navi.ini under [coop] (NX2NAVI_COOP_BETA) and takes effect at once. Co-op
itself is unchanged: coop = 1 still runs a session with or without the tab. The notes and the co-op guide say how to
show the tab.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
v0.8.0
2026-11-11 09:47:42 -05:00
chrg6
7f01711087 Make the release 0.8.0, with its notes.
The draft notes for the release after 0.7.1 become the notes of 0.8.0: every change since 0.7.1, the install and
update steps, the requirements (mesh shaders are no longer required, with the fallback untested on such a card), the
known issues and the thanks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 09:16:23 -05:00
chrg6
a516025760 Add the two flicker fixes to the draft release notes.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:59:01 -05:00
chrg6
4f85f3d59a Leave the pools as imports for NVIDIA's own driver on Linux in the game itself.
On Linux every driver got shadow storage (copies of guest memory beside it), which exists for amdgpu, where importing guest memory costs the write protection of its pages. NVIDIA's own driver imports without that cost, so there the copies are only the slower path: in Kokiri Forest on 0.7.1 (RTX 4090) imports ran at 51.9 frames a second and the copies at 27.4. Until now only the AppImage's play.sh knew, by setting NX2NAVI_SHADOW=0 when NVIDIA's kernel driver was present at build time, so a game started any other way got the copies, and a PC with that kernel driver whose game ran on another card got imports where it should not. The game now chooses by the driver of the device it runs on, play.sh no longer sets the variable, and NX2NAVI_SHADOW=1 or 0 still decides. The driver is asked when the device is picked, before the storage is chosen.

Windows is unchanged: the device probe here reads "mem: mode mirror" with no shadow storage line, and the shadow line with NX2NAVI_SHADOW=1. The Linux path itself was not run: there is no Linux machine here.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:58:48 -05:00
chrg6
08413ab265 Record that the dev folder's prebuild skip file is gone: the user approved deleting it, and it had already been removed.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:58:48 -05:00
chrg6
c308ee6510 Past the limit of released textures, drop one that nothing sampled lately, not one that no lookup reached.
The rule that spares a released entry the game still uses went by lookups, and the texture pool's refresh looks up
every registered slot in each submission that draws through the pool. With the game's own upscaler in use
(upscaler = fsr) its render targets move to new addresses in every frame and each leaves a released entry behind
whose descriptor stays registered: all 2,049 entries counted as looked up, the sweep fell back to the oldest lookup,
which among entries stamped in the same submission is no order, and took entries still drawn, 200 to 450 per 60
frames over a town, with buildings black or wrongly lit for single frames in a player's captures.
The entry that goes is now the oldest release that is overwritten or that nothing sampled or drew into for 120
presents (samp_frame: the pool marks and every lookup that is not the pool refresh), and only when all were sampled
within that time the one sampled longest ago.
Checked: it builds, and a player's hand test of 30,000 frames through eight areas with that upscaler kept the list at
its limit, dropped 50,182 entries past it and showed none of those frames. No scripted run was made, and which
entries pile up in a town was not traced to their kinds.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:58:13 -05:00
chrg6
ff3bfd1a4a Let the wait after a frame's first submission write the results the game reads before it returns.
That wait ends when the GPU has run the submission's own commands (wb_split = 1). The completion thread was then still
at the last frame's submissions, so the occlusion counts, counter reports and event values the game reads next reached
its memory after it had gone on. A player's capture in Hyrule Field shows the result: trees, ground and walls lose
their direct light for single frames about every 36 frames, 57 of 1,800 frames, and with the fence's wait
(wb_split = 0) the same place showed none.
The fence's wait also covers the rest of what the completion thread does for those submissions, 0.23 to 0.40 ms a
frame of page stamps the game does not read. So those results now have a queue of their own
(vk_completion_add_result), and the waiter runs the ones due for its submission and the ones before it as soon as
the GPU's signal is there; the completion thread runs them the same way, ahead of its other callbacks, one runner at
a time and in the order they were queued. wb_split = 3 is the bare wait as it was, to measure against.
Checked: it builds, the launcher tests and the address table check pass, and the player's hand test of this wait at
that place showed no such frame. Not measured: no scripted run of it was made (the one scripted run with the bare
wait in that field shows 1,170 occlusion counts a frame written late and no dark frame, so the script does not
reproduce the fault), and its cost against the bare wait is not known.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:58:00 -05:00
chrg6
8159908675 Bring four tests in line with the merged code.
The frame step test gets a stub for the debug menu's game speed, which frame_rate.c now reads; the mouse camera test
one for the input script's perf segment mark. The shared save test defined mem_probing twice. The launcher's self-test
draws 16 screens now that both lines added one.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:23:56 -05:00
chrg6
cd2a13062e Add the fixes line's changes to the draft release notes.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:21:36 -05:00
chrg6
bdc67cebfc Take out the GPU address history of a lost device's report.
The author of the pull request it was ported from closed that request on 2026-11-11 with the words that they give no
permission to use its code. The history (NX2NAVI_VA_REPORT, runtime/vk_vaddr.c, the stack walk it used and its notes
in the docs and the example settings) goes; the lost device's report keeps the breadcrumbs, the pass marks, the video
memory and the driver's fault information.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:18:55 -05:00
chrg6
3d394dd84e Merge the fixes line: the stutter, memory, flicker and crash fixes, co-op, the mesh shader fallback and the launcher fixes.
Brought onto the line with FSR 4, its frame generation and the debug menu. Where both sides had added to the same
place, both stay: the patch table keeps the pickup count and the free camera, the settings list keeps both sides'
names, the menu includes the co-op page and the debug menu, and the launcher builder takes the pipeline list and the
FSR 4 folder. Both sides had added the menu's typed-character event; one definition stays, with the window code that
passes characters outside the basic plane.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:18:01 -05:00
epicmeme546
b59c0d40a8 Add a free camera to the debug menu.
With it on, the game draws from a camera of the menu's instead of its own, in play and in cutscenes. The left stick moves it along its view and sideways, the right stick turns it, ZR and ZL raise and lower it, R makes it faster and L slower, and Link stands meanwhile; or the camera stays where it is and the pad plays the game.

It works inside the game's own camera update: a new patch site sends the instruction at which the frame's position, target and up vector are final to a host function, which replaces them for the camera that follows Link and the one the events direct, so the game draws, culls and loads detail for what the free camera sees. The camera of the interface's 3D models and the one the sound follows stay the game's. The set is off unless the menu switches it on. A teleport's arrival starts the free camera again from the game's view.

Tested in Hyrule Field with scripted stick input (turn, rise, strafe, with Link's position unchanged), with the pad playing while the camera stays, across a teleport to Kakariko Village, during the Kakariko arrival cutscene, and switched on by a click in the menu.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:04:19 -05:00
chrg6
6a8ebe7241 Give the freezing of idle memory regions a time budget and back off when a freeze is slow.
A freeze (a VirtualQuery and a VirtualProtect of 2 MiB) takes microseconds as a rule, but in the second after an area
load each took 8 to 17 ms. The newly loaded regions all go idle together, so 32 came up in one submission: its mirror
begin took 70.5 ms and the frame 78 ms, and a 9 ms freeze followed in each of the next 20 frames. In a play session
363 regions were frozen in the second after Kakariko loaded and 70 to 120 a second for the next 20 seconds, with the
frames over 50 ms in the same windows. A pass now stops once it has spent NX2NAVI_FREEZE_BUDGET_US (default 1000;
0 as before), and a freeze over 2 ms holds the passes for 250 ms, doubled for each slow one in a row up to 2 s. On the
Kakariko route the time in slow memory calls after the load went from 1374 ms in 170 calls to 115 ms in 18, the 78 ms
frame is gone, and the regions freeze some three seconds later, once the calls are fast again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 08:00:36 -05:00
chrg6
3ecede66f7 Log write-watch queries, freezes and mirror begins that take over 4 ms.
A frame some ten frames after an area load took 51.6 ms of replay with 1.2 ms of it in the replay's ops; the replaying
thread's samples sat in GetWriteWatch under vk_mem_mirror_begin and in the freeze's VirtualProtect. The lines say which
call and how much memory, under NX2NAVI_TRACE=perf.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 07:47:09 -05:00
chrg6
0f1885f9fd Count the game's GPU waits that return while event-ordered work is still held.
A submission stopped at an event wait returns its value with its remainder held for a later replay, so the game may
take its wait as the whole submission done. The log now says how often that happens, which decides whether the value
should be signalled only after the remainder. Audit finding F-2-05, first step.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 07:47:08 -05:00
chrg6
2d48afb052 Open the menu when the gamepad in use goes away and no other is connected.
The game is always told one controller is connected, so a disconnect read as nothing pressed and play went on without
the player noticing; the console would stop and ask for a controller. Audit finding F-8-04.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 07:47:08 -05:00
chrg6
83faa1daca Let a pool's finalize wait for the submissions issued so far instead of the idle queue.
The finalize of a used pool flushed and waited for every upload batch and then for the idle queue. During an area load
the queue also holds the load's texture uploads, which name no pool's storage: entering Kokiri Forest, one finalize
waited 418 ms and the frame took 462 ms. The game finalizes a pool once its own work with it is done, so the finalize
now waits for the submissions issued so far and returns; the pool's buffer and memory go once the upload batches handed
out by then and the submission being recorded are through. NX2NAVI_POOL_FINI_IDLE=1 keeps the old wait.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 07:37:38 -05:00
Martin
2765a752b0 Finalize only the slots a texture object registered itself, so a finalize no longer touches another live texture's slots at the same storage, and drop the early return that skipped the whole release when such a texture was live, which also kept textures the game expected released (Kakariko fog lines).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 09:30:37 -03:00
epicmeme546
fe3126e9a7 Add teleporting and cutscene starting to the debug menu.
The Teleport tab lists every area of the game with its named start positions, read from the player's own game files: the warp songs' pads, both sides of the loading zones and the boss rooms among them. A click changes area the way the game's own doors do: during a short event of the game that only waits, the menu reserves the next area and start position in the game's data and asks the game's sequence for the change, so the area unloads and loads as in play, a first visit's cutscene plays and a boss room starts its fight.

The Cutscenes tab lists the game's event scripts by name and starts one through the game's event manager.

Tested from Hyrule Field to Kakariko Village, the Forest Temple, Kokiri Forest in the child's time, the bottom of Lake Hylia, Volvagia's room, and the pads of two warp songs, four of them in one run, with Link walking afterwards; the Kakariko arrival cutscene started by name.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 07:29:17 -05:00
chrg6
83febb43ef Keep a released texture the game still looks up when the count of released ones passes its limit.
Past 2,048 released entries the oldest release was destroyed at each further release, whether or not a descriptor
still resolved to it. Ocarina reads its scene picture in every frame through a second descriptor at the picture's
address whose entry is released once, early in an area, and looked up from then on, so that entry headed the list:
when the count first reached the limit it went, was made again within the frame, and the frame came out with the 3D
scene black and the interface intact.
The entry that goes is now the oldest release that no lookup reaches any more or whose content is gone, and only
when every one is still looked up the one looked up longest ago.
Reproduced in Hyrule Field with the game's own upscaler in use (upscaler = fsr), where the render targets move to new
addresses in every frame and the released entries pile up: 8 black frames in 5 of 7 runs of 13,630 frames; in the
runs logged for it each black frame is the frame after that entry was made again, and the drop that took it is this
sweep. With the change one run of 18,730 frames dropped 834 released entries past the limit and showed no black
frame; two more runs are still to come.
A session with DLSS had the same black frame while its log showed 2,032 to 2,047 released entries. That it is the same
drop is read from those counts, not logged. Why the frame that remakes the entry is black was not traced.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 06:58:02 -05:00
chrg6
a4eae66a8a Merge keeping the upscaler's history when the game moves its scene to another light target.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 06:54:21 -05:00
chrg6
a79ac01a82 Merge the shadow sync once per guest submission that binds the device address table.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 06:54:21 -05:00
epicmeme546
5a69bdc91f Add a debug menu for testing Ocarina of Time: the game's flags by name, the game's speed, and a memory search, on F9.
With debug_menu = 1 (off by default; the Game tab has the switch) F9 opens a panel on the left edge in the
performance overlay's look, with the game in view beside it. ui/menu.cpp lays it out in the settings menu's place,
so its input and the game's blocked pad are the menu's own. Typed characters now reach the menu for its text fields.

Flags: the game's 11,292 on/off flags are read from its game data manager, and a click changes one through the
game's own function on the game's thread at its pad read (runtime/debug_tools.c dbg_tick), so the game applies it
at its next update as it does its own changes. The game knows a flag by the hash of its name only; the names shown
are found in the player's own event flow files, hashed and matched when the panel first opens (2,250 of them from
915 files in 0.2 s), and none is kept in the code. World: Link's position, and a speed factor from 0.05 to 8 that
multiplies the step the runtime gives the game each frame (measured 0.50 at 0.5x). Memory: a search of the heap
for a value of 1, 2 or 4 bytes or a float (about 2 s), narrowed by equals, changed, unchanged, went up or went
down, with a value to set at a place or to hold there every frame.

Tested through the window's own messages: F9 opened it, a click on a flag set that flag in the game, text typed
into the filter narrowed the list, and F9 closed it; a scripted run set and held a value and put it back.

Teleporting, a free camera and starting cutscenes are not in it: writing Link's position, or every copy of it in
the heap, moved him back within three frames, so they need the game's own warp, scene-change and event functions.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 06:19:47 -05:00
chrg6
295922c224 Sync the device address table's shadows once per guest submission that binds the table, and take out the port of pull request #353.
The author of pull request #353 closed it on 2026-11-11 with the words that they give no permission to use its code. Its port (3134f524) goes: the mark of a pipeline that declares the table (VkPipeInfo.gpa, vk_pipeline.c pipe_add) and of the part that draws with it (vk_mem_gpa_use in vk_exec_draw.c bind_resources and mo_emit), the sync of the table's pools in every such part's prologue (vk_mem_gpa_sync), the submission with a callback in the replay's place as it stood (vk_sync_probe_submit), and --probe-vkmem's read through the table with its shader (test_gpa_read, runtime/shaders/gpa_read.spvasm).

In its place, after pull request #551, which was written without that code: a shadow pool goes into the table and onto a list of the table's shadows (vk_memory.c shadow_table_add); the record of a binding of the table notes the guest submission (vk_exec_draw.c ssbo_info, vk_mem_shadow_table_read); and vk_mem_shadow_sync brings the CPU's writes into every shadow on the list once for that guest submission, before the part is submitted. Once is enough, because the copy-ins read the guest submission's write-watch snapshots, which a second sync would find unchanged. Measured by #551's author on Linux (RTX 4090, Kokiri Forest): 113 and 76 frames over 25 ms in 75 s against 217 and 429 with the port, 43 against 41 fps, the picture complete in both.

What this line had built on the port stays, on the new sync: the test that passes over a pool with nothing written (shadow_pool_clean), the upload of the same pages into a table pool's VRAM mirror, the write-back of stores through the table (NX2NAVI_SHADOW_TABLE_STORES, table_wb_cb, now asked once per guest submission that binds the table) and the counts of NX2NAVI_SHADOW_CHECK. The probes that record their own commands (the lost-device probe, --probe-vkmem's table parts) call vk_sync_submit_own, written anew. vk_mem_shadow_storage stays: one line that returns the mode. Finalized pools in the table were already kept for vk_mem_shutdown here.

--probe-vkmem has a check of its own for the sync (test_table_sync): the shadow of a pool that is never bound keeps its old word through a CPU write and a guest submission that does not bind the table, and holds the new one after a guest submission that does. It passes with NX2NAVI_SHADOW=1 on Windows (RTX 5090), as do the store check with NX2NAVI_SHADOW_TABLE_STORES=1 and the probe without shadow storage; --probe-devlost ends as before. Not run: the game, with or without shadow storage, and anything on Linux.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 06:10:09 -05:00
chrg6
a3f98ae7d1 Keep the upscaler's history when the game moves its scene to another light target.
The game draws its scene into one of a few pooled targets of the same size and moves to another whenever its pass list changes, while the camera and the scene carry on. vk_dlaa.c target_changed started a new history at every such change, so DLSS and FSR 3.1 began again from one jittered frame each time: a few soft, grainy frames with dots over the whole picture. The history is the upscaler's own and not in the target, so it now stays where the frame has valid motion vectors (the camera of this frame and of the last one); without them a new history starts as before. The log line of a change says which of the two happened, and the 300-frame line counts the changes with the history kept. NX2NAVI_DLAA_TARGET_KEEP=0 gives a new history at every change.

From pull request #538, whose author counted 35 resets in a walk of a minute through Kokiri Forest before and 1 after. Here it is compiled and the settings probe passes; it was not run in the game.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 06:09:51 -05:00
chrg6
31e0a02901 Merge the mesh shader fallback: task and mesh programs drawn through compute passes and an ordinary draw where the card has no mesh shaders.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 06:01:39 -05:00
chrg6
33d605fb13 Merge the texture origin diagnostic and the fill of a second descriptor's image from its storage, and let the play file replace a pipeline cache that is over the limit.
A pipeline cache over the size limit was dropped at every start and, since the file is no longer written in play, never replaced: every start began empty. The play file is now folded in at the next start whatever its size when the file beside it is over the limit.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:58:56 -05:00
chrg6
8bb9189250 Describe the mesh fallback in the architecture notes.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:58:43 -05:00
chrg6
b1408ee371 Add --probe-meshfb, which draws mesh programs through the mesh pipeline and through the fallback and compares the pictures.
The probe's programs are written in the shape the translator gives a task or mesh program and need no game files.
With a folder of game translations it converts those instead and builds their compute pipelines.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:58:43 -05:00
chrg6
a8c6e992ee Draw task and mesh programs through compute passes when the mesh fallback is on.
A mesh draw becomes its record (the workgroup count, copied on the GPU for an indirect draw), the task dispatch, a
scan that lists the mesh workgroups the tasks started, the mesh dispatch, and an instanced indirect draw with a
generated vertex stage and the program's fragment stage. The compute modules bind the resources of the task and mesh
stages, and their pipelines are made on a thread of their own while the program's draws are skipped.

The indirect mesh ring and the texture pool marks are released at a probe's shutdown.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:58:42 -05:00
chrg6
a3da8569c8 Make the mesh fallback's modules from the translations the shader cache holds.
A translated task or mesh module is the program as a compute function over shared memory plus an entry function
that hands that memory to the mesh pipeline. mesh_fb.c replaces the entry function by one that copies the memory
into a storage buffer, and generates the vertex stage that draws from that buffer. The translator and its identity
are not touched, so no install translates a shader again.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:58:32 -05:00
chrg6
f6aca1f9c7 Add the mesh_fallback setting and decide at device creation whether task and mesh programs are drawn through compute passes.
auto turns the fallback on for a device without VK_EXT_mesh_shader, 1 for every device (testing), 0 never.
mesh_fallback_mb sizes the buffers the passes write. Nothing draws through it yet.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:58:32 -05:00
chrg6
6c991d628d Start a texture the CPU does not write, made over storage the CPU writes, with that storage's bytes.
Two descriptors can name one CPU-written storage: one whose content the cache takes from the CPU, and a second with a texture flag for which it does not. The second has no upload of its own and its slot shows the first one's image while that entry is live. Once the first is released, a lookup of the second's slot makes it an entry of its own, start_at destroys the released first one, and the new image starts cleared and is never uploaded; the slot shows it from then on, also after the first descriptor is registered again. The same happens when both are released and the texture pool refresh looks the second's slot up before the next texture arrives in that memory.

With tex_split_fill = 1 (the default) start_at gives such an entry the storage's bytes: by a copy from the released CPU-written entry it is about to destroy when that image is current and alias_compatible allows, else by an upload from the storage. The image then follows the storage as a CPU-written texture's does until the GPU or WriteTexels writes it; 2 fills it once, 0 is the behaviour before. Depth, stencil and multisample images, pools without CPU access and storage over 32 MiB are left out, and an entry that is to be filled gets a new image instead of a released entry's, since a reused image goes through its first transition after the upload batch. The perf trace counts the copies, the fills with their bytes and time, the fills made again after a write and the entries left empty.

--probe-vkmem makes both sequences with the three values and reads the second descriptor's image back: zeros with 0, the storage's bytes with 1, and with 2 the bytes of the texture that was in the memory before when both descriptors were let go of. One case makes the entry inside a recorded submission, through a hook that lets the probe stand in for a replay, and there the content comes by the copy.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:57:23 -05:00
chrg6
15236bf5c2 Say in the perf trace where a texture sampled without content came from.
A texture drawn through an image nothing ever filled leaves no line in the log: no call fails and the image exists. With NX2NAVI_TRACE=perf the texture cache now keeps, per entry, the frame it was made, the drop of its descriptor's last entry when a ring of the last 4096 destroyed entries still holds it (with the reason: RELEASED_MAX, the size cap, commit or VRAM pressure, replaced at its address and the others), how its content started (on its own, filled from storage over a live entry, copied from a live or a released entry, empty over a live or a released entry), whether it took a released entry's image, and how often it was taken back.

vk_pool_marks_read names each entry a shader sampled while it never had content, one line per entry and up to six per address: "sampled without content", with the address, size, formats, shape, flags, the rule that keeps the cache from taking its content from the CPU, its origin, the slots registered at its address and every other descriptor there, live, released or dropped.

start_at writes a line when an entry the CPU writes is filled from storage over a live entry, and when an entry the CPU does not write is made at an address the CPU can see after the released CPU-written entry there was destroyed, each with both descriptors, up to eight per address.

A line "texture origins" beside the released textures line counts the entries sweep_released dropped past RELEASED_MAX, which no line counted, those replaced at their address, the entries made without content at an address the CPU can see, and the marked slots that met an entry without content or show no entry.

Every destroy_tex caller gives its reason through drop_tex. A run without the trace tests the flag and counts the drops.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:47:15 -05:00
chrg6
9c2b70957b Merge the shader and pipeline batch: FSR 3.1's pipelines through the kept pipeline caches, a pipeline cache save tried again when it did not happen, and a tool that checks a shader cache's translated shaders offline.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:37:21 -05:00
chrg6
0a535ff853 Add a tool that checks the translated shaders of a shader cache offline, with the game's own load checks and spirv-val.
tools/validate_shader_cache.py reads every module and its reflection from the pack and the loose files, says how many the game would refuse and translate again, runs spirv-val on the others and groups what it refuses by message. It writes nothing to the cache. tests/validate_shader_cache_test.py checks it on a made-up cache.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:29:06 -05:00
chrg6
f9219180b9 Try a pipeline cache save again when it did not happen, up to six times at the save interval.
A save that found no memory for its copy, could not write its file or met a build that had just begun was not tried again until the next new pipeline was built, so a run that built none and then ended without its orderly exit lost what it had compiled since the last file. The autosave thread now repeats the try, and the same bound holds for the save owed after the play file was folded in, which before was tried at every interval for as long as it failed. tests/save_retry_check.py checks the rule.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:25:38 -05:00
chrg6
d073d80e70 Create FSR 3.1's pipelines through the pipeline caches kept across runs, so a context is not compiled again at every start the driver's own cache does not serve.
The library creates its pipelines itself and names no pipeline cache. It is now handed pipeline creates of the runtime's in the place of the device's two, and a create without a cache is asked of the pipeline cache first and compiled into the play cache otherwise. ffx_pipe_cache = 0 turns it off. --probe-ffx-cache makes one upscaling context without a window or the game and says where its pipelines came from, and tests/ffx_cache_check.py runs it.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:22:56 -05:00
epicmeme546
45d0c87423 List the FSR 4 library's frame generation in the Frame generation row as a choice of its own.
The row showed AMD FSR 3.1 alone, and the frame generation of AMD's FSR SDK 2.4 could only be set in nx2navi.ini.
It is now listed after AMD FSR 3.1 as "AMD FSR 4 library" with the version the library runs on the card (3.1.6 on
an RX 7900 XT, the machine-learned 4.x on a Radeon RX 9000), where its libraries are there and FSR 4 runs. Choosing
it sets fsr4_fg and, since it generates only beside FSR 4 upscaling, FSR 4 as the upscaler; choosing AMD FSR 3.1
clears fsr4_fg. The performance overlay names the one whose swapchain is in place. In a test run the row went from
AMD FSR 3.1 to the new choice, back and to it again, and the swapchain followed each time.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:18:48 -05:00
chrg6
f38428fa4d Make the wait on the GPU's signal the default again after a frame's first submission.
The fence's wait cost about 4.5 % of the frames a second, and the player who reported the flicker still sees it and black frames with it. wb_split = 0 keeps the fence's wait for whoever wants to compare.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 05:18:37 -05:00
chrg6
b55d2eb3e1 Check in --probe-vkmem that writes made before a pool exists are still reported after it is made.
Making a CPU-visible pool imports its pages (or copies them into a shadow), and the first sync of its mirror and the
texture checks read the write watch afterwards: a write the CPU made before must still be on record then. Nothing in
this line takes it away: the import asks the write watch nothing, and the only reader that resets it stamps the page
generations under the same lock. The self-test now writes two pages, makes the pool and finds both reported, and
prints how many of the pool's pages making it marks by itself.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 04:59:27 -05:00
chrg6
ae70219570 Leave a page alone when a shadow write-back cannot hold the write it reports.
With shadow storage a write-back at a fence copies a page that has no base copy whole from the shadow into guest
memory. Every write the replay records gets base copies, so such a page means the pool the write was noted on was
finalized before the fence and another was made at its address: the new record's shadow is a copy of guest memory
from its own start, holds no byte of that write, and went over everything the CPU had written to the page since.
The page is now left alone when the record is younger than the submission whose fence it is, or when the CPU has
written the page since the shadow's last copy-in; the shadow line counts such pages.
--probe-vkmem has the case: with NX2NAVI_SHADOW=1 it fails without this change (0x11 over the CPU's 0x22, with
imports and with mirrors) and passes with it, as does the run without shadow storage.
Whether a game does finalize and remake a pool inside that window was not observed in play.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 04:59:27 -05:00
chrg6
2e28ba12df Merge the stutter fixes: a pipeline cache past 2 GB is read, the prepared shader list knows its seed, the pipeline cache is written only when it changed with a small file for what play adds, and a queued build a draw waits for goes first.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 04:59:05 -05:00
chrg6
70afa1584b Start a whole pipeline build a draw waits for ahead of the other queued builds.
A draw that waits for a pipeline with no fast link (a mesh pipeline, one without stage libraries, or one whose link failed) needs the whole build, and its job stood where it was queued: the draw queue is first in, first out, so on a burst of new pipelines the build a draw stood waiting for started after the fast links and builds of the draws before it, and the draw was skipped at the end of its wait all the same. graphics now hands the job to job_wanted: while no worker has taken it, it goes to the head of the draw queue and a worker is woken. A wait longer than 500 ms, which is no frame budget (a one-shot draw with oneshot_budget = 0), builds the job on the waiting thread at once when no worker is idle, as a stage library no worker took already is. A wait inside a frame's budget is never turned into a build on the replay thread: the budget is there so that thread is not held for a compile. The worker's build and bookkeeping moved into job_build for both to use; the log's statistics count both cases.

The other half of this item was there: the boot's prebuild asks the caches for a large compute shader's pipeline (compute_create, cached only) before it queues the background build (lb_compute), and with the play cache that question now reaches both caches.

Checked: it builds, --probe-cfg is ok, and --probe-prewarm builds the 3,212 recorded pipelines through the moved code as before. The queue jump and the build on the waiting thread need a draw that waits, which no probe makes: not run.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 04:57:21 -05:00
chrg6
719ee94e67 Write a pipeline cache only when its data grew, and give what a run compiles a cache file of its own.
pipeline-cache.bin was copied out of the driver and written whole at every save after any pipeline was created, also one the cache had held: tonight's logs show three saves of 358.1 MB in a run that added 0.3 MB, and 302 to 306 MB written in each of seven sessions that added about 0.5 MB each. The library warm in play built its 37,572 stage libraries into the same cache, which grew it by 1.6 GB: a save of 2026.7 MB in play, a file over pipeline_cache_max_mb, and the next start dropped it whole and compiled the pipelines it had held.

cache_save now asks a cache for the size of its data first and neither copies nor writes one whose size is what its file holds. What a run compiles goes into a second cache with its own file, pipeline-cache-play.bin (pipeline_cache_play, default 1; needs pipelineCreationCacheControl): pipe_create_in asks the first cache with VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT and builds into the play cache only when that says a compile is needed, and in play only the play file is saved. At a start the play file is read back and merged into the first cache in memory; once it reached pipeline_cache_play_mb (64) it is folded in for good: pipeline-cache.bin is written once, before play, and the play file removed. The preparation modes fold it at any size and build into the one file as before. The library warm's threads create with no cache of ours, so their libraries reach the driver's own cache alone.

Checked with --probe-prewarm on a copy of a dev folder's caches (3,212 recorded pipelines, 333 compute shaders), no game run: with a filled pipeline-cache.bin every pipeline came from it and neither file was written; with none and a cold driver cache the compiles went into pipeline-cache-play.bin (75.9 MB written, pipeline-cache.bin not created); the next start merged it and wrote pipeline-cache.bin once (191.1 MB) and removed it; kept below the fold size, a play file of 68.8 MB gave 1,445 pipelines at 0.3 ms from the first cache where 470 hit without the merge, and was not written again. Not checked in play: the saves during a session, the library warm without a cache, and drivers other than NVIDIA's.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 04:56:26 -05:00
chrg6
2ccd69ef15 Merge the crash and memory fixes: a clean stop on a lost device, a commit gate for background pipeline builds, a start-up memory warning, and a retry for a texture whose decode had no scratch memory.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 04:49:50 -05:00
epicmeme546
5bdf583331 Add frame generation through AMD's FSR SDK 2.4 as a setting to try with FSR 4, and never generate a frame without the HUD-less picture.
runtime/vk_fg4.cpp makes the frame generation swapchain and context with the libraries FSR 4 comes with
(amd_fidelityfx_loader_vk.dll and amd_fidelityfx_framegeneration_vk.dll beside the executable). vk_fg.cpp takes
that path only with fsr4_fg = 1 while FSR 4 is the upscaler; the default stays the FSR 3.1 library. The loader
picks the version for the card: the machine-learned FSR Frame Generation 4 on Radeon RX 9000 cards with Windows 11,
which is untested, and 3.1.6 elsewhere. On an RX 7900 XT (driver 26.10.1) it lists frame generation 3.1.6 and the
swapchains 4.0.0, which the driver brings and the loader chooses, and 3.1.7. The swapchain in place is wanted only
while its library is the one to use, so a change of the setting or of the upscaler, or a failure of this path,
takes it down as switching frame generation off does and the next present makes it with the other library.

The preparation gives this library the camera's position and axes, which FSR Frame Generation 4 requires, and a
scene scale of one metre a unit: with the 0.01 the FSR 3.1 path uses, version 3.1.6 drew grey translucent shapes
into the sky of its frames while the camera turned (160 captures of the screen during a camera sweep; clean with 1).

Both paths now generate a frame only when the picture without the HUD is there for it: generated from the
presented picture alone, the HUD would be warped with the scene behind it. In four configurations (21:9 with either
library, a 16:9 picture in a 21:9 window, a 1080 picture without HDR) every generated frame had it, and the log
counts the frames without. On screen, of the 6,404 pixels of the HUD's item button that stayed fixed through a
camera sweep with the FSR 3.1 library, 6,162 stayed fixed with this one.

Standing in Hyrule Field at 3440x1440 with FSR 4 Quality the game draws 43.0 frames a second with this path and
42.2 with the FSR 3.1 library, each shown twice over. One run changed the present mode, HDR, fullscreen, frame
generation, FSR 4, this setting and the upscaler in turn: 216 screenshots without a bad frame, and no failure.

The SDK's frame generation headers join runtime/third_party/ffx_sdk, unmodified. tools/make_kit.py and
tools/make_launcher.py take the third library from the --ffx4 folder when it is there, and tools/make_game.py
copies it beside the game.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 04:49:01 -05:00