Files
NX2navi/tests/stutter_hitch_check.c
chrg6 0472734008 Time the hand-off to the present thread, the present call and other threads' acquire waits, and count the acquire's GPU wait once.
The perf lines could not see pacing. In the 0.10.0 fresh session (nx2navi.1.log, 7,974,927 bytes) all 666 windows read
"pacing 0%" and "bound: cpu" and all 70 slow-frame lines "pacing 0.0 drain 0.0", while 610 windows had a 16.x ms
interval at fps_limit 60 under the game's own limiter. The pacer's wait happened where perf does not count it:
vk_backend.c present_image's wait for the present thread to take the previous picture was untimed, perf_end drops
waits on any thread but the presenting and replay ones (a game may acquire its window image on another), and the
acquire's GPU wait was counted twice, as pacing around b->fence_wait and as a fence wait inside vk_sync_fence_wait
(F-7-04).

- host.h: PERF_HANDOFF, the presenting thread's wait to hand the present thread the next picture, timed in
  present_image from under pl (where pending is read) and kept in PresentJob.handoff_ns. perf_end_any counts a wait
  on any other guest thread into a sum that perf_present adds to the frame before ft_frame reads its parts.
- nvn_api_obj.c nvnWindowAcquireTexture: the pacer's sleep is timed with perf_end_any; the GPU wait counts only as
  the fence wait it is; one line names the threads that acquire and present once the first present is known.
- vk_backend.c present_main: the TRACE=present line adds the present call's time (vkQueuePresentKHR, under the queue
  lock, where an overlay's frame limiter sleeps) and the job's hand-off wait; with trace=perf, a line per 60 presents
  gives the present thread's blit and submit, paced wait, present call (avg, max), time past target and the hand-off.
- perf.c: "handoff" in the window line's shares and the slow-frame line, "hand-off" in the worst-frame lines and as a
  cause of its own for frames over 25 ms and the stutter map. The "bound:" rule stays as it is until play-test numbers
  exist.
- The cause list changes together: perf.c FT_C_* and ft_cause_name, stutter_map.c SM_CAUSES and cause_short,
  tests/stutter_hitch_check.c names[] (now sized from SM_CAUSES), and tools/stutter_map.py, whose cause and hitch
  patterns now take a hyphen. flight.c's frames.tsv gets a handoff_ms column (blocked_names checked against PERF_N),
  and tools/flight_view.py lists it.
- tools/perf_summary.py reads the hand-off share, the present-thread lines and the TRACE=present lines, and prints
  percentiles of the present interval, paced wait, time past target, present call and hand-off.

New tests/perf_summary_check.py makes lines with the runtime's format strings (checked against the C sources) and
checks the percentiles, the window averages and the hand-off share, and that older lines without these fields still
parse; tests/stutter_map_check.py gets a hand-off hitch and area cause, which the old patterns dropped. Diagnostics
only: no wait, pacing or presentation change. Not reproduced before the change (it needs a game run with trace=perf).
perf_summary_check, stutter_map_check, stutter_hitch_check, flight_flash_check and frame_step_check pass; every
runtime file compiles with the dev flags after the host.h change, and the changed files add no -Wall -Wextra warnings.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 18:41:39 -05:00

101 lines
5.0 KiB
C

// tests/stutter_hitch_check.py builds this: runtime/stutter_map.c's hitch rule on made-up frame times, with the few
// runtime functions it calls stubbed. A steady change of pace (the game drawing at 60 fps after 200) counts no hitch;
// isolated long frames each count one; a frame over SM_HITCH_SURE_NS counts whatever follows it.
#include <stdarg.h>
#include <stdio.h>
#include "../runtime/stutter_map.c"
static uint64_t clock_ns;
int cfg_bool(const char *name) { return !strcmp(name, "NX2NAVI_STUTTER_MAP"); }
uint64_t kern_now_ns(void) { return clock_ns; }
void plat_mutex_lock(PlatMutex *m) { (void)m; }
void plat_mutex_unlock(PlatMutex *m) { (void)m; }
static int logged;
void rt_log(const char *fmt, ...) {
(void)fmt;
logged++;
}
// perf.c's causes, in its order (FT_C_*); the frames below are charged to the last, unattributed
static const char *const names[] = {"pipeline", "translation", "texture", "fence", "pacing", "hand-off", "replay",
"census", "unattributed"};
#define OTHER (SM_CAUSES - 1)
_Static_assert(sizeof names / sizeof *names == SM_CAUSES, "names follows perf.c's FT_C_* list");
static uint64_t frame_no;
static void frames(int n, double ms) {
uint64_t part[SM_CAUSES] = {0};
for (int i = 0; i < n; i++) {
uint64_t d = (uint64_t)(ms * 1e6);
clock_ns += d;
part[OTHER] = d;
stutter_frame(++frame_no, clock_ns, d, part, names, SM_CAUSES, OTHER);
}
}
static int fails;
static void expect(const char *what, uint64_t got, uint64_t want) {
if (got != want) printf("FAIL %s: %llu, expected %llu\n", what, (unsigned long long)got, (unsigned long long)want), fails++;
}
int main(void) {
stutter_map_init();
clock_ns = 10000000000ull; // well past any area load
frames(200, 5.0);
expect("steady 200 fps", areas[0].hitch, 0);
frames(300, 16.6); // the game's menus at 60 fps
expect("a change to 60 fps", areas[0].hitch, 0);
if (!paced_out) printf("FAIL the change of pace was not counted as one\n"), fails++;
frames(200, 7.0);
for (int k = 0; k < 5; k++) frames(1, 30.0), frames(60, 7.0); // five isolated spikes
expect("five isolated spikes", areas[0].hitch, 5);
frames(1, 150.0), frames(1, 150.0), frames(60, 7.0); // two long frames in a row: one episode of 300 ms
expect("two frames over the sure line", areas[0].hitch, 6);
expect("their episode's time", areas[0].worst_ns, 300000000ull);
frames(1, 40.0), frames(1, 40.0), frames(60, 7.0); // a double spike: one episode
expect("a double spike", areas[0].hitch, 7);
// three long frames, each followed by one as long, as after an area load in a session of 2026-11-13 (87, 91 and
// 96 ms): one episode, not three changes of pace
uint64_t paced0 = paced_out, charged0 = areas[0].cause_ns[OTHER];
frames(1, 87.0), frames(1, 91.0), frames(1, 96.0), frames(60, 7.0);
expect("three slow frames in a row", areas[0].hitch, 8);
expect("not a change of pace", paced_out, paced0);
expect("the episode's time", areas[0].cause_ns[OTHER] - charged0, 274000000ull);
// a change to 30 fps from 140: a run of long frames longer than SM_EPISODE_MAX, a change of pace
frames(200, 7.0);
frames(300, 33.3);
expect("a change to 30 fps", areas[0].hitch, 8);
frames(200, 7.0);
stutter_area("Kakariko"); // a load: what follows within SM_LOAD_NS is the load's
frames(1, 60.0), frames(30, 7.0);
expect("a spike right after a load (play)", areas[1].hitch, 0);
expect("a spike right after a load (load)", areas[1].load_hitch, 1);
clock_ns += 10000000000ull;
frames(60, 7.0);
stutter_load(); // the texture pool's load of an area, without the game's
frames(1, 60.0), frames(30, 7.0);
expect("a spike right after the pool's load (play)", areas[1].hitch, 0);
expect("a spike right after the pool's load (load)", areas[1].load_hitch, 2);
// At 30 fps every frame is over SM_HITCH_ANY_NS and so a candidate: a hitch followed by the steady frames ends at
// itself, not at the end of the slow run (an episode of 301 frames, 10 s long, before)
stutter_area("Lake Hylia");
clock_ns += 10000000000ull;
frames(200, 7.0);
frames(1, 150.0), frames(300, 33.3);
expect("150 ms then 300 frames at 30 fps", areas[2].hitch, 1);
expect("150 ms then 300 frames at 30 fps (worst)", areas[2].worst_ns, 150000000ull);
frames(200, 7.0); // the end of the slow run stands out from the frames after it: one more
stutter_area("Gerudo Valley");
clock_ns += 10000000000ull;
frames(200, 33.3); // a steady 30 fps with a 120 ms hitch every 60 frames: each counts
for (int k = 0; k < 5; k++) frames(1, 120.0), frames(59, 33.3);
expect("five hitches at 30 fps", areas[3].hitch, 5);
expect("five hitches at 30 fps (worst)", areas[3].worst_ns, 120000000ull);
expect("five hitches at 30 fps (their time)", areas[3].cause_ns[OTHER], 600000000ull);
if (!logged) printf("FAIL nothing was logged\n"), fails++;
if (fails) return 1;
printf("stutter_hitch_check: all checks passed\n");
return 0;
}