From f3a9d2967f20cd6c30ca0734a3ce44e1d37c97da Mon Sep 17 00:00:00 2001 From: Tobim6 <102646588+Tobim6@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:22:00 +0100 Subject: [PATCH] Profiler: name the exe's addresses from its own symbol table, and sample the replay thread alone. A NX2NAVI_PROFILE profile needed the link map to name its Rips, and the launcher's builds keep none. A MinGW link keeps the COFF symbol table in the exe, so prof_sampler_write now reads it (runtime/prof_syms.c, plain file reads) and appends `sym
+` for every exe address in the Rip and chain lists. NX2NAVI_PROFILE_REPLAY=1 samples only the replay thread: with NX2NAVI_REPLAY_ASYNC=1 the render thread spends 98% of a 37 ms frame waiting, and the replay thread (22 ms a frame recording Vulkan commands) is the one to look at. (cherry picked from commit 9d3126ca780d7f0f0b91468d42b8ee70572747c8) Co-Authored-By: Claude Opus 5.5 --- runtime/prof_syms.c | 112 ++++++++++++++++++++++++++++++++++++++++++++ runtime/prof_syms.h | 9 ++++ runtime/prof_win.c | 15 ++++++ 3 files changed, 136 insertions(+) create mode 100644 runtime/prof_syms.c create mode 100644 runtime/prof_syms.h diff --git a/runtime/prof_syms.c b/runtime/prof_syms.c new file mode 100644 index 00000000..dbf098df --- /dev/null +++ b/runtime/prof_syms.c @@ -0,0 +1,112 @@ +// Names for a sampling profile's exe addresses from the exe's own COFF symbol table (runtime/prof_win.c). A MinGW link +// keeps the table in the file (PointerToSymbolTable), so a profile names its functions without the link map: for each +// address the profile lists, `sym
+`. Plain file reads, no Windows headers, so the parser +// builds and is tested anywhere. +#include +#include +#include +#include + +#include "prof_syms.h" + +typedef struct { uint32_t rva; uint32_t str; char sname[8]; } CSym; // str: string-table offset, 0 short name + +static int cmp_sym(const void *a, const void *b) { + uint32_t x = ((const CSym *)a)->rva, y = ((const CSym *)b)->rva; + return x < y ? -1 : x > y; +} + +static int cmp_u64(const void *a, const void *b) { + uint64_t x = *(const uint64_t *)a, y = *(const uint64_t *)b; + return x < y ? -1 : x > y; +} + +static uint32_t rd32(const uint8_t *p) { return p[0] | p[1] << 8 | p[2] << 16 | (uint32_t)p[3] << 24; } +static uint16_t rd16(const uint8_t *p) { return (uint16_t)(p[0] | p[1] << 8); } + +int prof_syms_write(FILE *out, const char *exe_path, uint64_t base, const uint64_t *addr, size_t n) { + FILE *f = fopen(exe_path, "rb"); + if (!f) return -1; + uint8_t h[0x400]; + int named = -1; + CSym *syms = NULL; + char *strtab = NULL; + uint8_t *raw = NULL; + uint64_t *a = NULL; + if (fread(h, 1, 0x40, f) != 0x40 || h[0] != 'M' || h[1] != 'Z') goto done; + uint32_t pe = rd32(h + 0x3c); + if (fseek(f, pe, SEEK_SET) || fread(h, 1, 24, f) != 24 || memcmp(h, "PE\0\0", 4)) goto done; + uint16_t nsec = rd16(h + 6), opt = rd16(h + 20); + uint32_t symptr = rd32(h + 12), nsym = rd32(h + 16); + if (!symptr || !nsym || nsec > 96) goto done; + uint32_t sec_va[96], sec_exec[96]; + if (fseek(f, pe + 24 + opt, SEEK_SET)) goto done; + for (int i = 0; i < nsec; i++) { + if (fread(h, 1, 40, f) != 40) goto done; + sec_va[i] = rd32(h + 12); + sec_exec[i] = (rd32(h + 36) & 0x20000020) != 0; // CNT_CODE or MEM_EXECUTE + } + // the string table follows the symbols: its first 4 bytes are its size + uint8_t szb[4]; + if (fseek(f, (long)symptr + (long)nsym * 18, SEEK_SET) || fread(szb, 1, 4, f) != 4) goto done; + uint32_t strsz = rd32(szb); + strtab = malloc(strsz + 1u); + if (!strtab) goto done; + memcpy(strtab, szb, 4); + if (strsz > 4 && fread(strtab + 4, 1, strsz - 4, f) != strsz - 4) goto done; + strtab[strsz] = 0; + // the symbols in chunks; functions in executable sections + size_t ns = 0, cs = 1 << 16; + syms = malloc(cs * sizeof *syms); + enum { CH = 1 << 16 }; + raw = malloc(CH * 18); + if (!syms || !raw || fseek(f, symptr, SEEK_SET)) goto done; + uint32_t skip = 0; + for (uint32_t done_n = 0; done_n < nsym;) { + uint32_t k = nsym - done_n < CH ? nsym - done_n : CH; + if (fread(raw, 18, k, f) != k) goto done; + for (uint32_t i = 0; i < k; i++) { + const uint8_t *s = raw + i * 18; + if (skip) { skip--; continue; } // auxiliary records + skip = s[17]; + int16_t sec = (int16_t)rd16(s + 12); + uint8_t cls = s[16]; + if (sec <= 0 || sec > nsec || !sec_exec[sec - 1] || (cls != 2 && cls != 3)) continue; + CSym c = {sec_va[sec - 1] + rd32(s + 8), 0, {0}}; + if (rd32(s)) memcpy(c.sname, s, 8); + else c.str = rd32(s + 4); + const char *nm = c.str ? (c.str < strsz ? strtab + c.str : "") : c.sname; + if (nm[0] == '.' || !nm[0]) continue; // section symbols + if (ns == cs) { + CSym *g = realloc(syms, (cs *= 2) * sizeof *syms); + if (!g) goto done; + syms = g; + } + syms[ns++] = c; + } + done_n += k; + } + qsort(syms, ns, sizeof *syms, cmp_sym); + a = malloc((n ? n : 1) * sizeof *a); + if (!a) goto done; + memcpy(a, addr, n * sizeof *a); + qsort(a, n, sizeof *a, cmp_u64); + named = 0; + size_t j = 0; + for (size_t i = 0; i < n; i++) { + if (i && a[i] == a[i - 1]) continue; + if (a[i] < base || a[i] - base >= 0xffffffffull) continue; + uint32_t rva = (uint32_t)(a[i] - base); + while (j < ns && syms[j].rva <= rva) j++; // a is sorted, so j only grows + if (!j) continue; + const CSym *c = &syms[j - 1]; + char sn[9] = {0}; + const char *nm = c->str ? (c->str < strsz ? strtab + c->str : "?") : (memcpy(sn, c->sname, 8), sn); + fprintf(out, "sym %llx %s+0x%x\n", (unsigned long long)a[i], nm, rva - c->rva); + named++; + } +done: + free(a), free(raw), free(syms), free(strtab); + fclose(f); + return named; +} diff --git a/runtime/prof_syms.h b/runtime/prof_syms.h new file mode 100644 index 00000000..c583e8f4 --- /dev/null +++ b/runtime/prof_syms.h @@ -0,0 +1,9 @@ +#pragma once +#include +#include +#include + +// Writes `sym
+0x` for each of the n addresses (any order, repeats allowed) that falls in +// the image loaded at base, from the COFF symbol table of the file at exe_path. Returns the lines written, -1 when the +// file has no symbol table or cannot be read. +int prof_syms_write(FILE *out, const char *exe_path, uint64_t base, const uint64_t *addr, size_t n); diff --git a/runtime/prof_win.c b/runtime/prof_win.c index 95470d9c..a8df4008 100644 --- a/runtime/prof_win.c +++ b/runtime/prof_win.c @@ -29,6 +29,7 @@ #include "host.h" #include "perfmon.h" #include "prof.h" +#include "prof_syms.h" #define render_tid prof_render_tid #define main_tid prof_main_tid @@ -355,7 +356,21 @@ void prof_sampler_write(void) { fputc('\n', f); } if (stacks_dropped) fprintf(f, "stacks_dropped %llu\n", (unsigned long long)stacks_dropped); + // the exe's own symbol table names the addresses above, so the profile needs no link map + size_t na = 0, ca = (size_t)cnt + 1; + for (int i = 0; i < ns && i < PROF_STACKS; i++) ca += stacks[i].depth; + uint64_t *addrs = malloc(ca * sizeof *addrs); + char exe[MAX_PATH]; + int named = -1; + if (addrs && GetModuleFileNameA(NULL, exe, sizeof exe)) { + for (int i = 0; i < cnt && i < PROF_TOP; i++) addrs[na++] = table[i].rip; + for (int i = 0; i < ns && i < PROF_STACKS; i++) + for (uint32_t d = 0; d < stacks[i].depth; d++) addrs[na++] = stacks[i].rip[d]; + named = prof_syms_write(f, exe, (uint64_t)(uintptr_t)GetModuleHandleW(NULL), addrs, na); + } + free(addrs); fclose(f); + if (named < 0) rt_log("prof: no symbol table in the exe: the addresses stay unnamed"); rt_log("prof: %llu samples, %d Rips -> %s", (unsigned long long)total, cnt, out_path); }