mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-15 21:29:58 -04:00
Keep the texture events of the recorded frames in the flight recorder and write them with each dump as events.tsv, before the thumbnails.
Each texture made (with how its content started), uploaded, uploaded again, released, taken back or destroyed is one line with its frame, address, format, size, layers and flags, so a one-frame flicker in the thumbnails can be matched to the textures of that frame. events.tsv is written first: the thumbnails take about five seconds, and a game closed meanwhile kept no frames.tsv. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
107
runtime/flight.c
107
runtime/flight.c
@@ -1,7 +1,7 @@
|
||||
// NX2NAVI_FLIGHT=1 flight recorder: a ring of the last NX2NAVI_FLIGHT_FRAMES (600) presents, one record each (interval,
|
||||
// render-thread blocked time per perf kind, event counts) and a 320x180 thumbnail each (gfx_present.c, blitted on the
|
||||
// GPU by the present thread). A dump goes to <dir>/<YYYYMMDD-HHMMSS>-f<frame>/: frames.tsv and f<frame>.png per
|
||||
// thumbnail, written by a background thread. Triggers: F8 while the game window has focus, a frame interval over
|
||||
// GPU by the present thread). A dump goes to <dir>/<YYYYMMDD-HHMMSS>-f<frame>/: events.tsv (the texture events of its
|
||||
// frames, flight_tex), f<frame>.png per thumbnail and frames.tsv, written in that order by a background thread. Triggers: F8 while the game window has focus, a frame interval over
|
||||
// NX2NAVI_FLIGHT_SPIKE_MS (100; 0 off; at most one dump per 10 s), NX2NAVI_FLIGHT_AT=<frame>[,<frame>...] and
|
||||
// NX2NAVI_FLIGHT_EVERY=<n> (every n-th frame: with n under the ring's length the dumps of a run hold every frame of it
|
||||
// but the last n). A dump holds the frames up to FLIGHT_POST presents after the trigger, so the aftermath is in it
|
||||
@@ -40,11 +40,22 @@ typedef struct {
|
||||
uint32_t interval_us, blocked_us[PERF_N], n[C_N];
|
||||
} Rec;
|
||||
|
||||
// A texture event (flight_tex). seq is the event's index + 1 once it is written, 0 while a writer fills the slot, so
|
||||
// the copy start_dump takes leaves out a slot that is being written or was reused meanwhile.
|
||||
typedef struct {
|
||||
uint64_t seq, frame, addr;
|
||||
uint32_t kind, format, w, h, layers, flags, detail, us;
|
||||
} TexEv;
|
||||
#define TEX_RING (1u << 18) // events kept: 14 MiB; an area load makes a few thousand in one frame
|
||||
|
||||
typedef struct {
|
||||
int n; // records, oldest first
|
||||
uint64_t trig_frame, trig_interval_us;
|
||||
const char *why;
|
||||
char dir[PLAT_PATH_MAX];
|
||||
TexEv *ev; // the texture events of the records' frames, oldest first
|
||||
size_t nev;
|
||||
uint64_t ev_from; // the first frame with all its events kept, when the ring had dropped earlier ones; 0 all
|
||||
Rec r[];
|
||||
} DumpJob;
|
||||
|
||||
@@ -61,6 +72,8 @@ static char base_dir[PLAT_PATH_MAX];
|
||||
static uint64_t prev_cnt[PERF_CNT_N], prev_xlated;
|
||||
static VkExecFrame prev_exec;
|
||||
static volatile uint64_t cost_ns, cost_max_ns; // render-thread time in flight_frame, for the dump log line
|
||||
static TexEv *tex_ring;
|
||||
static volatile uint64_t tex_n; // texture events written so far
|
||||
|
||||
static unsigned env_u(const char *name, unsigned def) {
|
||||
const char *e = cfg_get(name);
|
||||
@@ -93,6 +106,7 @@ void flight_init(void) {
|
||||
if (!plat_full_path(tmp, base_dir, sizeof base_dir)) snprintf(base_dir, sizeof base_dir, "%s", tmp);
|
||||
thumbs_on = env_u("NX2NAVI_FLIGHT_THUMBS", 1) != 0;
|
||||
if (thumbs_on) vk_thumbs_enable(ring_n);
|
||||
if (!(tex_ring = calloc(TEX_RING, sizeof *tex_ring))) rt_log("flight: no memory for the texture events, none kept");
|
||||
flight_on = 1;
|
||||
rt_log("flight: on: last %d frames, %s; dump on F8, on a frame over %llu ms (one per 10 s)%s, to %s", ring_n,
|
||||
thumbs_on ? "thumbnails 320x180" : "no thumbnails", (unsigned long long)(spike_ns / 1000000),
|
||||
@@ -103,6 +117,80 @@ void flight_init(void) {
|
||||
(unsigned long long)((uint64_t)ring_n * FLIGHT_THUMB_W * FLIGHT_THUMB_H * 4 >> 20));
|
||||
}
|
||||
|
||||
void flight_tex(int kind, uint64_t addr, uint32_t format, uint32_t w, uint32_t h, uint32_t layers, uint32_t flags,
|
||||
uint32_t detail, uint32_t us) {
|
||||
if (!tex_ring) return;
|
||||
uint64_t i = __atomic_fetch_add(&tex_n, 1, __ATOMIC_RELAXED);
|
||||
TexEv *v = &tex_ring[i % TEX_RING];
|
||||
__atomic_store_n(&v->seq, 0, __ATOMIC_RELAXED);
|
||||
__atomic_thread_fence(__ATOMIC_RELEASE); // a reader that sees the fields below being written sees seq 0 first
|
||||
// The frame flight_frame records next: gfx_counters.frames counts the presents so far, and the counts of this
|
||||
// present's record (frames.tsv) gather until the next one.
|
||||
v->frame = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED) + 1;
|
||||
v->addr = addr;
|
||||
v->kind = (uint32_t)kind, v->format = format, v->w = w, v->h = h, v->layers = layers, v->flags = flags;
|
||||
v->detail = detail, v->us = us;
|
||||
__atomic_store_n(&v->seq, i + 1, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
// The texture events from frame `first` on, oldest first, into j (render thread, at the dump's start).
|
||||
static void copy_events(DumpJob *j, uint64_t first) {
|
||||
j->ev = NULL, j->nev = 0, j->ev_from = 0;
|
||||
if (!tex_ring) return;
|
||||
uint64_t end = __atomic_load_n(&tex_n, __ATOMIC_ACQUIRE), beg = end > TEX_RING ? end - TEX_RING : 0;
|
||||
if (end == beg || !(j->ev = malloc(sizeof *j->ev * (size_t)(end - beg)))) return;
|
||||
int dropped = beg > 0; // the ring has wrapped: events older than the oldest kept one are gone
|
||||
for (uint64_t i = beg; i < end; i++) {
|
||||
const TexEv *v = &tex_ring[i % TEX_RING];
|
||||
if (__atomic_load_n(&v->seq, __ATOMIC_ACQUIRE) != i + 1) continue;
|
||||
TexEv c = *v;
|
||||
__atomic_thread_fence(__ATOMIC_ACQUIRE);
|
||||
if (__atomic_load_n(&v->seq, __ATOMIC_RELAXED) != i + 1) continue; // reused while it was copied
|
||||
if (dropped) { // the oldest kept event's frame may have lost earlier events of its own: from the next one on
|
||||
if (c.frame >= first) j->ev_from = c.frame + 1;
|
||||
dropped = 0;
|
||||
}
|
||||
if (c.frame >= first) j->ev[j->nev++] = c;
|
||||
}
|
||||
}
|
||||
|
||||
static const char *const tex_kind_names[FLIGHT_TEX_N] = {"new", "up", "reup", "release", "takeback", "drop"};
|
||||
|
||||
// <dir>/events.tsv: one line per texture event of the dump's frames (flight_tex).
|
||||
static void write_events(const DumpJob *j) {
|
||||
char path[PLAT_PATH_MAX + 32];
|
||||
snprintf(path, sizeof path, "%s/events.tsv", j->dir);
|
||||
FILE *f = fopen(path, "w");
|
||||
if (!f) {
|
||||
rt_log("flight: cannot write %s", path);
|
||||
return;
|
||||
}
|
||||
fprintf(f, "# nx2navi flight dump texture events: frames %llu-%llu",
|
||||
(unsigned long long)j->r[0].frame, (unsigned long long)j->r[j->n - 1].frame);
|
||||
if (j->ev_from) fprintf(f, "; the ring kept all events from frame %llu on only", (unsigned long long)j->ev_from);
|
||||
fprintf(f, "\nframe\tevent\taddr\tformat\twidth\theight\tlayers\tflags\tdetail\tus\n");
|
||||
for (size_t i = 0; i < j->nev; i++) {
|
||||
const TexEv *e = &j->ev[i];
|
||||
if (e->frame > j->r[j->n - 1].frame) break;
|
||||
char fl[64];
|
||||
int k = 0;
|
||||
fl[0] = 0;
|
||||
static const char *const flag_names[] = {"depth", "stencil", "mirrored", "bound", "astc", "gpu"};
|
||||
for (int b = 0; b < 6; b++)
|
||||
if (e->flags & 1u << b) k += snprintf(fl + k, sizeof fl - (size_t)k, "%s%s", k ? "," : "", flag_names[b]);
|
||||
char detail[160];
|
||||
if (e->kind == FLIGHT_TEX_NEW) snprintf(detail, sizeof detail, "%s", vk_texture_start_name((int)e->detail));
|
||||
else if (e->kind == FLIGHT_TEX_DROP) snprintf(detail, sizeof detail, "%s", vk_texture_drop_name((int)e->detail));
|
||||
else if (e->kind == FLIGHT_TEX_UP || e->kind == FLIGHT_TEX_REUP)
|
||||
snprintf(detail, sizeof detail, "%u WriteTexels", e->detail);
|
||||
else detail[0] = 0;
|
||||
fprintf(f, "%llu\t%s\t%#llx\t%#x\t%u\t%u\t%u\t%s\t%s\t%u\n", (unsigned long long)e->frame,
|
||||
e->kind < FLIGHT_TEX_N ? tex_kind_names[e->kind] : "?", (unsigned long long)e->addr, e->format, e->w,
|
||||
e->h, e->layers, fl, detail, e->us);
|
||||
}
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- PNG (RGB, Paeth rows, fixed-Huffman deflate)
|
||||
typedef struct { uint8_t *p; size_t n; uint64_t bits; int nb; } Bits;
|
||||
|
||||
@@ -235,9 +323,10 @@ static void dump_main(void *arg) {
|
||||
plat_file_mkdir_p(j->dir);
|
||||
if (!plat_dir_exists(j->dir)) {
|
||||
rt_log("flight: cannot create %s", j->dir);
|
||||
free(j);
|
||||
free(j->ev), free(j);
|
||||
return;
|
||||
}
|
||||
write_events(j); // first: it takes a moment, the thumbnails seconds, and a game closed meanwhile keeps it
|
||||
uint8_t *have = calloc((size_t)j->n, 1);
|
||||
int n_thumbs = 0;
|
||||
if (thumbs_on && have) {
|
||||
@@ -268,7 +357,7 @@ static void dump_main(void *arg) {
|
||||
FILE *f = fopen(path, "w");
|
||||
if (!f) {
|
||||
rt_log("flight: cannot write %s", path);
|
||||
free(have), free(j);
|
||||
free(have), free(j->ev), free(j);
|
||||
return;
|
||||
}
|
||||
fprintf(f, "# nx2navi flight dump: %s at frame %llu, interval %.1f ms\n", j->why, (unsigned long long)j->trig_frame,
|
||||
@@ -285,12 +374,13 @@ static void dump_main(void *arg) {
|
||||
fprintf(f, "\t%d\n", have ? have[i] : 0);
|
||||
}
|
||||
fclose(f);
|
||||
rt_log("flight: dump %s: %s at frame %llu (%.1f ms), frames %llu-%llu, %d thumbnails, written in %llu ms; "
|
||||
"recorder %.1f us per frame (max %.0f us)", j->dir,
|
||||
rt_log("flight: dump %s: %s at frame %llu (%.1f ms), frames %llu-%llu, %d thumbnails, %zu texture events, written "
|
||||
"in %llu ms; recorder %.1f us per frame (max %.0f us)", j->dir,
|
||||
j->why, (unsigned long long)j->trig_frame, j->trig_interval_us / 1000.0, (unsigned long long)j->r[0].frame,
|
||||
(unsigned long long)j->r[j->n - 1].frame, n_thumbs, (unsigned long long)(plat_now_ms() - t_start),
|
||||
(unsigned long long)j->r[j->n - 1].frame, n_thumbs, j->nev, (unsigned long long)(plat_now_ms() - t_start),
|
||||
recorded ? cost_ns / 1e3 / (double)recorded : 0.0, cost_max_ns / 1e3);
|
||||
free(have);
|
||||
free(j->ev);
|
||||
free(j);
|
||||
return;
|
||||
}
|
||||
@@ -304,11 +394,12 @@ static void start_dump(void) {
|
||||
j->trig_interval_us = trig_interval_us;
|
||||
j->why = trig_why;
|
||||
for (int i = 0; i < n; i++) j->r[i] = ring[(recorded - (uint64_t)n + (uint64_t)i) % (uint64_t)ring_n];
|
||||
copy_events(j, j->r[0].frame);
|
||||
struct tm st;
|
||||
plat_local_time(&st);
|
||||
snprintf(j->dir, sizeof j->dir, "%s/%04d%02d%02d-%02d%02d%02d-f%llu", base_dir, st.tm_year + 1900, st.tm_mon + 1,
|
||||
st.tm_mday, st.tm_hour, st.tm_min, st.tm_sec, (unsigned long long)trig_frame);
|
||||
if (!plat_thread_spawn(dump_main, j, "flight dump", 0)) rt_log("flight: cannot start the dump thread"), free(j);
|
||||
if (!plat_thread_spawn(dump_main, j, "flight dump", 0)) rt_log("flight: cannot start the dump thread"), free(j->ev), free(j);
|
||||
}
|
||||
|
||||
static void trigger(uint64_t frame, uint64_t interval_ns, const char *why) {
|
||||
|
||||
@@ -15,6 +15,23 @@ void flight_init(void); // prof_start calls it
|
||||
void flight_frame(uint64_t frame, uint64_t now_ns, uint64_t interval_ns, const uint64_t blocked_ns[],
|
||||
const volatile int64_t counts[]);
|
||||
|
||||
// Texture events of the recorded frames (vk_texture.c), written with each dump as events.tsv: a texture made (with how
|
||||
// its content started), uploaded, uploaded again, released by the game, taken back after a release, or destroyed. Each
|
||||
// carries the frame whose counts in frames.tsv it is part of. Any thread: the ring takes no lock. A no-op until
|
||||
// flight_init turned the recorder on.
|
||||
enum { FLIGHT_TEX_NEW, FLIGHT_TEX_UP, FLIGHT_TEX_REUP, FLIGHT_TEX_RELEASE, FLIGHT_TEX_TAKEBACK, FLIGHT_TEX_DROP,
|
||||
FLIGHT_TEX_N };
|
||||
// The texture's flags: a depth or stencil image, mirrored (the CPU writes its storage), bound into pool memory, an ASTC
|
||||
// texture, written by the GPU (VkTexImage.gpu_owned).
|
||||
enum { FLIGHT_TF_DEPTH = 1, FLIGHT_TF_STENCIL = 2, FLIGHT_TF_MIRRORED = 4, FLIGHT_TF_BOUND = 8, FLIGHT_TF_ASTC = 16,
|
||||
FLIGHT_TF_GPU = 32 };
|
||||
// detail: for NEW how the content started (vk_texture_start_name), for UP and REUP the WriteTexels calls since the last
|
||||
// upload, for DROP why (vk_texture_drop_name). us: an upload's time, else 0.
|
||||
void flight_tex(int kind, uint64_t addr, uint32_t format, uint32_t w, uint32_t h, uint32_t layers, uint32_t flags,
|
||||
uint32_t detail, uint32_t us);
|
||||
const char *vk_texture_start_name(int start); // vk_texture.c: the names of Tex.og_start and of drop_tex's reasons
|
||||
const char *vk_texture_drop_name(int why);
|
||||
|
||||
// gfx_present.c: the present thread blits every presented frame into a host-visible ring of n thumbnails.
|
||||
void vk_thumbs_enable(int n); // before the first present; n slots of FLIGHT_THUMB_W x FLIGHT_THUMB_H
|
||||
void vk_thumbs_frame(uint64_t frame); // the present thread names the frame of the vk_present_image call that follows
|
||||
|
||||
@@ -16,6 +16,7 @@
|
||||
#include <string.h>
|
||||
|
||||
#include "cfg.h"
|
||||
#include "flight.h"
|
||||
#include "gfx.h"
|
||||
#include "host.h"
|
||||
#include "nvn_api.h"
|
||||
@@ -1609,6 +1610,17 @@ static const char *const start_names[START_N] = {
|
||||
"started on its own", "filled from storage over a live entry", "content copied from a live entry",
|
||||
"content copied from a released entry", "started empty over a live entry", "started empty over a released entry",
|
||||
"content copied from the released CPU-written entry it replaced (split fill)", "filled from its storage (split fill)"};
|
||||
const char *vk_texture_start_name(int start) { return start >= 0 && start < START_N ? start_names[start] : "?"; }
|
||||
const char *vk_texture_drop_name(int why) { return why >= 0 && why < DROP_N ? drop_names[why] : "?"; }
|
||||
|
||||
// An entry's event for the flight recorder (flight.h flight_tex, FLIGHT_TF_*): a no-op while the recorder is off.
|
||||
static void flight_ev(const Tex *e, int kind, uint32_t detail, uint32_t us) {
|
||||
if (!flight_on) return;
|
||||
uint32_t fl = (e->f.depth ? FLIGHT_TF_DEPTH : 0) | (e->f.stencil ? FLIGHT_TF_STENCIL : 0) |
|
||||
(e->pub.mirrored ? FLIGHT_TF_MIRRORED : 0) | (e->bound_to ? FLIGHT_TF_BOUND : 0) |
|
||||
(e->f.astc_bw ? FLIGHT_TF_ASTC : 0) | (e->pub.gpu_owned ? FLIGHT_TF_GPU : 0);
|
||||
flight_tex(kind, e->key.addr, (uint32_t)e->t.d.format, e->pub.width, e->pub.height, e->pub.layers, fl, detail, us);
|
||||
}
|
||||
|
||||
static uint64_t frames_now(void) { return __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED); }
|
||||
|
||||
@@ -1695,6 +1707,7 @@ static void write_back_n(Tex **v, int n);
|
||||
static uint64_t n_drop_wb; // entries written back before their drop since the last perf line
|
||||
|
||||
static void drop_tex(Tex *e, int why) {
|
||||
flight_ev(e, FLIGHT_TEX_DROP, (uint32_t)why, 0);
|
||||
if (why == DROP_COMMIT || why == DROP_IDLE_COMMIT) commit_drop_note(e);
|
||||
if (e->gpu_dirty && why != DROP_OVERWRITTEN && why != DROP_SHUTDOWN) {
|
||||
uint32_t now;
|
||||
@@ -3181,6 +3194,7 @@ static void upload(Tex *e) {
|
||||
} else {
|
||||
n_uploads++, perf_count(PERF_CNT_TEX_UP);
|
||||
}
|
||||
flight_ev(e, e->uploaded ? FLIGHT_TEX_REUP : FLIGHT_TEX_UP, e->wt_n, (uint32_t)(dt / 1000));
|
||||
e->wt_n = 0;
|
||||
e->uploaded = 1;
|
||||
e->n_up++;
|
||||
@@ -3652,6 +3666,7 @@ static Tex *entry_of(const tex_t *t) {
|
||||
origin_made(e);
|
||||
perf_count(PERF_CNT_TEX_NEW);
|
||||
start_at(e, &k, 0);
|
||||
flight_ev(e, FLIGHT_TEX_NEW, e->og_start, 0);
|
||||
e->next_at = nvn_hm_get(&by_addr, &k.addr);
|
||||
nvn_hm_put(&by_addr, &k.addr, e);
|
||||
nvn_hm_put(&by_key, &k, e);
|
||||
@@ -3661,6 +3676,7 @@ static Tex *entry_of(const tex_t *t) {
|
||||
e->samp_frame = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED); // new: not disused before it is drawn
|
||||
}
|
||||
if (e->released) {
|
||||
flight_ev(e, FLIGHT_TEX_TAKEBACK, 0, 0);
|
||||
e->samp_frame = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED); // in use again, as a new one
|
||||
uint64_t gap = e->samp_frame - e->rel_frame;
|
||||
if (gap > e->back_gap) e->back_gap = gap > UINT32_MAX ? UINT32_MAX : (uint32_t)gap;
|
||||
@@ -3725,6 +3741,7 @@ static void wb_cfg_init(void) {
|
||||
static int wb_wanted(const Tex *e) { return e->t.L.size <= wb_limit || e->run < WB_RUN; }
|
||||
|
||||
static void mark_released(Tex *e) { // tex_lock held; e is not released
|
||||
flight_ev(e, FLIGHT_TEX_RELEASE, 0, 0);
|
||||
e->released = 1;
|
||||
e->rel_epoch = submit_epoch;
|
||||
e->rel_frame = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED);
|
||||
|
||||
Reference in New Issue
Block a user