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

758 lines
40 KiB
C++

// The actual save function, with authored cache bytes and Vulkan/file API spies. No driver is loaded.
#include <atomic>
#include <chrono>
#include <cstdarg>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <exception>
#include <limits>
#include <new>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
#ifdef _WIN32
#include <windows.h>
#else
#include <sys/stat.h>
#include <unistd.h>
constexpr int MOVEFILE_REPLACE_EXISTING = 1, MOVEFILE_WRITE_THROUGH = 8;
void Sleep(unsigned ms) { std::this_thread::sleep_for(std::chrono::milliseconds(ms)); }
#endif
#include "file_whole.h" // ((Triforce, handoff §8) the save's Writing, and its .for file written whole)
// Arm only the allocating thread, after the query/copy API or immediately before thread construction.
// Real std::vector, std::string and std::thread allocations still run; nothing models their failure handling.
thread_local bool fail_next_new = false;
std::atomic<int> allocation_failures{0};
void* operator new(std::size_t n) {
if (fail_next_new) {
fail_next_new = false;
++allocation_failures;
throw std::bad_alloc();
}
if (void* p = std::malloc(n ? n : 1)) return p;
throw std::bad_alloc();
}
// Keep the replacement allocator boundary: GCC must not inline free into a caller of operator new.
[[gnu::noinline]] void operator delete(void* p) noexcept { std::free(p); }
void operator delete(void* p, std::size_t) noexcept { ::operator delete(p); }
void* operator new[](std::size_t n) { return ::operator new(n); }
void operator delete[](void* p) noexcept { ::operator delete(p); }
void operator delete[](void* p, std::size_t) noexcept { ::operator delete(p); }
using VkResult = int;
constexpr VkResult VK_SUCCESS = 0, VK_INCOMPLETE = 5, VK_ERROR_UNKNOWN = -13;
// props: the save in play is left out on Intel; the fixture's card is not one.
struct { int device = 1; struct { unsigned vendorID = 0x10DE; } props; } dev;
int pcache = 2;
// The stamp the file is kept for (written beside it as <file>.for), and the file's bound (0: none).
unsigned long long program_cache_stamp() { return 0x1122334455667788ull; }
#include "pcache_bound.h"
std::uint64_t pcache_bound_bytes = 0;
std::string pcache_path;
std::atomic<int64_t> pcache_built_since_save{32};
std::atomic<std::size_t> pcache_saved_size{0};
// The size the driver gives for the cache's data; a case grows it for pipelines taken in between saves.
std::atomic<std::size_t> cache_size{64};
enum Fault { NONE, VECTOR_ALLOC, VECTOR_LENGTH, TMP_ALLOC, QUERY_FAIL, EMPTY, COPY_FAIL, SHORT_WRITE, BLOCK_COPY, REPLACE_FAIL };
std::atomic<Fault> fault{NONE};
std::atomic<int> queries{0}, copies{0}, writes{0}, replacements{0}, save_errors{0}, start_errors{0};
std::atomic<bool> copy_blocked{false}, allow_copy{false};
// ((Triforce) the workers building while a checkpoint fetches (warm_checkpoint.h): the cache grows by this between the size
// asked and each copy, up to grow_until)
std::atomic<std::size_t> grow_on_copy{0}, grow_until{0};
std::atomic<int> incompletes{0};
#define CHECK(c) do { if (!(c)) { std::fprintf(stderr, "FAIL line %d: %s\n", __LINE__, #c); return 1; } } while (0)
void logf(const char* fmt, ...) {
char line[512];
va_list args;
va_start(args, fmt);
std::vsnprintf(line, sizeof line, fmt, args);
va_end(args);
std::fprintf(stderr, "%s\n", line);
if (std::strstr(line, "pipeline cache save failed:")) ++save_errors;
if (std::strstr(line, "could not start pipeline cache save:")) ++start_errors;
}
VkResult vkGetPipelineCacheData(int device, int cache, std::size_t* n, void* data) {
if (device != dev.device || cache != pcache) std::abort();
if (!data) {
++queries;
if (fault == QUERY_FAIL) return VK_ERROR_UNKNOWN;
*n = fault == VECTOR_LENGTH ? (std::numeric_limits<std::size_t>::max)() : fault == EMPTY ? 0 : cache_size.load();
if (fault == VECTOR_ALLOC) fail_next_new = true;
} else {
// (the data as the call found it: taken in by a pipeline built after it began, it need not be in this copy. Read
// before the copy is counted, which a case waits for before it grows the cache)
if (grow_on_copy && cache_size < grow_until) cache_size = std::min(cache_size + grow_on_copy, grow_until.load());
const std::size_t has = cache_size.load();
++copies;
if (fault == COPY_FAIL) return VK_ERROR_UNKNOWN;
if (fault == BLOCK_COPY) {
copy_blocked = true;
while (!allow_copy.load()) Sleep(1);
}
// (as the Vulkan rule has it: at most *n written, VK_INCOMPLETE when the data is larger, *n what was written)
const std::size_t put = std::min(*n, has);
std::memset(data, 'N', put);
*n = put;
if (fault == TMP_ALLOC) fail_next_new = true;
if (put < has) {
++incompletes;
return VK_INCOMPLETE;
}
}
return VK_SUCCESS;
}
std::size_t save_fwrite(const void* p, std::size_t size, std::size_t n, FILE* f) {
// The stamp written beside a saved file (<file>.for) is not the cache's data: neither counted nor made to fail.
if (n == 16 && std::memcmp(p, "1122334455667788", 16) == 0) return std::fwrite(p, size, n, f);
++writes;
if (fault == SHORT_WRITE) return 0;
return std::fwrite(p, size, n, f);
}
std::atomic<int> write_through{0};
int save_replace(const char* from, const char* to, unsigned flags) {
if ((flags & ~(unsigned)MOVEFILE_WRITE_THROUGH) != (unsigned)MOVEFILE_REPLACE_EXISTING || to != pcache_path) std::abort();
if (flags & MOVEFILE_WRITE_THROUGH) ++write_through;
++replacements;
if (fault == REPLACE_FAIL) return 0;
#ifdef _WIN32
return MoveFileExA(from, to, flags);
#else
return std::rename(from, to) == 0;
#endif
}
// (Triforce) The cache's gate (vk_draw.cpp pcache_use, pcache_gate.h): closed, the cache was let go for the PC's RAM and is
// neither asked nor written again. And the RAM a copy of the data needs in play (vk_memory.cpp memory_ram_fits)
std::atomic<bool> let_go{false}, ram_fits{true};
std::atomic<int> fit_asks{0};
struct UseStub {
int cache;
};
UseStub pcache_use() { return {let_go ? 0 : pcache}; }
bool memory_ram_fits(std::uint64_t bytes) {
++fit_asks;
return bytes && ram_fits;
}
// ((Triforce) and the same looked at now, for the preparation's checkpoint saves: vk_memory.cpp memory_ram_fits_now)
bool memory_ram_fits_now(std::uint64_t bytes) {
++fit_asks;
return bytes && ram_fits;
}
// ((Triforce) A checkpoint's (vk_draw.cpp, warm_checkpoint.h): the flag on its thread, a stop asked, the file flushed, the disk's
// room. And whether the cache began from the file, and the stamp the file's .own names (pcache_own_mark)
#include "warm_checkpoint.h"
thread_local bool pcache_checkpoint_now = false;
std::atomic<bool> stop_asked{false}, disk_room{true};
std::atomic<int> flushes{0}, disk_asks{0}, stop_asks{0};
// (a stop asked once this many stop asks were made: the first, before the fetch; the next, between the parts of the write)
std::atomic<int> stop_after{-1};
bool prepare_stopped() {
const int k = ++stop_asks;
return stop_asked || (stop_after >= 0 && k > stop_after);
}
bool pcache_file_flush(FILE* f) {
++flushes;
return std::fflush(f) == 0;
}
bool pcache_disk_fits(std::uint64_t) {
++disk_asks;
return disk_room;
}
bool pcache_from_file = false;
std::uint64_t pcache_own_stamp() { return 0xabcdef0123456789ull; }
// (Triforce) The play file (vk_draw.cpp pcache_play_save, pcache_play.h; tests/test_pcache_play.py): no play cache here, so the
// main file is saved as before
std::atomic<int64_t> pcache_main_built{0};
std::atomic<int> pcache_preparing{0};
bool pcache_play_save(int64_t) { return true; }
thread_local bool pcache_play_only_now = false; // ((Triforce, 11-22, PIPE-23) vk_draw.cpp: precompile_end_save's play-only save)
int pcache_play_cache = 0;
std::atomic<std::size_t> pcache_play_saved{0};
void pcache_main_written(int64_t) {}
// (Triforce) The carry over a stamp change (pcache_carry.h, tests/test_pcache_carry.py): vk_draw.cpp's own part, as it is
// (pcache_carry_past, pcache_carry_save_ok, pcache_carry_check, pcache_carry_held, pcache_carry_early, pcache_carry_saved, cut
// out by tests/test_pipeline_cache_save.py):
// a carried session writes only up to its cap or the bound where lower, past it names the stamp in <file>.nocarry, and each
// save in place writes the history beside the file
#include <mutex>
#include "pcache_carry.h"
#include "pcache_carry_part.inc"
#define fwrite save_fwrite
#define MoveFileExA save_replace
#include "pipeline_cache_save.inc"
#undef MoveFileExA
#undef fwrite
// ((Triforce) the preparation's checkpoint save, vk_draw.cpp's as it is (warm_checkpoint.h), through the save above
#include "pcache_checkpoint_save.inc"
bool wait_until(const std::atomic<int>& n, int target) {
const auto end = std::chrono::steady_clock::now() + std::chrono::seconds(3);
while (n.load() < target && std::chrono::steady_clock::now() < end) Sleep(1);
return n.load() >= target;
}
bool old_file() {
FILE* f = std::fopen(pcache_path.c_str(), "rb");
if (!f) return false;
char data[4]{};
const auto n = std::fread(data, 1, sizeof data, f);
std::fclose(f);
return n == 3 && std::memcmp(data, "old", 3) == 0;
}
bool side_file(std::uint64_t base, std::uint32_t carried) {
FILE* f = std::fopen((pcache_path + ".base").c_str(), "rb");
if (!f) return false;
std::uint8_t raw[pcache_carry::kSideBytes]{};
const auto n = std::fread(raw, 1, sizeof raw, f);
std::fclose(f);
pcache_carry::Side s;
return pcache_carry::get(raw, n, &s) && s.base == base && s.carried == carried && !std::memcmp(s.stamp, "1122334455667788", 16);
}
// The side file's open word (pcache_carry.h Side::open), -1 when there is no side file
int side_open() {
FILE* f = std::fopen((pcache_path + ".base").c_str(), "rb");
if (!f) return -1;
std::uint8_t raw[pcache_carry::kSideBytes]{};
const auto n = std::fread(raw, 1, sizeof raw, f);
std::fclose(f);
pcache_carry::Side s;
return pcache_carry::get(raw, n, &s) ? (int)s.open : -1;
}
// The 16 digits a side file of the pipeline cache's has ("" when there is none)
std::string sixteen(const std::string& path) {
FILE* f = std::fopen(path.c_str(), "rb");
if (!f) return "";
char data[17]{};
const auto n = std::fread(data, 1, 16, f);
std::fclose(f);
return n == 16 ? std::string(data, 16) : "";
}
bool tmp_left() {
FILE* f = std::fopen((pcache_path + ".tmp").c_str(), "rb");
if (f) std::fclose(f);
return f != nullptr;
}
bool nocarry_file() {
FILE* f = std::fopen((pcache_path + ".nocarry").c_str(), "rb");
if (!f) return false;
char data[17]{};
const auto n = std::fread(data, 1, sizeof data, f);
std::fclose(f);
return n == 16 && !std::memcmp(data, "1122334455667788", 16);
}
bool new_file() {
FILE* f = std::fopen(pcache_path.c_str(), "rb");
if (!f) return false;
char data[257]{};
const auto n = std::fread(data, 1, sizeof data, f);
std::fclose(f);
if (n != cache_size) return false;
for (std::size_t i = 0; i < n; ++i) if (data[i] != 'N') return false;
return true;
}
int run(const std::string& name) {
if (name == "success") {
pcache_built_since_save = 31;
pipeline_cache_save(false);
CHECK(queries == 0 && old_file());
pcache_built_since_save = 32;
pipeline_cache_save(false);
CHECK(wait_until(copies, 1));
cache_size = 96; // Pipelines taken in meanwhile: the forced save has new data to write.
pipeline_cache_save(true); // Wait for the worker, then preserve the existing forced-save behavior.
CHECK(queries == 2 && writes == 2 && replacements == 2 && new_file());
CHECK(save_errors == 0 && start_errors == 0);
pcache = 0;
pipeline_cache_save(true);
CHECK(queries == 2);
} else if (name == "force-vector" || name == "async-vector" || name == "force-length" ||
name == "force-string" || name == "async-string") {
fault = name == "force-length" ? VECTOR_LENGTH : name.find("string") != std::string::npos ? TMP_ALLOC : VECTOR_ALLOC;
const bool async = name.starts_with("async");
pipeline_cache_save(!async);
CHECK(wait_until(save_errors, 1));
CHECK(old_file() && replacements == 0 && start_errors == 0);
CHECK(allocation_failures == (fault == VECTOR_LENGTH ? 0 : 1));
fault = NONE;
pipeline_cache_save(true);
CHECK(new_file() && replacements == 1 && queries == 2); // No stuck busy flag after the failure.
} else if (name == "thread-start") {
fail_next_new = true;
pipeline_cache_save(false); // The real std::thread's state allocation, before it can run the worker.
CHECK(!fail_next_new && allocation_failures == 1 && start_errors == 1 && save_errors == 0);
CHECK(queries == 0 && old_file());
pipeline_cache_save(true);
CHECK(new_file() && queries == 1 && replacements == 1);
} else if (name == "api-results") {
for (Fault f : {QUERY_FAIL, EMPTY, COPY_FAIL}) {
fault = f;
pipeline_cache_save(true);
CHECK(old_file() && replacements == 0 && save_errors == 0 && start_errors == 0);
}
fault = NONE;
pipeline_cache_save(true);
CHECK(new_file() && replacements == 1);
} else if (name == "short-write") {
fault = SHORT_WRITE;
pipeline_cache_save(true);
CHECK(writes == 1 && replacements == 0 && old_file());
fault = NONE;
pipeline_cache_save(true);
CHECK(new_file() && replacements == 1);
} else if (name == "forced-wait") {
fault = BLOCK_COPY;
pipeline_cache_save(false);
const auto end = std::chrono::steady_clock::now() + std::chrono::seconds(3);
while (!copy_blocked.load() && std::chrono::steady_clock::now() < end) Sleep(1);
CHECK(copy_blocked);
std::atomic<bool> started{false}, finished{false};
std::thread waiter([&] { started = true; pipeline_cache_save(true); finished = true; });
while (!started.load()) Sleep(1);
Sleep(20);
const bool waited = !finished.load() && queries == 1;
cache_size = 96; // Taken in while the first save copied: the waiter has new data to write.
allow_copy = true;
waiter.join();
CHECK(waited && finished && queries == 2 && replacements == 2 && new_file());
} else if (name == "unchanged") {
pcache_saved_size = 64; // As pcache_init leaves it: the driver's size for the data read from the file.
pipeline_cache_save(true); // At exit, nothing taken in.
CHECK(queries == 1 && copies == 0 && writes == 0 && old_file());
pcache_built_since_save = 32; // In play: the precompile's pipelines, all found in the cache, still count.
pipeline_cache_save(false);
CHECK(wait_until(queries, 2));
pipeline_cache_save(true); // After the worker.
CHECK(queries == 3 && copies == 0 && writes == 0 && replacements == 0 && old_file());
cache_size = 96;
for (Fault f : {SHORT_WRITE, REPLACE_FAIL}) { // Not in place: tried again at the next save.
fault = f;
pipeline_cache_save(true);
CHECK(old_file() && pcache_saved_size == 64);
}
fault = NONE;
pipeline_cache_save(true);
CHECK(queries == 6 && copies == 3 && writes == 3 && replacements == 2 && new_file() && pcache_saved_size == 96);
pipeline_cache_save(true); // Written: nothing new since.
CHECK(queries == 7 && copies == 3 && writes == 3 && replacements == 2 && new_file());
cache_size = 80; // A different size of any kind is data the file lacks.
pipeline_cache_save(true);
CHECK(copies == 4 && replacements == 3 && new_file());
CHECK(save_errors == 0 && start_errors == 0);
} else if (name == "over-bound") {
pcache_bound_bytes = 80; // The data is 64 bytes: under the bound, written as ever.
pipeline_cache_save(true);
CHECK(new_file() && replacements == 1 && pcache_saved_size == 64);
cache_size = 80; // At the bound: still written.
pipeline_cache_save(true);
CHECK(new_file() && replacements == 2 && pcache_saved_size == 80);
cache_size = 96; // Over it: its size is asked, nothing is fetched or written, and the file keeps its last save.
pipeline_cache_save(true);
CHECK(queries == 3 && copies == 2 && writes == 2 && replacements == 2 && pcache_saved_size == 80);
cache_size = 80;
CHECK(new_file());
cache_size = 96;
pcache_built_since_save = 32; // In play too, on the worker.
pipeline_cache_save(false);
CHECK(wait_until(queries, 4));
pipeline_cache_save(true); // After the worker.
CHECK(queries == 5 && copies == 2 && writes == 2 && replacements == 2 && pcache_saved_size == 80);
pcache_bound_bytes = 0; // The bound lifted: the same data is written.
pipeline_cache_save(true);
CHECK(new_file() && copies == 3 && replacements == 3 && pcache_saved_size == 96);
CHECK(save_errors == 0 && start_errors == 0);
} else if (name == "carry-cap") {
// (Triforce) Carried over a stamp change with a base of 64 bytes: written up to 80 (1.25 x), its history with it.
pcache_carried = true;
pcache_side.base = 64, pcache_side.carried = 1;
pipeline_cache_save(true);
CHECK(new_file() && replacements == 1 && side_file(64, 1) && pcache_side.base == 64 && pcache_side.carried == 1);
CHECK(std::memcmp(pcache_side.stamp, "1122334455667788", 16) == 0);
cache_size = 80; // At the cap: still written, the base kept (a carried file's growth is not a new base).
pipeline_cache_save(true);
CHECK(new_file() && replacements == 2 && side_file(64, 1) && pcache_saved_size == 80);
CHECK(!pcache_carry_over && !nocarry_file());
cache_size = 96; // Past it: the size asked, nothing fetched or written, the file keeps its last save.
pipeline_cache_save(true);
CHECK(queries == 3 && copies == 2 && writes == 2 && replacements == 2 && pcache_saved_size == 80);
CHECK(pcache_carry_over && nocarry_file()); // Over: the rebuild is due, and a preparation begun again starts fresh.
cache_size = 80;
CHECK(new_file() && side_file(64, 1));
cache_size = 96; // Asked again: refused again.
pipeline_cache_save(true);
CHECK(copies == 2 && replacements == 2);
// A fresh cache in its place (pcache_carry_rebuild): no carry, its saves written and the base follows them.
pcache_carried = false;
pcache_carry_over = false;
pcache_side = pcache_carry::session(pcache_carry::Start::Fresh, pcache_side);
pipeline_cache_save(true);
CHECK(new_file() && replacements == 3 && pcache_side.base == 96 && pcache_side.carried == 0 && side_file(96, 0));
CHECK(!pcache_carry_over && save_errors == 0 && start_errors == 0);
} else if (name == "carry-bound") {
// (Triforce) Carried with a base of 64 bytes (cap 80) and a bound of 72: past the bound, under the cap, is past what it
// may hold (never left over the bound unwritten with no rebuild), and the bound's own refusal is not reached.
pcache_carried = true;
pcache_side.base = 64, pcache_side.carried = 1;
pcache_bound_bytes = 72;
cache_size = 72; // At the bound: written.
pipeline_cache_save(true);
CHECK(new_file() && replacements == 1 && !pcache_carry_over && !nocarry_file());
cache_size = 76; // Over the bound, under the cap.
pipeline_cache_save(true);
CHECK(copies == 1 && replacements == 1 && pcache_carry_over && nocarry_file() && pcache_saved_size == 72);
cache_size = 72;
CHECK(new_file());
// Not carried, the same size over the bound: the bound's rule as before, no rebuild asked.
pcache_carried = false;
pcache_carry_over = false;
cache_size = 76;
pipeline_cache_save(true);
CHECK(copies == 1 && replacements == 1 && !pcache_carry_over);
CHECK(save_errors == 0 && start_errors == 0);
} else if (name == "carry-done") {
// (Triforce) A carried session's history is open (pcache_carry.h Side::open) until its preparation goes through to
// its end (pcache_carry_close): a stopped one's save is read as carried by the preparation begun again.
pcache_carried = true;
pcache_side.base = 64;
std::memcpy(pcache_side.stamp, "aaaaaaaaaaaaaaaa", 16); // (the old stamp's file)
pcache_side = pcache_carry::session(pcache_carry::Start::Carried, pcache_side);
CHECK(pcache_side.open == 1 && pcache_side.carried == 1);
pcache_carry_close(); // Nothing saved under these shaders yet: no side file written, the next save writes it.
CHECK(side_open() == -1 && pcache_side.open == 0);
pcache_side.open = 1;
pipeline_cache_save(true); // Saved (a stop's last save): these shaders' stamp, the history open.
CHECK(new_file() && side_file(64, 1) && side_open() == 1);
pcache_carry_close(); // Gone through: no longer open, beside the file at once.
CHECK(side_file(64, 1) && side_open() == 0 && pcache_side.open == 0 && replacements == 1);
pcache_side.open = 1;
cache_size = 80;
pipeline_cache_save(true);
CHECK(replacements == 2 && side_open() == 1);
cache_size = 96; // Past what it may hold: not written, and not done: the file's history stays open.
pipeline_cache_save(true);
CHECK(replacements == 2 && pcache_carry_over && nocarry_file());
pcache_carry_close();
CHECK(side_open() == 1 && pcache_side.open == 1);
// Not carried (a fresh cache, pcache_carry_rebuild): nothing to do.
pcache_carried = false;
pcache_carry_over = false;
pcache_side = pcache_carry::session(pcache_carry::Start::Fresh, pcache_side);
pipeline_cache_save(true);
CHECK(replacements == 3 && side_file(96, 0) && side_open() == 0);
pcache_carry_close();
CHECK(side_open() == 0 && save_errors == 0 && start_errors == 0);
} else if (name == "checkpoint") {
// (Triforce) A checkpoint mid-warm (warm_checkpoint.h) in a session that carried the file over a stamp change (base
// 64, cap 80): saved under these shaders' stamp with the history open, as a stopped run's save. The start after a
// crash there reads it as carried still (pcache_carry::resumed), capped as this run was, and past the cap rebuilds.
pcache_carried = true;
pcache_side.base = 64;
std::memcpy(pcache_side.stamp, "aaaaaaaaaaaaaaaa", 16); // (the old stamp's file)
pcache_side = pcache_carry::session(pcache_carry::Start::Carried, pcache_side);
cache_size = 72;
ram_fits = false; // The RAM short: nothing fetched, nothing written, the old file kept.
CHECK(pcache_checkpoint_save() == 0 && fit_asks == 1 && copies == 0 && replacements == 0 && old_file());
ram_fits = true;
CHECK(pcache_checkpoint_save() == 72 && copies == 1 && replacements == 1 && new_file());
CHECK(side_file(64, 1) && side_open() == 1 && !pcache_carry_over);
{ // (the .for names these shaders now: the next start finds the file the same stamp's)
FILE* f = std::fopen((pcache_path + ".for").c_str(), "rb");
CHECK(f);
char had[17]{};
const auto got = std::fread(had, 1, 16, f);
std::fclose(f);
CHECK(got == 16 && !std::memcmp(had, "1122334455667788", 16));
}
CHECK(pcache_checkpoint_save() == 0 && copies == 1 && replacements == 1); // Nothing new: nothing written.
{ // The start after a crash here, as pcache_init reads the files: the same stamp, its history open, an update's
// preparation: carried still, no carry counted again, capped at 80 as this run was.
FILE* f = std::fopen((pcache_path + ".base").c_str(), "rb");
CHECK(f);
std::uint8_t raw[pcache_carry::kSideBytes]{};
const auto got = std::fread(raw, 1, sizeof raw, f);
std::fclose(f);
pcache_carry::Side had;
CHECK(pcache_carry::get(raw, got, &had));
const pcache_carry::Side history = pcache_carry::history(true, had, "1122334455667788", 72);
CHECK(pcache_carry::resumed(true, true, true, history));
const pcache_carry::Side again = pcache_carry::session(pcache_carry::Start::Same, history);
CHECK(again.open == 1 && again.carried == 1 && again.base == 64);
CHECK(!pcache_carry::over(true, 80, again, 0) && pcache_carry::over(true, 81, again, 0));
}
cache_size = 96; // Past the cap at a checkpoint: not written, the rebuild asked, the file as the last checkpoint left it.
CHECK(pcache_checkpoint_save() == 0 && copies == 1 && replacements == 1 && pcache_carry_over && nocarry_file());
cache_size = 72;
CHECK(new_file() && side_open() == 1);
// Not carried (a fresh cache): a checkpoint writes it, its history not open.
pcache_carried = false;
pcache_carry_over = false;
pcache_side = pcache_carry::session(pcache_carry::Start::Fresh, pcache_side);
cache_size = 88;
CHECK(pcache_checkpoint_save() == 88 && replacements == 2 && side_file(88, 0) && side_open() == 0);
let_go = true; // The cache let go: not asked.
const int asked = queries.load();
CHECK(pcache_checkpoint_save() == 0 && queries == asked && replacements == 2);
CHECK(save_errors == 0 && start_errors == 0);
} else if (name == "checkpoint-grow") {
// (Triforce) A checkpoint while the workers build (warm_checkpoint.h): the cache grows between the size asked and the
// copy. A save of the other kind (the size asked, no room) gets VK_INCOMPLETE and writes nothing, as before; a
// checkpoint fetches with room, writes what the driver gave, on the disk before it takes the old file's place.
grow_on_copy = 8, grow_until = 1u << 30;
pipeline_cache_save(true);
CHECK(incompletes == 1 && copies == 1 && replacements == 0 && old_file() && !tmp_left());
CHECK(pcache_checkpoint_save() == 80 && incompletes == 1 && copies == 2 && replacements == 1 && new_file());
CHECK(flushes == 1 && write_through == 1 && disk_asks == 1 && pcache_saved_size == 80);
// The other saves: no flush, no write-through, the disk not asked (nothing changed for them).
grow_on_copy = 0;
cache_size = 96;
pipeline_cache_save(true);
CHECK(replacements == 2 && new_file() && flushes == 1 && write_through == 1 && disk_asks == 1);
// Carried (base 64, cap 80): asked at 76, fetched at 84, past the cap. Looked at again on what was fetched: not written,
// the rebuild asked.
pcache_carried = true;
pcache_side.base = 64, pcache_side.carried = 1;
cache_size = 76, grow_on_copy = 8;
CHECK(pcache_checkpoint_save() == 0 && copies == 4 && replacements == 2 && pcache_carry_over && nocarry_file());
pcache_carried = false;
pcache_carry_over = false;
// The bound (88): asked at 84, fetched at 92, over it: not written.
pcache_bound_bytes = 88;
cache_size = 84;
CHECK(pcache_checkpoint_save() == 0 && copies == 5 && replacements == 2);
pcache_bound_bytes = 0;
// Growing past the room at every try: kFetchTries copies, the size asked again before each, nothing written.
grow_on_copy = warm_checkpoint::kRoomMin + 8;
const int had = copies.load(), asked = queries.load();
CHECK(pcache_checkpoint_save() == 0 && copies == had + warm_checkpoint::kFetchTries && replacements == 2);
CHECK(queries == asked + 1 + warm_checkpoint::kFetchTries && incompletes == 1 + warm_checkpoint::kFetchTries);
CHECK(save_errors == 0 && start_errors == 0);
} else if (name == "checkpoint-stop") {
// (Triforce) A stop asked (warm_checkpoint.h): a checkpoint gives up, before the fetch or in the write, and leaves no
// .tmp; the stop's own save (not a checkpoint) writes the cache as ever.
stop_asked = true;
CHECK(pcache_checkpoint_save() == 0 && copies == 0 && replacements == 0 && old_file());
stop_asked = false;
stop_after = stop_asks.load() + 1; // (the look before the fetch says not stopped, the one in the write says stopped)
CHECK(pcache_checkpoint_save() == 0 && copies == 1 && writes == 0 && replacements == 0 && old_file() && !tmp_left());
stop_after = -1;
stop_asked = true;
pipeline_cache_save(true);
CHECK(replacements == 1 && new_file() && flushes == 0);
stop_asked = false;
cache_size = 72;
CHECK(pcache_checkpoint_save() == 72 && replacements == 2 && new_file());
// The disk short of room for the .tmp beside the old file: not fetched, asked again later.
disk_room = false;
cache_size = 80;
CHECK(pcache_checkpoint_save() == 0 && copies == 3 && replacements == 2);
disk_room = true;
CHECK(pcache_checkpoint_save() == 80 && replacements == 3 && new_file());
// A write that fails leaves no .tmp to fill the disk.
cache_size = 88;
fault = SHORT_WRITE;
CHECK(pcache_checkpoint_save() == 0 && replacements == 3 && !tmp_left());
fault = NONE;
CHECK(save_errors == 0 && start_errors == 0);
} else if (name == "carry-begun") {
// (Triforce) pcache_carry.h begun: a carried session's save writes its history (these shaders' stamp, open) before the
// data takes the old file's place, and the .for after. Cut between them (here: the data not put in place), the start
// after reads the session's own history, capped, not one fresh set of the file's size, uncapped.
CHECK(file_writers::write_whole(pcache_path + ".for", "aaaaaaaaaaaaaaaa", 16));
pcache_carried = true;
pcache_side.base = 64;
std::memcpy(pcache_side.stamp, "aaaaaaaaaaaaaaaa", 16);
pcache_side = pcache_carry::session(pcache_carry::Start::Carried, pcache_side);
cache_size = 72;
fault = REPLACE_FAIL;
CHECK(pcache_checkpoint_save() == 0 && replacements == 1 && old_file() && !tmp_left());
CHECK(side_file(64, 1) && side_open() == 1 && sixteen(pcache_path + ".for") == "aaaaaaaaaaaaaaaa");
{
FILE* f = std::fopen((pcache_path + ".base").c_str(), "rb");
CHECK(f);
std::uint8_t raw[pcache_carry::kSideBytes]{};
const auto got = std::fread(raw, 1, sizeof raw, f);
std::fclose(f);
pcache_carry::Side had;
CHECK(pcache_carry::get(raw, got, &had));
CHECK(pcache_carry::begun(true, had, "1122334455667788", "aaaaaaaaaaaaaaaa"));
CHECK(pcache_carry::resumed(true, true, true, had));
const pcache_carry::Side again = pcache_carry::session(pcache_carry::Start::Same, had);
CHECK(again.open == 1 && again.carried == 1 && again.base == 64 && pcache_carry::over(true, 81, again, 0));
// (by the history's own rule the side file is not that file's: one fresh set of its size, never capped)
CHECK(pcache_carry::history(true, had, "aaaaaaaaaaaaaaaa", 3).open == 0);
}
// The history cannot be written: the data is not put in place, the old file and its .for stay.
fault = NONE;
std::remove((pcache_path + ".base").c_str());
#ifdef _WIN32
CHECK(CreateDirectoryA((pcache_path + ".base").c_str(), nullptr));
#else
CHECK(mkdir((pcache_path + ".base").c_str(), 0700) == 0);
#endif
CHECK(pcache_checkpoint_save() == 0 && replacements == 1 && old_file() && !tmp_left());
CHECK(sixteen(pcache_path + ".for") == "aaaaaaaaaaaaaaaa");
#ifdef _WIN32
CHECK(RemoveDirectoryA((pcache_path + ".base").c_str()));
#else
CHECK(rmdir((pcache_path + ".base").c_str()) == 0);
#endif
CHECK(pcache_checkpoint_save() == 72 && replacements == 2 && new_file() && side_file(64, 1) && side_open() == 1);
CHECK(sixteen(pcache_path + ".for") == "1122334455667788");
// Not carried: no history written before the data (as before), a cut save leaves none.
pcache_carried = false;
pcache_side = pcache_carry::session(pcache_carry::Start::Fresh, pcache_side);
std::remove((pcache_path + ".base").c_str());
cache_size = 80;
fault = REPLACE_FAIL;
CHECK(pcache_checkpoint_save() == 0 && replacements == 3 && side_open() == -1);
fault = NONE;
CHECK(save_errors == 0 && start_errors == 0);
} else if (name == "own") {
// (Triforce) <file>.own (pcache_own_mark): written beside the saves of a session that began with no file or with such a
// file, removed by those of a session that began with another file's data or carried one.
const std::string own = pcache_path + ".own";
pipeline_cache_save(true);
CHECK(new_file() && sixteen(own) == "abcdef0123456789" && pcache_own_named()); // (read so at the next start)
pcache_from_file = true; // (a file not of that kind: an older build's, after an update that kept the stamp)
cache_size = 72;
pipeline_cache_save(true);
CHECK(new_file() && sixteen(own).empty() && !pcache_own_named());
pcache_from_own = true; // (one of that kind: a checkpoint's before a crash)
cache_size = 80;
CHECK(pcache_checkpoint_save() == 80 && sixteen(own) == "abcdef0123456789");
pcache_carried = true; // (carried over a stamp change)
pcache_side.base = 80;
cache_size = 88;
pipeline_cache_save(true);
CHECK(new_file() && sixteen(own).empty() && replacements == 4);
CHECK(save_errors == 0 && start_errors == 0);
} else if (name == "carry-check") {
// (Triforce) The preparation's look at the size (prepare_run, warm_libraries): not carried, the driver is not asked.
CHECK(!pcache_carry_check(false) && !pcache_carry_check(true) && queries == 0);
pcache_carried = true;
pcache_side.base = 64;
pcache_bound_bytes = 0;
cache_size = 80; // At the cap: not past.
CHECK(!pcache_carry_check(true) && queries == 1 && !pcache_carry_over);
cache_size = 96;
dev.props.vendorID = 0x8086; // Intel: not asked while workers build into the cache, asked once they are joined.
CHECK(!pcache_carry_check(true) && queries == 1);
CHECK(pcache_carry_check(false) && queries == 2 && pcache_carry_over && nocarry_file());
CHECK(pcache_carry_check(true) && queries == 2); // Once past, it stays so without asking.
pcache_carry_over = false;
dev.props.vendorID = 0x10DE;
CHECK(pcache_carry_check(true) && queries == 3);
pcache_carry_over = false;
let_go = true; // The cache let go: nothing asked.
CHECK(!pcache_carry_check(false) && queries == 3);
CHECK(copies == 0 && writes == 0 && old_file());
} else if (name == "carry-early") {
// (Triforce) The early drop (warm_libraries, pcache_carry_early): not carried, nothing asked and nothing projected.
std::size_t from = 1;
CHECK(!pcache_carry_held(&from) && from == 0 && !pcache_carry_early(64, 100, 1000, 1500) && queries == 0);
pcache_carried = true;
pcache_side.base = 64; // (its limit 80: the room from 64 is 16, the margin 32 of projected growth)
pcache_bound_bytes = 0;
CHECK(pcache_carry_held(&from) && from == 64 && queries == 1);
cache_size = 68; // 4 bytes for a sample of 100 of 1000 programs: 40 over the warm at this rate, past the margin.
CHECK(!pcache_carry_early(from, 100, 1000, 1499));
CHECK(queries == 2 && !pcache_carry_over && !nocarry_file()); // (the sample too small: asked, not dropped)
cache_size = 65; // 1 byte for 100 of 1000: 10, under the margin.
CHECK(!pcache_carry_early(from, 100, 1000, 1500) && queries == 3 && !pcache_carry_over);
cache_size = 96; // Past already: left to pcache_carry_check, which says so.
CHECK(!pcache_carry_early(from, 100, 1000, 1500) && queries == 4 && !pcache_carry_over);
cache_size = 68;
dev.props.vendorID = 0x8086; // Intel: not asked while workers build, and no projection made (the warm's own order).
from = 1;
CHECK(!pcache_carry_held(&from) && from == 0 && !pcache_carry_early(64, 100, 1000, 1500) && queries == 4);
dev.props.vendorID = 0x10DE;
#ifdef _WIN32
_putenv("RX_VK_PCACHE_CARRY_PROJECT=0");
#else
setenv("RX_VK_PCACHE_CARRY_PROJECT", "0", 1);
#endif
// Off: past alone, and no projection made (the warm's own order).
CHECK(!pcache_carry_held(&from) && from == 0 && queries == 4);
CHECK(!pcache_carry_early(64, 100, 1000, 1500) && queries == 4 && !pcache_carry_over);
#ifdef _WIN32
_putenv("RX_VK_PCACHE_CARRY_PROJECT=");
#else
unsetenv("RX_VK_PCACHE_CARRY_PROJECT");
#endif
CHECK(pcache_carry_held(&from) && from == 68 && queries == 5);
from = 64;
// Dropped: as past what it may hold, the carry refused for these shaders, and the look past it says so without asking.
CHECK(pcache_carry_early(from, 100, 1000, 1500) && queries == 6 && pcache_carry_over && nocarry_file());
CHECK(pcache_carry_check(true) && queries == 6 && !pcache_carry_early(from, 100, 1000, 1500) && queries == 6);
// Not written: a carried cache dropped is not saved, and the file keeps what it was.
pipeline_cache_save(true);
CHECK(copies == 0 && writes == 0 && replacements == 0 && old_file());
} else if (name == "ram-short") {
ram_fits = false; // In play, a copy of the data would not fit in the RAM available: it waits, nothing fetched.
pcache_built_since_save = 32;
pipeline_cache_save(false);
CHECK(wait_until(fit_asks, 1));
Sleep(20);
CHECK(copies == 0 && old_file() && pcache_built_since_save >= 32); // Asked again at the next check in play.
pipeline_cache_save(true); // After the worker; at the game's close the RAM is not asked, the save is made.
CHECK(fit_asks == 1 && queries == 2 && copies == 1 && replacements == 1 && new_file());
pcache_built_since_save = 32;
ram_fits = true;
cache_size = 96;
pipeline_cache_save(false);
CHECK(wait_until(copies, 2));
pipeline_cache_save(true);
CHECK(fit_asks == 2 && replacements == 2 && new_file() && save_errors == 0);
} else if (name == "let-go") {
let_go = true; // The cache let go: no save asks the driver anything, the file keeps its last save.
pcache_built_since_save = 32;
pipeline_cache_save(false);
pipeline_cache_save(true);
Sleep(50);
CHECK(queries == 0 && copies == 0 && writes == 0 && replacements == 0 && old_file() && save_errors == 0);
} else {
CHECK(false);
}
std::printf("PASS: %s\n", name.c_str());
return 0;
}
int main(int argc, char** argv) {
// An old detached worker would terminate the process. The original-source negative runs in its own bounded child.
std::set_terminate([] { std::fputs("uncaught worker exception\n", stderr); std::_Exit(86); });
if (argc == 2 && std::strcmp(argv[1], "terminate-control") == 0) std::terminate();
if (argc == 2 && std::strcmp(argv[1], "uncaught-thread-control") == 0) {
#ifdef _MSC_VER
std::fputs("MSVC-target uncaught-thread control\n", stderr);
#endif
std::thread worker([] { throw std::bad_alloc(); });
worker.join();
return 2;
}
if (argc != 3) return 2;
pcache_path = std::string(argv[2]) + "/authored-pipeline-cache-with-a-path-longer-than-small-string-storage.bin";
FILE* f = std::fopen(pcache_path.c_str(), "wb");
if (!f) return 2;
std::fwrite("old", 1, 3, f);
std::fclose(f);
try {
return run(argv[1]);
} catch (const std::exception& e) {
std::fprintf(stderr, "uncaught caller exception: %s\n", e.what());
return 87;
}
}