mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-21 00:59:59 -04:00
Faster frames (the replay's memory work, held submits, helper threads, collection and capture cuts), the game letting old areas go (QueryMemoryInfo), the 0.5.2 stutter fixed, AMD RX 5000/6000 and integrated-GPU fixes, the GPU device chosen by name, the in-game menus and launcher reworked, controller, Linux and benchmark fixes.
202 lines
12 KiB
Python
202 lines
12 KiB
Python
"""The prepare keeps two stamps, and the driver's part is made from the program cache.
|
|
|
|
hookshot_prepared.bin said what the shaders were translated for (the translator and the seed), and the stage libraries were built
|
|
only as a program was translated. A program kept already was never translated again, so its libraries were never built again
|
|
either: a player who prepared without libraries and then switched them on had "0 new, 0 stage libraries", and after a driver
|
|
update, which empties the driver's cache, nothing made them again. The record now has a sixth word for the driver's part, and
|
|
that part (warm_libraries) walks the kept programs. This builds the record's reader, writer and check as they are in the source
|
|
and checks that a record of before the sixth word reads as warmed for nothing, that the word survives the record being written
|
|
again for a seed's new time, and that it does not survive another translator; and that the pieces are where they have to be: no
|
|
library built in the translation's loop, the walk on both of prepare_run's paths, the list of keys made without reading a
|
|
record, and RX_VK_GPL out of the translator's stamp.
|
|
python -I -B tests/test_prepared_stamps.py [--cxx g++]
|
|
"""
|
|
import argparse
|
|
import subprocess
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
RUN_ALL_ARGS = ["--cxx", "{cxx}"]
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
DRAW = ROOT / "gpu" / "vk" / "vk_draw.cpp"
|
|
SHADER = ROOT / "gpu" / "vk" / "vk_shader.cpp"
|
|
|
|
|
|
def block(text, marker):
|
|
start = text.index(marker)
|
|
at = text.index("{", start) + 1
|
|
depth = 1
|
|
while depth:
|
|
depth += (text[at] == "{") - (text[at] == "}")
|
|
at += 1
|
|
return text[start:at]
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser()
|
|
ap.add_argument("--cxx", default="g++")
|
|
a = ap.parse_args()
|
|
draw = DRAW.read_text(encoding="utf-8")
|
|
shader = SHADER.read_text(encoding="utf-8")
|
|
start = draw.index("struct PreparedFor {")
|
|
helpers = draw[start:draw.index("} // namespace", start)]
|
|
cpp = r"""
|
|
#ifdef _WIN32
|
|
#define NOMINMAX
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#endif
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <filesystem>
|
|
#include <string>
|
|
#include <vector>
|
|
#include "file_whole.h"
|
|
""" + helpers + r"""
|
|
int main(int argc, char** argv) {
|
|
const std::string dir = argv[1], path = dir + "/hookshot_prepared.bin", seed = dir + "/hookshot_shaders.bin";
|
|
int fails = 0;
|
|
const auto put = [&](const std::string& to, const void* d, size_t n) {
|
|
FILE* f = fopen(to.c_str(), "wb");
|
|
fwrite(d, 1, n, f);
|
|
fclose(f);
|
|
};
|
|
const auto size_of = [&] { return (long)std::filesystem::file_size(path); };
|
|
PreparedFor p;
|
|
if (prepared_read(path, &p) != 0 || p.warmed) std::puts("no file: wanted no record"), fails++;
|
|
const uint64_t five[5] = {0x1122334455667788ull, 2, 3, 4, 5}; // (a record of before the sixth word)
|
|
put(path, five, 40);
|
|
if (prepared_read(path, &p) != 2 || p.stamp != five[0] || !p.timed || p.warmed)
|
|
std::puts("a record of five words: wanted it whole, and warmed for nothing"), fails++;
|
|
put(path, five, 8); // (and one of before the seed was in it)
|
|
if (prepared_read(path, &p) != 1 || p.stamp != five[0] || p.warmed) std::puts("the stamp alone: wanted warmed for nothing"), fails++;
|
|
uint8_t cut[44];
|
|
std::memcpy(cut, five, 40);
|
|
std::memset(cut + 40, 9, 4);
|
|
put(path, cut, 44);
|
|
if (prepared_read(path, &p) != 2 || p.warmed) std::puts("a sixth word cut short: wanted warmed for nothing"), fails++;
|
|
PreparedFor w;
|
|
w.stamp = 0xAAAA, w.seed_hash = 7, w.seed_size = 8, w.seed_time = 9, w.warmed = 0xBBBB;
|
|
prepared_write(path, w);
|
|
uint64_t first = 0;
|
|
FILE* f = fopen(path.c_str(), "rb");
|
|
if (fread(&first, 8, 1, f) != 1 || first != 0xAAAA || size_of() != 48) // (prepare_is_update reads the first 8 bytes alone)
|
|
std::puts("the file: wanted 48 bytes, the translator's stamp first"), fails++;
|
|
fclose(f);
|
|
if (prepared_read(path, &p) != 2 || p.stamp != 0xAAAA || p.seed_hash != 7 || p.seed_size != 8 || p.seed_time != 9 || p.warmed != 0xBBBB)
|
|
std::puts("written and read: wanted every word back"), fails++;
|
|
|
|
// the check hands the record's warmed stamp on, and keeps it where it writes the record again itself
|
|
const std::string bytes(70000, 's');
|
|
put(seed, bytes.data(), bytes.size());
|
|
const auto hour_ago = std::filesystem::file_time_type::clock::now() - std::chrono::hours(1);
|
|
std::filesystem::last_write_time(seed, hour_ago);
|
|
PreparedFor now;
|
|
double ms = 0;
|
|
std::filesystem::remove(path);
|
|
if (prepare_check(path, seed, 5, &now, &ms) != PrepareWhy::First || now.warmed) std::puts("first start: wanted nothing warmed"), fails++;
|
|
now.warmed = 0xCCCC;
|
|
prepared_write(path, now);
|
|
PreparedFor next;
|
|
if (prepare_check(path, seed, 5, &next, &ms) != PrepareWhy::None || next.warmed != 0xCCCC)
|
|
std::puts("the next start: wanted the warmed stamp handed on"), fails++;
|
|
// (the seed written again as it was, by a build: hashed, and the record written again by the check for its new time)
|
|
put(seed, bytes.data(), bytes.size());
|
|
std::filesystem::last_write_time(seed, hour_ago + std::chrono::seconds(30));
|
|
if (prepare_check(path, seed, 5, &next, &ms) != PrepareWhy::None || ms == 0) std::puts("rewritten as it was: wanted it hashed, no prepare"), fails++;
|
|
if (prepared_read(path, &p) != 2 || p.warmed != 0xCCCC || p.seed_time != next.seed_time)
|
|
std::puts("rewritten as it was: the record written again lost the warmed stamp, or was not written"), fails++;
|
|
// (another translator: its programs are not these, so nothing of them is warmed)
|
|
if (prepare_check(path, seed, 6, &next, &ms) != PrepareWhy::Translator || next.warmed)
|
|
std::puts("another translator: wanted nothing warmed"), fails++;
|
|
// (a grown seed, the same translator: what was warmed is still warmed for what is kept; prepare_run decides the rest)
|
|
const std::string grown = bytes + "more";
|
|
put(seed, grown.data(), grown.size());
|
|
std::filesystem::last_write_time(seed, hour_ago + std::chrono::seconds(60));
|
|
if (prepare_check(path, seed, 5, &next, &ms) != PrepareWhy::Seed || next.warmed != 0xCCCC)
|
|
std::puts("a grown seed: wanted a prepare, and the warmed stamp handed on"), fails++;
|
|
if (fails) return 1;
|
|
std::puts("ok");
|
|
}
|
|
"""
|
|
with tempfile.TemporaryDirectory(prefix="prepared-stamps-") as tmp:
|
|
c, exe = Path(tmp) / "fixture.cpp", Path(tmp) / "fixture"
|
|
c.write_text(cpp, encoding="utf-8")
|
|
subprocess.run([a.cxx, "-std=c++20", "-Wall", "-I" + str(ROOT / "gpu" / "vk"), str(c), "-o", str(exe)], check=True)
|
|
work = Path(tmp) / "game"
|
|
work.mkdir()
|
|
got = subprocess.run([str(exe), str(work)], capture_output=True, text=True)
|
|
if got.returncode or got.stdout.strip() != "ok":
|
|
raise SystemExit("the prepared file:\n" + got.stdout + got.stderr)
|
|
prepare = block(draw, "bool prepare_run(")
|
|
if "build_graphics(" in prepare:
|
|
raise SystemExit("prepare_run builds stage libraries itself: only for the programs it translates, none for one kept already")
|
|
if prepare.count("warm_libraries(progress)") != 2:
|
|
raise SystemExit("prepare_run: wanted warm_libraries after the translation and on the path with no translation")
|
|
alone = prepare[:prepare.index("seed_open();\n if (!programs)")]
|
|
# ((Triforce) or when the stamp is the same and a sample finds the libraries gone from the cache: tests/test_lib_check.py)
|
|
if "warm_libraries(progress)" not in alone or \
|
|
"if (!cold && (prepared_for.warmed == warmed || background)) return false;" not in alone:
|
|
raise SystemExit("prepare_run does not make the driver's part alone when only its stamp differs")
|
|
at = 0
|
|
for _ in range(2): # (closed in the libraries: not written down as warmed)
|
|
at = prepare.index("if (!warm_libraries(progress)) {", at) + 1
|
|
if prepare.index("return false;", at) > prepare.index("prepared_for.warmed = warmed;\n", at):
|
|
raise SystemExit("prepare_run writes the driver's part down as made when its pass was stopped")
|
|
if prepare.count("prepared_for.warmed = warmed;\n") != 2 or prepare.count("prepared_for.warmed = 0;\n") != 1:
|
|
raise SystemExit("prepare_run: wanted the warmed stamp set on its two ways out, and cleared before the libraries are made")
|
|
cleared = prepare.index("prepared_for.warmed = 0;\n")
|
|
if prepare.index("prepared_write(path, prepared_for);", cleared) > prepare.index("if (!warm_libraries(progress)) {", cleared):
|
|
raise SystemExit("prepare_run: the translation is not written down before the libraries are made")
|
|
stamp = block(draw, "uint64_t warmed_stamp_of(")
|
|
for part in ("program_cache_stamp()", "pipelineCacheUUID", "driverVersion", "libraries", "kWarmRecipe"):
|
|
if part not in stamp:
|
|
raise SystemExit("warmed_stamp leaves out " + part)
|
|
# ((Triforce) the words added where they apply alone: every other device's stamp is what it was, nothing made again there)
|
|
if "if (patches) {" not in stamp or "if (rate) add(&kRateRecipe, sizeof kRateRecipe);" not in stamp or \
|
|
stamp.index("add(v, sizeof v);") > stamp.index("if (patches) {"):
|
|
raise SystemExit("warmed_stamp_of: the module patches' and the rate's words are not added after the others, and only "
|
|
"where they apply")
|
|
if "return warmed_stamp_of(libraries, module_patches(), false);" not in block(draw, "uint64_t warmed_stamp(") or \
|
|
"return warmed_stamp_of(libraries, module_patches(), libraries && dev.foliage_rate);" not in \
|
|
block(draw, "uint64_t libraries_stamp("):
|
|
raise SystemExit("warmed_stamp / libraries_stamp: wanted the modules' patches in both and the rate's libraries in the "
|
|
"driver's part's alone")
|
|
# ((Triforce, 11-19) and bit 2, the water's simplification (shader_water_mode, the RX 470 .. 590 port that came without a
|
|
# new stamp): those cards warm their driver's part again once)
|
|
if "return (dev.fixes.nan_bits && nan_selects ? 1u : 0u) | (shader_water_mode() ? 2u : 0u);" not in block(draw, "uint32_t module_patches("):
|
|
raise SystemExit("module_patches is not the NaN selects' rewrite as make_module decides it, with the water's bit")
|
|
# ((Triforce) and the pipeline cache's <file>.own, which names it (pcache_own_stamp: what a file of the part's own holds,
|
|
# warm_checkpoint.h); nothing there says the part is made)
|
|
own = 'uint64_t pcache_own_stamp() { return libraries_stamp(gpl_wanted() && !getenv("RX_VK_NO_WARM")); }'
|
|
if "const uint64_t warmed = libraries_stamp(libraries);" not in prepare or "libraries_stamp(" in draw.replace(
|
|
"uint64_t libraries_stamp(", "").replace("const uint64_t warmed = libraries_stamp(libraries);", "").replace(own, ""):
|
|
raise SystemExit("the driver's part's stamp (libraries_stamp) is used past prepare_run, or prepare_run does not use it")
|
|
carry = prepare.index("warm_skip_carry(warming + \".skip\", libraries, warmed);")
|
|
if carry > prepare.index("gpl_skip_set(gpl_rules::skip_read(warming + \".skip\", warmed));"):
|
|
raise SystemExit("prepare_run reads the skip list before what the stamp it was carries over")
|
|
carried = block(draw, "void warm_skip_carry(")
|
|
if "if (!gpl_rules::skip_read(skip, now).empty()) return;" not in carried or "gpl_rules::skip_add(skip, now, ids);" not in carried:
|
|
raise SystemExit("warm_skip_carry does not carry the list over only where the new stamp has none")
|
|
warm = block(draw, "bool warm_libraries(")
|
|
for call in ("program_cache_keys(", "program_cache_borrow(", "pipe_notes_read()", "ub_thread_off();", "prepare_stopped()"):
|
|
if call not in warm:
|
|
raise SystemExit("warm_libraries: no " + call)
|
|
if "program_cache_each(" in warm:
|
|
raise SystemExit("warm_libraries lists the programs with program_cache_each, which reads every record")
|
|
keys = block(shader, "std::vector<uint64_t> program_cache_keys(")
|
|
if "fread(" in keys or "disk_records" not in keys or "shader_mu" not in keys:
|
|
raise SystemExit("program_cache_keys: wanted the keys from the list of records and the variants in memory, no record read")
|
|
env = block(shader, "uint64_t disk_stamp(")
|
|
if '"RX_VK_GP"' in env or '"RX_VK_GP_"' not in env:
|
|
raise SystemExit("the translator's stamp takes RX_VK_GPL: switching the libraries on throws the program cache away")
|
|
print("PASS: two stamps in the prepared file; the driver's part is made from the program cache, on its own when it alone is stale")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|