mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-19 12:25:56 +00:00
Dump every thread's call chains of a slow present (TOTK_PROFILE_SLOW=<ms>), and never copy a stack whose Rsp sits in its guard page
The sampler keeps the last half second of every thread's chains in a ring and writes the samples of a present interval over the threshold to <TOTK_PROFILE>.f<frame>, per thread and time (tstack), with the samples that took over 2 ms to stop their thread (tstall: the thread was in a long kernel call). A thread that ran no cycle since its last sample repeats its chain without being suspended. A thread stopped between its sub rsp and the stack probe has Rsp in the guard page; copying from there raised STATUS_GUARD_PAGE_VIOLATION and ended a run. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
6fca957670
commit
adc4d7aa9c
1 file changed
+113
-22
+113
-22
@@ -9,6 +9,13 @@
|
||||
// thread's stack and, after
|
||||
// ResumeThread, unwinds the copy with the .pdata tables (RtlVirtualUnwind), so it takes no lock while the thread is
|
||||
// suspended. The unwind stops at the first frame outside the copy; deeper callers are cut.
|
||||
// TOTK_PROFILE_SLOW=<ms> keeps every thread's chains of the last half second in a ring (a thread outside the exe, mostly
|
||||
// waiting, copies 8 KiB of stack, one in it STK_COPY; a thread that ran no cycle since its previous sample is not
|
||||
// suspended and repeats its previous chain; a sample that took over 2 ms to stop its thread, which happens while the
|
||||
// thread is in a long kernel call, is written as `tstall <tid> <ms into the window> <ms stopping> <rip>...` with the
|
||||
// chain where the thread stopped) and, after a present at least <ms> after the previous one, writes
|
||||
// that interval's samples (plus the 20 ms before) to <TOTK_PROFILE>.f<frame>: the profile format, one `stack 1` line per
|
||||
// sample, and `tstack <tid> <ms into the window> <rip>...` lines that keep the thread and the time. At most 64 dumps.
|
||||
#include <windows.h>
|
||||
#include <psapi.h>
|
||||
#include <tlhelp32.h>
|
||||
@@ -25,14 +32,15 @@
|
||||
#define PROF_SLOTS (1u << 16) // Rip hash table, open addressing; a full table drops new Rips
|
||||
#define PROF_TOP 4000 // more than the 200 asked for: the report sums per function
|
||||
#define PROF_THREADS 512
|
||||
#define PROF_DEPTH 24 // frames kept per call chain, the sampled Rip first
|
||||
#define STK_SLOTS (1u << 15) // call-chain hash table, open addressing; a full table drops new chains
|
||||
#define PROF_STACKS 6000
|
||||
#define STK_COPY (64u << 10) // stack bytes copied per sample
|
||||
#define STK_SLACK (64u << 10) // zeros after the copy: a frame reaching past it reads zeros, and a zero Rip ends the chain
|
||||
|
||||
typedef struct { uint64_t rip, n; } RipCount;
|
||||
typedef struct { DWORD tid; HANDLE h; uint64_t n, in_exe; } ThreadSlot;
|
||||
#define PROF_DEPTH 24 // frames kept per call chain, the sampled Rip first
|
||||
// cycles, depth, last: TOTK_PROFILE_SLOW only, the thread's cycle count and chain at its previous sample
|
||||
typedef struct { DWORD tid; HANDLE h; uint64_t n, in_exe, cycles; uint32_t depth; uint64_t last[PROF_DEPTH]; } ThreadSlot;
|
||||
|
||||
static RipCount table[PROF_SLOTS];
|
||||
typedef struct { uint64_t hash, n; uint32_t depth; uint64_t rip[PROF_DEPTH]; } StackCount;
|
||||
@@ -54,6 +62,18 @@ static int chains; // call chains are kept: TOTK_PROFILE_RENDER
|
||||
static volatile uint64_t cur_frame; // last presented frame
|
||||
static uint64_t frame_lo, frame_hi; // TOTK_PROFILE_FRAMES=<lo>-<hi>: sample only while presents lo..hi-1 are pending
|
||||
|
||||
#define SLOW_RING (1u << 15) // TOTK_PROFILE_SLOW: about 0.5 s of samples of every thread
|
||||
#define SLOW_DUMPS 64
|
||||
typedef struct { uint64_t t; DWORD tid; uint32_t depth; uint64_t rip[PROF_DEPTH]; } Sample;
|
||||
static Sample ring[SLOW_RING];
|
||||
static uint64_t ring_n;
|
||||
#define STALL_RING 1024
|
||||
static Sample stalls[STALL_RING]; // t: when the stop began; rip[PROF_DEPTH - 1] holds the stop's ns
|
||||
static uint64_t stall_n;
|
||||
static uint64_t slow_ns; // TOTK_PROFILE_SLOW in ns, 0 off
|
||||
static volatile LONG64 dump_lo, dump_hi, dump_frame; // the render thread asks for a window, the sampler writes it
|
||||
static volatile DWORD replay_tid; // asynchronous replay (vk_backend.c): its waits hold up the frame too
|
||||
|
||||
static void count_rip(uint64_t rip) {
|
||||
uint32_t i = (uint32_t)((rip * 0x9E3779B97F4A7C15ull) >> 48);
|
||||
for (uint32_t k = 0; k < 64; k++, i = (i + 1) & (PROF_SLOTS - 1)) {
|
||||
@@ -138,6 +158,54 @@ static void refresh_threads(DWORD self) {
|
||||
n_threads = n;
|
||||
}
|
||||
|
||||
static void write_modules(FILE *f) {
|
||||
HMODULE mods[1024];
|
||||
DWORD need = 0;
|
||||
if (!EnumProcessModules(GetCurrentProcess(), mods, sizeof mods, &need)) return;
|
||||
for (DWORD i = 0; i < need / sizeof(HMODULE) && i < 1024; i++) {
|
||||
MODULEINFO mi;
|
||||
char path[MAX_PATH];
|
||||
if (GetModuleInformation(GetCurrentProcess(), mods[i], &mi, sizeof mi) && GetModuleFileNameA(mods[i], path, sizeof path))
|
||||
fprintf(f, "module %llx %lx %s\n", (unsigned long long)(uintptr_t)mi.lpBaseOfDll, mi.SizeOfImage, path);
|
||||
}
|
||||
}
|
||||
|
||||
// The sampler, between ticks: the samples of the window the render thread asked for.
|
||||
static void slow_dump(void) {
|
||||
uint64_t lo = (uint64_t)dump_lo, hi = (uint64_t)dump_hi, frame = (uint64_t)dump_frame;
|
||||
static int dumps;
|
||||
char path[1100];
|
||||
snprintf(path, sizeof path, "%s.f%llu", out_path, (unsigned long long)frame);
|
||||
FILE *f = dumps < SLOW_DUMPS ? fopen(path, "w") : NULL;
|
||||
if (f) {
|
||||
dumps++;
|
||||
fprintf(f, "totk-prof 1\nbase %llx\nperiod_us 1000\nframe %llu interval_ms %.1f\nmain %lu render %lu replay %lu\n",
|
||||
(unsigned long long)(uintptr_t)GetModuleHandleW(NULL), (unsigned long long)frame, (hi - lo) / 1e6 - 20,
|
||||
main_tid, render_tid, replay_tid);
|
||||
write_modules(f);
|
||||
uint64_t first = ring_n > SLOW_RING ? ring_n - SLOW_RING : 0;
|
||||
for (int pass = 0; pass < 2; pass++)
|
||||
for (uint64_t k = first; k < ring_n; k++) {
|
||||
const Sample *s = &ring[k & (SLOW_RING - 1)];
|
||||
if (s->t < lo || s->t > hi) continue;
|
||||
if (pass) fprintf(f, "tstack %lu %.1f", s->tid, (s->t - lo) / 1e6);
|
||||
else fprintf(f, "stack 1");
|
||||
for (uint32_t d = 0; d < s->depth; d++) fprintf(f, " %llx", (unsigned long long)s->rip[d]);
|
||||
fputc('\n', f);
|
||||
}
|
||||
for (uint64_t k = stall_n > STALL_RING ? stall_n - STALL_RING : 0; k < stall_n; k++) {
|
||||
const Sample *s = &stalls[k & (STALL_RING - 1)];
|
||||
if (s->t + s->rip[PROF_DEPTH - 1] < lo || s->t > hi) continue;
|
||||
fprintf(f, "tstall %lu %.1f %.1f", s->tid, ((double)s->t - (double)lo) / 1e6, s->rip[PROF_DEPTH - 1] / 1e6);
|
||||
for (uint32_t d = 0; d < s->depth; d++) fprintf(f, " %llx", (unsigned long long)s->rip[d]);
|
||||
fputc('\n', f);
|
||||
}
|
||||
fclose(f);
|
||||
rt_log("prof: slow frame %llu (%.1f ms) -> %s", (unsigned long long)frame, (hi - lo) / 1e6 - 20, path);
|
||||
}
|
||||
InterlockedExchange64(&dump_hi, 0);
|
||||
}
|
||||
|
||||
static DWORD WINAPI sampler_main(void *arg) {
|
||||
(void)arg;
|
||||
DWORD self = GetCurrentThreadId();
|
||||
@@ -153,27 +221,54 @@ static DWORD WINAPI sampler_main(void *arg) {
|
||||
Sleep(1);
|
||||
}
|
||||
if (tick % 64 == 0) refresh_threads(self);
|
||||
if (dump_hi) slow_dump();
|
||||
if (frame_hi && (cur_frame < frame_lo || cur_frame >= frame_hi)) continue;
|
||||
uint64_t now = slow_ns ? kern_now_ns() : 0;
|
||||
for (int i = 0; i < n_threads; i++) {
|
||||
ThreadSlot *t = &threads[i];
|
||||
if ((only_render && t->tid != render_tid) || (only_main && t->tid != main_tid)) continue;
|
||||
uint64_t cyc = 0;
|
||||
if (slow_ns && t->depth && QueryThreadCycleTime(t->h, &cyc) && cyc == t->cycles) { // still waiting
|
||||
Sample *s = &ring[ring_n++ & (SLOW_RING - 1)];
|
||||
s->t = now, s->tid = t->tid, s->depth = t->depth;
|
||||
memcpy(s->rip, t->last, t->depth * sizeof *t->last);
|
||||
continue;
|
||||
}
|
||||
ctx.ContextFlags = chains ? CONTEXT_CONTROL | CONTEXT_INTEGER : CONTEXT_CONTROL;
|
||||
uint64_t stop0 = slow_ns ? kern_now_ns() : 0;
|
||||
if (SuspendThread(t->h) == (DWORD)-1) continue;
|
||||
BOOL ok = GetThreadContext(t->h, &ctx);
|
||||
BOOL ok = GetThreadContext(t->h, &ctx); // returns once the thread has stopped in user mode
|
||||
uint64_t stop_ns = slow_ns ? kern_now_ns() - stop0 : 0;
|
||||
size_t n = 0;
|
||||
MEMORY_BASIC_INFORMATION mb;
|
||||
if (ok && chains && VirtualQuery((void *)ctx.Rsp, &mb, sizeof mb) && mb.State == MEM_COMMIT) {
|
||||
// a thread stopped between its sub rsp and the stack probe has Rsp in the guard page: touching it would fault
|
||||
if (ok && chains && VirtualQuery((void *)ctx.Rsp, &mb, sizeof mb) && mb.State == MEM_COMMIT &&
|
||||
!(mb.Protect & (PAGE_GUARD | PAGE_NOACCESS))) {
|
||||
n = (uintptr_t)mb.BaseAddress + mb.RegionSize - ctx.Rsp; // the committed stack above Rsp
|
||||
if (n > STK_COPY) n = STK_COPY;
|
||||
size_t cap = slow_ns && (ctx.Rip < exe_lo || ctx.Rip >= exe_hi) ? 8u << 10 : STK_COPY;
|
||||
if (n > cap) n = cap;
|
||||
memcpy(stk_buf, (void *)ctx.Rsp, n);
|
||||
}
|
||||
ResumeThread(t->h);
|
||||
if (!ok) continue;
|
||||
count_rip(ctx.Rip);
|
||||
if (n) {
|
||||
uint64_t chain[PROF_DEPTH];
|
||||
uint32_t d = unwind_copy(&ctx, ctx.Rsp, n, chain);
|
||||
if (d) count_stack(chain, d);
|
||||
uint64_t chain[PROF_DEPTH] = {ctx.Rip};
|
||||
uint32_t d = n ? unwind_copy(&ctx, ctx.Rsp, n, chain) : 0;
|
||||
if (d) count_stack(chain, d);
|
||||
if (slow_ns) {
|
||||
Sample *s = &ring[ring_n++ & (SLOW_RING - 1)];
|
||||
s->t = now, s->tid = t->tid, s->depth = d ? d : 1;
|
||||
memcpy(s->rip, chain, s->depth * sizeof *chain);
|
||||
if (stop_ns > 2000000) {
|
||||
Sample *w = &stalls[stall_n++ & (STALL_RING - 1)];
|
||||
*w = *s;
|
||||
w->t = stop0;
|
||||
if (w->depth > PROF_DEPTH - 1) w->depth = PROF_DEPTH - 1;
|
||||
w->rip[PROF_DEPTH - 1] = stop_ns;
|
||||
}
|
||||
QueryThreadCycleTime(t->h, &t->cycles); // after ResumeThread: the cycles the sample itself cost
|
||||
t->depth = s->depth;
|
||||
memcpy(t->last, chain, s->depth * sizeof *chain);
|
||||
}
|
||||
total++;
|
||||
t->n++;
|
||||
@@ -207,16 +302,7 @@ void prof_write(void) {
|
||||
(unsigned long long)total, (unsigned long long)dropped);
|
||||
for (int i = 0; i < n_threads; i++)
|
||||
fprintf(f, "thread %lu %llu %llu\n", threads[i].tid, (unsigned long long)threads[i].n, (unsigned long long)threads[i].in_exe);
|
||||
HMODULE mods[1024];
|
||||
DWORD need = 0;
|
||||
if (EnumProcessModules(GetCurrentProcess(), mods, sizeof mods, &need)) {
|
||||
for (DWORD i = 0; i < need / sizeof(HMODULE) && i < 1024; i++) {
|
||||
MODULEINFO mi;
|
||||
char path[MAX_PATH];
|
||||
if (GetModuleInformation(GetCurrentProcess(), mods[i], &mi, sizeof mi) && GetModuleFileNameA(mods[i], path, sizeof path))
|
||||
fprintf(f, "module %llx %lx %s\n", (unsigned long long)(uintptr_t)mi.lpBaseOfDll, mi.SizeOfImage, path);
|
||||
}
|
||||
}
|
||||
write_modules(f);
|
||||
int cnt = 0;
|
||||
for (uint32_t i = 0; i < PROF_SLOTS; i++)
|
||||
if (table[i].rip) table[cnt++] = table[i];
|
||||
@@ -267,7 +353,9 @@ void prof_start(void) {
|
||||
only_render = cfg_get("TOTK_PROFILE_RENDER") != NULL;
|
||||
only_main = !only_render && cfg_get("TOTK_PROFILE_MAIN") != NULL;
|
||||
const char *ch = cfg_get("TOTK_PROFILE_CHAINS");
|
||||
chains = only_render || only_main || (ch && *ch && strcmp(ch, "0"));
|
||||
const char *sl = cfg_get("TOTK_PROFILE_SLOW");
|
||||
slow_ns = sl && atoi(sl) > 0 ? (uint64_t)atoi(sl) * 1000000ull : 0;
|
||||
chains = only_render || only_main || slow_ns || (ch && *ch && strcmp(ch, "0"));
|
||||
const char *fr = cfg_get("TOTK_PROFILE_FRAMES");
|
||||
if (fr && sscanf(fr, "%llu-%llu", (unsigned long long *)&frame_lo, (unsigned long long *)&frame_hi) != 2) frame_hi = 0;
|
||||
MODULEINFO mi;
|
||||
@@ -290,8 +378,6 @@ static uint64_t wait_ns[PERF_N], frame_ns[PERF_N], worst_ns[PERF_N]; // window
|
||||
|
||||
uint64_t perf_begin(void) { return kern_now_ns(); }
|
||||
|
||||
static volatile DWORD replay_tid; // asynchronous replay (vk_backend.c): its waits hold up the frame too
|
||||
|
||||
void perf_replay_thread(void) { replay_tid = GetCurrentThreadId(); }
|
||||
void perf_main_thread(void) { main_tid = GetCurrentThreadId(); }
|
||||
|
||||
@@ -448,6 +534,11 @@ void perf_present(uint64_t frame) {
|
||||
cur_frame = frame;
|
||||
if (rt_trace & RT_TRACE_SCHED) kern_sched_report(frame);
|
||||
uint64_t now = kern_now_ns(), d = last ? now - last : 0;
|
||||
if (slow_ns && last && d >= slow_ns && !dump_hi) {
|
||||
dump_lo = (LONG64)(now - d - 20000000ull);
|
||||
dump_frame = (LONG64)frame;
|
||||
InterlockedExchange64(&dump_hi, (LONG64)now);
|
||||
}
|
||||
uint64_t rep = ft_frame(frame, now, d); // d is 0 on the first present: it only starts the period
|
||||
if (__atomic_load_n(&overlay, __ATOMIC_RELAXED)) // the overlay's only cost while it is off: this branch
|
||||
perfmon_frame(now, d, frame_ns, rep, __atomic_load_n(&counts[PERF_CNT_TEX_UP], __ATOMIC_RELAXED));
|
||||
|
||||
Reference in new issue
Block a user