From ec967d4daa1acd8698e573e387ddc78448aa6315 Mon Sep 17 00:00:00 2001 From: chrg6 Date: Fri, 13 Nov 2026 17:51:58 -0500 Subject: [PATCH] Say in perf_census.h that the census charge assumes the walk held the replay up, and say in the ini when the walk line is left out. The review of c05e6528 found two texts that said more than the code or the logs do. - runtime/perf_census.h stated as fact that the replaying thread's write-watch queries wait for the walk's address-space lock. The verifier's caveat stands: in the session the charge is based on, the presenting thread's 600-frame memory report (vk_memory.c vk_mem_census) ran at the same frames as the walks, and the log cannot tell which of the two held the 63 replay hitches up. The comment now says they sat beside such a walk, that the charge assumes the walk held them up, and that a play-test with mem_census = 0 checks it. - nx2navi.ini.example's mem_census paragraph said the "mem: process" line comes every 600 frames. Since c05e6528, vk_memory.c heap_log leaves its own walk out at a frame where perf.c census_check walked (every 3600th frame, and a commit census on growth that falls on a 600th), and the commit census lines stand in for it; the paragraph says so. Comment and settings text only. perf.c compiles with the dev flags; census_charge_check passes. Co-Authored-By: Claude Opus 5.5 --- nx2navi.ini.example | 9 +++++---- runtime/perf_census.h | 6 ++++-- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/nx2navi.ini.example b/nx2navi.ini.example index 687b71be..efb182bb 100644 --- a/nx2navi.ini.example +++ b/nx2navi.ini.example @@ -1007,10 +1007,11 @@ # fps or more with Link on the floor. Each pass slows the game for its few seconds. 0 is off. # floor_watch = 0 # 1: with trace = perf, walks of the process's address space count its private and write-combined memory every 600 -# frames (the "mem: process" line) and where its committed memory lies every 3600 frames, and when the process's own -# commit (without the video memory Windows charges to it) rose 1 GiB over the highest it was, at most once a minute -# (the "commit census" lines). Each walk holds the address-space lock for 100-260 ms and delays the next frame by as -# much, so they are off unless asked for: leave it off in a run whose smoothness is judged. +# frames (the "mem: process" line; at every 3600th frame, and any other where the commit census walks, that walk +# stands in for it) and where its committed memory lies every 3600 frames, and when the process's own commit (without +# the video memory Windows charges to it) rose 1 GiB over the highest it was, at most once a minute (the "commit +# census" lines). Each walk holds the address-space lock for 100-260 ms and delays the next frame by as much, so they +# are off unless asked for: leave it off in a run whose smoothness is judged. # mem_census = 0 # 1: with trace = perf, the process's handles counted by kind (events, sections, threads, files...) at the 600-frame # report when their number grew by 16 or more since the last count (the "mem: handles" line). It reads the system's diff --git a/runtime/perf_census.h b/runtime/perf_census.h index 1aac306e..ffe57ecb 100644 --- a/runtime/perf_census.h +++ b/runtime/perf_census.h @@ -1,8 +1,10 @@ // The part of a frame that an address-space walk of NX2NAVI_MEM_CENSUS overlapped, charged to the census (perf.c // ft_frame). vk_memory.c census_main walks on a thread of its own, but the walk holds the process's address-space lock, -// which the replaying thread's write-watch queries (vk_memory.c vk_mem_mirror_begin) and every page fault wait for: in +// which the replaying thread's write-watch queries (vk_memory.c vk_mem_mirror_begin) and every page fault take too. In // a session of 2026-11-13, 63 of the 66 hitches the stutter map charged to the replay sat beside such a walk, with a -// 20-34 ms write-watch query in them. So the time the frame overlapped the walk is taken out of the frame's replay part +// 20-34 ms write-watch query in them; the presenting thread's 600-frame memory report (vk_memory.c vk_mem_census) ran +// at the same frames, and that log cannot tell which of the two held them up. The charge assumes the walk did, which a +// play-test with mem_census = 0 checks: the time the frame overlapped the walk is taken out of the frame's replay part // first, then out of its unattributed part, never more than the overlap and never so much that the census part grows // past the frame. Apart from perf.c so that tests/census_charge_check.py builds it alone. #pragma once