#define VK_NO_PROTOTYPES #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace fixture { enum Cache { None = -1, Owner, Seen, Mine, Failure }; std::atomic fail_cache{None}; std::atomic allocation_faults{0}; template struct FaultAllocator : std::allocator { using value_type = T; FaultAllocator() = default; template FaultAllocator(const FaultAllocator&) {} template struct rebind { using other = FaultAllocator; }; T* allocate(size_t n) { int expected = Tag; if (fail_cache.compare_exchange_strong(expected, None)) { allocation_faults++; throw std::bad_alloc(); } return std::allocator{}.allocate(n); } }; template using FaultMap = std::unordered_map, std::equal_to, FaultAllocator, Tag>>; template using FaultSet = std::unordered_set, std::equal_to, FaultAllocator>; /* PARAMS */ /* ENUMS */ struct { VkDevice device{}; VkPhysicalDeviceProperties props{}; VkPhysicalDeviceFeatures features{}; bool custom_border_color = false; } dev; FaultMap samplers; std::mutex replay_mu; struct ParLock { std::lock_guard lock; ParLock() : lock(replay_mu) {} }; uint64_t generation = 1, frame_no = 1; unsigned creates = 0, destroyed = 0; VkResult create_result = VK_SUCCESS; bool garbage = false, arm_owner_commit = false, arm_failure_commit = false, cache_off = false; std::string policy; std::string descriptor_policy; float registration_lod_max = 8; struct Saved { VkSamplerCreateInfo ci{}; bool custom = false, reduced = false; VkSamplerReductionMode reduction{}; float border[4]{}; }; std::unordered_map live; uint64_t mix(uint64_t a, uint64_t b) { return (a ^ b) * 0x9e3779b97f4a7c15ull; } uint64_t texture_frame_no() { return frame_no; } bool sampler_cache_on() { return !cache_off; } uint64_t sampler_registrations_generation() { return generation; } uint32_t sampler_slot_version(int) { return (uint32_t)generation; } bool sampler_of(int id, nvn_samp_par* p) { if (id < 0) return false; *p = {}; p->minf = NVN_MIN_FILTER_LINEAR_MIPMAP_LINEAR; p->magf = NVN_MAG_FILTER_LINEAR; p->aniso = 1; p->lod_max = registration_lod_max; p->lod_bias = id * 0.25f; if (policy == "nearest" || policy == "force-linear" || policy.find("compare") == 0) p->minf = NVN_MIN_FILTER_NEAREST, p->magf = NVN_MAG_FILTER_NEAREST; if (policy == "linear") p->minf = NVN_MIN_FILTER_LINEAR; if (policy == "compare-explicit") p->cmp_mode = 1, p->cmp_func = 1; if (policy == "custom-border" || policy == "custom-reduction") { p->border[0] = 0.25f; p->border[1] = 0.5f; p->border[2] = 0.75f; p->border[3] = 1; } if (policy == "standard-border") std::fill(std::begin(p->border), std::end(p->border), 1.0f); if (policy == "reduction" || policy == "compare-reduction" || policy == "custom-reduction") p->reduction = 1; if (policy == "wrap") p->ws = NVN_WRAP_MODE_REPEAT, p->wt = NVN_WRAP_MODE_MIRRORED_REPEAT, p->wr = NVN_WRAP_MODE_CLAMP_TO_BORDER; if (policy == "lod-clamp") p->lod_bias = 100, p->lod_min = -3, p->lod_max = -1; return true; } const char* getenv(const char* name) { if (!std::strcmp(name, "RX_VK_PUSH_STATE_OLD") && descriptor_policy == "descriptor-old") return "1"; if (!std::strcmp(name, "RX_VK_PUSH_ALL") && descriptor_policy == "descriptor-whole") return "1"; if (!std::strcmp(name, "RX_VK_SAMPLER_CACHE") && cache_off) return "0"; if (!std::strcmp(name, "RX_VK_SHADOW_PCF") && policy == "compare-pcf-off") return "0"; if (!std::strcmp(name, "RX_VK_ANISO") && policy == "anisotropy") return "16"; if (!std::strcmp(name, "RX_VK_FORCE_LINEAR") && policy == "force-linear") return "1"; return nullptr; } void logf(const char*, ...) {} VkResult vkCreateSampler(VkDevice, const VkSamplerCreateInfo* ci, const VkAllocationCallbacks*, VkSampler* out) { creates++; *out = garbage ? reinterpret_cast(uintptr_t(0xdead)) : VK_NULL_HANDLE; if (create_result != VK_SUCCESS) { if (arm_failure_commit) { arm_failure_commit = false; fail_cache = Failure; } return create_result; } *out = reinterpret_cast(uintptr_t(100 + creates)); Saved saved; saved.ci = *ci; saved.ci.pNext = nullptr; for (auto* next = static_cast(ci->pNext); next; next = next->pNext) { if (next->sType == VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT) { auto* border = reinterpret_cast(next); saved.custom = true; std::copy(std::begin(border->customBorderColor.float32), std::end(border->customBorderColor.float32), saved.border); } if (next->sType == VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO) { saved.reduced = true; saved.reduction = reinterpret_cast(next)->reductionMode; } } live.emplace(*out, saved); // Arm after the resource exists: target the operation, not an STL-dependent nth allocation. if (arm_owner_commit) { arm_owner_commit = false; fail_cache = Owner; } return VK_SUCCESS; } void vkDestroySampler(VkDevice, VkSampler sampler, const VkAllocationCallbacks*) { if (!sampler) return; // (Vulkan permits null destruction; a non-null error output is still undefined) assert(live.erase(sampler) == 1); destroyed++; // (not undefined error output or an already-owned sampler) } /* ACTUAL */ struct Program { bool push = true; VkPipelineLayout layout{}; VkDescriptorSetLayout set_layout{}; }; struct DescriptorWrites { std::vector writes; } descriptor_writes; DescriptorWrites& dw() { return descriptor_writes; } struct Pushed; std::array& pushed(); struct Recording { VkDescriptorPool pool{}; std::vector extra; } recording; Recording* cur = &recording; bool g_fine = false; enum { FC_PUSH_FULL, FC_PUSH_WRITES, FC_PUSH_DESCS, FC_PUSH_DELTA, FC_POOL_SETS, FC_POOL_DESCS }; int64_t fine_n[6]{}; #define FINE_SCOPE(x) (void)0 #define FINE_N(x, n) (void)0 unsigned descriptor_allocs = 0, descriptor_updates = 0, descriptor_binds = 0, descriptor_pushes = 0; void check_writes(uint32_t n, const VkWriteDescriptorSet* writes) { for (uint32_t i = 0; i < n; i++) if (writes[i].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) for (uint32_t k = 0; k < writes[i].descriptorCount; k++) assert(live.count(writes[i].pImageInfo[k].sampler)); } void vkCmdPushDescriptorSetKHR(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t n, const VkWriteDescriptorSet* writes) { check_writes(n, writes); descriptor_pushes++; } VkDescriptorPool make_pool() { return reinterpret_cast(uintptr_t(11)); } void vkDestroyDescriptorPool(VkDevice, VkDescriptorPool pool, const VkAllocationCallbacks*) { assert(pool); } VkResult vkAllocateDescriptorSets(VkDevice, const VkDescriptorSetAllocateInfo*, VkDescriptorSet* out) { descriptor_allocs++; *out = reinterpret_cast(uintptr_t(12)); return VK_SUCCESS; } void vkUpdateDescriptorSets(VkDevice, uint32_t n, const VkWriteDescriptorSet* writes, uint32_t, const VkCopyDescriptorSet*) { check_writes(n, writes); descriptor_updates++; } void vkCmdBindDescriptorSets(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkDescriptorSet*, uint32_t, const uint32_t*) { descriptor_binds++; } /* DESCRIPTORS */ std::array& pushed() { static std::array state; return state; } std::string route; VkSampler get(int id = 0, bool compare = false) { return route == "make" ? sampler_make(id, compare) : sampler_for(id, compare); } void valid(VkSampler sampler) { assert(sampler && live.count(sampler)); } void retry(const std::string& test) { create_result = test == "host-oom" ? VK_ERROR_OUT_OF_HOST_MEMORY : test == "unknown" ? VK_ERROR_UNKNOWN : VK_ERROR_OUT_OF_DEVICE_MEMORY; garbage = test == "error-output"; assert(!get()); assert(!get()); assert(creates == 1 && live.empty() && destroyed == 0); create_result = VK_SUCCESS; assert(!get()); assert(creates == 1); // (bounded until a later present) frame_no++; if (test == "generation-retry") generation++; VkSampler next{}; if (test == "thread-retry") { std::thread worker([&] { next = get(); }); worker.join(); } else next = get(); valid(next); assert(creates == 2 && get() == next); } void run(const std::string& test) { cache_off = route == "cache-off"; dev.props.limits.maxSamplerLodBias = 16; dev.props.limits.maxSamplerAnisotropy = 8; dev.features.samplerAnisotropy = VK_TRUE; dev.custom_border_color = true; if (test.find("descriptor-") == 0) { descriptor_policy = test; recording.pool = make_pool(); // A live recording already owns its initial pool before binding. Program p; p.push = test != "descriptor-pool"; p.layout = reinterpret_cast(uintptr_t(20)); const auto bp = test == "descriptor-compute" ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS; const auto cmd = reinterpret_cast(uintptr_t(21)); auto first = get(); valid(first); VkDescriptorImageInfo images[2]{{first, {}, VK_IMAGE_LAYOUT_GENERAL}, {first, {}, VK_IMAGE_LAYOUT_GENERAL}}; VkWriteDescriptorSet w{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; w.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; w.descriptorCount = 2; w.pImageInfo = images; dw().writes = {w}; create_result = VK_ERROR_OUT_OF_DEVICE_MEMORY; images[1].sampler = get(1); assert(!images[1].sampler && !bind_descriptors(cmd, bp, p)); assert(!descriptor_allocs && !descriptor_updates && !descriptor_binds && !descriptor_pushes); create_result = VK_SUCCESS; frame_no++; images[1].sampler = get(1); valid(images[1].sampler); assert(bind_descriptors(cmd, bp, p)); auto before = pushed()[bp == VK_PIPELINE_BIND_POINT_COMPUTE]; const auto allocs = descriptor_allocs, updates = descriptor_updates, binds = descriptor_binds, pushes = descriptor_pushes; create_result = VK_ERROR_OUT_OF_DEVICE_MEMORY; images[1].sampler = get(2); assert(!images[1].sampler); assert(!bind_descriptors(cmd, bp, p)); assert(descriptor_allocs == allocs && descriptor_updates == updates && descriptor_binds == binds && descriptor_pushes == pushes); const auto& after = pushed()[bp == VK_PIPELINE_BIND_POINT_COMPUTE]; assert(after.cmd == before.cmd && after.layout == before.layout && after.n == before.n && after.words == before.words && after.writes == before.writes && after.at == before.at); create_result = VK_SUCCESS; frame_no++; images[1].sampler = get(2); valid(images[1].sampler); assert(bind_descriptors(cmd, bp, p)); assert(p.push ? descriptor_pushes == pushes + 1 : descriptor_updates == updates + 1 && descriptor_binds == binds + 1); // Storage images do not consume a sampler: their null sampler remains legal. dw().writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; images[0].sampler = images[1].sampler = VK_NULL_HANDLE; assert(bind_descriptors(cmd, bp, p)); return; } if (test == "host-oom" || test == "device-oom" || test == "unknown" || test == "error-output" || test == "generation-retry" || test == "thread-retry") { retry(test); return; } if (test == "independent") { create_result = VK_ERROR_OUT_OF_HOST_MEMORY; assert(!get()); create_result = VK_SUCCESS; auto second = get(1); valid(second); assert(creates == 2 && !get() && get(1) == second); return; } if (test == "owner-commit") { arm_owner_commit = true; assert(!get()); assert(live.empty() && destroyed == 1 && allocation_faults == 1); assert(!get() && creates == 1); frame_no++; valid(get()); assert(creates == 2); return; } if (test == "concurrent") { std::vector workers; for (int i = 0; i < 4; i++) workers.emplace_back([] { for (int j = 0; j < 50; j++) assert(get()); }); for (auto& worker : workers) worker.join(); assert(creates == 1 && live.size() == 1); return; } if (test == "seen-commit") { auto first = get(); valid(first); // A distinct ID forces the parameter acceleration insertion. // Use sampler_make directly to test this cache even when the outer ID table is bypassed. if (!cache_off) { fail_cache = Seen; auto next = sampler_make(1, false); valid(next); assert(allocation_faults == 1); assert(live.at(next).ci.mipLodBias == 0.25f && live.at(next).ci.maxLod == 8); } else valid(get(1)); assert(destroyed == 0); return; } if (test == "mine-commit") { auto first = sampler_make(0, false); valid(first); fail_cache = Mine; assert(sampler_make(0, false) == first); assert(allocation_faults == 1 && creates == 1 && destroyed == 0 && live.size() == 1); return; } if (test == "valid-after-failure" || test == "failure-commit") { auto first = get(); valid(first); create_result = VK_ERROR_OUT_OF_DEVICE_MEMORY; arm_failure_commit = test == "failure-commit"; assert(!get(1)); assert(get() == first); create_result = VK_SUCCESS; if (test == "failure-commit") { assert(allocation_faults == 1 && !get(2) && creates == 2); } else valid(get(2)); assert(!get(1)); frame_no++; valid(get(1)); assert(get() == first && destroyed == 0); return; } if (test == "registration") { auto first = get(); valid(first); generation++; registration_lod_max = 3; auto second = get(); valid(second); assert(second != first && creates == 2 && live.at(second).ci.maxLod == 3); return; } if (test == "shared-thread") { auto first = get(); valid(first); VkSampler other{}; std::thread worker([&] { other = get(); }); worker.join(); assert(other == first && creates == 1); return; } policy = test; const bool compare = test.find("compare") == 0; const int id = test == "unknown-id" ? -1 : 0; auto sampler = get(id, compare); valid(sampler); const auto& saved = live.at(sampler); const auto& ci = saved.ci; assert(get(id, compare) == sampler && creates == 1); if (test == "nearest") assert(ci.minFilter == VK_FILTER_NEAREST && ci.magFilter == VK_FILTER_NEAREST && ci.maxLod == 0.25f); if (test == "linear") assert(ci.minFilter == VK_FILTER_LINEAR && ci.maxLod == 0.25f); if (test == "unknown-id" || test == "force-linear") assert(ci.minFilter == VK_FILTER_LINEAR && ci.magFilter == VK_FILTER_LINEAR && ci.maxLod == 0.25f); if (test == "wrap") assert(ci.addressModeU == VK_SAMPLER_ADDRESS_MODE_REPEAT && ci.addressModeV == VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT && ci.addressModeW == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER); if (test == "lod-clamp") assert(ci.mipLodBias == 16 && ci.minLod == 0 && ci.maxLod == 0); if (compare) { assert(ci.compareEnable && ci.compareOp == (test == "compare-explicit" ? VK_COMPARE_OP_NEVER : VK_COMPARE_OP_LESS_OR_EQUAL)); assert(ci.minFilter == (test == "compare-pcf-off" ? VK_FILTER_NEAREST : VK_FILTER_LINEAR)); } if (test == "custom-border" || test == "custom-reduction") assert(saved.custom && ci.borderColor == VK_BORDER_COLOR_FLOAT_CUSTOM_EXT && saved.border[0] == 0.25f && saved.border[3] == 1); if (test == "standard-border") assert(!saved.custom && ci.borderColor == VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE); if (test == "reduction" || test == "custom-reduction") assert(saved.reduced && saved.reduction == VK_SAMPLER_REDUCTION_MODE_MIN); if (test == "compare-reduction") assert(!saved.reduced); if (test == "anisotropy") assert(ci.anisotropyEnable && ci.maxAnisotropy == 8); } } // namespace fixture int main(int argc, char** argv) { assert(argc == 3); fixture::route = argv[1]; fixture::run(argv[2]); return 0; }