Files
Triforce-Source/tests/test_spv_nan_select.cpp
ruckus7382sfgsgdf 6c7117635c Triforce v0.6.0 "Sage Of Power"
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.
2026-11-20 17:06:21 -06:00

321 lines
15 KiB
C++

// spv_nan_select::rewrite (gpu/vk/spv_nan_select.h): float selects of a NaN constant made selects of the bits, on authored
// SPIR-V as the translation writes it; what comes out is read back (each id defined once and below the bound, the new types
// and constants before the first function, every select of a NaN constant an integer one) and evaluated, and gives the same
// bits as the select it replaces for either condition. Modules with nothing to change are left alone.
// tests/test_spv_nan_select.py; with a folder argument, the modules made are written there for spirv-val
#include "../gpu/vk/spv_nan_select.h"
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <initializer_list>
#include <map>
#include <string>
static int failures = 0;
static void expect(bool ok, const char* what) {
if (!ok) {
std::printf("FAIL: %s\n", what);
failures++;
}
}
namespace {
uint32_t bits(float f) {
uint32_t u;
std::memcpy(&u, &f, 4);
return u;
}
// ids: 2 void, 3 function type, 4 bool, 5 float, 6 uint, 7 vec2, 8 float function pointer, 9 half, 10 ushort, 11 half
// function pointer; 20.. constants; 1 main, 100 its label, 101 a float variable, 102 its load (x), 103 the condition,
// 104 a half variable, 105 its load; 110.. the selects
enum : uint32_t {
kVoid = 2, kFn = 3, kBool = 4, kFloat = 5, kUint = 6, kVec2 = 7, kPtr = 8, kHalf = 9, kUshort = 10, kHptr = 11,
kNan = 20, kOne = 21, kMinusOne = 22, kInf = 23, kNegNan = 24, kVecNan = 25, kHnan = 26, kHone = 27, kUmask = 28,
kX = 102, kCond = 103, kHx = 105,
};
struct Options {
bool uint = true; // (a 32-bit unsigned type declared)
bool half = false; // (16-bit floats, and their selects)
bool ushort = true; // (with half: a 16-bit unsigned type declared)
bool umask = false; // (an integer constant of the mask's bits already there)
};
struct Module {
std::vector<uint32_t> w{0x07230203u, 0x00010500u, 0, 1000, 0};
uint32_t next = 110;
void op(uint16_t code, std::initializer_list<uint32_t> args) {
w.push_back((uint32_t)(args.size() + 1) << 16 | code);
for (uint32_t a : args) w.push_back(a);
}
Options o;
explicit Module(Options opt = {}) : o(opt) {
op(17, {1}); // OpCapability Shader
if (o.half) op(17, {9}), op(17, {22}); // OpCapability Float16, Int16
op(14, {0, 1}); // OpMemoryModel Logical GLSL450
op(15, {5, 1, 0x6e69616du, 0}); // OpEntryPoint GLCompute %1 "main"
op(16, {1, 17, 1, 1, 1}); // OpExecutionMode %1 LocalSize 1 1 1
op(19, {kVoid}); // OpTypeVoid
op(33, {kFn, kVoid}); // OpTypeFunction
op(20, {kBool}); // OpTypeBool
op(22, {kFloat, 32}); // OpTypeFloat 32
if (o.uint) op(21, {kUint, 32, 0}); // OpTypeInt 32 0
op(23, {kVec2, kFloat, 2}); // OpTypeVector
op(32, {kPtr, 7, kFloat}); // OpTypePointer Function
if (o.half) {
op(22, {kHalf, 16});
if (o.ushort) op(21, {kUshort, 16, 0});
op(32, {kHptr, 7, kHalf});
}
op(43, {kFloat, kNan, 0xffffffffu}); // OpConstant: the mask, typed as a float
op(43, {kFloat, kOne, bits(1.0f)});
op(43, {kFloat, kMinusOne, bits(-1.0f)});
op(43, {kFloat, kInf, 0x7f800000u}); // (infinity: not a NaN)
op(43, {kFloat, kNegNan, 0xffc00000u});
op(44, {kVec2, kVecNan, kNan, kOne}); // OpConstantComposite
if (o.half) op(43, {kHalf, kHnan, 0x7e00u}), op(43, {kHalf, kHone, 0x3c00u});
if (o.umask && o.uint) op(43, {kUint, kUmask, 0xffffffffu});
op(54, {kVoid, 1, 0, kFn}); // OpFunction
op(248, {100}); // OpLabel
op(59, {kPtr, 101, 7}); // OpVariable Function
if (o.half) op(59, {kHptr, 104, 7});
op(61, {kFloat, kX, 101}); // OpLoad
if (o.half) op(61, {kHalf, kHx, 104});
op(184, {kBool, kCond, kX, kOne}); // OpFOrdLessThan
}
uint32_t select(uint32_t type, uint32_t a, uint32_t b) {
const uint32_t id = next++;
op(169, {type, id, kCond, a, b});
return id;
}
void use(uint32_t id) { op(129, {kFloat, next++, id, kX}); } // OpFAdd: the select's result read on as a float
void end() {
op(253, {}); // OpReturn
op(56, {}); // OpFunctionEnd
}
};
// ---- reading a module back ----
struct Read {
bool ok = true;
std::string why;
std::map<uint32_t, size_t> def; // (each id's defining instruction)
size_t fn_at = 0;
};
// (which instructions have a result id, and where it is: enough for what the fixtures hold)
int result_at(uint32_t o) {
switch (o) {
case 19: case 20: case 21: case 22: case 23: case 32: case 33: case 248: return 1;
case 41: case 42: case 43: case 44: case 54: case 59: case 61: case 124: case 129: case 169: case 184: return 2;
default: return 0;
}
}
Read read(const std::vector<uint32_t>& w) {
Read r;
if (w.size() < 5 || w[0] != 0x07230203u) return r.ok = false, r.why = "no header", r;
for (size_t i = 5; i < w.size();) {
const uint32_t o = w[i] & 0xffffu, l = w[i] >> 16;
if (!l || i + l > w.size()) return r.ok = false, r.why = "cut short", r;
if (o == 54 && !r.fn_at) r.fn_at = i;
if (const int at = result_at(o)) {
const uint32_t id = w[i + at];
if (id == 0 || id >= w[3]) return r.ok = false, r.why = "an id past the bound", r;
if (!r.def.emplace(id, i).second) return r.ok = false, r.why = "an id defined twice", r;
// (types, constants and variables of module scope before the first function; nothing else there)
const bool global = o == 19 || o == 20 || o == 21 || o == 22 || o == 23 || o == 32 || o == 33 || o == 43 || o == 44;
if (global && r.fn_at) return r.ok = false, r.why = "a type or constant inside a function", r;
if (!global && !r.fn_at) return r.ok = false, r.why = "an instruction outside a function", r;
}
// (every operand id defined before it is used, but for a function's own forward references, which these have none of)
if (o == 43 || o == 124 || o == 169 || o == 129) {
for (uint32_t k = 1; k < l; k++) {
if (o == 43 && k == 3) break; // (a constant's literal)
if (k == 2) continue; // (the result)
if (!r.def.count(w[i + k])) return r.ok = false, r.why = "an operand used before it is defined", r;
}
}
i += l;
}
return r;
}
/// The bits of id with the condition c (only what the fixtures make: constants, bitcasts, selects; x stands as 0x3f000000)
bool eval(const std::vector<uint32_t>& w, const Read& r, uint32_t id, bool c, uint32_t* out, int depth = 0) {
if (depth > 8) return false;
if (id == kCond) return *out = c, true;
if (id == kX) return *out = bits(0.5f), true;
if (id == kHx) return *out = 0x3800u, true;
const auto it = r.def.find(id);
if (it == r.def.end()) return false;
const size_t i = it->second;
switch (w[i] & 0xffffu) {
case 43: return *out = w[i + 3], true;
case 124: return eval(w, r, w[i + 3], c, out, depth + 1);
case 169: {
uint32_t cv;
if (!eval(w, r, w[i + 3], c, &cv, depth + 1)) return false;
return eval(w, r, w[i + (cv ? 4 : 5)], c, out, depth + 1);
}
default: return false;
}
}
/// The type a result id has
uint32_t type_of(const std::vector<uint32_t>& w, const Read& r, uint32_t id) {
const auto it = r.def.find(id);
return it == r.def.end() ? 0 : w[it->second + 1];
}
bool float_select_of_nan(const std::vector<uint32_t>& w, const Read& r) {
for (size_t i = r.fn_at; i && i < w.size(); i += w[i] >> 16) {
if ((w[i] & 0xffffu) != 169) continue;
const uint32_t t = w[i + 1];
if (t != kFloat && t != kHalf) continue;
for (int k = 4; k <= 5; k++) {
uint32_t b = 0;
const auto d = r.def.find(w[i + k]);
if (d != r.def.end() && (w[d->second] & 0xffffu) == 43 && eval(w, r, w[i + k], false, &b) &&
spv_nan_select::nan(t == kFloat ? 32 : 16, b))
return true;
}
}
return false;
}
const char* out_dir = nullptr;
int written = 0;
void save(const std::vector<uint32_t>& w, const char* name) {
if (!out_dir) return;
const std::string path = std::string(out_dir) + "/" + name + ".spv";
if (FILE* f = std::fopen(path.c_str(), "wb")) {
std::fwrite(w.data(), 4, w.size(), f), std::fclose(f), written++;
} else {
expect(false, "could not write a module for spirv-val");
}
}
/// The rewrite of m, checked: as many selects as want, the output well formed, the selects' results the same bits under
/// either condition and of the same float type, and no float select of a NaN constant left (but 16-bit ones, left)
void check(Module& m, uint32_t want, const std::vector<uint32_t>& selects, const char* name, uint32_t want_left = 0) {
m.end();
save(m.w, (std::string(name) + "-in").c_str());
const Read before = read(m.w);
expect(before.ok, (std::string(name) + ": the fixture reads back (") .append(before.why).append(")").c_str());
spv_nan_select::Result res;
const std::vector<uint32_t> out = spv_nan_select::rewrite(m.w.data(), m.w.size(), &res);
expect(res.selects == want, (std::string(name) + ": selects rewritten").c_str());
expect(res.left == want_left, (std::string(name) + ": 16-bit selects left").c_str());
if (!want) {
expect(out.empty(), (std::string(name) + ": nothing changed").c_str());
return;
}
if (out.empty()) return expect(false, (std::string(name) + ": a module came out").c_str());
save(out, (std::string(name) + "-out").c_str());
const Read after = read(out);
expect(after.ok, (std::string(name) + ": the output reads back (").append(after.why).append(")").c_str());
if (!after.ok) return;
expect(out[3] > m.w[3], (std::string(name) + ": the bound grows").c_str());
expect(std::equal(m.w.begin(), m.w.begin() + 3, out.begin()) && out[4] == m.w[4],
(std::string(name) + ": the header but its bound kept").c_str());
expect(!want_left ? !float_select_of_nan(out, after) : true, (std::string(name) + ": no float select of a NaN left").c_str());
for (uint32_t s : selects) {
expect(type_of(out, after, s) == type_of(m.w, before, s), (std::string(name) + ": a select's result keeps its type").c_str());
for (bool c : {false, true}) {
uint32_t a = 1, b = 2;
const bool ea = eval(m.w, before, s, c, &a), eb = eval(out, after, s, c, &b);
expect(ea && eb && a == b, (std::string(name) + ": a select gives the same bits").c_str());
}
}
// (a second pass finds nothing: what came out is not rewritten again)
spv_nan_select::Result again;
expect(spv_nan_select::rewrite(out.data(), out.size(), &again).empty() && again.selects == 0,
(std::string(name) + ": rewritten once").c_str());
}
} // namespace
int main(int argc, char** argv) {
if (argc > 1) out_dir = argv[1];
using namespace spv_nan_select;
expect(nan(32, 0xffffffffu) && nan(32, 0x7f800001u) && nan(32, 0xffc00000u) && nan(32, 0x7fc00000u), "32-bit NaNs");
expect(!nan(32, 0x7f800000u) && !nan(32, 0xff800000u) && !nan(32, bits(1.0f)) && !nan(32, 0), "32-bit numbers");
expect(nan(16, 0x7e00u) && nan(16, 0xfc01u) && !nan(16, 0x7c00u) && !nan(16, 0x3c00u) && !nan(64, 0xffffffffu), "16-bit");
expect(on(nullptr) && on("") && on("1") && !on("0"), "RX_VK_NAN_SELECTS");
{ // (the mask on either side, against a constant and against a value; a select's result read on)
Module m;
const uint32_t a = m.select(kFloat, kNan, kOne), b = m.select(kFloat, kX, kNan), c = m.select(kFloat, kNegNan, kNan);
m.use(a), m.use(b);
check(m, 3, {a, b, c}, "f32");
}
{ // (no 32-bit unsigned type in the module: one is declared)
Module m(Options{false});
const uint32_t a = m.select(kFloat, kOne, kNan);
check(m, 1, {a}, "f32-no-uint");
}
{ // (an integer constant of the mask's bits already there: another is declared, which SPIR-V allows)
Options o;
o.umask = true;
Module m(o);
const uint32_t a = m.select(kFloat, kNan, kMinusOne);
check(m, 1, {a}, "f32-umask");
}
{ // (16-bit floats with a 16-bit unsigned type: rewritten too)
Options o;
o.half = true;
Module m(o);
const uint32_t a = m.select(kHalf, kHnan, kHone), b = m.select(kHalf, kHx, kHnan), c = m.select(kFloat, kNan, kX);
check(m, 3, {a, b, c}, "f16");
}
{ // (16-bit floats without one: those left, the 32-bit one rewritten)
Options o;
o.half = true, o.ushort = false;
Module m(o);
m.select(kHalf, kHnan, kHone);
const uint32_t c = m.select(kFloat, kNan, kX);
check(m, 1, {c}, "f16-no-ushort", 1);
}
{ // (nothing to change: numbers, infinity, a vector select, a select of no constant)
Module m;
m.select(kFloat, kOne, kMinusOne), m.select(kFloat, kInf, kX), m.select(kFloat, kX, kX);
const uint32_t v = m.next++;
m.op(169, {kVec2, v, kCond, kVecNan, kVecNan}); // (a vector select: left as it is)
check(m, 0, {}, "none");
}
{ // (only 16-bit ones and no 16-bit unsigned type: nothing changed, and said)
Options o;
o.half = true, o.ushort = false;
Module m(o);
m.select(kHalf, kHone, kHnan);
check(m, 0, {}, "f16-only-left", 1);
}
{ // (what it does not read: left alone)
Module m;
m.select(kFloat, kNan, kOne);
m.end();
std::vector<uint32_t> w = m.w;
expect(rewrite(nullptr, 0).empty(), "no module");
w[0] = 0x12345678u;
expect(rewrite(w.data(), w.size()).empty(), "not SPIR-V");
w = m.w, w[3] = 0;
expect(rewrite(w.data(), w.size()).empty(), "a bound of 0");
w = m.w, w[3] = kMaxBound + 1;
expect(rewrite(w.data(), w.size()).empty(), "a bound past the limit");
w = m.w, w.resize(w.size() - 3);
expect(rewrite(w.data(), w.size()).empty(), "cut short");
w = m.w, w[w.size() - 2] = 0; // (an instruction of no length: the return)
expect(rewrite(w.data(), w.size()).empty(), "an instruction of no length");
expect(!rewrite(m.w.data(), m.w.size()).empty(), "the module itself is rewritten");
}
if (out_dir) std::printf("%d modules written for spirv-val\n", written);
if (failures) return 1;
std::printf("spv_nan_select: ok\n");
return 0;
}