Merge the stability pass's fixes for the points its review found.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

# Conflicts:
#	runtime/cfg.c
This commit is contained in:
chrg6
2026-11-12 22:32:48 -05:00
22 changed files with 641 additions and 226 deletions

View File

@@ -8,6 +8,12 @@
// goes to the play cache until that is folded in), and "done" is what keeps those starts ordinary ones. After
// BOOT_WARM_TRIES starts that began the warm and did not end it the file stays as it is, and starts on that GPU and
// driver are ordinary ones too.
//
// boot_end_decide: what a marker means that a start left behind while the boot built pipelines
// (<cache folder>/pipeline-prewarm-running.txt, "<GPU and driver> <ends in a row before it>"; vk_pipeline.c
// pm_skipped). With the crash handler's note the driver crashed in those builds and the prebuild is skipped on that
// GPU and driver. Without it the start was closed or stopped, which only counts; BOOT_QUIET_ENDS such ends in a row
// skip the prebuild as well, for the driver that ends the process without a fault the handler sees.
#pragma once
#include <stdio.h>
@@ -37,3 +43,21 @@ static inline int boot_warm_decide(const char *text, const char *key, int foreig
*tries = (int)n + 1;
return BOOT_WARM_YES;
}
#define BOOT_QUIET_ENDS 3
// OTHER: the marker is another GPU's or driver's and means nothing here. SKIP: the prebuild is skipped on this GPU
// and driver from now on. COUNTED: this start builds again, and writes *quiet into its own marker.
enum { BOOT_END_OTHER, BOOT_END_SKIP, BOOT_END_COUNTED };
// text: the marker's content (a marker of 0.9.2 holds the GPU and driver alone). crashed: the crash handler's note was
// there. *quiet: the ends in a row without a note, this one counted; 0 with BOOT_END_OTHER.
static inline int boot_end_decide(const char *text, const char *key, int crashed, int *quiet) {
char was[64] = "";
int n = 0;
if (sscanf(text, "%63s %d", was, &n) < 2 || n < 0) n = 0;
*quiet = 0;
if (strcmp(was, key)) return BOOT_END_OTHER;
*quiet = n + 1;
return crashed || n + 1 >= BOOT_QUIET_ENDS ? BOOT_END_SKIP : BOOT_END_COUNTED;
}

View File

@@ -61,7 +61,7 @@ static const char *const known[] = {
"MVOBJ_ALL", "MVOBJ_BANKS", "MVOBJ_EQUAL", "MVOBJ_EXACT", "MVOBJ_EXEC", "MVOBJ_NOC4", "MVOBJ_ONLY", "MVOBJ_TIMES", "MVPREV_CHECK", "MVPREV_GROW", "MVPREV_SKIP", "MVPREV_TRUST", "MV_CHECK",
"MV_SURVEY",
"PIPE_SEED_BOOT", "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PACE_HZ", "PASS_CRUMBS", "PATCH_OUTPUT", "PATCH_RES_FIXED", "PATCH_SCENE", "PATCH_WIDE_ASPECT", "PATCH_WIDE_HUD", "PATCH_WIDE_MOVIE", "PATCH_WIDE_OUT", "PATCH_FREECAM", "PATCH_OCCLUSION_OFF", "PATCH_WIDE_SAVE", "PATCH_WIDE_SCENE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPELINE_CACHE_MAX_MB", "PIPELINE_CACHE_PLAY", "PIPELINE_CACHE_PLAY_MB", "PIPE_BINARIES", "PIPE_BINARIES_MAX_MB", "PIPE_FEEDBACK", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SEED", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", "POWER_FULL", "TEX_SAME", "TEX_SAME_BIG", "TEX_FLAT3D", "TEX_KEEP_TAKEN", "TEX_STALE_KEPT", "PRESENT_HELD", "HELD_SYNC",
"PREPARE_PIPELINES", "PREWARM_FULL", "PREWARM_WAIT_MS", "PREWARM_XLATE", "PROBE_MOVIE", "PROBE_MOVIE_SHOT", "PROFILE", "PROFILE_CHAINS", "PROFILE_DIR", "PROFILE_FRAMES", "PROFILE_REPLAY", "PROFILE_SLOW",
"PREPARE_PIPELINES", "PREWARM_FULL", "PREWARM_FULL_S", "PREWARM_WAIT_MS", "PREWARM_XLATE", "PROBE_MOVIE", "PROBE_MOVIE_SHOT", "PROFILE", "PROFILE_CHAINS", "PROFILE_DIR", "PROFILE_FRAMES", "PROFILE_REPLAY", "PROFILE_SLOW",
"POOL_FAST", "POOL_GROUP", "POOL_GROUP_CHECK", "POOL_PRESNAP", "POOL_PRESNAP_RUNS",
"SUBMIT_FINISH_GPU", "SVC_WAITS", "SNAP_WIDEN", "SUBMIT_FINISH_RESULTS", "SUBMIT_FINISH_KINDS", "FOLIAGE", "MIRROR_STAGE", "FLUSH_SKIP_CLEAN", "MIRROR_HOT", "MESH_EMULATION", "MESH_EMU_MB", "MESH_EMU_TASKS", "MESH_EMU_BATCH", "GUEST_OPT", "LOG_TEX_NEW", "DUMP_KEY", "VEC_INDEX_FIX", "PASS_TIMES",
"PROFILE_MAIN", "PROFILE_RENDER", "PROMPTS", "PUSH_SKIP", "PUSH_STAGE", "RDOC", "RDOC_DIR", "RDOC_DLL", "REALTIME", "REC_END", "REEXEC",
@@ -340,7 +340,9 @@ static const CfgMeta metas[] = {
{"FOLIAGE", "full", "full|reduced|off", RESTART}, // vk_exec_draw.c foliage_skip
{"VRAM_HEAP_LIMIT", "0", NULL, RESTART}, // vk_device.c vram_heap_limits: auto, 0 or MiB
{"VRAM_RESERVE_MB", "0", "0..4096", RESTART}, // vk_vma_budget.c: video memory kept free of VMA's allocations
{"UPLOAD_BATCH_MB", "0", NULL, RESTART}, // vk_memory.c: MiB of staging before a batch goes early, 0 no limit
// vk_memory.c vk_upload_end: MiB of staging before a batch goes early. 0: at 64 MiB, the staging pool's own limit
// (STG_FLUSH), which also holds for every value above it
{"UPLOAD_BATCH_MB", "0", NULL, RESTART},
{"MESH_EMULATION", "0", "0|1", RESTART}, {"MESH_EMU_MB", "256", "32..2048", RESTART},
{"MESH_EMU_TASKS", "16384", "256..262144", RESTART}, {"MESH_EMU_BATCH", "1", "0|1", RESTART}, {"VEC_INDEX_FIX", "0", "0|auto|1", RESTART},
{"GUEST_OPT", "1", "1|2", RESTART}, // tools/make_game.py: the next Rebuild the Game

View File

@@ -359,11 +359,15 @@ uint64_t res_heap_extra_kib(void); // added to the HeapD
int res_heapdef_build(const void *in, size_t n, void **out, size_t *out_n); // the HeapDef table (.byml.zs) with
// the grown heaps, malloc'd; 0 = cannot (logged)
void res_heapdef_served(void); // romfs.c serves the grown table
int res_heapdef_ok(void); // 1 once it does; 0 after fs_init: the game has the shipped heaps
void wide_init(void);
void wide_present(void); // each present: DLSS's render scale (res_fixed) // after rt_patches_init: widescreen.c, NX2NAVI_GAME_ASPECT
int wide_available(void); // the generated C has the widescreen sets
void wide_picture(unsigned *w, unsigned *h); // the picture the game draws (its scene is never larger)
uint64_t wide_heap_extra_kib(void); // the texture heap's growth for the widescreen picture
// The most res_heap_extra_kib may be (memory.c): with more the application pool passes the heap region and the
// game's own SetHeapSize is refused. A whole number of 2 MiB.
uint64_t mem_heap_extra_max_kib(void);
void res_init(void); // after rt_patches_init: the patch page and the sets
float res_dlss_lod_bias(void); // NX2NAVI_DLSS upscaling: texture LOD bias (<= 0)
int res_dlss_mode(const char *mode); // NX2NAVI_DLSS changed while running: new scene size
@@ -456,6 +460,9 @@ int vk_pipeline_warm_shaders(void); // vk_pipeline.c: --w
int vk_pipeline_prepare_pipelines(void); // vk_pipeline.c: --prepare-pipelines (the shared pipeline list)
int vk_pipeline_probe_prewarm(void); // vk_pipeline.c: --probe-prewarm
int vk_pipeline_probe_buildgate(void); // vk_pipeline.c: --probe-buildgate
// main.c crash_handler: a fault while the boot builds pipelines or stage libraries leaves a note, which tells the
// next start that the marker or journal it finds is a crash's and not a stopped start's (vk_pipeline.c pm_skipped).
void vk_pipeline_crash_note(void);
int vk_ffx_probe_cache(void); // vk_ffx.cpp: --probe-ffx-cache
// vk_device.c: the drivers' own shader caches beside the exe (MESA_SHADER_CACHE_DIR, on NVIDIA's Linux driver
// __GL_SHADER_DISK_CACHE_PATH and _SIZE) in the environment, once; before any thread can load a Vulkan driver

View File

@@ -297,6 +297,7 @@ static void crash_handler(const PlatCrash *x) {
mode_rc);
plat_exit(mode_rc);
}
vk_pipeline_crash_note(); // first: the next start tells a crash in the boot's builds from a stopped start by it
rt_log_sync(); // the lines before the crash, then the report, each written as it is made
char d[160];
uintptr_t rip = x->rip;

View File

@@ -1306,6 +1306,12 @@ static int inside(uint64_t a, uint64_t n, RtRange r) { return a >= r.base && n <
static uint32_t map_gen;
uint32_t mem_map_gen(void) { return __atomic_load_n(&map_gen, __ATOMIC_ACQUIRE); }
// The application pool is the title's own plus res_heap_extra_bytes (mem_init), and the game asks for a heap of
// nearly all of it: past HEAP_CAP the request below is refused, so this is the most that may be added.
uint64_t mem_heap_extra_max_kib(void) {
return HEAP_CAP > DEFAULT_POOL ? ((HEAP_CAP - DEFAULT_POOL) & ~0x1fffffull) >> 10 : 0;
}
// ---- 0x01 SetHeapSize
uint32_t mem_set_heap_size(uint64_t size, uint64_t *addr) {
uint64_t t0 = perf_mark_begin(); // NX2NAVI_TRACE=perf: the commit or decommit, the wait for the lock included

View File

@@ -236,17 +236,20 @@ NVN_API(nvnDeviceRegisterFastClearDepth) { ret_x(c, 0); }
NVN_API(nvnDeviceGetImageHandle) { ret_x(c, (uint64_t)(int64_t)(int)arg_x(c, 1)); }
// NVNtextureHandle nvnDeviceGetTextureHandle(const NVNdevice *d, int texture_id, int sampler_id):
// texture id (20 bits) | sampler id << 20, the encoding the replay decodes (NVN_HANDLE_TEX / NVN_HANDLE_SAMP)
// An id out of range (-1: the game had no texture to give, as when its render-target heap is full) gets the handle of
// the last texture slot, which no game registers (its pool has 32,768), so a draw through it samples the stand-in as
// for any slot without a texture, and sampler 0. Ending the game here turned one missing texture into a crash.
// An id out of range (-1: the game had no texture to give, as when its render-target heap is full) gets texture
// slot 0 and sampler slot 0: the first 256 slots of both pools are reserved (nvnDeviceGetInteger 0x11 and 0x12 above)
// and no game registers into them, so slot 0 holds the stand-in. That holds for a draw that binds the handle, where
// handle 0 is "no texture" (vk_exec_draw.c), and for a shader that takes the handle out of a uniform buffer and
// indexes the pool arrays with it: slot 0 is inside their VK_POOL_TEX entries, which a slot past them is not.
// Ending the game here turned one missing texture into a crash.
NVN_API(nvnDeviceGetTextureHandle) {
int tid = (int)arg_x(c, 1), sid = (int)arg_x(c, 2);
if (tid < 0 || tid >= (1 << 20) || sid < 0 || sid >= (1 << 12)) {
static int said;
if (said < 8 && ++said)
rt_log("nvn: texture handle asked for with ids out of range (texture %d, sampler %d): the handle of an "
"empty slot is given, which draws the stand-in", tid, sid);
if (tid < 0 || tid >= (1 << 20)) tid = (1 << 20) - 1;
rt_log("nvn: texture handle asked for with ids out of range (texture %d, sampler %d): the handle of the "
"reserved slot 0 is given, which draws the stand-in", tid, sid);
if (tid < 0 || tid >= (1 << 20)) tid = 0;
if (sid < 0 || sid >= (1 << 12)) sid = 0;
}
ret_x(c, (uint64_t)tid | (uint64_t)sid << 20);

View File

@@ -284,6 +284,7 @@ int res_heapdef_build(const void *in, size_t n, void **out, size_t *out_n) {
}
void res_heapdef_served(void) { R.heapdef_ok = 1; }
int res_heapdef_ok(void) { return R.heapdef_ok; }
// ---- sun shadow map size: each frame the engine sizes its shadow cascades to the area they cover, down to about 400 near
// the ground, which draws foliage shadows blocky, and each change of size moves the shadow texels, so leaf shadows jump.

View File

@@ -483,6 +483,76 @@ static int test_remade(uint8_t *guest) {
return 0;
}
// A pool in the device address table gets its VRAM mirror while a guest submission is recorded, as on a draw's first
// use of it as a buffer (vk_memory.c mirror_create). The table takes the mirror up by a store the GPU runs after the
// mirror's first copy (vk_gpa.c vk_gpa_flip_cmd), so nothing is changed when the mirror is made; read from the table's
// own memory once the submission is done, the pool's page reads the mirror and writes guest memory as well, and the
// mirror holds the pool's bytes.
static void mirror_use_record(VkCommandBuffer cb, void *arg) {
vk_texture_new_submit();
vk_mem_mirror_begin();
vk_mem_use(arg);
vk_mem_mirror_end(cb, vk_sync_issued() + 1);
}
static int test_table_mirror(uint8_t *guest) {
VkCtx *c = vk_ctx();
if (vk_mem_shadow_storage() || !vk_gpa_wanted()) {
printf("probe-vkmem: a new mirror in the device address table: skipped (%s)\n",
vk_mem_shadow_storage() ? "shadow storage, no mirrors" : "no device address table");
return 0;
}
pool_t pool = {.magic = NVN_POOL_MAGIC, .flags = 0x24, .mem = guest + 0xD00000, .size = 0x10000,
.game_mem = guest + 0xD00000};
volatile uint32_t *w = (volatile uint32_t *)(pool.mem + 0x3000);
uint64_t a = (uintptr_t)w, f0 = 0, t0 = 0, f1 = 0, t1 = 0, fm = 0, tm = 0;
*w = 0x600DF00Du;
GCHECK(vk_gpa_on() && vk_pool_init(&pool), "a CPU-visible pool in the device address table");
VkBuffer sb;
VmaAllocation sa;
volatile uint32_t *s = vk_staging(0x1000, &sb, &sa);
VkMemSpan sp;
int bad = 1;
#define TM_CHECK(cond, ...) do { if (!(cond)) { printf("probe-vkmem: FAIL table mirror: "); printf(__VA_ARGS__); printf("\n"); goto done; } } while (0)
TM_CHECK(vk_mem_lookup(a, 4, &sp) && sp.buffer && sp.pool, "the pool has no buffer");
VkBuffer imported = sp.buffer;
TM_CHECK(vk_gpa_probe(a, &f0, &t0) && f0 == t0 && f0 == vk_gpa_device_address(imported) + sp.offset,
"before a mirror the table gives %#llx / %#llx for the pool's page, expected its imported buffer twice",
(unsigned long long)f0, (unsigned long long)t0);
uint64_t fence = vk_sync_submit_own(mirror_use_record, &sp);
// read while the submission may still be in flight: the table as the CPU left it when the mirror was made
int mid = vk_gpa_probe(a, &fm, &tm);
TM_CHECK(vk_sync_fence_wait(fence, 5000000000ull), "fence timed out");
if (sp.buffer == imported) {
printf("probe-vkmem: a new mirror in the device address table: skipped (the pool got no mirror)\n");
bad = 0;
goto done;
}
TM_CHECK(vk_gpa_probe(a, &f1, &t1), "the pool's page left the table");
if (vk_mem_gpa_late()) // else the table changes when the mirror is made, as up to 0.9.2
TM_CHECK(mid && (fm == f0 || fm == f1) && tm == f0, "while the submission ran the table gave %#llx / %#llx: neither "
"the state before the store (%#llx twice) nor after it", (unsigned long long)fm, (unsigned long long)tm,
(unsigned long long)f0);
TM_CHECK(f1 == vk_gpa_device_address(sp.buffer) + sp.offset, "after the submission the page reads %#llx, expected the "
"mirror's %#llx", (unsigned long long)f1, (unsigned long long)(vk_gpa_device_address(sp.buffer) + sp.offset));
TM_CHECK(t1 == f0, "after the submission the page's twin is %#llx, expected the imported buffer's %#llx",
(unsigned long long)t1, (unsigned long long)f0);
copy_wait(sp.buffer, sp.offset, sb, 0, 4);
vmaInvalidateAllocation(c->vma, sa, 0, VK_WHOLE_SIZE);
TM_CHECK(s[0] == 0x600DF00Du, "the mirror holds %#010x, expected the pool's 0x600df00d", s[0]);
g_gpu_checks += 4;
printf("probe-vkmem: a pool that gets its mirror in a recorded submission: the device address table names the mirror "
"after it, with guest memory as the twin (%s)\n",
vk_mem_gpa_late() ? "by a store in queue order, after the mirror's first copy" : "changed at once, NX2NAVI_GPA_LATE=0");
bad = 0;
done:
vk_sync_finish();
vmaDestroyBuffer(c->vma, sb, sa);
vk_pool_fini(&pool);
#undef TM_CHECK
return bad;
}
// test_table_sync, test_table_store: a guest submission of one part that records nothing. bound: its record binds the
// device address table, as the replay of a draw whose shader reads through the table does (vk_exec_draw.c ssbo_info),
// so its prologue brings every shadow of the table up to date (vk_memory.c vk_mem_shadow_sync).
@@ -1366,7 +1436,7 @@ static int test_gpu(void) {
vk_mem_stats(&st);
GCHECK(!st.imported_pools && !st.physical_pools && !st.virtual_pools, "pools left after fini");
g_gpu_checks += 2;
return test_table_sync(h) || test_table_store(h) || test_remade(h);
return test_table_sync(h) || test_table_store(h) || test_remade(h) || test_table_mirror(h);
}
int probe_vkmem(void) {

View File

@@ -130,8 +130,9 @@ static const char *const text_en[UI_TEXT_COUNT] = {
"driver does not run out. Off: no limit.",
[UI_MENU_LOWEND_UPLOAD_BATCH] = "Upload batch limit",
[UI_MENU_LOWEND_UPLOAD_BATCH_DESC] = "Texture uploads waiting in staging memory are sent to the GPU early once they "
"hold this much, so an area load cannot run video memory out.",
[UI_MENU_LOWEND_NO_LIMIT] = "No limit",
"hold this much, so an area load cannot run video memory out. Every batch is "
"sent at 64 MB at the latest, so none of these choices changes anything now.",
[UI_MENU_LOWEND_NO_LIMIT] = "64 MB",
[UI_MENU_LOWEND_ASTC_KEEP] = "Keep the ASTC decode buffer",
[UI_MENU_LOWEND_ASTC_KEEP_DESC] = "The buffer that GPU-decodes compressed textures is kept between upload batches "
"instead of being allocated again for each one.",

View File

@@ -192,7 +192,8 @@ void vk_pass_marks_format(const char *source, uint32_t started, uint32_t finishe
void vk_pass_marks_report(void); // vk_device.c device_fault_report: the AMD words and the NVIDIA checkpoints, formatted
// Draw marks (vk_crumbs.c, NX2NAVI_DRAW_CRUMBS=1 with VK_AMD_buffer_marker; off by default): a mark where the shaders
// or the pipeline state change inside pass m, before the draw with index draw in that pass, so a lost device's report
// names the shaders of the draws the GPU had not finished. Replay thread only; nothing while vk_draw_marks_on is 0.
// names the shaders of the draws the GPU had not finished. From any thread that records draws (the replay and its
// workers): the mark takes its number atomically. Nothing while vk_draw_marks_on is 0.
extern int vk_draw_marks_on;
void vk_draw_mark(VkCommandBuffer cb, const VkPassMark *m, const GfxShader *vs, const GfxShader *fs, uint32_t draw);
@@ -381,6 +382,7 @@ void vk_mvprev_frame(void); // each present, beside vk_dlaa_frame
void vk_mem_mirror_begin(void);
int vk_mem_mirror_end(VkCommandBuffer cb, uint64_t fence);
int vk_mem_mirror_pending(void);
int vk_mem_gpa_late(void); // --probe-vkmem: NX2NAVI_GPA_LATE, the table takes a new mirror up in queue order
void vk_mem_mirror_prologue(VkCommandBuffer cb);
// Staged mirror uploads (vk_memory.c): the GPU of the submission being recorded reads guest memory itself (noted by
// vk_mem_note_live); vk_mem_take_live returns that and starts the next submission's note.

View File

@@ -149,16 +149,21 @@ static void pass_marks_init(VkCtx *c) {
// which every draw had finished: the draw that hung was recorded after it, with its shaders or those of one of the few
// marks up to the one in word 4. It costs two marker writes per change, a few thousand a frame, so it is for the
// player who can reproduce a loss, not for everyone.
// The marks are numbered as they are recorded, by the replay thread and by its workers when a pass's chunks are
// recorded side by side (vk_exec.c): the number is taken atomically and each number has its own slot of the ring, so
// no two threads write one. The two marks the GPU names are exact either way. The numbers between them are in queue
// order only where one thread recorded the pass; with workers some of them belong to chunks that ran earlier, which
// the report says.
#define VK_DRAW_MARKS 8192 // power of two
typedef struct { uint32_t id, pass, draw; const GfxShader *vs, *fs; } DrawMark;
static DrawMark dring[VK_DRAW_MARKS];
static uint32_t dseq; // draw marks made; only the replay thread writes it
static volatile uint32_t dseq; // draw marks made; any recording thread takes the next number
int vk_draw_marks_on;
void vk_draw_mark(VkCommandBuffer cb, const VkPassMark *m, const GfxShader *vs, const GfxShader *fs, uint32_t draw) {
if (!vk_draw_marks_on || !cb) return;
uint32_t id = ++dseq;
if (!id) id = ++dseq; // 0 means no mark
uint32_t id = __atomic_add_fetch(&dseq, 1, __ATOMIC_RELAXED);
if (!id) id = __atomic_add_fetch(&dseq, 1, __ATOMIC_RELAXED); // 0 means no mark
dring[id & (VK_DRAW_MARKS - 1)] = (DrawMark){id, m ? m->id : 0, draw, vs, fs};
rec_pass_mark(cb, id, 2);
}
@@ -793,7 +798,9 @@ static void draw_marks_report(void) {
uint32_t reached = words[4], finished = words[5];
char t[256];
rt_log("vk: draw marks (NX2NAVI_DRAW_CRUMBS, %u made): the GPU last reached draw mark %u, and every draw before draw "
"mark %u had finished; the draws it had not finished follow these marks:", (unsigned)dseq, (unsigned)reached,
"mark %u had finished; the draws it had not finished follow these marks. The marks are numbered as they were "
"recorded: with replay workers on, the numbers between the two are not all later in the queue, and only the "
"two marks named here are certain:", (unsigned)__atomic_load_n(&dseq, __ATOMIC_RELAXED), (unsigned)reached,
(unsigned)finished);
uint32_t n = reached >= finished ? reached - finished + 1 : 1;
if (n > DRAW_MARK_LINES) n = DRAW_MARK_LINES;
@@ -803,6 +810,10 @@ static void draw_marks_report(void) {
}
if (reached >= finished && reached - finished + 1 > n)
rt_log("vk: and %u more up to draw mark %u", (unsigned)(reached - finished + 1 - n), (unsigned)reached);
if (reached < finished || reached - finished + 1 > n) { // the mark the GPU last reached, when the list left it out
describe_draw_mark(reached, t, sizeof t);
rt_log("vk: draw mark %u, the last the GPU reached: %s", (unsigned)reached, t);
}
}
void vk_pass_marks_report(void) {

View File

@@ -19,8 +19,11 @@
// writes (vk_exec_draw.c ssbo_info), so with the mirror alone the CPU never saw them, and a sync of a page the CPU wrote
// copied the stale guest page over them. The game's compute passes write tree and foliage records this way, and a
// record overwritten so drew a tree stretched into a column reaching the sky (Hyrule Field, Kakariko, Death Mountain).
// A record a page entry names is never written: a new mapping takes a new record, and a record goes back to the free
// list only once the GPU finished every submission issued while a page could still name it (vk_completion_add). Page
// A record a page entry names is never written by the CPU: a new mapping takes a new record, and a record goes back
// to the free list only once the GPU finished every submission issued while a page could still name it
// (vk_completion_add). The one write to a record in use is the GPU's own, in queue order, when a pool's new mirror
// takes its record over (vk_gpa_flip_cmd): what was queued before it reads the old addresses, what comes after it
// the new ones. Page
// and L1 entries are single 32-bit stores, so a shader that reads the table while it changes sees the old mapping or
// the new one, never half of each. The CPU keeps a copy (shadow) for its reads: the GPU copy is often device memory
// behind the PCIe BAR, slow to read back.
@@ -110,7 +113,8 @@ static int create(void) {
G.free_recs = malloc(RECS * sizeof *G.free_recs);
if (!G.cpu || !G.free_recs) return 0;
VkBufferCreateInfo bi = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .size = (VkDeviceSize)WORDS * 4,
.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, .sharingMode = VK_SHARING_MODE_EXCLUSIVE};
.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, // vk_gpa_flip_cmd
.sharingMode = VK_SHARING_MODE_EXCLUSIVE};
VmaAllocationCreateInfo ai = {.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT,
.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE};
VmaAllocationInfo info;
@@ -352,23 +356,39 @@ static uint32_t remap(uint64_t lo, uint64_t hi, uint32_t old_rec, VkBuffer buf,
// the twin: the buffer the pages named before (the pool's imported buffer), so writes reach guest memory too.
uint64_t twin = old_rec && twins_on() && keep_twin ? rec_first(old_rec) : dev - buf_lo;
uint32_t r = dev ? rec_alloc(dev - buf_lo, twin) : 0;
if (!r) { plat_mutex_unlock(&gpa_lock); return old_rec; }
if (!r) { // no record left: the pages keep the old one, and the caller its number
static int said;
plat_mutex_unlock(&gpa_lock);
if (!said++)
rt_log("vk_gpa: WARNING: no record left for a buffer that takes over %llu pages (%u records in all): they "
"keep naming the buffer they named", (unsigned long long)(p1 > p0 ? p1 - p0 : 0), RECS - 1);
return old_rec;
}
pages_move(p0, p1, old_rec, r);
plat_mutex_unlock(&gpa_lock);
if (old_rec) vk_completion_add(vk_sync_issued() + 1, rec_free_cb, (void *)(uintptr_t)old_rec);
return r;
}
uint32_t vk_gpa_remap_writes(uint64_t lo, uint64_t hi, uint32_t old_rec, VkBuffer buf, uint64_t buf_lo) {
if (!old_rec || !buf || !vk_gpa_on() || !twins_on()) return 0;
// Records into cb the store that hands record rec over to buf, a pool's new VRAM mirror: from that point of the queue
// on the pages that name rec read buf, and their twin is the buffer they read until then (keep_twin, with twins on) or
// buf again. A change of the table made on the CPU is seen at once by every shader still running, the ones queued
// before the mirror's first copy included, which would then read or write the mirror before anything had filled it;
// this store runs where the command stands, after that copy (vk_memory.c vk_mem_mirror_prologue). The caller puts
// barriers around it. No new record is taken, so there is none to run out of. The shadow takes the new words now:
// the CPU never reads a record's addresses back for a record handed over this way. 0 when nothing was recorded.
int vk_gpa_flip_cmd(VkCommandBuffer cb, uint32_t rec, VkBuffer buf, uint64_t buf_lo, int keep_twin) {
if (!rec || !buf || !vk_gpa_on()) return 0;
uint64_t dev = vk_gpa_device_address(buf);
uint64_t p0 = (lo + 4095) >> PAGE_SHIFT, p1 = hi >> PAGE_SHIFT;
if (!dev) return 0;
uint32_t at = REC_WORD + rec * REC_WORDS, w[REC_WORDS];
plat_mutex_lock(&gpa_lock);
uint32_t r = dev ? rec_alloc(rec_first(old_rec), dev - buf_lo) : 0;
if (r) pages_move(p0, p1, old_rec, r);
uint64_t first = dev - buf_lo, twin = keep_twin && twins_on() ? rec_first(rec) : first;
w[0] = (uint32_t)first, w[1] = (uint32_t)(first >> 32), w[2] = (uint32_t)twin, w[3] = (uint32_t)(twin >> 32);
memcpy(G.cpu + at, w, sizeof w);
plat_mutex_unlock(&gpa_lock);
if (r) vk_completion_add(vk_sync_issued() + 1, rec_free_cb, (void *)(uintptr_t)old_rec);
return r;
vkCmdUpdateBuffer(cb, G.buf, (VkDeviceSize)at * 4, sizeof w, w);
return 1;
}
uint32_t vk_gpa_remap(uint64_t lo, uint64_t hi, uint32_t old_rec, VkBuffer buf, uint64_t buf_lo) {
@@ -379,6 +399,21 @@ uint32_t vk_gpa_remap_plain(uint64_t lo, uint64_t hi, uint32_t old_rec, VkBuffer
return remap(lo, hi, old_rec, buf, buf_lo, 0);
}
// --probe-vkmem: what the table's own memory, as the GPU has it, resolves addr to: the device address a shader reads
// there and the one it writes as well. 0 when no page maps addr. Slow (the table may be device memory), and only
// meaningful with no submission in flight.
int vk_gpa_probe(uint64_t addr, uint64_t *first, uint64_t *twin) {
if (G.state <= 0 || addr >> 40) return 0;
vmaInvalidateAllocation(vk_ctx()->vma, G.alloc, 0, VK_WHOLE_SIZE);
uint32_t blk = G.gpu[L1_WORD + (addr >> 24)];
uint32_t rec = blk ? G.gpu[L2_WORD + blk * L2_N + ((addr >> PAGE_SHIFT) & (L2_N - 1))] : 0;
if (!rec) return 0;
const volatile uint32_t *r = G.gpu + REC_WORD + rec * REC_WORDS;
*first = ((uint64_t)r[0] | (uint64_t)r[1] << 32) + addr;
*twin = ((uint64_t)r[2] | (uint64_t)r[3] << 32) + addr;
return 1;
}
void vk_gpa_report(void) {
if (G.state <= 0) return;
plat_mutex_lock(&gpa_lock);

View File

@@ -24,9 +24,12 @@ uint32_t vk_gpa_remap(uint64_t lo, uint64_t hi, uint32_t old_rec, VkBuffer buf,
// The same without the twin: the pages name buf alone (a pool whose VRAM mirror is evicted goes back to its imported
// buffer).
uint32_t vk_gpa_remap_plain(uint64_t lo, uint64_t hi, uint32_t old_rec, VkBuffer buf, uint64_t buf_lo);
// The pages of [lo, hi) that name old_rec keep reading old_rec's buffer and get buf as their twin: shaders read the
// pool where they did and write buf too (a VRAM mirror until its first copy has run, vk_memory.c mirror_create).
// Returns the new record, or 0 when there is none to give or twins are off (old_rec then stays as it is).
uint32_t vk_gpa_remap_writes(uint64_t lo, uint64_t hi, uint32_t old_rec, VkBuffer buf, uint64_t buf_lo);
// Records into cb the store that hands record rec over to buf (a pool's new VRAM mirror) in queue order: what is
// queued after it reads buf through rec's pages, with the buffer they read before as the twin (keep_twin) or buf
// again; what was queued before it sees no change. 0 when nothing was recorded (no record, no table).
int vk_gpa_flip_cmd(VkCommandBuffer cb, uint32_t rec, VkBuffer buf, uint64_t buf_lo, int keep_twin);
// --probe-vkmem: the device addresses the table, read from its own memory, gives a shader for addr: the one it
// reads and the one it writes as well. 0 when no page maps addr.
int vk_gpa_probe(uint64_t addr, uint64_t *first, uint64_t *twin);
void vk_gpa_report(void);
void vk_gpa_shutdown(void);

View File

@@ -61,8 +61,8 @@ typedef struct PoolRec {
// VRAM mirror (POOL_IMPORT, "VRAM mirror" below). mstate and mbuf change on the replay thread only.
uint8_t mstate; // MS_NONE until the first buffer use, then MS_ON or MS_REFUSED
uint32_t gpa_rec; // POOL_IMPORT: its record in the device address table (vk_gpa.c), 0 none
uint64_t gpa_at; // pool_lock: the submission after which the table reads the mirror (gpa_switch);
// 0 when it does already, or there is no mirror
uint8_t gpa_flip; // as pend: the next prologue records the store that hands its table record to
// the mirror (gpa_flip_cmds); 0 when the table names the mirror, or none exists
struct GpaMap { uint64_t lo, hi; uint32_t rec; } *vmaps; // POOL_VIRT: its mapped ranges in the table
int nvmaps, cvmaps;
VkBuffer mbuf; // MS_ON: device-local copy of [import_lo, import_hi), same offsets as buf
@@ -2758,50 +2758,58 @@ static int twin_wanted(const PoolRec *r) {
return !twin_max || (int64_t)(r->import_hi - r->import_lo) <= twin_max;
}
// ---- when the device address table starts reading a new mirror (NX2NAVI_GPA_LATE, default 1; 0 = at once, as before)
// A mirror is made while the replay records a submission, and its first copy of the pool is in that submission's
// prologue. The table is memory the shaders read as they run, so with its pages moved to the mirror at once, every
// part already handed to the queue (the submissions before, and the earlier parts of this one) read the mirror through
// the table before that copy had run: memory nothing had written yet, and on a card over its budget a block the
// driver had not made resident for those parts. A GTX 1650 4 GB lost its device that way at area loads in every
// session: six reports of a GPU read fault at byte 0 of a mirror made in the faulting submission, each the first byte
// of a new 2 MiB-aligned block, with mirrors being made over the budget; with the table kept empty the same routes ran
// without a loss.
// Now the pages keep reading the imported buffer and name the mirror as their twin (vk_gpa_remap_writes): what shaders
// write through the table goes to both, so the mirror misses nothing, and what they read is guest memory, as before
// the mirror existed. Once the GPU has finished the submission whose prologue holds the copy, the pages move to the
// mirror with the imported buffer as the twin (gpa_switch, at the start of a later submission). In between, a shader
// that reads through the table what another wrote through a buffer binding sees guest memory, which gets such a write
// at the write-back; data written through the table itself, as the game's foliage, instance and light records are,
// is read where it was written.
static int n_gpa_wait; // pool_lock: mirrors whose pages still read the imported buffer (PoolRec.gpa_at)
static uint64_t n_gpa_late; // replay: pages moved to their mirror after its first copy, so far
// ---- when the device address table takes up a new mirror (NX2NAVI_GPA_LATE, default 1; 0 = at once, as before)
// A mirror is made while the replay records a part of a submission, and its first copy of the pool is in that part's
// prologue. The table is memory the shaders read as they run, so a change of it made here, at record time, reaches
// every part already handed to the queue (the submissions before, and the earlier parts of this one), which run
// before that copy: they read the mirror through the table, memory nothing had written yet, and wrote into it, and on
// a card over its budget the block was one the driver had not made resident for them. A GTX 1650 4 GB lost its device
// that way at area loads in every session: six reports of a GPU read fault at byte 0 of a mirror made in the faulting
// submission, each the first byte of a new 2 MiB-aligned block, with mirrors being made over the budget; with the
// table kept empty the same routes ran without a loss.
// So the table is not touched here. The prologue that holds the mirror's first copy also holds, right after it, a
// store into the pool's record (vk_gpa_flip_cmd): the GPU runs it in its place in the queue, so the parts before it
// read and write guest memory through the table as if no mirror existed, and the parts from this one on read the
// mirror and write both. What the earlier parts wrote through the table is in guest memory when the first copy reads
// it there (a twinned pool's first copy is always the GPU's own copy from the imported buffer, mirror_capture), so
// the mirror misses none of it, and no shader reads through the table a state older than the one its place in the
// queue gives it.
static int n_gpa_flip; // as pend: mirrors whose record the next prologue hands over (PoolRec.gpa_flip)
static uint64_t n_gpa_late; // replay: records handed to their mirror in queue order, so far
static int gpa_late(void);
int vk_mem_gpa_late(void) { return gpa_late(); } // --probe-vkmem
static int gpa_late(void) {
static int on = -1;
if (on < 0) {
on = rt_knob("GPA_LATE", "1") == 1;
rt_log("mem: the device address table reads a new VRAM mirror %s (NX2NAVI_GPA_LATE)",
on ? "once the mirror's first copy has run" : "at once, as before");
rt_log("mem: the device address table takes up a new VRAM mirror %s (NX2NAVI_GPA_LATE)",
on ? "in queue order, after the mirror's first copy" : "at once, as before");
}
return on;
}
// Replay thread, at the start of a submission: the mirrors whose first copy the GPU has finished take the table's reads.
static void gpa_switch(void) {
if (!__atomic_load_n(&n_gpa_wait, __ATOMIC_RELAXED)) return;
uint64_t done = vk_sync_fence_done();
static void mbarrier(VkCommandBuffer cb, VkPipelineStageFlags2 ss, VkAccessFlags2 sa, VkPipelineStageFlags2 ds,
VkAccessFlags2 da);
// Prologue, after the copies into the mirrors: the stores that hand the new mirrors' records over. Everything queued
// before is done with the table before the stores run, and everything after sees them.
static void gpa_flip_cmds(VkCommandBuffer cb) {
if (!n_gpa_flip) return;
mbarrier(cb, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT,
VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT);
plat_mutex_lock(&pool_lock);
for (int i = 0; i < nm && n_gpa_wait; i++) {
for (int i = 0; i < nm && n_gpa_flip; i++) {
PoolRec *r = mlist[i];
if (!r->gpa_at || done < r->gpa_at) continue;
r->gpa_at = 0, n_gpa_wait--;
if (!r->gpa_rec || !r->mbuf) continue;
r->gpa_rec = r->twin ? vk_gpa_remap(r->import_lo, r->import_hi, r->gpa_rec, r->mbuf, r->import_lo)
: vk_gpa_remap_plain(r->import_lo, r->import_hi, r->gpa_rec, r->mbuf, r->import_lo);
n_gpa_late++;
if (!r->gpa_flip) continue;
r->gpa_flip = 0, n_gpa_flip--;
if (r->gpa_rec && r->mbuf && vk_gpa_flip_cmd(cb, r->gpa_rec, r->mbuf, r->import_lo, r->twin)) n_gpa_late++;
}
n_gpa_flip = 0;
plat_mutex_unlock(&pool_lock);
mbarrier(cb, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT,
VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT);
}
// Replay thread: the pool's mirror on its first buffer use.
@@ -2897,25 +2905,19 @@ static void mirror_create(PoolRec *r) {
r->mstate = MS_ON;
r->asked_room = 0;
// The device address table names the mirror: the GPU's writes go there, and the sync copies the CPU's. With a
// twin they also go to the imported buffer; without one (twin_wanted) the record names the mirror twice. Reads
// move to the mirror once its first copy has run (gpa_late, below).
// twin they also go to the imported buffer; without one (twin_wanted) the record names the mirror twice. The
// table takes the mirror up in queue order, after its first copy (gpa_late, above).
r->twin = (uint8_t)twin_wanted(r);
if (!r->twin) {
plat_inc64(&m_untwinned_n);
plat_add64(&m_untwinned_bytes, (int64_t)n);
}
if (r->gpa_rec) {
if (r->gpa_rec && gpa_late()) {
r->gpa_flip = 1, n_gpa_flip++; // vk_mem_mirror_prologue, with the copy range_add queues below
} else if (r->gpa_rec) {
plat_mutex_lock(&pool_lock);
uint32_t late = gpa_late() ? vk_gpa_remap_writes(r->import_lo, r->import_hi, r->gpa_rec, r->mbuf, r->import_lo) : 0;
if (late) {
uint64_t f = vk_exec_recording_fence();
r->gpa_rec = late;
r->gpa_at = f ? f : vk_sync_issued() + 1; // the submission being recorded: its prologue holds the copy
n_gpa_wait++;
} else {
r->gpa_rec = r->twin ? vk_gpa_remap(r->import_lo, r->import_hi, r->gpa_rec, r->mbuf, r->import_lo)
: vk_gpa_remap_plain(r->import_lo, r->import_hi, r->gpa_rec, r->mbuf, r->import_lo);
}
r->gpa_rec = r->twin ? vk_gpa_remap(r->import_lo, r->import_hi, r->gpa_rec, r->mbuf, r->import_lo)
: vk_gpa_remap_plain(r->import_lo, r->import_hi, r->gpa_rec, r->mbuf, r->import_lo);
plat_mutex_unlock(&pool_lock);
}
range_add(&pend, &npend, &cpend, r, 0, n);
@@ -2926,7 +2928,7 @@ static void mirror_create(PoolRec *r) {
static void mirror_forget(PoolRec *r) {
__atomic_add_fetch(&mirror_gen, 1, __ATOMIC_RELEASE);
if (r->gpa_at) r->gpa_at = 0, n_gpa_wait--; // the caller takes the table's pages off the mirror
if (r->gpa_flip) r->gpa_flip = 0, n_gpa_flip--; // gone before its first copy: its record stays as it is
for (int i = 0; i < nm; i++)
if (mlist[i] == r) {
memmove(mlist + i, mlist + i + 1, (size_t)(nm - i - 1) * sizeof *mlist);
@@ -3993,7 +3995,7 @@ static void hot_check(void) {
}
void vk_mem_mirror_begin(void) {
if (vk_mirror_on) gpa_switch(), hot_check();
if (vk_mirror_on) hot_check();
if (!vk_mirror_on) { // import mode: the texture checks' snapshots still skip frozen regions
if (!freeze_idle) return;
plat_mutex_lock(&gen_lock);
@@ -4039,7 +4041,7 @@ void vk_mem_mirror_begin(void) {
slow_mem_call("mirror begin (its queries and freezes)", 0, ww_bytes - b0, q, qpc() - t0);
}
int vk_mem_mirror_pending(void) { return npend || snl_copied < nsnl; }
int vk_mem_mirror_pending(void) { return npend || snl_copied < nsnl || n_gpa_flip; }
// NX2NAVI_MIRROR_CAPTURE_KB: the pages the CPU wrote since a VRAM mirror's last sync are copied out of guest memory by
// the CPU when the part that needs them is handed to the queue, up to this many KiB a part, into a host buffer the
@@ -4163,7 +4165,7 @@ static void mirror_capture(VkCommandBuffer cb) {
}
void vk_mem_mirror_prologue(VkCommandBuffer cb) {
if (!npend && snl_copied == nsnl) return;
if (!npend && snl_copied == nsnl && !n_gpa_flip) return;
mbarrier(cb, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_ACCESS_2_MEMORY_WRITE_BIT, VK_PIPELINE_STAGE_2_COPY_BIT,
VK_ACCESS_2_TRANSFER_READ_BIT | VK_ACCESS_2_TRANSFER_WRITE_BIT);
mirror_capture(cb);
@@ -4176,6 +4178,7 @@ void vk_mem_mirror_prologue(VkCommandBuffer cb) {
}
mbarrier(cb, VK_PIPELINE_STAGE_2_COPY_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT);
gpa_flip_cmds(cb); // after the new mirrors' first copies
npend = 0;
mrep.prologues++;
}
@@ -4448,10 +4451,9 @@ static void mirror_log(uint64_t frame) {
"%.2f, %.3f MiB, from %.1f flushes of %.3f MiB; flushed and not copied (write-watched) %.3f MiB%s",
(unsigned long long)frame, a.page_bytes / f / M, a.flush_n / f,
a.flush_bytes / f / M, a.flush_calls / f, a.flush_sum / f / M, a.flush_skipped / f / M, capl);
if (n_gpa_late || __atomic_load_n(&n_gpa_wait, __ATOMIC_RELAXED))
rt_log("mem: mirror frame %llu: the device address table took up %llu mirrors after their first copy so far, %d "
"wait for theirs (NX2NAVI_GPA_LATE)", (unsigned long long)frame, (unsigned long long)n_gpa_late,
__atomic_load_n(&n_gpa_wait, __ATOMIC_RELAXED));
if (n_gpa_late)
rt_log("mem: mirror frame %llu: the device address table took up %llu mirrors in queue order, after their first "
"copy, so far (NX2NAVI_GPA_LATE)", (unsigned long long)frame, (unsigned long long)n_gpa_late);
}
// After vram_log: every heap's usage as the driver reports it (VK_EXT_memory_budget) beside VMA's share of it, VMA by
@@ -5095,7 +5097,8 @@ VkCommandBuffer vk_upload_begin(void) {
// NX2NAVI_UPLOAD_BATCH_MB (256 with low_end_gpu = 1; 0, the default, = no limit of its own): once the open batch's
// staging buffers hold that much, the outermost vk_upload_end submits it. It does so too once the batch's staging
// reaches STG_FLUSH, so that an area load's staging stays inside the staging pool's blocks (the staging pool's
// comment). A save load made thousands of textures between two replay submissions, and every one of them went into
// comment): 0 therefore means STG_FLUSH (64 MiB), not "never", and a value above STG_FLUSH changes nothing, the
// low-end mode's 256 and the settings menu's 128 to 1024 included. A save load made thousands of textures between two replay submissions, and every one of them went into
// one batch: about 1.5 GB of raw ASTC blocks plus the decoder's work in a single submission,
// which AMD's 23.10 driver on an RX 580 refused with VK_ERROR_OUT_OF_DEVICE_MEMORY. Submitted early, a batch still
// precedes the replay submission that uses its textures (the queue keeps order), and its staging is freed as it retires.
@@ -5166,19 +5169,27 @@ void vk_mem_oom_report(const char *what, VkResult r) {
// which it waits for in order (a wait covers all the queue's work submitted ahead of that batch, tens of ms on a heavy
// frame, with cmd_lock held). Only when none of that makes room (the open batch's own staging, staging buffers their
// callers hold, the blocks' fragmentation) does the pool grow by a block, and the log says so.
// A discrete GPU keeps STG_MIN_BLOCKS blocks; an integrated one, whose host memory is the machine's RAM and where low
// memory ended the game before (vk_mem_give_back), keeps STG_MIN_BLOCKS_UMA, and its loads wait for batches sooner.
// A discrete GPU keeps STG_MIN_BLOCKS blocks, 256 MiB of host memory for the whole run (128 MiB up to 0.9.2); an
// integrated one, whose host memory is the machine's RAM and where low memory ended the game before
// (vk_mem_give_back), keeps STG_MIN_BLOCKS_UMA, 128 MiB, and its loads wait for batches sooner.
#define STG_BLOCK (64ull << 20)
#define STG_MIN_BLOCKS 4
#define STG_MIN_BLOCKS_UMA 2
static VmaPool stg_pool;
static int stg_pool_tried;
static uint64_t stg_room_cache, stg_room_wait, stg_room_new; // cmd_lock: how stg_create found room (rt_log below)
static uint64_t stg_wait_ticks, stg_wait_max; // cmd_lock: qpc ticks stg_create waited for batches
// vmaCreateBuffer of a staging buffer (*ai names stg_pool) inside the pool's blocks: when they are full, the kept
// staging buffers and the arena's idle chunks go, then the oldest batch in flight is waited for and retired, until the
// buffer fits. chunk: the buffer is an arena chunk, and VK_INCOMPLETE says that a retired batch gave chunks back to
// arena_free, to take one of those instead. Without a batch to wait for (or once the device is lost) the pool grows.
// The wait runs with cmd_lock held, and cannot leave it: the caller is inside vk_upload_begin .. vk_upload_end with
// the open batch's command buffer in hand, and the staging buffer it asks for belongs to that batch, so letting go of
// the lock would let another thread submit the batch under it. Meanwhile a replay submission that wants to send its
// uploads (vk_upload_flush) waits for the lock; its own commands would queue behind the same batches, so what it
// loses is recording time, not GPU time. How long that is on a load is not measured anywhere yet: the waits are
// timed here and logged (the first four, then at every doubling of their count), so a played session's log says.
static VkResult stg_create(VkCtx *c, const VkBufferCreateInfo *bi, const VmaAllocationCreateInfo *ai, VkBuffer *b,
VmaAllocation *a, VmaAllocationInfo *info, int chunk) {
VmaAllocationCreateInfo in = *ai;
@@ -5196,13 +5207,23 @@ static VkResult stg_create(VkCtx *c, const VkBufferCreateInfo *bi, const VmaAllo
}
if (ninflight && !vk_device_is_lost()) {
int before = ninflight;
uint64_t w0 = qpc();
VkResult w = vkWaitForFences(c->device, 1, &inflight[0].fence, VK_TRUE, UINT64_MAX);
if (w != VK_SUCCESS) {
vk_device_lost_check(w, "the wait for an upload batch");
rt_fatal("vk: the wait for an upload failed (%d)", (int)w);
}
uint64_t took = qpc() - w0;
stg_wait_ticks += took;
if (took > stg_wait_max) stg_wait_max = took;
retire(c, 0);
stg_room_wait++;
if (stg_room_wait <= 4 || !(stg_room_wait & (stg_room_wait - 1)))
rt_log("vk: a staging buffer of %.1f MiB waited %.1f ms for an upload batch to finish, with the upload "
"lock held (%llu such waits so far, %.0f ms in all, the longest %.1f ms; %d batches still in "
"flight). A replay submission that sends its uploads waits for that lock",
bi->size / 1048576.0, qpc_ms(took), (unsigned long long)stg_room_wait, qpc_ms(stg_wait_ticks),
qpc_ms(stg_wait_max), ninflight);
if (chunk && narena_free) {
r = VK_INCOMPLETE;
break;
@@ -5562,7 +5583,7 @@ void vk_mem_shutdown(void) {
plat_mutex_lock(&pool_lock);
for (int i = 0; i < pool_index.n; i++) destroy_rec(c, pool_index.e[i].buf);
pool_index.n = 0;
nm = npend = nwbl = nsnl = snl_copied = nswl = 0; // mirrors went with their pools
nm = npend = nwbl = nsnl = snl_copied = nswl = n_gpa_flip = 0; // mirrors went with their pools
swl_marks = -1;
plat_mutex_lock(&snap_pool_lock);
for (int i = 0; i < nsnap_pool; i++) vmaDestroyBuffer(c->vma, snap_pool[i].buf, snap_pool[i].alloc);

View File

@@ -5526,6 +5526,7 @@ static struct {
int on; // this start waits for all of it
int lw; // lb_start left the library warm's start to bf_wait
volatile int32_t game; // the wait is over: the warm ended, or the boot let the game start beside it
double t_end; // now_ms() at which the whole warm's time on the boot screen is up; 0 no limit
char owed[PLAT_PATH_MAX * 2 + 48]; // boot-warm-owed.txt
} BF;
@@ -5849,9 +5850,11 @@ static void prewarm_run(void) {
// (bf_decide) waits for all of them, with its count on the boot screen, as a start without the library does.
int all = (full && !strcmp(full, "1")) || (BF.on && queued);
if (P.gpl && all && BF.on && !(full && !strcmp(full, "1")))
rt_log("vk_pipeline: prewarm: the start waits for all %u recorded pipelines and not %d s (the whole warm after a "
"driver change)", queued, (int)(PREWARM_PIPE_MS / 1000));
rt_log("vk_pipeline: prewarm: the start waits for the %u recorded pipelines as long as the whole warm after a "
"driver change may take, and not %d s", queued, (int)(PREWARM_PIPE_MS / 1000));
K.until = P.gpl && !all ? now_ms() + PREWARM_PIPE_MS : 0; // before the builders start
// the whole warm's own limit: what it leaves goes to the pool's workers, as after PREWARM_PIPE_MS
if (P.gpl && BF.on && BF.t_end && !(full && !strcmp(full, "1"))) K.until = BF.t_end;
PlatThread *t[64];
int nt = 0;
if (queued) warm_builder((void *)1); // the first alone (warm_builder)
@@ -5905,29 +5908,81 @@ static void prewarm_run(void) {
// each one is built at its first draw instead, as with NX2NAVI_PIPE_PREBUILD=0. Another driver version, or deleting
// the file, brings the prebuild back. Only the boot's own share is covered: a crash during play, where the pool also
// builds what the boot left, says nothing about these builds. An orderly end of the process during the boot (the
// window closed, the guest's ExitProcess, a --seconds run) deletes the marker as well: only a process that died leaves it.
// window closed, the guest's ExitProcess, a --seconds run) deletes the marker as well.
// A marker left over is not yet a driver crash: a start stopped from outside (the task manager, a program that ends
// the game, the power) leaves one too, and since the whole warm (bf_decide) the boot builds for minutes. So the crash
// handler says which it was (vk_pipeline_crash_note: <dir>/boot-build-crash.txt, written while the boot's builds
// run): with that file the next start skips the prebuild as before; without it the end is taken for a stopped start
// and only counted, in the marker itself. BOOT_QUIET_ENDS such ends in a row skip the prebuild after all: a driver
// that takes the process down without a fault our handler sees would otherwise end every start (boot_warm.h
// boot_end_decide).
static int cache_dir(char *dir, size_t n);
static void gpu_key(char *out, size_t n);
static char PM_run[PLAT_PATH_MAX * 2 + 48];
static char PM_run[PLAT_PATH_MAX * 2 + 48], PM_crash[PLAT_PATH_MAX * 2 + 48];
static volatile int32_t pm_on;
static volatile int32_t jr_boot_on; // the boot's journal of library builds is open (journal_open)
static int pm_quiet; // starts in a row before this one that ended in the boot's builds without a crash report
static void crash_path_init(const char *dir) {
if (!PM_crash[0]) snprintf(PM_crash, sizeof PM_crash, "%s/boot-build-crash.txt", dir);
}
// main.c crash_handler, before its report: a fault while the boot's pipeline builds or its journalled library builds
// run. The file is all the next start needs; nothing here allocates.
void vk_pipeline_crash_note(void) {
static const char text[] = "the process faulted while the boot built pipelines or stage libraries "
"(runtime/vk_pipeline.c vk_pipeline_crash_note)\n";
if (!PM_crash[0] || (!__atomic_load_n(&pm_on, __ATOMIC_ACQUIRE) && !__atomic_load_n(&jr_boot_on, __ATOMIC_ACQUIRE)))
return;
plat_file_write(PM_crash, text, sizeof text - 1);
}
// 1 when the last start left the crash handler's note; asked once a start, and the note goes.
static int crash_noted(void) {
static int was = -1;
if (was < 0) {
was = PM_crash[0] && plat_file_exists(PM_crash);
if (was) plat_file_delete(PM_crash);
}
return was;
}
static int pm_skipped(void) {
char dir[PLAT_PATH_MAX * 2], sp[sizeof PM_run], key[32];
if (!cache_dir(dir, sizeof dir)) return 0;
snprintf(PM_run, sizeof PM_run, "%s/pipeline-prewarm-running.txt", dir);
snprintf(sp, sizeof sp, "%s/pipeline-prewarm-skip.txt", dir);
crash_path_init(dir);
gpu_key(key, sizeof key);
uint64_t n = 0;
uint8_t *left = plat_file_read(PM_run, &n);
char *left = (char *)plat_file_read(PM_run, &n);
if (left) {
char text[256];
int len = snprintf(text, sizeof text,
"# The boot's pipeline prebuild did not finish on this GPU and driver (runtime/vk_pipeline.c "
"pm_skipped): starts skip it\n# while this line matches. Delete this file to build ahead of play "
"again.\n%s\n", key);
if (plat_file_write_atomic(sp, text, (size_t)len)) plat_file_delete(PM_run);
rt_log("vk_pipeline: the last start died while the boot built pipelines (%s was left); %s now skips that "
"prebuild on this GPU and driver (%s)", PM_run, sp, key);
char head[64];
snprintf(head, sizeof head, "%.*s", (int)(n < sizeof head - 1 ? n : sizeof head - 1), left);
int crashed = crash_noted(), quiet = 0, what = boot_end_decide(head, key, crashed, &quiet);
if (what == BOOT_END_OTHER) { // another GPU or driver's builds
plat_file_delete(PM_run);
} else if (what == BOOT_END_SKIP) {
char text[256];
int len = snprintf(text, sizeof text,
"# The boot's pipeline prebuild did not finish on this GPU and driver (runtime/vk_pipeline.c "
"pm_skipped): starts skip it\n# while this line matches. Delete this file to build ahead of play "
"again.\n%s\n", key);
if (plat_file_write_atomic(sp, text, (size_t)len)) plat_file_delete(PM_run);
if (crashed)
rt_log("vk_pipeline: the last start crashed while the boot built pipelines (%s was left, with the crash "
"handler's note); %s now skips that prebuild on this GPU and driver (%s)", PM_run, sp, key);
else
rt_log("vk_pipeline: %d starts in a row ended while the boot built pipelines, none with a crash report "
"(%s was left each time); %s now skips that prebuild on this GPU and driver (%s)", quiet, PM_run,
sp, key);
} else {
pm_quiet = quiet;
plat_file_delete(PM_run);
rt_log("vk_pipeline: the last start ended while the boot built pipelines and reported no crash: taken for a "
"start that was closed or stopped, and the pipelines are built again (%d in a row; at %d the prebuild "
"is skipped on this GPU and driver)", pm_quiet, BOOT_QUIET_ENDS);
}
free(left);
}
uint8_t *skip = plat_file_read(sp, &n);
@@ -5948,10 +6003,11 @@ static int pm_skipped(void) {
static void pm_set(void) {
if (!PM_run[0]) return;
char key[32];
char key[32], text[64];
gpu_key(key, sizeof key);
int len = snprintf(text, sizeof text, "%s %d\n", key, pm_quiet);
// straight to the disk: the file has to be there if the driver takes the process down a moment later
if (plat_file_write_atomic(PM_run, key, strlen(key))) plat_xchg32(&pm_on, 1);
if (plat_file_write_atomic(PM_run, text, (size_t)len)) plat_xchg32(&pm_on, 1);
}
void vk_pipeline_prewarm_marker_clear(void) {
@@ -5979,10 +6035,16 @@ void vk_pipeline_prewarm_marker_clear(void) {
// into it (cache_load), some starts later. After BOOT_WARM_TRIES starts that did not end the warm the file stays as
// well, and starts on this GPU and driver are ordinary ones again. While the boot waits, the library builds write
// the preparation's journal (journal_mark), so a variant the driver's compiler dies on is skipped from the next
// start on (skip_init) instead of ending every start.
// NX2NAVI_PREWARM_FULL=0 turns it off. NX2NAVI_PREWARM_WAIT_MS and a minute without progress end the wait as for any
// prewarm (boot_wait); what is left then runs as in play (vk_pipeline_prewarm_detach). Not for a --shot image, which
// no build timing may change and which nobody watches.
// start on (skip_init) instead of ending every start; a start that was only closed or stopped then blames no variant
// (the crash handler's note decides, as at pm_skipped).
// The wait has a limit, NX2NAVI_PREWARM_FULL_S seconds from here (default 600, 0 none): the 425 s above are a fast
// machine's, and a slow one would sit on the screen for half an hour. At the limit the game starts and what is left
// goes on as on any other start: the recorded pipelines on the pool's workers, the compute pipelines and the library
// warm on their idle threads (vk_pipeline_prewarm_detach). The file then says "done" as well: the boot screen had its
// turn, and the rest is the background's, as it always was. NX2NAVI_PREWARM_WAIT_MS and a minute without progress
// end the wait the same way, as for any prewarm (boot_wait).
// NX2NAVI_PREWARM_FULL=0 turns the whole warm off. Not for a --shot image, which no build timing may change and
// which nobody watches.
static void bf_decide(void) {
const char *full = cfg_get("NX2NAVI_PREWARM_FULL");
char dir[PLAT_PATH_MAX * 2], key[32], line[100];
@@ -6008,11 +6070,14 @@ static void bf_decide(void) {
int len = snprintf(line, sizeof line, "%s %d\n", key, tries);
if (!plat_file_write_atomic(BF.owed, line, (size_t)len)) rt_log("vk_pipeline: cannot write %s", BF.owed);
BF.on = 1;
const char *se = cfg_get("NX2NAVI_PREWARM_FULL_S");
double secs = se && *se ? atof(se) : 600;
BF.t_end = secs > 0 ? now_ms() + secs * 1000 : 0;
rt_log("vk_pipeline: the whole warm on the boot screen (%s, start %d of %d at most): the start waits for the "
"recorded pipelines, the compute pipelines and the driver's cache of stage libraries. "
"NX2NAVI_PREWARM_FULL=0 leaves them to the background",
"recorded pipelines, the compute pipelines and the driver's cache of stage libraries, for %.0f s at most "
"(NX2NAVI_PREWARM_FULL_S; 0 = no limit). NX2NAVI_PREWARM_FULL=0 leaves them to the background",
cache_foreign ? "the pipeline cache was written by another device or driver" : "an earlier start began it",
tries, BOOT_WARM_TRIES);
tries, BOOT_WARM_TRIES, secs > 0 ? secs : 0.0);
}
free(f);
}
@@ -6316,54 +6381,76 @@ static int hex_digit(int c) {
return c >= '0' && c <= '9' ? c - '0' : c >= 'a' && c <= 'f' ? c - 'a' + 10 : c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1;
}
// A journal a crashed run left into the skip list, then the skip list's variants for this GPU and driver into SK.
// The variants a leftover journal j (jn bytes, of file jp) names join the skip list's text *s (*sn bytes; NULL
// without a list) for this GPU and driver, and the list's file sp is written again. 1 when the journal may go:
// nothing in it, or the list holds it now.
static int journal_fold(const uint8_t *j, uint64_t jn, const char *jp, const char *sp, const char *key, char **s,
uint64_t *sn) {
static const char head[] =
"# Shader variants the graphics driver was building when the process died during preparation\n"
"# (runtime/vk_pipeline.c skip_init): input id, stage, GPU vendor:device:driver version. Preparation skips\n"
"# them on that GPU and driver. Delete this file to build them again.\n";
size_t cap = (*s ? *sn : sizeof head) + (jn / JR_SLOT + 1) * 128, len = 0;
char *out = malloc(cap);
int added = 0;
if (!out) return 1;
len = *s ? *sn : sizeof head - 1;
memcpy(out, *s ? *s : head, len);
if (len && out[len - 1] != '\n') out[len++] = '\n';
for (uint64_t o = 0; o + 33 <= jn; o += JR_SLOT) {
int set = 0;
for (int b = 0; b < 32; b++) set |= j[o + b];
if (!set) continue;
char hex[65];
for (int b = 0; b < 32; b++) snprintf(hex + 2 * b, 3, "%02x", j[o + b]);
len += (size_t)snprintf(out + len, cap - len, "%s %s %s\n", hex, stage_name(j[o + 32]), key);
added++;
}
out[len] = 0; // parsed by skip_init as the list's text
if (added && plat_file_write_atomic(sp, out, len)) {
rt_log("vk_pipeline: the last shader preparation, or the last start's warm on the boot screen, died while "
"the driver built %d variants; %s now lists them and they are skipped ahead of play on this GPU and "
"driver (%s)", added, sp, key);
free(*s), *s = out, *sn = len;
return 1;
}
if (added) rt_log("vk_pipeline: cannot write %s; %s stays for the next run", sp, jp);
free(out);
return !added;
}
// A journal a run that died left into the skip list, then the skip list's variants for this GPU and driver into SK.
// The preparation's journal (shader-prepare-journal.bin) always counts. The boot's (shader-warm-journal.bin,
// journal_open) counts only with the crash handler's note (crash_noted): without it the start was closed or stopped
// while it waited, and the variants it happened to be building are no one's fault.
static void skip_init(const char *dir) {
if (SK.loaded) return;
SK.loaded = 1;
char jp[PLAT_PATH_MAX * 2 + 48], sp[PLAT_PATH_MAX * 2 + 48], key[32];
char jp[PLAT_PATH_MAX * 2 + 48], bj[PLAT_PATH_MAX * 2 + 48], sp[PLAT_PATH_MAX * 2 + 48], key[32];
snprintf(jp, sizeof jp, "%s/shader-prepare-journal.bin", dir);
snprintf(bj, sizeof bj, "%s/shader-warm-journal.bin", dir);
snprintf(sp, sizeof sp, "%s/shader-prepare-skip.txt", dir);
crash_path_init(dir);
gpu_key(key, sizeof key);
uint64_t jn = 0, sn = 0;
uint8_t *j = plat_file_read(jp, &jn);
uint64_t jn = 0, bn = 0, sn = 0;
uint8_t *j = plat_file_read(jp, &jn), *b = plat_file_read(bj, &bn);
char *s = (char *)plat_file_read(sp, &sn);
int keep_journal = 0;
if (j) {
static const char head[] =
"# Shader variants the graphics driver was building when the process died during preparation\n"
"# (runtime/vk_pipeline.c skip_init): input id, stage, GPU vendor:device:driver version. Preparation skips\n"
"# them on that GPU and driver. Delete this file to build them again.\n";
size_t cap = (s ? sn : sizeof head) + (jn / JR_SLOT + 1) * 128, len = 0;
char *out = malloc(cap);
int added = 0;
if (out) {
len = s ? sn : sizeof head - 1;
memcpy(out, s ? s : head, len);
if (len && out[len - 1] != '\n') out[len++] = '\n';
for (uint64_t o = 0; o + 33 <= jn; o += JR_SLOT) {
int set = 0;
for (int b = 0; b < 32; b++) set |= j[o + b];
if (!set) continue;
char hex[65];
for (int b = 0; b < 32; b++) snprintf(hex + 2 * b, 3, "%02x", j[o + b]);
len += (size_t)snprintf(out + len, cap - len, "%s %s %s\n", hex, stage_name(j[o + 32]), key);
added++;
}
out[len] = 0; // parsed below as the list's text
if (!j || journal_fold(j, jn, jp, sp, key, &s, &sn)) plat_file_delete(jp);
if (b) {
int marked = 0;
for (uint64_t o = 0; o + 33 <= bn; o += JR_SLOT)
for (int k = 0; k < 32; k++)
if (b[o + k]) { marked++; break; }
if (marked && !crash_noted()) {
rt_log("vk_pipeline: the last start ended during the library warm on the boot screen, with %d variants in "
"the driver's hands, and reported no crash: taken for a start that was closed or stopped; no variant "
"is skipped for it", marked);
plat_file_delete(bj);
} else if (journal_fold(b, bn, bj, sp, key, &s, &sn)) {
plat_file_delete(bj);
}
if (added && plat_file_write_atomic(sp, out, len)) {
rt_log("vk_pipeline: the last shader preparation, or the last start's warm on the boot screen, died while "
"the driver built %d variants; %s now lists them and they are skipped ahead of play on this GPU and "
"driver (%s)", added, sp, key);
free(s), s = out, sn = len, out = NULL;
} else if (added) {
rt_log("vk_pipeline: cannot write %s; %s stays for the next run", sp, jp);
keep_journal = 1;
}
free(out);
free(j);
}
if (!keep_journal) plat_file_delete(jp);
free(j), free(b);
for (char *line = s, *next; line && *line; line = next) {
next = strchr(line, '\n');
if (next) *next++ = 0;
@@ -6371,10 +6458,10 @@ static void skip_init(const char *dir) {
uint8_t iid[32];
int ok = line[0] != '#' && sscanf(line, "%64s %15s %31s", hex, st, k) == 3 && strlen(hex) == 64 &&
!strcmp(k, key);
for (int b = 0; ok && b < 32; b++) {
int hi = hex_digit(hex[2 * b]), lo = hex_digit(hex[2 * b + 1]);
for (int b2 = 0; ok && b2 < 32; b2++) {
int hi = hex_digit(hex[2 * b2]), lo = hex_digit(hex[2 * b2 + 1]);
if (hi < 0 || lo < 0) ok = 0;
else iid[b] = (uint8_t)(hi << 4 | lo);
else iid[b2] = (uint8_t)(hi << 4 | lo);
}
uint8_t (*grown)[32] = ok ? realloc(SK.iid, (SK.n + 1) * sizeof *SK.iid) : NULL;
if (grown) memcpy(grown[SK.n++], iid, 32), SK.iid = grown;
@@ -6405,12 +6492,13 @@ static void journal_mark(int slot, const GfxWarmEnt *e) {
plat_mutex_unlock(&SK.jlock);
}
// The boot's journal, for the library builds the start waits for (bf_wait). skip_init has run (lb_start) and has
// dealt with a leftover one.
// The boot's journal, for the library builds the start waits for (bf_wait), in a file of its own: skip_init treats
// one left over differently from the preparation's. skip_init has run (lb_start) and has dealt with a leftover one.
static void journal_open(void) {
char dir[PLAT_PATH_MAX * 2];
if (!cache_dir(dir, sizeof dir)) return;
snprintf(SK.jpath, sizeof SK.jpath, "%s/shader-prepare-journal.bin", dir);
crash_path_init(dir);
snprintf(SK.jpath, sizeof SK.jpath, "%s/shader-warm-journal.bin", dir);
PlatFile *j = plat_fs_create(SK.jpath, NULL);
if (!j) {
rt_log("vk_pipeline: cannot create %s: a driver crash in this start's library warm will not be recorded", SK.jpath);
@@ -6420,6 +6508,7 @@ static void journal_open(void) {
plat_mutex_lock(&SK.jlock);
SK.journal = j;
plat_mutex_unlock(&SK.jlock);
__atomic_store_n(&jr_boot_on, 1, __ATOMIC_RELEASE);
}
// Ends the boot's journal: when the library warm is done, when the game starts beside it (a crash in play says
@@ -6428,6 +6517,7 @@ static void journal_open(void) {
// flight write nothing afterwards (journal_mark).
static void journal_close(void) {
if (!SK.jpath[0]) return;
__atomic_store_n(&jr_boot_on, 0, __ATOMIC_RELEASE);
plat_mutex_lock(&SK.jlock);
PlatFile *j = SK.journal;
SK.journal = NULL;
@@ -7602,50 +7692,62 @@ static void lb_stop(void) {
if (BG.th) plat_thread_join(BG.th), BG.th = NULL; // after its current build, if one runs
}
// 1 once the whole warm's time on the boot screen is up (BF.t_end): the builders go on as on any other start.
static int bf_time_up(void) {
if (!BF.t_end || !bf_waiting() || now_ms() < BF.t_end) return 0;
vk_pipeline_prewarm_detach();
return 1;
}
// The whole warm's wait (comment at bf_decide), on the prewarm thread after the recorded pipelines: the compute
// pipelines lb_start has just started, then the library warm. The counts go to the boot screen
// (vk_pipeline_prewarm_progress). Should the boot stop waiting (vk_pipeline_prewarm_detach), this thread still sees
// the warm to its end, which the builders then reach as in play.
// (vk_pipeline_prewarm_progress). It ends with the warm, at the warm's time limit, or when the boot stops waiting
// (vk_pipeline_prewarm_detach); in the last two the builders go on beside the game.
static void bf_wait(void) {
double t0 = now_ms();
int up = bf_time_up(); // the recorded pipelines took all of it
if (LB.n && LB.threads) {
__atomic_store_n(&pw_pipe_done, 0, __ATOMIC_RELAXED);
__atomic_store_n(&pw_pipe_total, (int64_t)LB.n, __ATOMIC_RELAXED);
__atomic_store_n(&pw_phase, 3, __ATOMIC_RELEASE);
while (__atomic_load_n(&LB.running, __ATOMIC_ACQUIRE) > 0 && !LB.stop) {
while (__atomic_load_n(&LB.running, __ATOMIC_ACQUIRE) > 0 && !LB.stop && bf_waiting()) {
plat_sleep_ms(100);
plat_mutex_lock_shared(&LB.stat);
uint64_t d = LB.done;
plat_mutex_unlock_shared(&LB.stat);
__atomic_store_n(&pw_pipe_done, (int64_t)d, __ATOMIC_RELAXED);
up |= bf_time_up();
}
}
double t1 = now_ms();
int libs = 0;
if (BF.lw && !LB.stop) {
if (bf_waiting()) journal_open();
lw_start();
lw_start(); // beside the game when the wait is over: the check and the warm as on any other start
if (LW.th[0]) {
libs = 1;
__atomic_store_n(&pw_pipe_done, 0, __ATOMIC_RELAXED);
__atomic_store_n(&pw_pipe_total, (int64_t)LW.n, __ATOMIC_RELAXED);
__atomic_store_n(&pw_phase, 4, __ATOMIC_RELEASE);
while ((!LW.checked || LW.running > 0) && !LW.stop) {
while ((!LW.checked || LW.running > 0) && !LW.stop && bf_waiting()) {
plat_sleep_ms(100);
__atomic_store_n(&pw_pipe_done, (int64_t)LW.done, __ATOMIC_RELAXED);
if (!bf_waiting()) journal_close(); // the game runs
up |= bf_time_up();
}
}
journal_close();
journal_close(); // the warm is over, or the game runs
}
int stopped = LB.stop || LW.stop, beside = __atomic_load_n(&BF.game, __ATOMIC_ACQUIRE);
rt_log("vk_pipeline: the whole warm %s: %zu compute pipelines in %.0f ms, the driver's cache of stage libraries %s in "
"%.0f ms (%lld of %zu prepared variants built)%s", stopped ? "stopped with the process" : "is done", LB.n,
t1 - t0, !libs ? "not warmed (no prepared list, or the graphics pipeline library or NX2NAVI_LIB_WARM is off)"
: LW.done ? "warmed" : "left as it is (the check found it warm, or gave the warm up)",
now_ms() - t1, (long long)LW.done, LW.n,
beside ? "; the boot had stopped waiting, so the game ran beside the end of it" : "");
if (!stopped) { // done for this GPU and driver (boot_warm.h)
int stopped = LB.stop || LW.stop;
int over = __atomic_load_n(&LB.running, __ATOMIC_ACQUIRE) <= 0 && (!libs || (LW.checked && LW.running <= 0));
rt_log("vk_pipeline: the whole warm %s: the compute pipelines (%zu) took %.0f ms of the wait, the driver's cache of "
"stage libraries %.0f ms (%s; %lld of %zu prepared variants built so far)",
stopped ? "stopped with the process" : over ? "is done"
: up ? "goes on beside the game: its time on the boot screen is up (NX2NAVI_PREWARM_FULL_S)"
: "goes on beside the game: the boot stopped waiting", LB.n, t1 - t0, now_ms() - t1,
!libs ? "not warmed: no prepared list, or the graphics pipeline library or NX2NAVI_LIB_WARM is off"
: LW.done ? "being warmed" : "left as it is so far: the check found it warm, gave the warm up, or still runs",
(long long)LW.done, LW.n);
if (!stopped) { // the boot screen's turn is over for this GPU and driver (boot_warm.h)
char key[32], line[64];
gpu_key(key, sizeof key);
int len = snprintf(line, sizeof line, "%s done\n", key);

View File

@@ -90,29 +90,48 @@ static unsigned picture_height(void) {
static double dlss_share(void);
double wide_dlss_share(void) { return dlss_share(); } // vk_dlaa.c: the mode's share, 0 off
static double heap_share(void);
static double dlss_share(void) {
if (!vk_dlaa_wanted() || !cfg_bool("NX2NAVI_DLAA") || (!vk_dlaa_fsr3() && !vk_dlaa_available())) return 0;
const char *m = cfg_value("NX2NAVI_DLSS");
double s = !strcmp(m, "quality") ? 2.0 / 3 : !strcmp(m, "balanced") ? 0.58 : !strcmp(m, "performance") ? 0.5
: !strcmp(m, "ultra_performance") ? 1.0 / 3 : 1.0;
// Never more than the texture heap was made for at the start (heap_share): only an upscaler switched on in the
// menu of a run that began without one can ask for more, and it gets the whole picture after a restart.
if (s > heap_share()) {
static int said;
if (!said++)
rt_log("widescreen: the scene stays at %.0f%% of the picture until a restart: the game's render-target heap "
"was sized at the start, without an upscaler, and %.0f%% does not fit it", heap_share() * 100, s * 100);
s = heap_share();
}
return s;
}
// Without DLSS or FSR 3.1 (FSR 1, bilinear) the game's dynamic resolution took the scene down to a third of the picture
// under load, and a plain scale shows every step of that. The most the game's controller ever gives (wide_init) is held.
#define PLAIN_SHARE 0.75
static double heap_share(void);
// Set by wide_init when the grown heap table (wide_heap_extra_kib) did not reach the game: romfs.c could not build
// it (a table in a form it does not rewrite, as a mod's may be) or could not write it to the profile folder. The game
// then has the shipped heap, made for its own picture with the scene at PLAIN_SHARE, and gets no more than that:
// a larger scene or picture in the shipped heap is the crash the growth is there to prevent.
static int heap_unserved;
// The most the scene can be of the picture in the heap the game has.
static double fit_share(void) {
return heap_unserved ? PLAIN_SHARE : heap_share();
}
// The share of the picture the upscaler's mode renders (NX2NAVI_DLSS; NVIDIA's ratios).
static double mode_share(void) {
const char *m = cfg_value("NX2NAVI_DLSS");
return !strcmp(m, "quality") ? 2.0 / 3 : !strcmp(m, "balanced") ? 0.58 : !strcmp(m, "performance") ? 0.5
: !strcmp(m, "ultra_performance") ? 1.0 / 3 : 1.0;
}
static double dlss_share(void) {
if (!vk_dlaa_wanted() || !cfg_bool("NX2NAVI_DLAA") || (!vk_dlaa_fsr3() && !vk_dlaa_available())) return 0;
double s = mode_share();
// Never more than the texture heap the game has was made for (fit_share). A mode chosen in the menu that renders
// more than the start's did gets its size after a restart; a heap at its limit never holds the whole picture.
if (s > fit_share()) {
static int said;
if (!said++)
rt_log("widescreen: the scene is %.0f%% of the picture, not the mode's %.0f%%: the game's render-target heap "
"%s. A mode chosen in the menu gets its size after a restart, unless the start's log says the heap "
"is at its limit", fit_share() * 100, s * 100,
heap_unserved ? "is the shipped one (the start's log says why the grown one was not served)"
: "was sized at the start for that much");
s = fit_share();
}
return s;
}
static double scene_share(void) {
static double plain = -1;
if (plain < 0) {
@@ -120,23 +139,45 @@ static double scene_share(void) {
plain = e && *e ? atof(e) : PLAIN_SHARE;
}
double s = dlss_share();
return s > 0 ? s : plain;
return s > 0 ? s : plain > fit_share() ? fit_share() : plain; // NX2NAVI_SCENE_SHARE above the heap the game has
}
static int picture_size(unsigned *ow, unsigned *oh, int quiet);
// The picture's pixels over the game's own 2560x1440.
static double picture_ratio(void) {
unsigned ow, oh;
if (!wide_available() || !picture_size(&ow, &oh, 1)) ow = GAME_W, oh = GAME_H;
return (double)ow * oh / ((double)GAME_W * GAME_H);
}
// The largest share of the picture the scene can have in this run, which the texture heap is made for
// (wide_heap_extra_kib). Decided once, at the first call, which is the start (memory.c sizes the application pool
// from it before any device exists): the whole picture when the upscaler setting is on, whatever its mode, since
// the menu changes the mode in play and DLAA and FSR at native size render all of it; else the game's own most,
// PLAIN_SHARE, or NX2NAVI_SCENE_SHARE when that asks for more. From the settings, not from what runs: DLSS is known
// to run only once the device is up.
// from it before any device exists): the game's own most, PLAIN_SHARE, or more where the settings at the start ask
// for more: NX2NAVI_SCENE_SHARE, or the upscaler's mode when the upscaler is on (DLAA and FSR at native size render
// the whole picture; the modes below PLAIN_SHARE need nothing). From the settings, not from what runs: DLSS is known
// to run only once the device is up. A mode chosen in the menu later that renders more keeps the start's share until
// a restart (dlss_share).
// Never more than the application pool can take: the heap grows with the share's square (wide_heap_extra_kib), and
// past mem_heap_extra_max_kib the game's own SetHeapSize is refused and nothing starts. A 10240x2880 picture has room
// for 80% there, not for all of it, and the scene is then that much.
static double heap_share(void) {
static double share = -1;
if (share < 0) {
const char *e = cfg_get("NX2NAVI_SCENE_SHARE");
double s = e && *e ? atof(e) : PLAIN_SHARE;
if (s < PLAIN_SHARE) s = PLAIN_SHARE;
if (rt_patch_set("res_fixed") >= 0 && cfg_bool("NX2NAVI_DLAA") && mode_share() > s) s = mode_share();
if (s > 1) s = 1;
if (rt_patch_set("res_fixed") >= 0 && cfg_bool("NX2NAVI_DLAA")) s = 1;
double room = (double)mem_heap_extra_max_kib() / GAME_DTA_KIB + 1; // the heap's most over the shipped one
double most = sqrt(room / picture_ratio()) * PLAIN_SHARE;
if (s > most) {
if (most < PLAIN_SHARE) most = PLAIN_SHARE; // wide_heap_extra_kib says what a picture this large lacks
rt_log("widescreen: the scene can be %.0f%% of the picture at most, not %.0f%%: the game's render-target "
"heap for more does not fit the application pool (%llu MiB of growth at most)", most * 100, s * 100,
(unsigned long long)(mem_heap_extra_max_kib() >> 10));
s = most;
}
share = s;
}
return share;
@@ -191,15 +232,29 @@ static int picture_size(unsigned *ow, unsigned *oh, int quiet) {
// is all of the picture, 2560x1440 where the game never goes past 1920x1080, and a player's game ended in that same
// function, reading address 0x48, each time a dialogue closed in Castle Town (0.8.0, 1440 lines, dlss = dlaa).
// The heap and its parent grow by the shipped size times the picture's pixels over 2560x1440 and times the scene's
// pixels over the game's most (heap_share: its targets are the picture's size or the scene's), in whole MiB;
// resolution.c rewrites the table (res_heapdef_build) and memory.c adds the amount to the application pool, so no
// other heap shrinks. 0 for the game's picture and scene, and for a larger picture without the widescreen sets.
// pixels over the game's most (heap_share: its targets are the picture's size or the scene's, so this is the most
// they can need), in whole MiB; resolution.c rewrites the table (res_heapdef_build) and memory.c adds the amount to
// the application pool, so no other heap shrinks. 0 for the game's picture and scene, and for a larger picture
// without the widescreen sets. In MiB, with the scene at the game's own most and with all of the picture (DLAA):
// 2560x1440 0 and 238, 3440x1440 105 and 424, 3840x2160 382 and 915, 5120x2160 610 and 1,322, 7680x2160 1,068 and
// 2,135. The heap is committed as the game first writes it (memory.c, NX2NAVI_HEAP_LAZY), so the room a run does not
// use costs address space and no memory.
// At most mem_heap_extra_max_kib: heap_share has taken the scene's share down to what fits, and a picture too large
// even with the game's own scene (above 10240x2880) gets the most there is, with a line that says so.
uint64_t wide_heap_extra_kib(void) {
unsigned ow, oh;
if (!wide_available() || !picture_size(&ow, &oh, 1)) ow = GAME_W, oh = GAME_H;
double k = heap_share() / PLAIN_SHARE;
double grow = (double)ow * oh / ((double)GAME_W * GAME_H) * k * k - 1;
return grow > 0 ? (uint64_t)ceil(GAME_DTA_KIB * grow / 1024) * 1024 : 0;
double grow = picture_ratio() * k * k - 1;
uint64_t kib = grow > 0 ? (uint64_t)ceil(GAME_DTA_KIB * grow / 1024) * 1024 : 0, most = mem_heap_extra_max_kib();
if (kib > most) {
static int said;
if (!said++)
rt_log("widescreen: WARNING: a picture of %.1f times the game's own needs %llu MiB more render-target heap "
"and the application pool has room for %llu: the game may end when a screen needs more targets "
"than fit. A smaller game_res or a narrower game_aspect fits", picture_ratio(),
(unsigned long long)(kib >> 10), (unsigned long long)(most >> 10));
kib = most;
}
return kib;
}
// The save's picture (recomp/patches-v111.txt, set wide_save): the game draws the whole picture into a target 543
@@ -221,7 +276,19 @@ void wide_init(void) {
// (wide_present).
double game = (double)GAME_W / GAME_H, f = 0.75;
unsigned ow, oh;
// The grown heap table is served from here on, or is not (romfs.c heapdef_overlay says why in the log): before
// the guest runs and before the first present asks for the scene's share.
if (wide_heap_extra_kib()) {
fs_init();
if (!res_heapdef_ok()) {
heap_unserved = 1;
rt_log("widescreen: the game's render-target heap stays the shipped one (the grown table was not served, see "
"the RomFS and resolution lines above): the scene is %.0f%% of the picture at most and the picture "
"the game's own 2560x1440", PLAIN_SHARE * 100);
}
}
if (!picture_size(&ow, &oh, 0)) return; // the game's own sizes: every set stays off
if (heap_unserved) return; // a larger picture's targets do not fit the shipped heap
if (so < 0 || ss < 0 || sa < 0 || sh < 0 || sm < 0) {
rt_log("widescreen: the generated C has no widescreen patch sets (gen.py --patches recomp/patches-v111.txt); "
"the game's own 2560x1440 picture");
@@ -274,7 +341,7 @@ void wide_init(void) {
void wide_picture(unsigned *w, unsigned *h) {
static unsigned pw, ph;
if (!pw) {
if (!wide_available() || !picture_size(&pw, &ph, 1)) pw = GAME_W, ph = GAME_H;
if (!wide_available() || heap_unserved || !picture_size(&pw, &ph, 1)) pw = GAME_W, ph = GAME_H;
}
*w = pw, *h = ph;
}