mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-17 09:19:58 -04:00
At 40 fps or less every frame is over 25 ms and so a hitch candidate. A frame that stood out opened an episode with
its hitch flag set, every following paced candidate joined it as a consecutive frame, and the cut after
SM_EPISODE_MAX frames applied only to episodes without a hitch. So the episode grew until the frame rate rose again:
a 150 ms frame followed by 300 frames at 30 fps counted one hitch of about 10 s, and five 120 ms hitches at a steady
30 fps counted as one.
cand_decide now keeps the episode up to its last frame that stood out (frame, summed time, frame count). When more
than SM_EPISODE_MAX paced frames follow that frame, the paced frames are a change of pace and the episode ends at the
frame that stood out and is counted with its time to there. An episode without such a frame is cut as before, and
episode_close is unchanged, so the 87/91/96 ms episode of 2f640fb8 keeps its 274 ms.
tests/stutter_hitch_check.c gets both cases: 150 ms then 300 frames at 30 fps counts one hitch of 150 ms, and five
120 ms hitches at 30 fps count five of 120 ms each. Both failed before the change (0 hitches counted while the run
lasted). stutter_hitch_check and stutter_map_check pass; stutter_map.c compiles with the dev flags and with -Wall
-Wextra without new warnings.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
99 lines
4.8 KiB
C
99 lines
4.8 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_*)
|
|
static const char *const names[8] = {"pipeline", "translation", "texture", "fence", "pacing", "replay", "census",
|
|
"unattributed"};
|
|
static uint64_t frame_no;
|
|
|
|
static void frames(int n, double ms) {
|
|
uint64_t part[8] = {0};
|
|
for (int i = 0; i < n; i++) {
|
|
uint64_t d = (uint64_t)(ms * 1e6);
|
|
clock_ns += d;
|
|
part[7] = d;
|
|
stutter_frame(++frame_no, clock_ns, d, part, names, 8, 7);
|
|
}
|
|
}
|
|
|
|
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[7];
|
|
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[7] - 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[7], 600000000ull);
|
|
if (!logged) printf("FAIL nothing was logged\n"), fails++;
|
|
if (fails) return 1;
|
|
printf("stutter_hitch_check: all checks passed\n");
|
|
return 0;
|
|
}
|