Ocarina of Time: #805 + #573 + #874 + #836 integration, up to date with nx2 (48 -> 58 fps over build 130 on RX 9070 XT)

AGENTS.md

@@ -80,7 +80,7 @@ Use these before guessing. All are off unless the variable is set; pass them as
 | A newly lowered program changes the image | `EDEN_NX2_REJECT_HASH=<hash>,...` (native program keys from shader dump file names, or shader hashes from the frame dump) | Those programs are rejected as if unsupported; the log shows `rejected by EDEN_NX2_REJECT_HASH` per hit. Bisect by halving the list. The key covers the captured code, so recompute it when the capture rules change. |
 | Draw and render-state questions | `EDEN_NX2_RENDER_TRACE=1`, filter `*:Info HW.GPU:Debug Render.Vulkan:Debug Shader:Debug` | Per-draw state, rejected stages and zero-format texture descriptors. |
 | Video playback | `EDEN_NX2_VDEC_TRACE=1`, `EDEN_NX2_VDEC_DUMP=<dir>` | Decoder submit, decode and composite trace; decoded frames. |
-| Performance and frame pacing | `EDEN_NX2_GPU_PROFILE=1`, `EDEN_DKB_FRAME_TRACE=1` | GPU thread, back thread and Vulkan worker time per second by zone, GPU waits by the zone they happen in, waits for the back by site, and spin mutex contention; per-present interval, CPU and fence timing. The profile also logs `Async read-back per second` every 10 s: guest reads of GPU-written memory, their waits, and macro DMA reads that waited for the split's back or drained it. |
+| Performance and frame pacing | `EDEN_NX2_GPU_PROFILE=1`, `EDEN_DKB_FRAME_TRACE=1` | GPU thread, back thread and Vulkan worker time per second by zone, GPU waits by the zone they happen in, waits for the back by site, and spin mutex contention; per-present interval, CPU and fence timing. The #805 integration also logs `GPU waits in ... s` every 10 s with guest reads, reactive flushes and front/back waits; it retains #805's read tracing rather than the port's duplicate async-readback counters. |
 | HostTiming CPU or timer lateness (late guest timers, audio or vsync jitter) | `EDEN_NX2_HOSTTIMING_STATS=1`, or live with the debug server's `host_timing {"stats": true}` | One `HostTiming wait` line per second: waits, waits woken by newly scheduled events, OS sleep and `WaitFor` time (ms/s), how late timed waits ended and how late events fired (p50/p99/max µs), and the thread's CPU %. |
 | Shader stutter or not, boot and cache costs | `EDEN_NX2_STUTTER_TRACE=1` | One `Nx2Stutter` line per frame presented over 33 ms after the last, with its top cause (gfx/compute pipeline built on the GPU thread, pipeline wait, shader capture, texture, buffer, query/fence, present, other) and each GPU thread's ms; `Nx2StutterSummary` every 10 s (frame-time histogram, builds, cache lookups, cache file size); `Nx2Boot` boot phases with commit and peak commit. Frames over `EDEN_NX2_STUTTER_DETAIL_MS` (default 50) also get `Nx2StutterDetail`: each GPU thread's eight largest zones (ms/calls) and the rare sites that ran (device memory allocate/free, staging, buffer and image create/delete/GC, synchronous downloads, `Scheduler::Finish`), with each run over 2 ms by thread; the summary adds the sites per 10 s. The category totals in the summary are every frame's steady cost, not hitch time. `python3 -I tools/nx2/cache_metrics.py parse <log>` turns a log into JSON, `compare` A/B runs; `tools/nx2/cache_bench.py` runs the cold/warm matrix on the PC. |
 | Command corruption or pop-in | `EDEN_NX2_PB_CHECK=1`; A/B with `EDEN_NX2_PB_SNAPSHOT=0` or `EDEN_NX2_FETCH_DRAIN=1` | How many pushbuffer entries change between submit and parse. |

NX2_GPU_THREAD_SPLIT.md

@@ -61,3 +61,80 @@ with stage 2, 50,000-66,500 with stage 3. The front waits ~4,000-5,000 times a s
 acquires, MME DMA reads); the back still spends ~200 ms a second outside its zones (ring dispatch,
 method sink). Clean A/B (NX2_NOTES row 145): 1.46x throughput, frames 17% shorter; on by
 default since. The back is ~92% busy, ~53% of it draw setup: the next step is there, not the ring.
+
+## Fast draw ports on the #805 performance branch (2026-11-09)
+
+The port of nx2 `1c25fbdfb4` (#921) makes full resolves and texture memo hits use
+the same image-preparation predicate. Empty descriptor views backed by the null
+image are excluded even when their view id is not the null view id. Delta draws
+fall back when a sampled image needs an upload or alias synchronization, or when
+the draw's serial, mappings, command buffer or render pass changed before the
+caches were locked. Rescaling ends the chain too.
+
+Only the uniform-keep and image-descriptor replay portions of nx2 `a4f6287327`
+(#949) are ported: `6b38851501`, `ee98215f14`, and the CPU-write follow-up
+`3e86407514`. The test-runtime support in `b2375cff7f` already exists on #805.
+Its semaphore, waiter and acquire/drain replacements are not included; #805
+retains its own implementations. The subsequent nx2 merge keeps the independent
+scheduler-owner guard on buffer-cache writes from CPU/service threads, without
+replacing #805's back-owned `Run` operations with nx2's `back_quiet` drain scheme.
+
+Small streamed uniforms can reuse the previous allocation without rereading
+guest memory when the stage, slot, device range and command-buffer tick still
+match, and no overlapping inline data, notified CPU write, GPU write or buffer
+deletion invalidated it. More than eight notified writes between draws disable
+keeps for the next draw. Unsynchronized CPU writes unknown to the caches remain
+an assumption to check on the game. Per-stage image descriptor entries and
+rescaling words are replayed until the views are recaptured or the scale epoch
+changes; buffer descriptors still bind on every draw.
+
+Validate a fixed scene with these diagnostics separately (set each to `1`):
+
+- `EDEN_NX2_TEXTURE_MEMO_VERIFY`: compare views, samplers and prepared image sets.
+- `EDEN_NX2_FAST_DRAW_VERIFY`: full-resolve comparison; this deliberately bypasses
+  delta draws, so it does not exercise uniform keeps or descriptor replay.
+- `EDEN_NX2_UBO_KEEP_VERIFY`: reread would-be kept uniforms and report changed bytes.
+- `EDEN_NX2_DELTA_DESCRIPTORS_VERIFY`: regenerate and compare image descriptors
+  and rescaling words.
+- `EDEN_NX2_GPU_PROFILE`: report keep/replay counts and draw fallback reasons;
+  value `2` also retains #805's fine uniform-binding counters.
+
+After building the test target, run `tests.exe "[buffer_ports]"`,
+`tests.exe "[video_core][texture_cache]"`, and
+`tests.exe "Uniform stream*"`. These ports were reviewed without building on
+the porting machine; compilation, runtime verification and visual A/B testing
+are still required. #949's reported Bananza gain (+8–9%, back thread about
+56.0 to 52.2 ms/frame on a Ryzen 9 5900X) includes its acquire changes and does
+not predict the gain of this partial port in Ocarina of Time.
+
+## nx2 integration through 1a5e995a38
+
+- #1028 does not replace #805's read downloads, write tracking, sampled method
+  profiling or diagnostics. Its correctness fixes are retained: discard/DMA
+  destinations first land overlapping read downloads, and older deferred query
+  results cannot mark newer GPU writes clean. Synced #874 payload callbacks still
+  do not advance `fenced_landed` or retire an older deferred report's tracking;
+  `FencedPayloadLanding` remains authoritative.
+- #979/#1014 retain every registered semaphore region and the direct-release
+  shadow. Mirrored releases are emitted only when `ViewApplies()` is false
+  (unsplit, back macros, or delayed/high-accuracy releases). The full #805 front
+  view continues to decide from the original releases, never a second mirrored
+  counter. Its unbounded, source-tracking waiter collection is retained.
+- Shader cache v2 replaces the legacy Vulkan cache. #970's no-flush TIC reads
+  apply to worker translation too, so no pool-wide flush is introduced before
+  launching workers. As with #970, pending GPU writes to descriptors remain a
+  runtime validation risk. AMD shader exceptions, the image recycler and memory
+  usage caching are unchanged.
+- #965/#1039 add stutter sites, GPU waits by zone, queue/present waits, contention
+  and opt-in live-read comparisons around the existing split. Method profiling
+  still takes the fast path and samples timing, rather than timing every write.
+- #1056's macro-on-back port arrived during integration. Keep #805's full effect
+  analysis and back-macro machinery, but take the review fixes: recheck command
+  pages even when the writer wait did not block, and remember the actual last
+  writer at each host sync rather than waiting through unrelated intervening work.
+
+In-game validation should cover low/default and high/delayed fence modes,
+cross-channel semaphore waits, concurrent CPU read-back, cold/migrated/warm v2
+caches, and the fast-draw checks above. The integration build disables
+`BUILD_TESTING`; the updated C++ regression sources must be run separately in a
+test-enabled build.

src/common/nx2_sampler.cpp

@@ -34,6 +34,7 @@ constexpr size_t MaxDepth = 40;
 struct Sample {
     unsigned thread;
     unsigned depth;
+    bool faulted; ///< the walk stopped at an access violation
     std::array<DWORD64, MaxDepth> frames;
 };
 
@@ -146,15 +147,15 @@ std::vector<Target> FindThreads(const std::vector<std::string>& patterns) {
 // could be paused holding the heap lock. A wrong unwind step (code with missing or wrong unwind
 // data) leaves a garbage stack pointer: reading through it crashed the process, so the walk
 // stops once the stack pointer leaves the thread's stack.
-unsigned Walk(CONTEXT context, std::array<DWORD64, MaxDepth>& frames, const NT_TIB* tib) {
+void Walk(CONTEXT context, std::array<DWORD64, MaxDepth>& frames, const NT_TIB* tib,
+          unsigned& depth) {
     if (tib == nullptr) {
-        return 0;
+        return;
     }
     const auto on_stack = [tib](DWORD64 rsp) {
         return rsp >= reinterpret_cast<DWORD64>(tib->StackLimit) &&
                rsp + 8 <= reinterpret_cast<DWORD64>(tib->StackBase) && (rsp & 7) == 0;
     };
-    unsigned depth = 0;
     while (depth < MaxDepth && context.Rip != 0 && on_stack(context.Rsp)) {
         frames[depth++] = context.Rip;
         DWORD64 image_base{};
@@ -174,6 +175,26 @@ unsigned Walk(CONTEXT context, std::array<DWORD64, MaxDepth>& frames, const NT_T
         RtlVirtualUnwind(UNW_FLAG_NHANDLER, image_base, context.Rip, function, &context,
                          &handler_data, &establisher_frame, nullptr);
     }
+}
+
+// RtlVirtualUnwind also reads through the frame register, which the stack check above doesn't
+// cover: a thread paused in a fiber switch with Rbp 0 made it read address 0, and the access
+// violation took the process down (EDEN_NX2_SAMPLE=CPUCore_*). Such a walk keeps the frames it
+// found.
+unsigned GuardedWalk(const CONTEXT& context, std::array<DWORD64, MaxDepth>& frames,
+                     const NT_TIB* tib, bool& faulted) {
+    unsigned depth = 0;
+    faulted = false;
+#ifdef _MSC_VER
+    __try {
+        Walk(context, frames, tib, depth);
+    } __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER
+                                                                 : EXCEPTION_CONTINUE_SEARCH) {
+        faulted = true;
+    }
+#else
+    Walk(context, frames, tib, depth);
+#endif
     return depth;
 }
 
@@ -257,8 +278,15 @@ std::string Report(const std::vector<Target>& targets, const std::vector<Sample>
         std::map<std::string, unsigned> inclusive;
         std::map<std::string, unsigned> self_caller;
         unsigned total = 0;
+        unsigned faulted = 0;
+        unsigned empty = 0;
         for (const Sample& sample : samples) {
-            if (sample.thread != thread || sample.depth == 0) {
+            if (sample.thread != thread) {
+                continue;
+            }
+            faulted += sample.faulted ? 1 : 0;
+            if (sample.depth == 0) {
+                ++empty;
                 continue;
             }
             ++total;
@@ -289,7 +317,9 @@ std::string Report(const std::vector<Target>& targets, const std::vector<Sample>
                              sorted[i].second.c_str());
             }
         };
-        text += fmt::format("=== thread \"{}\": {} samples\n", targets[thread].name, total);
+        text += fmt::format("=== thread \"{}\": {} samples ({} without a stack, {} walks stopped "
+                            "by a fault)\n",
+                            targets[thread].name, total, empty, faulted);
         print("self (where the thread is)", self, 60);
         // The hottest instructions as module offsets, for llvm-symbolizer --relative-address
         // (which line of a function, inlined code included).
@@ -371,7 +401,8 @@ std::string SampleThreads(const std::vector<std::string>& patterns, double secon
             if (GetThreadContext(handle, &context)) {
                 Sample& sample = samples.emplace_back();
                 sample.thread = i;
-                sample.depth = Walk(context, sample.frames, targets[i].tib);
+                sample.depth =
+                    GuardedWalk(context, sample.frames, targets[i].tib, sample.faulted);
             }
             ResumeThread(handle);
         }

src/core/hle/service/nx2_gsv.h

@@ -39,6 +39,7 @@
 #include "core/frontend/framebuffer_layout.h"
 #include "core/perf_stats.h"
 #include "video_core/gpu.h"
+#include "video_core/gpu_wait_stats.h"
 #include "video_core/framebuffer_config.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_client_session.h"
@@ -1802,6 +1803,7 @@ class INx2Vi2Session final : public ServiceFramework<INx2Vi2Session> {
             m_vsync->trace_present.store(m_presents, std::memory_order_relaxed);
         }
         const u64 present = Core::g_nx2_present_count.fetch_add(1, std::memory_order_relaxed) + 1;
+        VideoCommon::GpuWaitStats::NotePresent();
         if (Core::g_nx2_present_time_services.load(std::memory_order_relaxed) != 0) {
             const u64 present_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
                                        std::chrono::steady_clock::now().time_since_epoch())

src/core/memory.cpp

@@ -35,6 +35,7 @@
 #include "core/hle/kernel/k_process.h"
 #include "core/memory.h"
 #include "video_core/gpu.h"
+#include "video_core/gpu_wait_stats.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/host1x/host1x.h"
 #include "video_core/rasterizer_download_area.h"
@@ -891,6 +892,7 @@ struct Memory::Impl {
             return;
         }
         const size_t core = system.GetCurrentHostThreadID();
+        VideoCommon::GpuWaitStats::CountRasterizerRead(core);
         if (core >= Core::Hardware::NUM_CPU_CORES) {
             // A service thread has no slot in the arrays below, and it does not use a slot of a
             // core. It keeps no area, so it asks on each read.
@@ -943,6 +945,7 @@ struct Memory::Impl {
                 sys_core_guard.unlock();
             }
         };
+        VideoCommon::GpuWaitStats::CountRasterizerWrite(core);
         gpu_device_memory->ApplyOpOnPointer(p, scratch_buffers[core], [&](DAddr address) {
             auto& current_area = rasterizer_write_areas[core];
             PAddr subaddress = address >> YUZU_PAGEBITS;
@@ -952,8 +955,11 @@ struct Memory::Impl {
             // we should let the compiler just do it's thing...
             if (current_area.last_address != subaddress) {
                 // Short circuit the need to check for address/size
+                const u64 check_start = VideoCommon::GpuWaitStats::Now();
                 auto const do_collection = (address != 0 && size != 0)
                     && system.GPU().OnCPUWrite(address, size);
+                VideoCommon::GpuWaitStats::AddWriteCheck(core, VideoCommon::GpuWaitStats::Now() -
+                                                                   check_start);
                 if (do_collection) {
                     current_area.last_address = subaddress;
                 } else {

src/tests/CMakeLists.txt

@@ -191,6 +191,7 @@ add_executable(tests
     video_core/turing_macro_effects.cpp
     video_core/turing_macro_ram.cpp
     video_core/uniform_stream_reuse.cpp
+    video_core/upload_order.cpp
     video_core/usage_tracker.cpp
     video_core/shader_invalidation.cpp
     video_core/descriptor_table.cpp