diff --git a/runtime/vk.h b/runtime/vk.h index 453ec635..3d334efa 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -271,6 +271,7 @@ int vk_texture_slot_swz(int id, uint8_t swz[4]); // vk_dump: swizzle of the d int vk_texture_read_image(const tex_t *t, const view_t *v, const NVNcopyRegion *r, uint8_t *dst, uint64_t row, uint64_t img); // always from the image (GPU copy, waited for); 0 on failure int vk_texture_cpu_stale(uint64_t addr, uint64_t size); // a GPU-written mirrored texture there has stale storage +uint64_t vk_texture_dirty_fence(uint64_t addr, uint64_t size); // newest recorded writer of such a texture; 0: none void vk_texture_write_back(uint64_t addr, uint64_t size); // writes those images back into their storage (waits) void vk_texture_range_gone(uint64_t lo, uint64_t size, VmaAllocation alloc); // vk_pool_fini: drop the images there void vk_texture_stats(uint64_t *images, uint64_t *uploads, uint64_t *reuploads); diff --git a/runtime/vk_backend.c b/runtime/vk_backend.c index 27fa0bcd..03515864 100644 --- a/runtime/vk_backend.c +++ b/runtime/vk_backend.c @@ -153,7 +153,7 @@ enum { DR_POOL_FINI, DR_MAP_VIRTUAL, DR_TEX_RELEASE, DR_PROG_RELEASE, DR_FINISH, DR_GUEST_READ, DR_FRAME, DR_FULL, DR_CHECK, DR_N }; static const char *const dr_name[DR_N] = { "pool_fini", "map_virtual", "texture_release (queued)", "program_release", "finish", "read_texels (writer fence)", - "write_texels", "guest_read", "frame bound", "queue full", "check drain"}; + "write_texels", "guest_read (writer fence)", "frame bound", "queue full", "check drain"}; static SRWLOCK rl = SRWLOCK_INIT; static CONDITION_VARIABLE rcv = CONDITION_VARIABLE_INIT; // item queued, item taken, item done @@ -475,10 +475,29 @@ static void vk_be_write_texels(const tex_t *t, const view_t *v, const NVNcopyReg vk_write_texels(t, v, r, src, row, img); } static void vk_be_guest_written(uint64_t addr, uint64_t size) { vk_sync_start(); vk_guest_written(addr, size); } +// A CPU read of GPU-written mirrored storage (memcpy, pool invalidate). With the replay queued it waits for the newest +// submission recorded to write the textures there, not for the whole queue: the write-back copy then runs after their +// renders, and clears gpu_dirty only for content that is on the queue. Submissions not replayed yet render after the +// copy, as on hardware when the GPU has not reached them; they mark the texture dirty again for a later read. static void vk_be_guest_read(uint64_t addr, uint64_t size) { if (!vk_texture_cpu_stale(addr, size)) return; vk_sync_start(); - replay_drain(DR_GUEST_READ); + if (gfx_replay_async()) { + uint64_t f = vk_texture_dirty_fence(addr, size); + AcquireSRWLockExclusive(&rl); + dr_calls[DR_GUEST_READ]++, dr_tcalls[DR_GUEST_READ]++; + ReleaseSRWLockExclusive(&rl); + if (f && vk_sync_fence_done() < f) { + uint64_t t0 = kern_now_ns(); + NVN_BLOCKING(); + vk_sync_fence_wait(f, UINT64_MAX); + uint64_t d = kern_now_ns() - t0; + AcquireSRWLockExclusive(&rl); + dr_waits[DR_GUEST_READ]++, dr_twaits[DR_GUEST_READ]++; + dr_ns[DR_GUEST_READ] += d, dr_tns[DR_GUEST_READ] += d; + ReleaseSRWLockExclusive(&rl); + } + } vk_present_drain(); vk_texture_write_back(addr, size); } diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index 317adbc2..d8a8bc81 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -1253,6 +1253,21 @@ int vk_texture_cpu_stale(uint64_t addr, uint64_t size) { return dirty; } +// The newest submission recorded to write a GPU-written mirrored texture overlapping [addr, addr+size); 0: none. +uint64_t vk_texture_dirty_fence(uint64_t addr, uint64_t size) { + if (!size || !__atomic_load_n(&nowned, __ATOMIC_ACQUIRE)) return 0; + lock(); + uint64_t f = 0; + for (int i = owned_lower(addr > max_owned ? addr - max_owned : 0); i < nowned && owned[i]->pub.addr < addr + size; i++) { + const Tex *e = owned[i]; + if (!e->gpu_dirty || e->pub.addr + e->t.L.size <= addr) continue; + if (e->gpu_fence > f) f = e->gpu_fence; + if (e->wr_fence > f) f = e->wr_fence; + } + unlock(); + return f; +} + // The image is the newest content only while nothing wrote the storage since the GPU render: TotK finalizes grass maps, // reuses their storage for new data and memcpys that data on, and writing the old image back first handed the copy // a stale map or stale resource bytes (wrong textures in the distance). Every hit is checked before any is written