Files
Triforce-Source/tests/test_dlss_prewarm.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

161 lines
9.5 KiB
Python

"""NVIDIA DLSS at the output's size takes a scaled mode with RX_VK_DLSS_PREWARM=1, so the Render resolution row's Auto
makes one feature, not two (gpu/vk/dlss_checks.h dlaa_feature, vk_dlss.cpp prepare; no game, no GPU, no NVIDIA SDK).
(Triforce, 11-22, the performance audit's PRESENT-32, after Source A's: its first step.) prepare made a one-size feature
(NGX's DLAA mode) whenever the render size was the output's. With the row at Auto the game starts at the output's size
and lowers it some frames later: a second feature made in play. With the rule only NVIDIA DLAA gets the one-size mode;
DLSS at full size takes the scaled mode whose range holds it, which the smaller sizes reuse.
The entry's other steps (the feature, the chain's images and a first evaluation made ahead in a light frame) are not
built: see the commit. This checks what is.
It compiles dlss_checks.h and dlss_feature.h and runs prepare's decisions (the reuse test, the one-size test, the mode,
the size the feature is made for: the same functions in the same order, NGX's ranges as it answers them) over a load-in:
17 frames at the output's size, then the game's dynamic resolution going down and up. With the row at Auto: two
features without the rule, one with it, and that one takes every later size. With NVIDIA DLAA: one feature, of one
size, either way. With a fixed share: the same feature either way (the rule changes nothing there). Without the switch
every decision is the one from before.
Then the source: prepare asks dlaa_feature with the switch (read once) and whether DLAA is the Upscaler's choice, the
switch is on only at 1, and its row is in the development guide.
python -I -B tests/test_dlss_prewarm.py [--cxx clang++]
"""
import argparse
import subprocess
import tempfile
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
VK = ROOT / "gpu" / "vk"
RUN_ALL_ARGS = ["--cxx", "{cxx}"]
def check(ok, why):
if not ok:
raise SystemExit("FAIL: " + why)
PROGRAM = r"""
#include <algorithm>
#include <cstdint>
#include <cstdio>
#include "dlss_checks.h"
#include "dlss_feature.h"
static int fails = 0;
#define CHECK(x) do { if (!(x)) { std::printf("FAIL:%d %s\n", __LINE__, #x); fails++; } } while (0)
namespace dc = mkwvk::dlss_checks;
// vk_dlss.cpp prepare's decisions, without NGX: the feature there is, and what a frame of rw x rh into ow x oh does to it
struct Feature {
bool has = false, exact = false, one_size = false;
uint32_t w = 0, h = 0, ow = 0, oh = 0, min_w = 0, min_h = 0;
int mode = -1; // (the index into the scaled modes; -1: the one-size list's first, DLAA's)
};
struct Run {
Feature f;
bool range_seen = false;
int made = 0, refused = 0;
bool rule, dlaa, auto_row;
Run(bool rule, bool dlaa, bool auto_row) : rule(rule), dlaa(dlaa), auto_row(auto_row) {}
void frame(uint32_t rw, uint32_t rh, uint32_t ow, uint32_t oh) {
const bool same = f.has && f.ow == ow && f.oh == oh;
if (same && dlss_feature::takes(f.exact, f.w, f.h, f.min_w, f.min_h, rw, rh)) return; // (the feature there is draws it)
if (dlss_feature::found_range(same, f.exact, f.w, f.h, rw, rh)) range_seen = true;
const bool aa = dc::dlaa_feature(rule, dlaa, rw, rh, ow, oh);
uint32_t max_w = 0, max_h = 0, min_w = 0, min_h = 0;
int mode = -1;
if (aa) {
max_w = min_w = ow, max_h = min_h = oh;
} else {
// (NGX's ranges for the scaled list: Quality, DLAA, Balanced, Performance from half the output to the output's own,
// DLAA's and Ultra Performance's one size)
const dc::ModeRange r[5] = {{ow / 2, oh / 2, ow, oh, true}, {ow, oh, ow, oh, true}, {ow / 2, oh / 2, ow, oh, true},
{ow / 2, oh / 2, ow, oh, true}, {ow / 3, oh / 3, ow / 3, oh / 3, true}};
bool widened = false;
mode = dc::mode_for(r, 5, rw, rh, ow, oh, true, &widened);
if (mode < 0) { refused++; return; }
min_w = std::min(r[mode].min_w, rw), min_h = std::min(r[mode].min_h, rh);
max_w = std::max(r[mode].max_w, rw), max_h = std::max(r[mode].max_h, rh);
}
const dlss_feature::Size s = dlss_feature::size(aa, range_seen || auto_row, rw, rh, max_w, max_h);
f = {true, s.exact, aa, s.w, s.h, ow, oh, min_w, min_h, mode};
made++;
}
};
/// A load-in at an output of ow x oh: 17 frames at `start` percent, then the game's dynamic resolution moving
static void load_in(Run& run, uint32_t ow, uint32_t oh, unsigned start) {
for (int i = 0; i < 17; i++) run.frame(ow * start / 100, oh * start / 100, ow, oh);
for (unsigned pct : {95u, 90u, 80u, 75u, 60u, 50u, 65u, 85u, 100u, 70u}) run.frame(ow * pct / 100, oh * pct / 100, ow, oh);
}
int main() {
const uint32_t outs[][2] = {{1920, 1080}, {2560, 1440}, {3840, 2160}, {4416, 1864}, {5120, 2160}};
for (const auto& o : outs) {
// NVIDIA DLSS, the Render resolution row at Auto, the game starting at the output's size
Run before(false, false, true), with(true, false, true);
load_in(before, o[0], o[1], 100), load_in(with, o[0], o[1], 100);
CHECK(before.made == 2 && before.refused == 0); // (the one-size feature, then the scaled mode's)
CHECK(with.made == 1 && with.refused == 0); // (the scaled mode's from the first frame)
CHECK(with.f.mode == 0 && !with.f.one_size && !with.f.exact && with.f.w == o[0] && with.f.h == o[1]);
CHECK(before.f.mode == with.f.mode && before.f.w == with.f.w && before.f.h == with.f.h && before.f.exact == with.f.exact);
// NVIDIA DLAA: the output's one size, either way, and never a second feature at that size
Run aa_before(false, true, false), aa_with(true, true, false);
for (int i = 0; i < 40; i++) aa_before.frame(o[0], o[1], o[0], o[1]), aa_with.frame(o[0], o[1], o[0], o[1]);
CHECK(aa_before.made == 1 && aa_with.made == 1 && aa_before.f.one_size && aa_with.f.one_size);
CHECK(aa_with.f.w == o[0] && aa_with.f.h == o[1] && aa_with.f.mode == -1);
// a fixed share (the row's Quality, 8 twelfths rounded up as the menu does): the rule changes nothing
const uint32_t rw = (o[0] * 8 + 11) / 12, rh = o[1] * 8 / 12;
Run fixed_before(false, false, false), fixed_with(true, false, false);
for (int i = 0; i < 40; i++) fixed_before.frame(rw, rh, o[0], o[1]), fixed_with.frame(rw, rh, o[0], o[1]);
CHECK(fixed_before.made == 1 && fixed_with.made == 1 && fixed_with.f.exact && fixed_with.f.w == rw && fixed_with.f.h == rh);
CHECK(fixed_before.f.mode == fixed_with.f.mode && fixed_before.f.w == fixed_with.f.w);
// DLSS with a fixed share of all of the output (one saved with the game's own): one size before, the scaled mode's with
Run full_before(false, false, false), full_with(true, false, false);
for (int i = 0; i < 40; i++) full_before.frame(o[0], o[1], o[0], o[1]), full_with.frame(o[0], o[1], o[0], o[1]);
CHECK(full_before.made == 1 && full_with.made == 1 && full_before.f.one_size && !full_with.f.one_size && full_with.f.mode == 0);
}
std::printf("the row's Auto from the output's size down: 2 features before, 1 with the rule, at %d outputs\n",
(int)(sizeof outs / sizeof outs[0]));
return fails ? 1 : 0;
}
"""
def check_source():
dlss = (VK / "vk_dlss.cpp").read_text(encoding="utf-8")
prepare = dlss[dlss.index("int prepare(VkCommandBuffer cmd"):]
prepare = prepare[:prepare.index("\n}\n")]
check('static const bool dlaa_rule = dlss_checks::prewarm_rule(getenv("RX_VK_DLSS_PREWARM"));' in prepare,
"prepare does not read RX_VK_DLSS_PREWARM once")
one = "const bool aa = dlss_checks::dlaa_feature(dlaa_rule, temporal_mode() == upscaler_rows::DLAA, rw, rh, ow, oh);"
check(one in prepare and "const bool aa = rw == ow && rh == oh;" not in prepare and prepare.count("const bool aa =") == 1,
"prepare's one-size test is not dlaa_feature's, with the switch and the Upscaler's choice")
check(prepare.index(one) < prepare.index("const NVSDK_NGX_PerfQuality_Value* modes = aa ? same : scaled;")
< prepare.index("dlss_feature::size(aa, "), "prepare picks its modes or its size before the one-size test")
checks = (VK / "dlss_checks.h").read_text(encoding="utf-8")
check("return rule ? full && dlaa : full;" in checks and "return text && *text && std::atoi(text) == 1;" in checks,
"dlss_checks.h: the rule is not off unless RX_VK_DLSS_PREWARM=1, or is not the entry's")
docs = (ROOT / "docs" / "development.md").read_text(encoding="utf-8")
check("| `RX_VK_DLSS_PREWARM=1` |" in docs, "docs/development.md has no row for RX_VK_DLSS_PREWARM")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--cxx", default="clang++")
args = parser.parse_args()
check_source()
with tempfile.TemporaryDirectory(prefix="dlss-prewarm-") as tmp:
src, exe = Path(tmp) / "prewarm.cpp", Path(tmp) / "prewarm.exe"
src.write_text(PROGRAM, encoding="utf-8")
subprocess.run([args.cxx, "-std=c++20", "-O1", "-Wall", "-Wextra", "-Werror", "-I", str(VK), str(src), "-o", str(exe)], check=True)
out = subprocess.run([str(exe)], stdout=subprocess.PIPE, text=True, timeout=60)
print(out.stdout.strip())
if out.returncode:
raise SystemExit("FAIL: the rule's run")
print("PASS: with RX_VK_DLSS_PREWARM=1 DLSS at the output's size takes a scaled mode (one feature for the row's Auto); "
"off, every decision is the one from before")
if __name__ == "__main__":
main()