Files
Triforce-Source/tests/test_flush_nothing_held.py
ruckus7382sfgsgdf e6f2f248f2 Triforce v0.7.0 "Sage Of Courage"
The 0.6 crashes after warps and area changes fixed (no write-back into memory the capture leaves out), invisible objects fixed (occlusion gate), DLSS frame generation flicker fixed, achievements, the renderer built with a play profile, faster translated game code, helper threads judged on settled scenes, memory, shader preparation, audio effects, launcher, controls and Linux fixes.
2026-11-22 11:59:06 -06:00

224 lines
10 KiB
Python

"""Flushes with nothing held skip the queue's lock (gpu/vk/vk_replay.cpp pend_held, RX_VK_PEND_HELD).
queue_flush_for and queue_flush_poll took dev.present_mu to find nothing held, at every fence wait and progress poll (with
batching off, always), behind a present or a late page's fix waiting on the GPU. pend_held is raised under the lock when a
submit is held and lowered when the batch goes out; both flushes look at it first. A held submit's recording is registered
for the waiters only after it is in pend with the flag raised, so a waiter that finds the registration finds it held (or
already sent) and flushes it.
Checked, compiled (pend_held, pend_held_on, queue_flush_for and queue_flush_poll cut out of vk_replay.cpp unchanged, with a
counting mutex for dev.present_mu): nothing held, no lock; held, the lock and the flush; RX_VK_PEND_HELD=0 and the lab knob
nopendheld, the lock every time; four waiters against a submitter that holds, raises and then registers: every waiter's
flush after it found a registration leaves that recording sent. In the source: the lowering after pend.cbs.clear(); in
submit_recording the registration before the lock only when not registered late, after the push and the raise when held,
before the direct submit otherwise; wait_recorded's counter read before its flush; vk_timeline_wait's second flush once its
lookup finds the recording; the docs row.
python -I -B tests/test_flush_nothing_held.py [--cxx clang++]
"""
import argparse
import os
import subprocess
import tempfile
from pathlib import Path
RUN_ALL_ARGS = ["--cxx", "{cxx}"]
ROOT = Path(__file__).resolve().parents[1]
def block(text, marker):
start = text.index(marker)
end = text.index("{", start) + 1
depth = 1
while depth:
depth += (text[end] == "{") - (text[end] == "}")
end += 1
return text[start:end]
def fail(message):
raise SystemExit("FAIL: " + message)
def in_order(text, parts, where):
at = 0
for part in parts:
found = text.find(part, at)
if found < 0:
fail("%s: %r is missing, or not after the part before it" % (where, part))
at = found + len(part)
FIXTURE = r"""
#include <atomic>
#include <chrono>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <mutex>
#include <thread>
#include <vector>
namespace lab_ab {
bool knob = false;
bool on(const char* name) { return knob && !strcmp(name, "nopendheld"); }
}
struct CountingMutex {
std::mutex m;
std::atomic<long> locks{0};
void lock() { locks.fetch_add(1); m.lock(); }
void unlock() { m.unlock(); }
};
struct { CountingMutex present_mu; } dev;
struct { std::vector<int> cbs; } pend;
int flush_reason;
enum { FR_OTHER, FR_POLL, FR_WAIT, FR_VALUE };
std::chrono::steady_clock::time_point pend_since;
DECL
uint64_t held_seq; // (the newest recording in pend; dev.present_mu)
std::atomic<uint64_t> sent_seq{0}; // (the newest one sent)
long flushes;
void queue_flush_locked() { // (the real one's end: the batch out, then the flag lowered)
if (pend.cbs.empty()) return;
flushes++;
sent_seq.store(held_seq, std::memory_order_relaxed);
pend.cbs.clear();
pend_held.store(false, std::memory_order_release);
}
void hold(uint64_t seq) { // (submit_recording's held path)
std::lock_guard lk(dev.present_mu);
pend.cbs.push_back(1);
held_seq = seq;
pend_held.store(true, std::memory_order_release);
}
FLUSH
int main(int argc, char** argv) {
const char* mode = argc > 1 ? argv[1] : "";
int bad = 0;
auto check = [&](bool ok, const char* what) { if (!ok) { std::printf("FAIL %s\n", what); bad++; } };
if (!strcmp(mode, "basic") || !strcmp(mode, "off") || !strcmp(mode, "knob")) {
lab_ab::knob = !strcmp(mode, "knob");
const bool skip = !strcmp(mode, "basic");
const long l0 = dev.present_mu.locks;
for (int i = 0; i < 1000; i++) queue_flush_for(FR_WAIT), queue_flush_poll();
check(skip ? dev.present_mu.locks == l0 : dev.present_mu.locks == l0 + 2000, "nothing held: the lock as the mode says");
check(flushes == 0, "nothing held: no flush");
hold(7);
const long l1 = dev.present_mu.locks;
queue_flush_for(FR_WAIT);
check(dev.present_mu.locks == l1 + 1 && flushes == 1 && sent_seq == 7 && !pend_held.load(), "held: the lock and the flush");
hold(8);
queue_flush_poll();
check(flushes == 2 && sent_seq == 8 && pend.cbs.empty(), "held: the poll flushes (RX_VK_BATCH_POLL_US=0)");
const long l2 = dev.present_mu.locks;
queue_flush_for(FR_WAIT), queue_flush_poll();
check(skip ? dev.present_mu.locks == l2 : dev.present_mu.locks == l2 + 2, "after the flush: nothing held again");
std::printf("%s: %ld locks, %ld flushes\n", mode, (long)dev.present_mu.locks, flushes);
return bad;
}
if (!strcmp(mode, "race")) {
std::mutex map_mu; // (rec_map_mu)
uint64_t registered = 0;
std::atomic<bool> stop{false};
std::atomic<long> late{0}, looks{0};
std::thread submitter([&] {
for (uint64_t s = 1; s <= 200000; s++) {
{
std::lock_guard lk(dev.present_mu);
pend.cbs.push_back(1);
held_seq = s;
pend_held.store(true, std::memory_order_release);
std::lock_guard mk(map_mu); // (registered after the raise, under the lock)
registered = s;
}
if (s % 64 == 0) { std::lock_guard lk(dev.present_mu); queue_flush_locked(); } // (the cap)
}
stop = true;
});
std::vector<std::thread> waiters;
for (int w = 0; w < 4; w++)
waiters.emplace_back([&] {
while (!stop) {
uint64_t s;
{
std::lock_guard mk(map_mu);
s = registered;
}
if (!s) continue;
queue_flush_for(FR_WAIT);
looks++;
if (sent_seq.load(std::memory_order_relaxed) < s) late++;
}
});
submitter.join();
for (auto& t : waiters) t.join();
std::printf("race: %ld looks, %ld left a found recording held\n", (long)looks, (long)late);
return late != 0;
}
return 1;
}
"""
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--cxx", default="clang++")
args = parser.parse_args()
src = (ROOT / "gpu" / "vk" / "vk_replay.cpp").read_text(encoding="utf-8")
if "std::atomic<bool> pend_held{false};" not in src:
fail("vk_replay.cpp has no pend_held")
decl = src[src.index("std::atomic<bool> pend_held{false};"):]
decl = decl[:decl.index(block(decl, "bool pend_held_on() {")) + len(block(decl, "bool pend_held_on() {"))]
flush = block(src, "void queue_flush_for(int why) {") + "\n" + block(src, "void queue_flush_poll() {")
for name in ("queue_flush_for", "queue_flush_poll"):
body = block(src, "void %s(" % name)
if body.index("pend_held.load(std::memory_order_acquire)") > body.index("std::lock_guard lk(dev.present_mu);"):
fail("%s: the look is not before the lock" % name)
locked = block(src, "void queue_flush_locked() {")
in_order(locked, ["pend.cbs.clear()", "pend_held.store(false, std::memory_order_release);"], "queue_flush_locked")
sub = block(src, "void submit_recording(Recording& r, bool signal_value = true, uint64_t signal_at = 0, bool part = false) {")
in_order(sub, ["seq = ++rec_seq;", "const auto register_recording = [&] {", "std::lock_guard mk(rec_map_mu);",
"fin_rec.submitted(rec_open_values, seq, !part);", "};",
"const bool batching = batch_on(), registered_late = batching && pend_held_on();",
"if (!registered_late) register_recording();", "std::lock_guard lk(dev.present_mu);", "if (batch_on()) {",
"for (uint32_t i = 0; i < n; i++) pend.cbs.push_back(cb[i]);", "pend.recs++;",
"pend_held.store(true, std::memory_order_release);", "if (registered_late) register_recording();",
"queue_flush_locked();", "return;", "if (registered_late) register_recording();",
"vkQueueSubmit2(dev.queue, 1, &si, r.fence);"], "submit_recording")
if sub.count("register_recording();") != 3:
fail("submit_recording: the registration is made somewhere this test does not know")
wr = block(src, "bool wait_recorded(uint64_t f, uint64_t timeout_ns, int* ok) {")
in_order(wr, ["seq = it->second;", "pend_held_on() && vkGetSemaphoreCounterValue(dev.device, rec_timeline, &rec_done) == VK_SUCCESS && rec_done >= seq",
"*ok = 1;", "return true;", "queue_flush_for(FR_WAIT);"], "wait_recorded")
tw = block(src, "void vk_timeline_wait(uint64_t v) {")
in_order(tw, ["queue_flush_for(FR_VALUE);", "seq = fin_rec.of(v);", "if (seq && pend_held_on()) queue_flush_for(FR_VALUE);"],
"vk_timeline_wait")
docs = (ROOT / "docs" / "development.md").read_text(encoding="utf-8")
if "`RX_VK_PEND_HELD=0`" not in docs:
fail("docs/development.md: no RX_VK_PEND_HELD row")
print("ok the source: the look before the lock, the lowering after the clear, the registration after the raise, the "
"counter read, the second flush")
with tempfile.TemporaryDirectory(prefix="flush-nothing-held-") as tmp:
c, exe = Path(tmp) / "fixture.cpp", Path(tmp) / "fixture.exe"
c.write_text(FIXTURE.replace("DECL", decl).replace("FLUSH", flush), encoding="utf-8")
subprocess.run([args.cxx, "-std=c++20", "-O1", "-pthread", "-Wall", "-Wextra", "-Werror", str(c), "-o", str(exe)], check=True)
for mode, env in (("basic", {}), ("off", {"RX_VK_PEND_HELD": "0"}), ("knob", {}), ("race", {})):
e = dict(os.environ, RX_VK_BATCH_POLL_US="0")
e.pop("RX_VK_PEND_HELD", None)
e.update(env)
r = subprocess.run([str(exe), mode], capture_output=True, text=True, env=e, timeout=300)
print(("ok " if r.returncode == 0 else "FAIL ") + r.stdout.strip().replace("\n", "; "))
if r.returncode:
fail("the fixture's %s mode" % mode)
print("PASS: flushes with nothing held skip the queue's lock")
if __name__ == "__main__":
main()