1161 lines
56 KiB
C++
1161 lines
56 KiB
C++
#include "graphics/shader/recompiler/ir/ShaderIR.h"
|
|
#include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
|
|
|
|
#include <bit>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <limits>
|
|
#include <memory>
|
|
|
|
namespace {
|
|
|
|
void Check(bool value, const char *text) {
|
|
if (!value) {
|
|
std::fprintf(stderr, "ResourceMaterializationTests: failed: %s\n", text);
|
|
std::abort();
|
|
}
|
|
}
|
|
|
|
bool RejectSpecializationRead(void *userdata, uint64_t, std::span<uint32_t>) {
|
|
++*static_cast<uint32_t *>(userdata);
|
|
return false;
|
|
}
|
|
|
|
Libs::Graphics::ShaderRecompiler::IR::Block &
|
|
AddValueBlock(Libs::Graphics::ShaderRecompiler::IR::Program &program) {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
auto block = std::make_unique<Block>();
|
|
auto *result = block.get();
|
|
program.blocks.push_back(result);
|
|
result->id = static_cast<uint32_t>(program.blocks.size() - 1u);
|
|
program.block_storage.push_back(std::move(block));
|
|
return *result;
|
|
}
|
|
|
|
Libs::Graphics::ShaderRecompiler::IR::Program SrtProgram(uint64_t address) {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = true;
|
|
program.resource_tracking_complete = true;
|
|
auto &value_block = AddValueBlock(program);
|
|
|
|
MemoryInfo memory;
|
|
memory.kind = ResourceKind::ScalarAddress;
|
|
memory.planning_only = true;
|
|
program.memory_info.push_back(memory);
|
|
const auto low = Value(static_cast<uint32_t>(address));
|
|
const auto high = Value(static_cast<uint32_t>(address >> 32u));
|
|
auto &handle =
|
|
value_block.AppendNewInst(ValueOpcode::GetAddressResource, {low, high});
|
|
auto &raw = value_block.AppendNewInst(
|
|
ValueOpcode::LoadAddressU32,
|
|
{Value(&handle), Value(0u), Value(0u), Value(true)});
|
|
raw.SetFlags(MemoryFlags{.index = 0, .pc = 0x40});
|
|
program.srt_reads.push_back({Value(&raw), 0});
|
|
|
|
auto &srt = value_block.AppendNewInst(ValueOpcode::GetSrtResource);
|
|
auto &flat = value_block.AppendNewInst(ValueOpcode::ReadConst,
|
|
{Value(&srt), Value(0u)});
|
|
DescriptorSource source;
|
|
source.dwords[0] = Value(&flat);
|
|
source.dwords[1] = Value(0u);
|
|
source.dword_count = 2;
|
|
program.descriptor_sources.push_back(source);
|
|
return program;
|
|
}
|
|
|
|
Libs::Graphics::ShaderRecompiler::IR::ResourcePlan UnbasedFlatPlan() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = true;
|
|
program.resource_tracking_complete = true;
|
|
AddValueBlock(program);
|
|
program.info.uses_dma = true;
|
|
return ExtractResourcePlan(program);
|
|
}
|
|
|
|
Libs::Graphics::ShaderRecompiler::IR::ResourcePlan UserDataBufferPlan() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = true;
|
|
program.resource_tracking_complete = true;
|
|
auto &value_block = AddValueBlock(program);
|
|
|
|
auto &user_data = value_block.AppendNewInst(
|
|
ValueOpcode::GetUserData, {Value(static_cast<ScalarReg>(0))});
|
|
DescriptorSource source;
|
|
source.dwords[0] = Value(&user_data);
|
|
source.dwords[1] = Value(0u);
|
|
source.dwords[2] = Value(0u);
|
|
source.dwords[3] = Value(0u);
|
|
source.dword_count = 4;
|
|
program.descriptor_sources.push_back(source);
|
|
program.info.buffers.push_back({.source = 0});
|
|
return ExtractResourcePlan(program);
|
|
}
|
|
|
|
Libs::Graphics::ShaderRecompiler::IR::Program MixedSamplerProgram() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = true;
|
|
program.resource_tracking_complete = true;
|
|
auto &block = AddValueBlock(program);
|
|
|
|
const auto AddSource = [&program](uint32_t dword_count) {
|
|
DescriptorSource source;
|
|
source.dword_count = dword_count;
|
|
for (uint32_t i = 0; i < dword_count; i++) {
|
|
source.dwords[i] = Value(0u);
|
|
}
|
|
program.descriptor_sources.push_back(source);
|
|
return static_cast<uint32_t>(program.descriptor_sources.size() - 1u);
|
|
};
|
|
|
|
const auto image0 = AddSource(8);
|
|
const auto image1 = AddSource(8);
|
|
const auto sampler0 = AddSource(4);
|
|
const auto sampler1 = AddSource(4);
|
|
program.descriptor_sources[image1].dwords[0] = Value(1u);
|
|
program.descriptor_sources[image1].dwords[1] = Value(static_cast<uint32_t>(
|
|
Libs::Graphics::Prospero::BufferFormat::k11_11_10UInt) << 20u);
|
|
program.descriptor_sources[image1].dwords[3] = Value(static_cast<uint32_t>(
|
|
Libs::Graphics::Prospero::ImageType::kColor2D) << 28u);
|
|
for (uint32_t index = 0; index < 2; ++index) {
|
|
auto &value = block.AppendNewInst(
|
|
ValueOpcode::GetUserData, {Value(static_cast<ScalarReg>(index))});
|
|
program.descriptor_sources[sampler0 + index].dwords[0] = Value(&value);
|
|
}
|
|
program.info.images.push_back(
|
|
{.source = image0,
|
|
.resource_class = ImageResourceClass::Sampled,
|
|
.numeric_class = Libs::Graphics::Prospero::TextureNumericClass::Float,
|
|
.dimension =
|
|
Libs::Graphics::ShaderRecompiler::Decoder::ImageDimension::Dim2D});
|
|
program.info.images.push_back(
|
|
{.source = image1,
|
|
.resource_class = ImageResourceClass::Sampled,
|
|
.numeric_class = Libs::Graphics::Prospero::TextureNumericClass::Float,
|
|
.dimension =
|
|
Libs::Graphics::ShaderRecompiler::Decoder::ImageDimension::Dim2D});
|
|
program.info.samplers.push_back({.source = sampler0});
|
|
program.info.samplers.push_back({.source = sampler1});
|
|
program.info.sampled_pairs.push_back({.image = 0, .sampler = 0});
|
|
program.info.sampled_pairs.push_back({.image = 0, .sampler = 1});
|
|
program.info.sampled_pairs.push_back({.image = 1, .sampler = 1});
|
|
return program;
|
|
}
|
|
|
|
void TestMappedSrtUsesDirectReaderByDefault() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
const uint32_t dword = 0x12345678;
|
|
auto plan = ExtractResourcePlan(SrtProgram(reinterpret_cast<uint64_t>(&dword)));
|
|
uint32_t specialization_reads = 0;
|
|
const SrtRuntime runtime{.userdata = &specialization_reads,
|
|
.read_specialization_memory =
|
|
RejectSpecializationRead};
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization),
|
|
"mapped SRT stage materialization failed");
|
|
Check(specialization_reads == 0,
|
|
"ordinary SRT read used the specialization reader");
|
|
Check(snapshot.flattened_srt.size() == 1 &&
|
|
snapshot.flattened_srt[0] == dword,
|
|
"cache rematerialization did not use the direct reader by default");
|
|
}
|
|
|
|
void TestNativeNestedSrtRefresh() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
std::array<uint32_t, 3> first{0u, 0x12345678u, 0xabcdef01u};
|
|
std::array<uint32_t, 3> second{0u, 0x87654321u, 0x10fedcbau};
|
|
const auto pointer_words = [](const void *pointer) {
|
|
const auto address = reinterpret_cast<uint64_t>(pointer);
|
|
return std::array<uint32_t, 2>{static_cast<uint32_t>(address) | 3u,
|
|
static_cast<uint32_t>(address >> 32u) | 0xabcd0000u};
|
|
};
|
|
auto table = pointer_words(first.data());
|
|
const auto user_data = pointer_words(table.data());
|
|
auto program = SrtProgram(0u);
|
|
program.user_data_base = 4;
|
|
program.user_data_count = 2;
|
|
auto &block = *program.blocks[0];
|
|
const auto emit = [&](ValueOpcode opcode, std::initializer_list<Value> args) {
|
|
return Value(&block.AppendNewInst(opcode, args));
|
|
};
|
|
const auto low = emit(ValueOpcode::GetUserData, {Value(ScalarReg(4))});
|
|
const auto high = emit(ValueOpcode::GetUserData, {Value(ScalarReg(5))});
|
|
const auto root = emit(ValueOpcode::GetAddressResource, {low, high});
|
|
const auto read = [&](Value address, uint32_t offset) {
|
|
const auto value = emit(ValueOpcode::LoadAddressU32,
|
|
{address, Value(offset), Value(0u), Value(true)});
|
|
value.Instruction()->SetFlags(MemoryFlags{.index = 0});
|
|
program.srt_reads.push_back(
|
|
{value, static_cast<uint32_t>(program.srt_reads.size())});
|
|
return value;
|
|
};
|
|
const auto pointer_low = read(root, 0u);
|
|
const auto pointer_high = read(root, 4u);
|
|
auto *leaf = program.srt_reads[0].value.Instruction();
|
|
leaf->Arg(0).Instruction()->SetArg(0, pointer_low);
|
|
leaf->Arg(0).Instruction()->SetArg(1, pointer_high);
|
|
leaf->SetArg(1, Value(7u));
|
|
read(leaf->Arg(0), 11u);
|
|
auto plan = ExtractResourcePlan(program);
|
|
Check(plan.srt_code != nullptr, "nested user-data tree did not compile an x86 walker");
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
const SrtRuntime runtime{.user_data = user_data};
|
|
{
|
|
SrtWalker walker(plan, runtime);
|
|
Check(walker.RefreshFlatBuffer(snapshot.flattened_srt),
|
|
"native SRT refresh failed");
|
|
const auto loaded = first[1];
|
|
first[1] ^= 0xffffffffu;
|
|
uint32_t value = 0;
|
|
Check(walker.Evaluate(plan.srt_reads[0].value, value) && value == loaded,
|
|
"descriptor evaluation reloaded a value already copied by the native walker");
|
|
first[1] = loaded;
|
|
}
|
|
for (const auto *data : {&first, &second}) {
|
|
table = pointer_words(data->data());
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization) &&
|
|
snapshot.flattened_srt ==
|
|
std::vector<uint32_t>{(*data)[1], table[0], table[1], (*data)[2]},
|
|
"native SRT refresh lost pointer masking, alignment, or current values");
|
|
}
|
|
Check(!MaterializeResources(plan, {.user_data = std::span(user_data).first(1)},
|
|
snapshot, specialization),
|
|
"native SRT walk accepted truncated user data");
|
|
const std::array<uint32_t, 2> fake_user_data{0x1003u, 0xabcd0000u};
|
|
uint32_t reads = 0;
|
|
const SrtRuntime callback_runtime{
|
|
.user_data = fake_user_data,
|
|
.read_memory = +[](void *data, uint64_t address, std::span<uint32_t> words) {
|
|
++*static_cast<uint32_t *>(data);
|
|
switch (address) {
|
|
case 0x1000u: words[0] = 0x2003u; break;
|
|
case 0x1004u: words[0] = 0xabcd0000u; break;
|
|
case 0x2004u: words[0] = 0x1234u; break;
|
|
case 0x2008u: words[0] = 0x5678u; break;
|
|
default: return false;
|
|
}
|
|
return true;
|
|
},
|
|
.userdata = &reads};
|
|
Check(MaterializeResources(plan, callback_runtime, snapshot, specialization) && reads == 4 &&
|
|
snapshot.flattened_srt ==
|
|
std::vector<uint32_t>{0x1234u, 0x2003u, 0xabcd0000u, 0x5678u},
|
|
"native-eligible SRT bypassed its callback or repeated nested pointer reads");
|
|
leaf->SetArg(0, root);
|
|
leaf->SetArg(1, Value(0u));
|
|
program.srt_reads.resize(1);
|
|
for (const int32_t offset : {-1, 7}) {
|
|
program.memory_info[0].offset = static_cast<uint32_t>(offset);
|
|
auto bounded = ExtractResourcePlan(program);
|
|
auto base = pointer_words(second.data() + 1);
|
|
Check(bounded.srt_code != nullptr &&
|
|
MaterializeResources(bounded, {.user_data = base}, snapshot, specialization) &&
|
|
snapshot.flattened_srt[0] == second[offset < 0 ? 0 : 2],
|
|
"native SRT applied a signed immediate offset incorrectly");
|
|
base = offset < 0 ? std::array<uint32_t, 2>{0u, 0u}
|
|
: std::array<uint32_t, 2>{0xfffffffcu, 0xffffu};
|
|
Check(!MaterializeResources(bounded, {.user_data = base}, snapshot, specialization),
|
|
"native SRT accepted address underflow or 48-bit overflow");
|
|
}
|
|
high.Instruction()->SetArg(0, Value(ScalarReg(6)));
|
|
Check(ExtractResourcePlan(program).srt_code == nullptr,
|
|
"native SRT accepted nonadjacent user-data pointer words");
|
|
high.Instruction()->SetArg(0, Value(ScalarReg(5)));
|
|
program.memory_info[0].offset = 0;
|
|
program.srt_reads.push_back({pointer_low, 1});
|
|
program.srt_reads.push_back({pointer_high, 2});
|
|
leaf->SetArg(0, emit(ValueOpcode::GetAddressResource, {pointer_low, pointer_high}));
|
|
pointer_high.Instruction()->SetArg(1, Value(8u));
|
|
Check(ExtractResourcePlan(program).srt_code == nullptr,
|
|
"native SRT accepted nonadjacent nested pointer words");
|
|
}
|
|
|
|
void TestIntegerRuntimeValueFollowsSrtReads() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
auto plan = SrtProgram(0x10000);
|
|
const auto root = plan.descriptor_sources.front().dwords[0];
|
|
Check(ValidateRuntimeValue(plan, root, RuntimeValueType::Integer),
|
|
"integer SRT read was rejected");
|
|
|
|
Block values;
|
|
auto &comparison = values.AppendNewInst(ValueOpcode::FPOrdLessThanEqual32,
|
|
{Value::F32(1.f), Value::F32(0.f)});
|
|
auto &selection = values.AppendNewInst(
|
|
ValueOpcode::SelectU32, {Value(&comparison), Value(1u), Value(0u)});
|
|
plan.srt_reads[0].value = Value(&selection);
|
|
Check(ValidateRuntimeValue(plan, root),
|
|
"ordinary SRT validation rejected a floating-point dependency");
|
|
Check(!ValidateRuntimeValue(plan, root, RuntimeValueType::Integer),
|
|
"integer SRT validation missed a hidden floating-point dependency");
|
|
|
|
auto &first =
|
|
values.AppendNewInst(ValueOpcode::ReadFirstLane, {root, Value(true)});
|
|
Check(!ValidateRuntimeValue(plan, Value(&first), RuntimeValueType::Integer),
|
|
"read-first-lane lost integer-only SRT validation");
|
|
|
|
auto &active = values.AppendNewInst(ValueOpcode::ReadFirstLane,
|
|
{Value(&selection), Value(&comparison)});
|
|
Check(!ValidateRuntimeValue(plan, Value(&active), RuntimeValueType::Integer),
|
|
"floating-point execution mask was accepted as integer-only");
|
|
|
|
auto &lane = values.AppendNewInst(
|
|
ValueOpcode::GetBuiltin,
|
|
{Value(static_cast<uint32_t>(StageInputKind::LocalInvocationId)),
|
|
Value(0u)});
|
|
auto &mask =
|
|
values.AppendNewInst(ValueOpcode::INotEqual32, {Value(&lane), Value(0u)});
|
|
selection.SetArg(0, Value(&mask));
|
|
active.SetArg(1, Value(&mask));
|
|
Check(ValidateRuntimeValue(plan, Value(&active), RuntimeValueType::Integer),
|
|
"nonuniform integer execution mask was rejected");
|
|
auto &float_value =
|
|
values.AppendNewInst(ValueOpcode::BitCastU32F32, {Value::F32(1.f)});
|
|
selection.SetArg(2, Value(&float_value));
|
|
Check(!ValidateRuntimeValue(plan, Value(&active), RuntimeValueType::Integer),
|
|
"floating-point inactive arm was accepted as integer-only");
|
|
|
|
plan.srt_reads[0].value = Value(&first);
|
|
Check(!ValidateRuntimeValue(plan, root, RuntimeValueType::Integer),
|
|
"cyclic SRT read-first-lane dependency was accepted");
|
|
}
|
|
|
|
void TestSrtAliasesRetainReadPolicy() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
auto program = SrtProgram(0x1000u);
|
|
auto &block = *program.blocks[0];
|
|
const auto append_read = [&](uint32_t address) {
|
|
auto &handle = block.AppendNewInst(ValueOpcode::GetAddressResource,
|
|
{Value(address), Value(0u)});
|
|
auto &read = block.AppendNewInst(ValueOpcode::LoadAddressU32,
|
|
{Value(&handle), Value(0u), Value(0u), Value(true)});
|
|
// Different reads deliberately share MemoryInfo but have different guest PCs.
|
|
read.SetFlags(MemoryFlags{.index = 0, .pc = address});
|
|
const auto slot = static_cast<uint32_t>(program.srt_reads.size());
|
|
program.srt_reads.push_back({Value(&read), slot});
|
|
auto &srt = block.AppendNewInst(ValueOpcode::GetSrtResource);
|
|
return Value(&block.AppendNewInst(ValueOpcode::ReadConst,
|
|
{Value(&srt), Value(slot)}));
|
|
};
|
|
const auto ordinary = append_read(0x2000u);
|
|
const auto pointer = append_read(0x3000u);
|
|
program.srt_reads[0].value.Instruction()->Arg(0).Instruction()->SetArg(0, pointer);
|
|
auto &mask = block.AppendNewInst(ValueOpcode::INotEqual32, {ordinary, Value(0u)});
|
|
auto &first = block.AppendNewInst(ValueOpcode::ReadFirstLane,
|
|
{Value(9u), Value(&mask)});
|
|
program.descriptor_sources.push_back({.dwords = {Value(&first), Value(0u)},
|
|
.dword_count = 2});
|
|
DescriptorSource indirect;
|
|
indirect.indirect_descriptor.emplace(DescriptorSource::IndirectDescriptor{}).sources = {0, 1};
|
|
program.descriptor_sources.push_back(indirect);
|
|
auto plan = ExtractResourcePlan(program);
|
|
for (const auto &inst : plan.value_storage) {
|
|
Check(inst.GetOpcode() != ValueOpcode::ReadConst &&
|
|
inst.GetOpcode() != ValueOpcode::GetSrtResource,
|
|
"retained plan still contains flattened-read aliases");
|
|
}
|
|
Check(plan.descriptor_sources[0].dwords[0] == plan.srt_reads[0].value &&
|
|
plan.srt_reads[0].value.Instruction()->Flags<SrtReadFlags>().clean == 1u &&
|
|
plan.srt_reads[1].value.Instruction()->Flags<SrtReadFlags>().clean == 0u &&
|
|
plan.srt_reads[2].value.Instruction()->Flags<SrtReadFlags>().clean == 1u,
|
|
"alias normalization lost read identity or retained discarded EXEC provenance");
|
|
Check(plan.srt_code == nullptr,
|
|
"captured strict reads compiled an unused x86 walker");
|
|
struct Reads { uint32_t strict = 0; uint32_t ordinary = 0; bool dirty = false; } reads;
|
|
const SrtRuntime runtime{
|
|
.read_memory = +[](void *data, uint64_t address, std::span<uint32_t> words) {
|
|
++static_cast<Reads *>(data)->ordinary;
|
|
if (address == 0x2000u) words[0] = 0x2222u;
|
|
else if (address == 0x3000u) words[0] = 0x8000u;
|
|
else if (address == 0x8000u) words[0] = 0xeeeeu;
|
|
else return false;
|
|
return true;
|
|
},
|
|
.userdata = &reads,
|
|
.read_specialization_memory = +[](void *data, uint64_t address,
|
|
std::span<uint32_t> words) {
|
|
auto &reads = *static_cast<Reads *>(data);
|
|
++reads.strict;
|
|
if (reads.dirty) return false;
|
|
if (address == 0x3000u) words[0] = 0x1000u;
|
|
else if (address == 0x1000u) words[0] = 0x1111u;
|
|
else return false;
|
|
return true;
|
|
}};
|
|
std::vector<uint32_t> flat;
|
|
DescriptorValue descriptor;
|
|
{
|
|
SrtWalker clean(plan, CleanRuntime(runtime));
|
|
SrtWalker walker(plan, runtime, &clean);
|
|
Check(walker.RefreshFlatBuffer(flat) &&
|
|
flat == std::vector<uint32_t>{0x1111u, 0x2222u, 0x1000u} &&
|
|
walker.EvaluateDescriptor(0, descriptor) && descriptor.dwords[0] == 0x1111u &&
|
|
reads.strict == 2 && reads.ordinary == 1,
|
|
"normalized aliases changed nested strict reads or repeated a shared read");
|
|
}
|
|
Check(!SrtWalker(plan, runtime).RefreshFlatBuffer(flat),
|
|
"strict flat read accepted a missing clean evaluator");
|
|
auto no_reader = runtime;
|
|
no_reader.read_specialization_memory = nullptr;
|
|
{
|
|
SrtWalker clean(plan, CleanRuntime(no_reader));
|
|
Check(!SrtWalker(plan, no_reader, &clean).RefreshFlatBuffer(flat),
|
|
"strict flat read accepted a missing strict reader");
|
|
}
|
|
Check(SrtWalker(plan, runtime).EvaluateDescriptor(0, descriptor) &&
|
|
descriptor.dwords[0] == 0xeeeeu && reads.strict == 2 && reads.ordinary == 3,
|
|
"direct descriptor evaluation without a clean evaluator changed read domains");
|
|
reads.dirty = true;
|
|
{
|
|
SrtWalker clean(plan, CleanRuntime(runtime));
|
|
Check(!SrtWalker(plan, runtime, &clean).RefreshFlatBuffer(flat) &&
|
|
reads.strict == 3 && reads.ordinary == 3,
|
|
"dirty strict pointer fell back to an ordinary read");
|
|
}
|
|
}
|
|
|
|
void TestUniformVectorDescriptorRead() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = program.resource_tracking_complete = true;
|
|
auto &block = AddValueBlock(program);
|
|
auto &handle = block.AppendNewInst(ValueOpcode::GetBufferResource,
|
|
{Value(0x1000u), Value(4u << 16u), Value(1u), Value(0x16204u)});
|
|
program.memory_info.push_back({.kind = ResourceKind::Buffer});
|
|
auto &count = block.AppendNewInst(ValueOpcode::LoadBufferU32,
|
|
{Value(&handle), Value(0u), Value(0u), Value(0u), Value(true)});
|
|
count.SetFlags(MemoryFlags{.index = 0});
|
|
// The captured indirect kernel shares one read across sibling scalar lane reads,
|
|
// enclosed by a different EXEC mask. Its resource plan must share that read too.
|
|
auto &lane = block.AppendNewInst(ValueOpcode::GetBuiltin,
|
|
{Value(static_cast<uint32_t>(StageInputKind::LocalInvocationId)), Value(0u)});
|
|
auto &active = block.AppendNewInst(ValueOpcode::ULessThan32, {Value(&lane), Value(32u)});
|
|
auto &first = block.AppendNewInst(ValueOpcode::ReadFirstLane, {Value(&count), Value(true)});
|
|
auto &next = block.AppendNewInst(ValueOpcode::IAdd32, {Value(&count), Value(1u)});
|
|
auto &second = block.AppendNewInst(ValueOpcode::ReadFirstLane, {Value(&next), Value(true)});
|
|
auto &sum = block.AppendNewInst(ValueOpcode::IAdd32, {Value(&first), Value(&second)});
|
|
auto &small = block.AppendNewInst(ValueOpcode::ULessThanEqual32, {Value(&count), Value(72u)});
|
|
auto &selected = block.AppendNewInst(ValueOpcode::SelectU32, {Value(&small), Value(&sum), Value(&count)});
|
|
auto &masked = block.AppendNewInst(ValueOpcode::SelectU32, {Value(&active), Value(&selected), Value(0u)});
|
|
auto &records = block.AppendNewInst(ValueOpcode::ReadFirstLane, {Value(&masked), Value(&active)});
|
|
DescriptorSource source;
|
|
source.dword_count = 4;
|
|
source.dwords = {Value(0x2000u), Value(4u << 16u), Value(&records), Value(0x16204u)};
|
|
program.descriptor_sources.push_back(source);
|
|
program.info.buffers.push_back({.source = 0, .written = true});
|
|
Check(ValidateRuntimeValue(program, Value(&count)), "uniform DWORD count was rejected");
|
|
struct Reads { uint32_t value = 72; uint32_t strict = 0; uint32_t ordinary = 0; bool clean = true; } reads;
|
|
const SrtRuntime runtime{
|
|
.read_memory = [](void *data, uint64_t, std::span<uint32_t> words) {
|
|
++static_cast<Reads *>(data)->ordinary;
|
|
words[0] = 999;
|
|
return true;
|
|
},
|
|
.userdata = &reads,
|
|
.read_specialization_memory = [](void *data, uint64_t address, std::span<uint32_t> words) {
|
|
auto &reads = *static_cast<Reads *>(data);
|
|
++reads.strict;
|
|
if (!reads.clean || address != 0x1000u || words.size() != 1) return false;
|
|
words[0] = reads.value;
|
|
return true;
|
|
}};
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
for (const bool written : {false, true}) {
|
|
program.info.buffers[0].written = written;
|
|
auto plan = ExtractResourcePlan(program);
|
|
Check(plan.control_flow.empty() && plan.requires_specialization_memory &&
|
|
plan.capture_specialization_reads,
|
|
"vector descriptor read depended on incidental control-flow capture");
|
|
reads = {};
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization) &&
|
|
snapshot.buffers[0].dwords[2] == 145 && reads.strict == 1 && reads.ordinary == 0 &&
|
|
snapshot.specialization_reads ==
|
|
std::vector<std::pair<uint64_t, uint64_t>>{{0x1000u, 4u}},
|
|
"vector descriptor input was not read and captured exactly once");
|
|
reads.clean = false;
|
|
reads.strict = 0;
|
|
Check(!MaterializeResources(plan, runtime, snapshot, specialization) &&
|
|
reads.strict == 1 && reads.ordinary == 0,
|
|
"dirty vector descriptor input fell back to an ordinary memory read");
|
|
}
|
|
count.SetArg(4, Value(false));
|
|
auto &inactive = block.AppendNewInst(ValueOpcode::ReadFirstLane, {Value(&count), Value(false)});
|
|
program.descriptor_sources.push_back({.dwords = {Value(&inactive)}, .dword_count = 1});
|
|
reads.strict = 0;
|
|
uint32_t result = 99;
|
|
{
|
|
const auto plan = ExtractResourcePlan(program);
|
|
Check(SrtWalker(plan, runtime).Evaluate(plan.descriptor_sources.back().dwords[0], result) &&
|
|
result == 0 && reads.strict == 0 && reads.ordinary == 0,
|
|
"literal false EXEC read vector memory");
|
|
}
|
|
count.SetArg(4, Value(true));
|
|
handle.SetArg(3, Value(0x204u));
|
|
program.descriptor_sources.back().dwords[0] = Value(&count);
|
|
{
|
|
const auto plan = ExtractResourcePlan(program);
|
|
Check(SrtWalker(plan, runtime).Evaluate(plan.descriptor_sources.back().dwords[0], result) &&
|
|
result == 0 && reads.strict == 0 && reads.ordinary == 0,
|
|
"invalid vector buffer format read memory");
|
|
}
|
|
handle.SetArg(3, Value(0x16204u));
|
|
count.SetArg(1, Value(&lane));
|
|
Check(!ValidateRuntimeValue(program, Value(&count)),
|
|
"varying vector address was treated as a uniform descriptor read");
|
|
}
|
|
|
|
void TestExactReciprocalDescriptorArithmetic() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
Program program;
|
|
auto &block = AddValueBlock(program);
|
|
for (const float divisor : {64.f, 128.f, 256.f, 512.f,
|
|
std::numeric_limits<float>::min(),
|
|
std::bit_cast<float>(253u << 23u)}) {
|
|
auto &reciprocal = block.AppendNewInst(ValueOpcode::FPRecipIFlag32, {Value::F32(divisor)});
|
|
uint32_t result = 0;
|
|
Check(SrtWalker(program, {}).Evaluate(Value(&reciprocal), result) &&
|
|
result == std::bit_cast<uint32_t>(1.f / divisor),
|
|
"power-of-two reciprocal was not exact");
|
|
}
|
|
for (const float divisor : {0.f, 3.f, -64.f, std::numeric_limits<float>::infinity(),
|
|
std::numeric_limits<float>::denorm_min(),
|
|
std::bit_cast<float>(254u << 23u)}) {
|
|
auto &reciprocal = block.AppendNewInst(ValueOpcode::FPRecipIFlag32, {Value::F32(divisor)});
|
|
uint32_t result = 0;
|
|
Check(!SrtWalker(program, {}).Evaluate(Value(&reciprocal), result),
|
|
"unsupported reciprocal rounding or exceptional input was accepted");
|
|
}
|
|
}
|
|
|
|
void TestUnbasedFlatCacheHitMaterializes() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
auto plan = UnbasedFlatPlan();
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
Check(MaterializeResources(plan, {}, snapshot, specialization),
|
|
"unbased FLAT stage materialization failed");
|
|
Check(snapshot.buffers.empty() && snapshot.images.empty(),
|
|
"unbased FLAT plan produced unexpected descriptors");
|
|
}
|
|
|
|
void TestWrittenDescriptorPredicateReads(bool memory_condition) {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.user_data_count = 1;
|
|
program.srt_plan_complete = true;
|
|
program.resource_tracking_complete = true;
|
|
auto &block = AddValueBlock(program);
|
|
program.memory_info.push_back({.kind = ResourceKind::ScalarAddress});
|
|
auto &handle = block.AppendNewInst(ValueOpcode::GetAddressResource,
|
|
{Value(0x1000u), Value(0u)});
|
|
auto &offset = block.AppendNewInst(ValueOpcode::GetUserData,
|
|
{Value(static_cast<ScalarReg>(0))});
|
|
auto &read = block.AppendNewInst(ValueOpcode::LoadAddressU32,
|
|
{Value(&handle), Value(&offset), Value(0u), Value(false)});
|
|
read.SetFlags(MemoryFlags{.index = 0});
|
|
DescriptorSource source;
|
|
source.dwords = {Value(&read), Value(0u), Value(4u), Value(0u)};
|
|
source.dword_count = 4;
|
|
program.descriptor_sources.push_back(source);
|
|
program.info.buffers.push_back({.source = 0, .written = true});
|
|
// Only memory-derived host decisions need clean, disjoint descriptor reads.
|
|
auto &condition = block.AppendNewInst(ValueOpcode::IEqual32,
|
|
{memory_condition ? Value(&read) : Value(&offset),
|
|
Value(memory_condition ? 0x8000u : 4u)});
|
|
auto &store_block = AddValueBlock(program);
|
|
AddValueBlock(program);
|
|
program.blocks[0]->condition = Value(&condition);
|
|
program.blocks[0]->terminator.kind =
|
|
Libs::Graphics::ShaderRecompiler::CFG::TerminatorKind::ConditionalBranch;
|
|
program.blocks[0]->terminator.true_block = program.blocks[1];
|
|
program.blocks[0]->terminator.false_block = program.blocks[2];
|
|
program.blocks[1]->id = 1;
|
|
program.blocks[1]->terminator.kind =
|
|
Libs::Graphics::ShaderRecompiler::CFG::TerminatorKind::Return;
|
|
program.blocks[2]->id = 2;
|
|
program.blocks[2]->terminator.kind =
|
|
Libs::Graphics::ShaderRecompiler::CFG::TerminatorKind::Return;
|
|
program.memory_info.push_back({.kind = ResourceKind::Buffer, .resource = 0});
|
|
auto &output = store_block.AppendNewInst(ValueOpcode::GetBufferResource,
|
|
{source.dwords[0], source.dwords[1], source.dwords[2], source.dwords[3]});
|
|
store_block.AppendNewInst(ValueOpcode::StoreBufferU32,
|
|
{Value(&output), Value(0u), Value(0u), Value(0u), Value(1u), Value(true)})
|
|
.SetFlags(MemoryFlags{.index = 1});
|
|
auto plan = ExtractResourcePlan(program);
|
|
Check(plan.capture_specialization_reads == memory_condition && !plan.control_flow.empty(),
|
|
"conditional writable descriptor used the wrong memory dependency policy");
|
|
struct Reads { uint32_t ordinary = 0; uint32_t strict = 0; bool clean = false; } reads;
|
|
const std::array<uint32_t, 1> user_data{4u};
|
|
const SrtRuntime runtime{
|
|
.user_data = user_data,
|
|
.read_memory = +[](void *data, uint64_t, std::span<uint32_t> words) {
|
|
++static_cast<Reads *>(data)->ordinary;
|
|
words[0] = 0x8000u;
|
|
return true;
|
|
},
|
|
.userdata = &reads,
|
|
.read_specialization_memory = +[](void *data, uint64_t address, std::span<uint32_t> words) {
|
|
auto &reads = *static_cast<Reads *>(data);
|
|
++reads.strict;
|
|
if (!reads.clean || address != 0x1004u) return false;
|
|
words[0] = 0x8000u;
|
|
return true;
|
|
}};
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
for (const bool clean : {false, true}) {
|
|
reads = {.clean = clean};
|
|
// A failed predicate explores both edges; its dirty read also rejects the writable descriptor.
|
|
const bool expected = !memory_condition || clean;
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization) == expected &&
|
|
reads.ordinary == (memory_condition ? 0u : 1u) &&
|
|
reads.strict == (memory_condition ? 1u : 0u),
|
|
"writable descriptor changed reader policy or bypassed a dirty memory predicate");
|
|
if (!expected) continue;
|
|
Check(snapshot.buffers[0].dwords[0] == 0x8000u &&
|
|
snapshot.specialization_reads == (memory_condition
|
|
? std::vector<std::pair<uint64_t, uint64_t>>{{0x1004u, 4u}}
|
|
: std::vector<std::pair<uint64_t, uint64_t>>{}),
|
|
"writable descriptor lost its address or captured an immutable predicate");
|
|
}
|
|
}
|
|
|
|
void TestFailedMaterializationRejectsStage() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
auto plan = UserDataBufferPlan();
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
Check(!MaterializeResources(plan, {}, snapshot, specialization),
|
|
"missing runtime user data did not reject the cached stage");
|
|
}
|
|
|
|
void TestSharedControlPredicates() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
using Libs::Graphics::ShaderRecompiler::CFG::TerminatorKind;
|
|
constexpr uint32_t depth = 8;
|
|
for (const auto operation : {ValueOpcode::LogicalAnd, ValueOpcode::LogicalOr}) {
|
|
Program program;
|
|
program.user_data_count = 1;
|
|
program.srt_plan_complete = program.resource_tracking_complete = true;
|
|
auto &block = AddValueBlock(program);
|
|
const auto emit = [&](ValueOpcode opcode, std::initializer_list<Value> args) {
|
|
return Value(&block.AppendNewInst(opcode, args));
|
|
};
|
|
const auto user = emit(ValueOpcode::GetUserData, {Value(ScalarReg(0))});
|
|
const auto uniform = emit(ValueOpcode::INotEqual32, {user, Value(0u)});
|
|
const auto lane = emit(ValueOpcode::GetBuiltin,
|
|
{Value(static_cast<uint32_t>(StageInputKind::LocalInvocationId)), Value(0u)});
|
|
auto varying = emit(ValueOpcode::INotEqual32, {lane, Value(0u)});
|
|
// Both failed and partially uniform subgraphs share their operands exponentially.
|
|
for (uint32_t i = 0; i < depth; ++i)
|
|
varying = emit(ValueOpcode::LogicalOr, {varying, varying});
|
|
auto condition = emit(operation, {varying, uniform});
|
|
for (uint32_t i = 0; i < depth; ++i)
|
|
condition = emit(ValueOpcode::LogicalOr, {condition, condition});
|
|
condition = emit(ValueOpcode::LogicalNot, {condition});
|
|
condition = emit(ValueOpcode::ConditionRef, {condition});
|
|
for (uint32_t i = 0; i < 3; ++i) AddValueBlock(program);
|
|
for (uint32_t i = 0; i < 2; ++i) {
|
|
program.blocks[i]->condition = condition;
|
|
program.blocks[i]->terminator.kind = TerminatorKind::ConditionalBranch;
|
|
program.blocks[i]->terminator.true_block = program.blocks[i == 0 ? 1 : 3];
|
|
program.blocks[i]->terminator.false_block = program.blocks[2];
|
|
}
|
|
auto plan = ExtractResourcePlan(program);
|
|
Check(plan.value_storage.size() <= 2u * depth + 12u &&
|
|
plan.control_flow.size() == 4 &&
|
|
plan.control_flow[0].condition == plan.control_flow[1].condition &&
|
|
!plan.capture_specialization_reads,
|
|
"shared predicates expanded into trees or retained varying dependencies");
|
|
for (const uint32_t flag : {0u, 1u}) {
|
|
const std::array<uint32_t, 1> user_data{flag};
|
|
SrtWalker walker(plan, {.user_data = user_data});
|
|
uint32_t result = 99;
|
|
const bool conjunction = operation == ValueOpcode::LogicalAnd;
|
|
const bool known = conjunction ? flag == 0 : flag != 0;
|
|
Check(walker.Evaluate(plan.control_flow[0].condition, result) == known &&
|
|
(!known || result == uint32_t{conjunction}),
|
|
"shared predicate changed its uniform factor or cached runtime values");
|
|
std::vector<uint32_t> flat;
|
|
Check(walker.RefreshFlatBuffer(flat) &&
|
|
plan.visited_blocks == (known
|
|
? (conjunction ? std::vector<uint8_t>{1, 1, 0, 1}
|
|
: std::vector<uint8_t>{1, 0, 1, 0})
|
|
: std::vector<uint8_t>{1, 1, 1, 1}),
|
|
"shared predicate skipped an unknown branch or followed a rejected branch");
|
|
}
|
|
}
|
|
}
|
|
|
|
void TestNestedExecPredicatesReuseReads() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
using Libs::Graphics::ShaderRecompiler::CFG::TerminatorKind;
|
|
constexpr uint32_t depth = 12;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = program.resource_tracking_complete = true;
|
|
for (uint32_t i = 0; i < 3; ++i) AddValueBlock(program);
|
|
auto &entry = *program.blocks[0];
|
|
auto &use = *program.blocks[1];
|
|
auto &exit = *program.blocks[2];
|
|
const auto emit = [&](ValueOpcode opcode, std::initializer_list<Value> args) {
|
|
return Value(&entry.AppendNewInst(opcode, args));
|
|
};
|
|
const auto lane = emit(ValueOpcode::GetBuiltin,
|
|
{Value(static_cast<uint32_t>(StageInputKind::LocalInvocationId)), Value(0u)});
|
|
program.memory_info.push_back({.kind = ResourceKind::ScalarAddress, .planning_only = true});
|
|
const auto address = emit(ValueOpcode::GetAddressResource, {Value(0x1000u), Value(0u)});
|
|
const auto count = emit(ValueOpcode::LoadAddressU32,
|
|
{address, Value(0u), Value(0u), Value(true)});
|
|
count.Instruction()->SetFlags(MemoryFlags{.index = 0});
|
|
auto condition = emit(ValueOpcode::LogicalNot,
|
|
{emit(ValueOpcode::ULessThanEqual32, {count, lane})});
|
|
// A compact shared DAG must not become a tree of fresh EXEC evaluations.
|
|
for (uint32_t i = 0; i < depth; ++i) {
|
|
const auto mask = emit(ValueOpcode::INotEqual32, {lane, Value(i)});
|
|
condition = emit(ValueOpcode::LogicalAnd,
|
|
{mask, emit(ValueOpcode::LogicalOr, {condition, condition})});
|
|
}
|
|
entry.condition = condition;
|
|
entry.terminator.kind = TerminatorKind::ConditionalBranch;
|
|
entry.terminator.true_block = &use;
|
|
entry.terminator.false_block = &exit;
|
|
entry.AddBranch(&use);
|
|
entry.AddBranch(&exit);
|
|
use.terminator.kind = TerminatorKind::Branch;
|
|
use.terminator.true_block = &exit;
|
|
use.AddBranch(&exit);
|
|
DescriptorSource source;
|
|
source.dwords = {Value(0x8000u), Value(1u << 16u), Value(16u), Value(3u << 28u)};
|
|
source.dword_count = 4;
|
|
program.descriptor_sources.push_back(source);
|
|
program.info.buffers.push_back({.source = 0, .read = true});
|
|
program.memory_info.push_back({.kind = ResourceKind::Buffer, .resource = 0});
|
|
const auto buffer = Value(&use.AppendNewInst(ValueOpcode::GetBufferResource,
|
|
{source.dwords[0], source.dwords[1], source.dwords[2], source.dwords[3]}));
|
|
use.AppendNewInst(ValueOpcode::LoadBufferU32,
|
|
{buffer, Value(0u), Value(0u), Value(0u), Value(true)})
|
|
.SetFlags(MemoryFlags{.index = 1});
|
|
auto plan = ExtractResourcePlan(program);
|
|
struct Reads { uint32_t value = 0; bool clean = true; uint32_t strict = 0, ordinary = 0; } reads;
|
|
const SrtRuntime runtime{
|
|
.read_memory = +[](void *data, uint64_t, std::span<uint32_t>) {
|
|
++static_cast<Reads *>(data)->ordinary;
|
|
return false;
|
|
},
|
|
.userdata = &reads,
|
|
.read_specialization_memory = +[](void *data, uint64_t address, std::span<uint32_t> words) {
|
|
auto &reads = *static_cast<Reads *>(data);
|
|
++reads.strict;
|
|
Check(reads.strict <= depth + 1,
|
|
"shared EXEC predicates repeated scalar reads beyond their distinct masks");
|
|
if (!reads.clean || address != 0x1000u || words.size() != 1) return false;
|
|
words[0] = reads.value;
|
|
return true;
|
|
}};
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
for (const auto state : {Reads{64u, true}, Reads{0u, true}, Reads{0u, false}, Reads{64u, true}}) {
|
|
reads = state;
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization),
|
|
"nested EXEC predicates rejected a valid resource snapshot");
|
|
const bool inactive = reads.clean && reads.value == 0;
|
|
Check(snapshot.buffers[0].dwords[0] == (inactive ? 0u : 0x8000u),
|
|
"nested EXEC predicates lost an unknown branch or retained stale runtime facts");
|
|
Check(reads.strict > 0 && reads.ordinary == 0 &&
|
|
snapshot.specialization_reads.size() <= depth + 1,
|
|
"shared EXEC predicates repeated scalar reads beyond their distinct masks");
|
|
}
|
|
}
|
|
|
|
void TestFiniteImageRefreshReusesScalarReads() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = true;
|
|
program.resource_tracking_complete = true;
|
|
auto &block = AddValueBlock(program);
|
|
program.memory_info.push_back({.kind = ResourceKind::ScalarAddress});
|
|
auto &handle = block.AppendNewInst(ValueOpcode::GetAddressResource,
|
|
{Value(0x1000u), Value(0u)});
|
|
auto &srt = block.AppendNewInst(ValueOpcode::GetSrtResource);
|
|
for (uint32_t index = 0; index < 3; ++index) {
|
|
auto &read = block.AppendNewInst(ValueOpcode::LoadAddressU32,
|
|
{Value(&handle), Value(index * 4u), Value(0u), Value(true)});
|
|
read.SetFlags(MemoryFlags{.index = 0});
|
|
program.srt_reads.push_back({Value(&read), index});
|
|
auto &flat = block.AppendNewInst(ValueOpcode::ReadConst,
|
|
{Value(&srt), Value(index)});
|
|
DescriptorSource source;
|
|
source.dword_count = 8;
|
|
source.dwords.fill(Value(0u));
|
|
source.dwords[0] = Value(&flat);
|
|
source.dwords[1] = Value(static_cast<uint32_t>(
|
|
Libs::Graphics::Prospero::BufferFormat::k32_32_32_32Float) << 20u);
|
|
source.dwords[3] = Value(Libs::Graphics::DstSel(4, 5, 6, 7) |
|
|
(static_cast<uint32_t>(Libs::Graphics::Prospero::ImageType::kColor2D) << 28u));
|
|
program.descriptor_sources.push_back(source);
|
|
}
|
|
DescriptorSource root;
|
|
root.dword_count = 8;
|
|
root.dwords.fill(Value(0u));
|
|
root.indirect_descriptor.emplace(DescriptorSource::IndirectDescriptor{}).sources = {0, 1, 2, 1};
|
|
program.descriptor_sources.push_back(root);
|
|
program.info.images.push_back({
|
|
.source = 3,
|
|
.resource_class = ImageResourceClass::Sampled,
|
|
.numeric_class = Libs::Graphics::Prospero::TextureNumericClass::Float,
|
|
.dimension = Libs::Graphics::ShaderRecompiler::Decoder::ImageDimension::Dim2D});
|
|
auto plan = ExtractResourcePlan(program);
|
|
struct Reads {
|
|
std::array<uint32_t, 3> words{0x100u, 0x200u, 0x200u};
|
|
std::array<uint32_t, 3> counts{};
|
|
uint32_t ordinary = 0;
|
|
} reads;
|
|
const SrtRuntime runtime{
|
|
.read_memory = +[](void *data, uint64_t, std::span<uint32_t>) {
|
|
++static_cast<Reads *>(data)->ordinary;
|
|
return false;
|
|
},
|
|
.userdata = &reads,
|
|
.read_specialization_memory = +[](void *data, uint64_t address,
|
|
std::span<uint32_t> words) {
|
|
if (words.size() != 1 || address < 0x1000u || address >= 0x100cu ||
|
|
(address & 3u) != 0) return false;
|
|
auto &reads = *static_cast<Reads *>(data);
|
|
const auto index = (address - 0x1000u) / 4u;
|
|
++reads.counts[index];
|
|
words[0] = reads.words[index];
|
|
return true;
|
|
}};
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
const auto capacities = [&] {
|
|
return std::array{snapshot.images.capacity(), snapshot.flattened_srt.capacity(),
|
|
snapshot.specialization_reads.capacity(), specialization.images.capacity()};
|
|
};
|
|
const auto check_mapping = [&](std::array<uint32_t, 4> ordinals) {
|
|
const auto offset = specialization.images[0].indirect_mapping_offset;
|
|
Check(snapshot.images.size() == 2 && snapshot.flattened_srt[offset] == 4,
|
|
"finite image candidates were not deduplicated");
|
|
for (uint32_t key = 0; key < ordinals.size(); ++key) {
|
|
Check(snapshot.flattened_srt[offset + 1u + key * 2u] == key &&
|
|
snapshot.flattened_srt[offset + 2u + key * 2u] == ordinals[key],
|
|
"finite image selector mapping is stale or incorrect");
|
|
}
|
|
};
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization),
|
|
"finite image materialization failed");
|
|
Check(reads.ordinary == 0 && reads.counts == std::array<uint32_t, 3>{1, 1, 1} &&
|
|
snapshot.specialization_reads.size() == 3,
|
|
"finite image candidates repeated scalar reads or bypassed clean provenance");
|
|
check_mapping({0, 1, 1, 1});
|
|
const auto warm_capacities = capacities();
|
|
reads.words = {0x300u, 0x300u, 0x400u};
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization),
|
|
"finite image refresh failed after descriptor changes");
|
|
Check(reads.ordinary == 0 && reads.counts == std::array<uint32_t, 3>{2, 2, 2} &&
|
|
snapshot.specialization_reads.size() == 3 &&
|
|
snapshot.images[0].dwords[0] == 0x300u && snapshot.images[1].dwords[0] == 0x400u,
|
|
"finite image refresh retained old scalar values or repeated reads");
|
|
check_mapping({0, 0, 1, 0});
|
|
Check(capacities() == warm_capacities,
|
|
"finite image refresh grew reusable resource storage after warmup");
|
|
}
|
|
|
|
void TestEmptyTraversalSkipsUnmappedDescriptor(bool independent_mask) {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
using Libs::Graphics::ShaderRecompiler::CFG::TerminatorKind;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = program.resource_tracking_complete = true;
|
|
for (uint32_t i = 0; i < 6; ++i) AddValueBlock(program);
|
|
auto &entry = *program.blocks[0];
|
|
auto &loop = *program.blocks[1];
|
|
auto &body = *program.blocks[2];
|
|
auto &merge = *program.blocks[3];
|
|
auto &use = *program.blocks[4];
|
|
auto &exit = *program.blocks[5];
|
|
const auto emit = [](Block &block, ValueOpcode opcode, std::initializer_list<Value> args) {
|
|
return Value(&block.AppendNewInst(opcode, args));
|
|
};
|
|
const auto branch = [](Block &block, Block &target, Value condition = {}, Block *other = nullptr) {
|
|
block.terminator.kind = other ? TerminatorKind::ConditionalBranch : TerminatorKind::Branch;
|
|
block.terminator.true_block = ⌖
|
|
block.terminator.false_block = other;
|
|
block.condition = condition;
|
|
block.AddBranch(&target);
|
|
if (other) block.AddBranch(other);
|
|
};
|
|
const auto lane = emit(entry, ValueOpcode::GetBuiltin,
|
|
{Value(static_cast<uint32_t>(StageInputKind::LocalInvocationId)), Value(0u)});
|
|
const auto active = emit(entry, ValueOpcode::INotEqual32, {lane, Value(0u)});
|
|
const auto initial_mask = independent_mask
|
|
? emit(entry, ValueOpcode::IEqual32, {lane, Value(0u)}) : active;
|
|
const auto initial = emit(entry, ValueOpcode::SelectU32,
|
|
{initial_mask, Value(UINT32_MAX), Value(0u)});
|
|
program.memory_info.push_back({.kind = ResourceKind::ScalarAddress, .planning_only = true});
|
|
const auto address = emit(entry, ValueOpcode::GetAddressResource, {Value(0x1000u), Value(0u)});
|
|
const auto count = emit(entry, ValueOpcode::LoadAddressU32,
|
|
{address, Value(0u), Value(0u), Value(true)});
|
|
count.Instruction()->SetFlags(MemoryFlags{.index = 0});
|
|
const auto rejected = emit(entry, ValueOpcode::ULessThanEqual32, {count, lane});
|
|
const auto accepted = emit(entry, ValueOpcode::LogicalNot, {rejected});
|
|
branch(entry, loop, emit(entry, ValueOpcode::LogicalAnd, {active, accepted}), &merge);
|
|
|
|
// A nonempty traversal contains a varying loop-carried value. Its cycle must
|
|
// remain unknown; only the proven empty traversal can select the bypass arm.
|
|
auto &carried = loop.AppendNewInst(ValueOpcode::Phi);
|
|
carried.SetFlags(Type::U32);
|
|
const auto next = emit(body, ValueOpcode::IAdd32, {Value(&carried), Value(1u)});
|
|
carried.AddPhiOperand(&entry, lane);
|
|
carried.AddPhiOperand(&body, next);
|
|
branch(loop, body, emit(loop, ValueOpcode::INotEqual32, {Value(&carried), Value(UINT32_MAX)}), &merge);
|
|
loop.terminator.loop_header = true;
|
|
loop.terminator.continue_block = &body;
|
|
loop.terminator.merge_block = &merge;
|
|
branch(body, loop);
|
|
auto &selected = merge.AppendNewInst(ValueOpcode::Phi);
|
|
selected.SetFlags(Type::U32);
|
|
selected.AddPhiOperand(&entry, initial);
|
|
selected.AddPhiOperand(&loop, Value(&carried));
|
|
const auto valid = emit(merge, ValueOpcode::INotEqual32, {Value(&selected), Value(UINT32_MAX)});
|
|
branch(merge, use, emit(merge, ValueOpcode::LogicalAnd, {active, valid}), &exit);
|
|
branch(use, exit);
|
|
DescriptorSource source;
|
|
source.dwords = {Value(0x8000u), Value(1u << 16u), Value(16u), Value(3u << 28u)};
|
|
source.dword_count = 4;
|
|
program.descriptor_sources.push_back(source);
|
|
program.info.buffers.push_back({.source = 0, .read = true});
|
|
program.memory_info.push_back({.kind = ResourceKind::Buffer, .resource = 0});
|
|
const auto buffer = emit(use, ValueOpcode::GetBufferResource,
|
|
{source.dwords[0], source.dwords[1], source.dwords[2], source.dwords[3]});
|
|
emit(use, ValueOpcode::LoadBufferU32, {buffer, Value(0u), Value(0u), Value(0u), Value(true)})
|
|
.Instruction()->SetFlags(MemoryFlags{.index = 1});
|
|
auto plan = ExtractResourcePlan(program);
|
|
struct Reads { uint32_t count = 0; bool clean = true; } reads;
|
|
const SrtRuntime runtime{
|
|
.userdata = &reads,
|
|
.read_specialization_memory = +[](void *data, uint64_t address, std::span<uint32_t> words) {
|
|
const auto &reads = *static_cast<Reads *>(data);
|
|
if (!reads.clean || address != 0x1000u || words.size() != 1) return false;
|
|
words[0] = reads.count;
|
|
return true;
|
|
}};
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
for (const auto state : {Reads{0u, true}, Reads{4u, true}, Reads{0u, false}, Reads{0u, true}}) {
|
|
reads = state;
|
|
uint32_t condition = 99;
|
|
Check(!SrtWalker(plan, runtime).Evaluate(plan.control_flow[3].condition, condition),
|
|
"direct merge evaluation used missing or previous runtime reachability");
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization),
|
|
"partial traversal proof rejected a valid resource snapshot");
|
|
const bool inactive = !independent_mask && reads.clean && reads.count == 0u;
|
|
Check(snapshot.buffers[0].dwords[0] == (inactive ? 0u : 0x8000u),
|
|
"empty traversal kept its descriptor or an uncertain traversal lost it");
|
|
Check(specialization.buffers[0].zero_stride_oob == inactive,
|
|
"inactive traversal did not expose dead vector reads to specialization");
|
|
if (inactive) {
|
|
Check(!snapshot.specialization_reads.empty(), "empty traversal lost its clean scalar read");
|
|
for (const auto &read : snapshot.specialization_reads)
|
|
Check(read == std::pair<uint64_t, uint64_t>{0x1000u, 4u},
|
|
"empty traversal proof captured an unrelated memory range");
|
|
}
|
|
}
|
|
}
|
|
|
|
void TestCyclicControlPredicatesRemainUnknown() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
using Libs::Graphics::ShaderRecompiler::CFG::TerminatorKind;
|
|
Program program;
|
|
program.stage = Libs::Graphics::ShaderType::Compute;
|
|
program.srt_plan_complete = program.resource_tracking_complete = true;
|
|
for (uint32_t i = 0; i < 4; ++i) AddValueBlock(program);
|
|
auto &entry = *program.blocks[0];
|
|
auto &left = *program.blocks[1];
|
|
auto &right = *program.blocks[2];
|
|
auto &exit = *program.blocks[3];
|
|
const auto lane = Value(&entry.AppendNewInst(ValueOpcode::GetBuiltin,
|
|
{Value(static_cast<uint32_t>(StageInputKind::LocalInvocationId)), Value(0u)}));
|
|
const auto u = Value(&entry.AppendNewInst(ValueOpcode::INotEqual32, {lane, Value(0u)}));
|
|
const auto v = Value(&entry.AppendNewInst(ValueOpcode::INotEqual32, {lane, Value(1u)}));
|
|
auto &p = left.AppendNewInst(ValueOpcode::Phi);
|
|
auto &q = right.AppendNewInst(ValueOpcode::Phi);
|
|
p.SetFlags(Type::U1);
|
|
q.SetFlags(Type::U1);
|
|
const auto a = Value(&left.AppendNewInst(ValueOpcode::LogicalAnd, {u, Value(&p)}));
|
|
const auto b = Value(&right.AppendNewInst(ValueOpcode::LogicalAnd, {v, Value(&q)}));
|
|
p.AddPhiOperand(&entry, Value(true));
|
|
p.AddPhiOperand(&right, b);
|
|
q.AddPhiOperand(&entry, Value(true));
|
|
q.AddPhiOperand(&left, a);
|
|
const auto branch = [](Block &block, Value condition, Block &yes, Block &no) {
|
|
block.condition = condition;
|
|
block.terminator.kind = TerminatorKind::ConditionalBranch;
|
|
block.terminator.true_block = &yes;
|
|
block.terminator.false_block = &no;
|
|
block.AddBranch(&yes);
|
|
block.AddBranch(&no);
|
|
};
|
|
// Two loop entries have no single header whose Phi can be discarded up front.
|
|
branch(entry, u, left, right);
|
|
branch(left, a, right, exit);
|
|
branch(right, b, left, exit);
|
|
auto plan = ExtractResourcePlan(program);
|
|
SrtWalker walker(plan, {});
|
|
uint32_t value = 99;
|
|
Check(!walker.Evaluate(plan.control_flow[1].condition, value) &&
|
|
!walker.Evaluate(plan.control_flow[2].condition, value),
|
|
"cyclic varying control acquired an unsupported uniform value");
|
|
std::vector<uint32_t> flat;
|
|
Check(walker.RefreshFlatBuffer(flat) && plan.visited_blocks == std::vector<uint8_t>({1, 1, 1, 1}),
|
|
"cyclic control lost a possible branch during reachability");
|
|
}
|
|
|
|
void TestMixedSamplerVariantsShareRuntimeDescriptor() {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
auto program = MixedSamplerProgram();
|
|
auto plan = ExtractResourcePlan(program);
|
|
std::array<uint32_t, 2> user_data{0x11111111u, 0x22222222u};
|
|
const SrtRuntime runtime{.user_data = user_data};
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization),
|
|
"mixed sampler materialization failed");
|
|
ApplyResourceSpecialization(program, specialization);
|
|
const auto &samplers = program.info.samplers;
|
|
Check(snapshot.samplers.size() == 2 && samplers.size() == 3 &&
|
|
samplers[0].snapshot_index == 0 && samplers[1].snapshot_index == 1 &&
|
|
samplers[2].snapshot_index == 1 &&
|
|
samplers[0].source == plan.info.samplers[0].source &&
|
|
samplers[1].source == plan.info.samplers[1].source &&
|
|
samplers[2].source == samplers[1].source &&
|
|
!samplers[1].force_point_filtering && samplers[2].force_point_filtering &&
|
|
program.info.sampled_pairs[2].sampler == 2,
|
|
"native sampler variants lost their source identity or binding order");
|
|
const auto capacity = snapshot.samplers.capacity();
|
|
user_data[1] = 0x33333333u;
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization) &&
|
|
snapshot.samplers.size() == 2 && snapshot.samplers.capacity() == capacity &&
|
|
snapshot.samplers[samplers[0].snapshot_index].dwords[0] == user_data[0] &&
|
|
snapshot.samplers[samplers[1].snapshot_index].dwords[0] == user_data[1] &&
|
|
snapshot.samplers[samplers[2].snapshot_index].dwords[0] == user_data[1],
|
|
"sampler variants retained stale or duplicated descriptors after refresh");
|
|
}
|
|
|
|
void TestIndirectImageSamplerClasses(bool mixed) {
|
|
using namespace Libs::Graphics::ShaderRecompiler::IR;
|
|
using Libs::Graphics::Prospero::BufferFormat;
|
|
using Libs::Graphics::Prospero::TextureNumericClass;
|
|
auto program = MixedSamplerProgram();
|
|
auto &first = program.descriptor_sources[0];
|
|
first.dwords[0] = Value(0x100u);
|
|
first.dwords[1] = Value(static_cast<uint32_t>(BufferFormat::k8UNorm) << 20u);
|
|
first.dwords[3] = program.descriptor_sources[1].dwords[3];
|
|
program.descriptor_sources[1].dwords[1] = Value(static_cast<uint32_t>(
|
|
mixed ? BufferFormat::k8UInt : BufferFormat::k8UNorm) << 20u);
|
|
DescriptorSource root;
|
|
root.dword_count = 8;
|
|
root.dwords.fill(Value(0u));
|
|
root.indirect_descriptor.emplace().sources = {0, 1, 0};
|
|
program.info.images.resize(1);
|
|
program.info.images[0].source = static_cast<uint32_t>(program.descriptor_sources.size());
|
|
program.descriptor_sources.push_back(root);
|
|
program.info.samplers.resize(1);
|
|
program.info.sampled_pairs.resize(1);
|
|
auto plan = ExtractResourcePlan(program);
|
|
std::array<uint32_t, 1> user_data{0x11111111u};
|
|
uint32_t reads = 0;
|
|
const SrtRuntime runtime{.user_data = user_data, .userdata = &reads,
|
|
.read_specialization_memory = RejectSpecializationRead};
|
|
ResourceSnapshot snapshot;
|
|
ResourceSpecialization specialization;
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization) && reads == 0 &&
|
|
snapshot.images.size() == 2 && snapshot.images[0].dwords[0] == 0x100u &&
|
|
snapshot.images[1].dwords[0] == 1u &&
|
|
specialization.images[0].numeric_class == TextureNumericClass::Float &&
|
|
specialization.images[1].numeric_class ==
|
|
(mixed ? TextureNumericClass::Uint : TextureNumericClass::Float),
|
|
"indirect image materialization rejected or changed a typed candidate");
|
|
const auto offset = specialization.images[0].indirect_mapping_offset;
|
|
Check(snapshot.flattened_srt[offset] == 3u &&
|
|
snapshot.flattened_srt[offset + 2u] == 0u &&
|
|
snapshot.flattened_srt[offset + 4u] == 1u &&
|
|
snapshot.flattened_srt[offset + 6u] == 0u,
|
|
"mixed image classes changed selector ordinals or duplicated candidates");
|
|
ApplyResourceSpecialization(program, specialization);
|
|
Check(program.info.images[0].indirect_resources == std::vector<uint32_t>({0, 1}) &&
|
|
snapshot.samplers.size() == 1 && program.info.samplers.size() == (mixed ? 2u : 1u),
|
|
"indirect images lost candidates or created unnecessary sampler variants");
|
|
user_data[0] = 0x33333333u;
|
|
Check(MaterializeResources(plan, runtime, snapshot, specialization),
|
|
"mixed image sampler refresh failed");
|
|
for (uint32_t index = 0; index < program.info.samplers.size(); ++index) {
|
|
const auto &sampler = program.info.samplers[index];
|
|
Check(sampler.snapshot_index == 0u && sampler.source == plan.info.samplers[0].source &&
|
|
sampler.force_point_filtering == (index != 0u) &&
|
|
sampler.integer_border == (index != 0u) &&
|
|
snapshot.samplers[sampler.snapshot_index].dwords[0] == user_data[0],
|
|
"typed sampler variants lost filtering, border class, or shared live descriptor");
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace Common {
|
|
|
|
int DbgExitHandler(const char *, int, std::string_view) { std::abort(); }
|
|
|
|
int DbgExitHandler(const char *, int, fmt::text_style, std::string_view) {
|
|
std::abort();
|
|
}
|
|
|
|
int DbgExitIfHandler(const char *, const char *, int) { return 1; }
|
|
|
|
void DbgExit(int) { std::abort(); }
|
|
|
|
} // namespace Common
|
|
|
|
int main() {
|
|
TestMappedSrtUsesDirectReaderByDefault();
|
|
TestNativeNestedSrtRefresh();
|
|
TestIntegerRuntimeValueFollowsSrtReads();
|
|
TestSrtAliasesRetainReadPolicy();
|
|
TestUniformVectorDescriptorRead();
|
|
TestExactReciprocalDescriptorArithmetic();
|
|
TestUnbasedFlatCacheHitMaterializes();
|
|
for (const bool memory_condition : {false, true})
|
|
TestWrittenDescriptorPredicateReads(memory_condition);
|
|
TestFailedMaterializationRejectsStage();
|
|
TestSharedControlPredicates();
|
|
TestNestedExecPredicatesReuseReads();
|
|
TestFiniteImageRefreshReusesScalarReads();
|
|
for (const bool independent_mask : {false, true})
|
|
TestEmptyTraversalSkipsUnmappedDescriptor(independent_mask);
|
|
TestCyclicControlPredicatesRemainUnknown();
|
|
TestMixedSamplerVariantsShareRuntimeDescriptor();
|
|
for (const bool mixed : {false, true}) TestIndirectImageSamplerClasses(mixed);
|
|
std::puts("ResourceMaterializationTests: all cases passed");
|
|
return 0;
|
|
}
|
|
|
|
// Keep this focused standalone target self-contained by amalgamating its small
|
|
// typed-IR implementation set.
|
|
#include "graphics/shader/recompiler/ir/Block.cpp"
|
|
#include "graphics/shader/recompiler/ir/Program.cpp"
|
|
#include "graphics/shader/recompiler/ir/Type.cpp"
|
|
#include "graphics/shader/recompiler/ir/Value.cpp"
|
|
#include "graphics/shader/recompiler/ir/opcodes/ValueOpcodes.cpp"
|