mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-17 15:49:57 -04:00
present_image ran the frame's bookkeeping on the presenting thread without a lock: vk_exec_frame_log (the trace counts and vk_exec_cond_frame_end's frame count, which the conditional draws go by), dynres_frame, vk_exec_barrier_log, vk_dlaa_frame (the DLSS mode and its LOD bias, the frame's points, the swap image, the idle releases), vk_mvsurvey_frame, vk_mvprev_frame (which swaps the two motion tables the draws insert into) and vk_gpu_passes_frame. All of it is state the replay reads and writes as it records, under sub_lock. With the replay on the submitting threads the game presents on one thread while another may be replaying (the overlap lines of the 0.10.0 fresh session, at area changes), so the present reset it in the middle of that replay: a DLSS frame reset halfway, the motion tables swapped halfway (with MVPREV_CHECK=1 an index out of bounds), the conditional draws counted against the next frame. Now the bookkeeping is frame_end, and runtime/vk_frame_owed.h decides where it runs. present_image marks its frame owed and runs it itself only when it gets sub_lock at once (vk_sync.c vk_sync_try_locked); otherwise vk_sync.c submit runs every owed frame's, in frame order, right after it takes the lock and before its replay (vk_present_frames_owed), on whichever thread submits next, the present thread's blit submission included. The presenting thread never waits for another thread's replay for it: no new wait on a drawing thread; the thread that takes the lock next does the work it would have done at the present, tens of microseconds normally. The hand-off, vk_texture_get with its upload flush and vk_present_drain stay outside the lock, as frame_end must not wait for the present thread or submit; its callees were checked for that. vk_sampler_aniso_live and vk_mem_census keep their place in present_image (their own locks). In the asynchronous replay the other holder of sub_lock is the present thread's blit, and the same applies. NX2NAVI_PRESENT_ORDER (present_order in [diagnostics], default 1, read at start) puts it back at the present with 0, as in 0.10.1: metas, known and sections rows and an nx2navi.ini.example entry. Not reproduced before the change. Checks that passed: the new tests/frame_owed_check (one presenting and three replaying threads, some replays holding the lock 40 ms, over 20,000 frames: every frame's bookkeeping once, in order, never during a replay and before any replay that took the lock after its present; the longest present under 1 ms with 19,000 presents made during a long hold), cfg_rows_check with 0 problems, pass_cc_check on every runtime file (headers changed), no new -Wall -Wextra warnings in vk_backend.c, vk_sync.c, vk_exec.c and cfg.c. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
38 lines
2.3 KiB
C
38 lines
2.3 KiB
C
// A frame's bookkeeping at its present (vk_backend.c frame_end: the replay's per-frame state that a present closes), in
|
|
// replay order. Header only, so that tests/frame_owed_check.c checks it without a device.
|
|
//
|
|
// The replay reads and writes that state as it records, under the submission lock (vk_sync.c sub_lock). With the
|
|
// replay on the submitting threads the game presents on one thread while another may be replaying, and running the
|
|
// bookkeeping then reset the state in the middle of that replay. The presenting thread does not wait for the replay:
|
|
// it marks its frame owed and runs the bookkeeping itself only when it gets the lock at once; otherwise the next thread
|
|
// to take the lock (vk_sync.c submit) runs every owed frame's bookkeeping, in frame order, before its own replay. A frame
|
|
// caught up behind a later present runs as two presents with no submission between them always did.
|
|
#pragma once
|
|
#include <stdint.h>
|
|
|
|
typedef struct {
|
|
uint64_t owed; // the newest presented frame (atomic: the presenting thread raises it, the lock's holder reads it)
|
|
uint64_t done; // the newest frame whose bookkeeping ran (the lock's holder only)
|
|
} FrameOwed;
|
|
|
|
typedef void (*FrameEnd)(uint64_t frame, void *arg);
|
|
|
|
// The lock's holder: whether a frame waits for its bookkeeping (one atomic load, for every submission).
|
|
static inline int fo_waiting(FrameOwed *o) { return __atomic_load_n(&o->owed, __ATOMIC_ACQUIRE) != o->done; }
|
|
|
|
// The lock's holder: the bookkeeping of every frame presented since the last run, in frame order; returns how many.
|
|
static inline uint64_t fo_run(FrameOwed *o, FrameEnd end, void *arg) {
|
|
uint64_t owed = __atomic_load_n(&o->owed, __ATOMIC_ACQUIRE), n = 0;
|
|
while (o->done < owed) end(++o->done, arg), n++;
|
|
return n;
|
|
}
|
|
|
|
// The presenting thread, frame numbers rising (a smaller one than owed leaves it: that frame's bookkeeping ran or is
|
|
// owed already). try_run(arg) takes the lock without waiting, runs fo_run under it and returns 1, or returns 0 when
|
|
// another thread holds it. Returns whether the bookkeeping ran here.
|
|
static inline int fo_present(FrameOwed *o, uint64_t frame, int (*try_run)(void *), void *arg) {
|
|
uint64_t was = __atomic_load_n(&o->owed, __ATOMIC_RELAXED);
|
|
while (was < frame && !__atomic_compare_exchange_n(&o->owed, &was, frame, 1, __ATOMIC_RELEASE, __ATOMIC_RELAXED)) {}
|
|
return try_run(arg);
|
|
}
|