mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-20 03:59:59 -04:00
Sync the device address table's shadows once per guest submission that binds the table, and take out the port of pull request #353.
The author of pull request #353 closed it on 2026-11-11 with the words that they give no permission to use its code. Its port (3134f524) goes: the mark of a pipeline that declares the table (VkPipeInfo.gpa, vk_pipeline.c pipe_add) and of the part that draws with it (vk_mem_gpa_use in vk_exec_draw.c bind_resources and mo_emit), the sync of the table's pools in every such part's prologue (vk_mem_gpa_sync), the submission with a callback in the replay's place as it stood (vk_sync_probe_submit), and --probe-vkmem's read through the table with its shader (test_gpa_read, runtime/shaders/gpa_read.spvasm).
In its place, after pull request #551, which was written without that code: a shadow pool goes into the table and onto a list of the table's shadows (vk_memory.c shadow_table_add); the record of a binding of the table notes the guest submission (vk_exec_draw.c ssbo_info, vk_mem_shadow_table_read); and vk_mem_shadow_sync brings the CPU's writes into every shadow on the list once for that guest submission, before the part is submitted. Once is enough, because the copy-ins read the guest submission's write-watch snapshots, which a second sync would find unchanged. Measured by #551's author on Linux (RTX 4090, Kokiri Forest): 113 and 76 frames over 25 ms in 75 s against 217 and 429 with the port, 43 against 41 fps, the picture complete in both.
What this line had built on the port stays, on the new sync: the test that passes over a pool with nothing written (shadow_pool_clean), the upload of the same pages into a table pool's VRAM mirror, the write-back of stores through the table (NX2NAVI_SHADOW_TABLE_STORES, table_wb_cb, now asked once per guest submission that binds the table) and the counts of NX2NAVI_SHADOW_CHECK. The probes that record their own commands (the lost-device probe, --probe-vkmem's table parts) call vk_sync_submit_own, written anew. vk_mem_shadow_storage stays: one line that returns the mode. Finalized pools in the table were already kept for vk_mem_shutdown here.
--probe-vkmem has a check of its own for the sync (test_table_sync): the shadow of a pool that is never bound keeps its old word through a CPU write and a guest submission that does not bind the table, and holds the new one after a guest submission that does. It passes with NX2NAVI_SHADOW=1 on Windows (RTX 5090), as do the store check with NX2NAVI_SHADOW_TABLE_STORES=1 and the probe without shadow storage; --probe-devlost ends as before. Not run: the game, with or without shadow storage, and anything on Linux.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
@@ -647,8 +647,7 @@ static CmdSlot *take_slot(VkCtx *c, uint64_t fence) {
|
||||
// part was recorded, sub_lock held; may move slots[].
|
||||
// First brings the shadow storage up to date with the CPU's writes, which needs no command buffer.
|
||||
static VkCommandBuffer prologue(VkCtx *c, uint64_t fence) {
|
||||
vk_mem_shadow_sync(); // shadow storage: the CPU's writes go in before the part is submitted
|
||||
vk_mem_gpa_sync(fence); // a part whose shaders read through the device address table never resolved the pools they reach
|
||||
vk_mem_shadow_sync(fence); // shadow storage: the CPU's writes go in before the part is submitted
|
||||
vk_mem_lazy_part_end(); // what the part left in the mirror and has to write back after all joins the snapshots
|
||||
if (!vk_mem_mirror_pending()) return VK_NULL_HANDLE;
|
||||
int i = claim_slot(c, fence); // before reading slots: the claim may move it
|
||||
@@ -710,7 +709,13 @@ uint64_t vk_sync_reserve(void) {
|
||||
return v;
|
||||
}
|
||||
|
||||
static uint64_t submit(const uint64_t *handles, int n, void (*probe_record)(VkCommandBuffer, void *), void *arg) {
|
||||
// own: NULL for the replay of handles; else the caller's commands in the replay's place (vk_sync_submit_own).
|
||||
typedef struct {
|
||||
void (*record)(VkCommandBuffer, void *);
|
||||
void *arg;
|
||||
} OwnCommands;
|
||||
|
||||
static uint64_t submit(const uint64_t *handles, int n, const OwnCommands *own) {
|
||||
vk_sync_start();
|
||||
// The run is ending (vk_device.c vk_device_lost_check): nothing is recorded or submitted and no value is issued.
|
||||
// The value returned is the last one issued; a wait for it sleeps until the process ends.
|
||||
@@ -733,8 +738,8 @@ static uint64_t submit(const uint64_t *handles, int n, void (*probe_record)(VkCo
|
||||
ts_begin(s->cb);
|
||||
rec_begin(s->cb, fence);
|
||||
vk_gpu_passes_part(s->cb, 0);
|
||||
int recorded;
|
||||
if (probe_record) { probe_record(s->cb, arg); recorded = 1; }
|
||||
int recorded = 1;
|
||||
if (own) own->record(s->cb, own->arg);
|
||||
else recorded = vk_exec_record(s->cb, handles, n, fence);
|
||||
s = &slots[cur_slot]; // the last part (vk_sync_split)
|
||||
vk_gpu_passes_part(s->cb, 1);
|
||||
@@ -781,11 +786,12 @@ static uint64_t submit(const uint64_t *handles, int n, void (*probe_record)(VkCo
|
||||
return fence;
|
||||
}
|
||||
|
||||
uint64_t vk_sync_submit(const uint64_t *handles, int n) { return submit(handles, n, NULL, NULL); }
|
||||
uint64_t vk_sync_submit(const uint64_t *handles, int n) { return submit(handles, n, NULL); }
|
||||
|
||||
// Memory probes record their shader here, not in the upload batch (which is submitted before the memory prologue).
|
||||
uint64_t vk_sync_probe_submit(void (*record)(VkCommandBuffer, void *), void *arg) {
|
||||
return submit(NULL, 0, record, arg);
|
||||
// The upload batch is no place for a probe's commands: it is submitted before the memory prologue.
|
||||
uint64_t vk_sync_submit_own(void (*record)(VkCommandBuffer, void *), void *arg) {
|
||||
OwnCommands own = {record, arg};
|
||||
return submit(NULL, 0, &own);
|
||||
}
|
||||
|
||||
void vk_completion_add(uint64_t fence, void (*fn)(void *), void *arg) {
|
||||
@@ -980,7 +986,7 @@ int vk_sync_probe_devlost(void) {
|
||||
int ran = plat_cas32(&probe_ran[1], 1, 1), reached = vk_sync_fence_done() >= v2;
|
||||
volatile int32_t recorded = 0;
|
||||
uint64_t before = vk_sync_issued(), t0 = plat_now_ms();
|
||||
uint64_t got = vk_sync_probe_submit(probe_lost_record, (void *)&recorded);
|
||||
uint64_t got = vk_sync_submit_own(probe_lost_record, (void *)&recorded);
|
||||
vk_upload_flush(1);
|
||||
int waited = vk_sync_exec_wait(v2, 5000000000ull);
|
||||
uint64_t ms = plat_now_ms() - t0;
|
||||
|
||||
Reference in New Issue
Block a user