Catcrafts/Crafter.Graphics
2
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

test(pipeline): cover pipeline-cache header validation (#69)

Browse source 
PipelineCacheValidation drives Device::PipelineCacheDataCompatible
directly (no GPU): synthetic device identities + 32-byte cache headers
assert that a matching header is accepted while foreign vendor/device,
a bumped UUID (driver update), unknown version, undersized headerSize,
and short/empty blobs are all rejected. Mirrors the GPU-free style of
MemoryTypeFallback / UploadStrategy. Also gitignore the serialized
pipeline_cache.bin a real-device test run drops in the working dir.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
catbot 2026-06-16 18:23:25 +00:00
commit a728482731
3 changed files with 188 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -1,2 +1,3 @@
build/ build/
bin/ bin/
pipeline_cache.bin

29
project.cpp
View file

@ -587,6 +587,35 @@ extern "C" Configuration CrafterBuildProject(std::span<const std::string_view> a
hitImpls.emplace_back("tests/InputFieldHitTest/main"); hitImpls.emplace_back("tests/InputFieldHitTest/main");
hc.GetInterfacesAndImplementations(ifaces, hitImpls); hc.GetInterfacesAndImplementations(ifaces, hitImpls);
cfg.tests.push_back(std::move(hitTest)); cfg.tests.push_back(std::move(hitTest));
// Issue #69: the engine feeds one shared Device::pipelineCache to every
// vkCreate*Pipelines call and persists it across runs, discarding an
// on-disk blob whose header doesn't match the current GPU. That gate —
// Device::PipelineCacheDataCompatible — is pure logic over the standard
// VkPipelineCache header and Device::deviceProperties, so this test
// stamps synthetic device identities + headers and drives it directly,
// no GPU device needed at runtime.
Test cacheTest;
Configuration& cc = cacheTest.config;
cc.path = cfg.path;
cc.name = "PipelineCacheValidation";
cc.outputName = "PipelineCacheValidation";
cc.type = ConfigurationType::Executable;
cc.target = cfg.target;
cc.march = cfg.march;
cc.mtune = cfg.mtune;
cc.debug = cfg.debug;
cc.sysroot = cfg.sysroot;
cc.dependencies = cfg.dependencies;
cc.externalDependencies = cfg.externalDependencies;
cc.compileFlags = cfg.compileFlags;
cc.linkFlags = cfg.linkFlags;
cc.defines = cfg.defines;
cc.cFiles = cfg.cFiles;
std::vector<fs::path> cacheImpls(impls.begin(), impls.end());
cacheImpls.emplace_back("tests/PipelineCacheValidation/main");
cc.GetInterfacesAndImplementations(ifaces, cacheImpls);
cfg.tests.push_back(std::move(cacheTest));
} }
return cfg; return cfg;

157
tests/PipelineCacheValidation/main.cpp Normal file
View file

@ -0,0 +1,157 @@
/*
Crafter®.Graphics
Copyright (C) 2026 Catcrafts®
catcrafts.net
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation;
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
// Regression test for issue #69: the engine feeds a shared Device::pipelineCache
// to every vkCreate*Pipelines call and persists it across runs. A blob written
// by a different GPU (or a corrupt/short file) must be rejected before it is
// handed to vkCreatePipelineCache, otherwise the driver ignores or rejects it.
// Device::PipelineCacheDataCompatible is that gate: pure logic over the standard
// 32-byte VkPipelineCacheHeaderVersionOne header (headerSize, headerVersion,
// vendorID, deviceID, pipelineCacheUUID) compared against Device::deviceProperties.
// It needs no GPU, so this test stamps synthetic device identities and headers
// and drives it directly, mirroring MemoryTypeFallback / UploadStrategy.
#include <cstdlib>
#include <cstring>
#include "vulkan/vulkan.h"
import Crafter.Graphics;
import std;
using namespace Crafter;
namespace {
int failures = 0;
void Check(bool ok, std::string_view what) {
std::println("{} {}", ok ? "PASS" : "FAIL", what);
if (!ok) ++failures;
}
// Stamp the device identity the validator compares against.
void SetDevice(std::uint32_t vendorID, std::uint32_t deviceID,
const std::array<std::uint8_t, VK_UUID_SIZE>& uuid) {
Device::deviceProperties = {};
Device::deviceProperties.vendorID = vendorID;
Device::deviceProperties.deviceID = deviceID;
std::memcpy(Device::deviceProperties.pipelineCacheUUID, uuid.data(), VK_UUID_SIZE);
}
// Build a 32-byte VkPipelineCacheHeaderVersionOne blob, optionally with extra
// trailing payload bytes (the real cache body). Fields are written little-endian
// at fixed offsets, matching how the driver lays the header out on disk.
std::vector<std::byte> MakeHeader(std::uint32_t headerSize,
std::uint32_t headerVersion,
std::uint32_t vendorID,
std::uint32_t deviceID,
const std::array<std::uint8_t, VK_UUID_SIZE>& uuid,
std::size_t trailing = 0) {
std::vector<std::byte> blob(16 + VK_UUID_SIZE + trailing, std::byte{0xAB});
auto put = [&](std::size_t off, std::uint32_t v) {
std::memcpy(blob.data() + off, &v, sizeof(v));
};
put(0, headerSize);
put(4, headerVersion);
put(8, vendorID);
put(12, deviceID);
std::memcpy(blob.data() + 16, uuid.data(), VK_UUID_SIZE);
return blob;
}
constexpr std::uint32_t kVendor = 0x10DE; // NVIDIA
constexpr std::uint32_t kDevice = 0x2204; // some GPU device id
constexpr std::array<std::uint8_t, VK_UUID_SIZE> kUuid = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10
};
constexpr std::uint32_t kV1 = VK_PIPELINE_CACHE_HEADER_VERSION_ONE;
constexpr std::uint32_t kHeaderSize = 16 + VK_UUID_SIZE; // 32
} // namespace
int main() {
SetDevice(kVendor, kDevice, kUuid);
// --- the happy path: a header written by this exact device --------------
{
auto blob = MakeHeader(kHeaderSize, kV1, kVendor, kDevice, kUuid);
Check(Device::PipelineCacheDataCompatible(blob),
"matching vendor/device/UUID header is accepted");
auto withBody = MakeHeader(kHeaderSize, kV1, kVendor, kDevice, kUuid, /*trailing*/ 4096);
Check(Device::PipelineCacheDataCompatible(withBody),
"matching header followed by a cache body is accepted");
}
// --- foreign / stale blobs must be rejected -----------------------------
{
auto otherVendor = MakeHeader(kHeaderSize, kV1, 0x1002 /*AMD*/, kDevice, kUuid);
Check(!Device::PipelineCacheDataCompatible(otherVendor),
"different vendorID is rejected");
auto otherDevice = MakeHeader(kHeaderSize, kV1, kVendor, 0x9999, kUuid);
Check(!Device::PipelineCacheDataCompatible(otherDevice),
"different deviceID is rejected");
std::array<std::uint8_t, VK_UUID_SIZE> otherUuid = kUuid;
otherUuid[15] ^= 0xFF; // a driver update bumps the UUID
auto staleUuid = MakeHeader(kHeaderSize, kV1, kVendor, kDevice, otherUuid);
Check(!Device::PipelineCacheDataCompatible(staleUuid),
"different pipelineCacheUUID (e.g. driver update) is rejected");
}
// --- malformed headers --------------------------------------------------
{
auto badVersion = MakeHeader(kHeaderSize, 0xDEAD, kVendor, kDevice, kUuid);
Check(!Device::PipelineCacheDataCompatible(badVersion),
"unknown headerVersion is rejected");
auto smallHeaderSize = MakeHeader(8, kV1, kVendor, kDevice, kUuid);
Check(!Device::PipelineCacheDataCompatible(smallHeaderSize),
"headerSize smaller than the 32-byte header is rejected");
Check(!Device::PipelineCacheDataCompatible({}),
"empty blob (no file / cold start) is rejected");
std::vector<std::byte> truncated(20, std::byte{0});
Check(!Device::PipelineCacheDataCompatible(truncated),
"blob too short to hold the header is rejected");
}
// --- identity follows the active device ---------------------------------
{
// Re-stamp as a different device; a blob valid for the old one is now
// foreign. Guards against the validator caching identity anywhere but
// Device::deviceProperties.
auto blob = MakeHeader(kHeaderSize, kV1, kVendor, kDevice, kUuid);
SetDevice(0x8086 /*Intel*/, 0x1234, kUuid);
Check(!Device::PipelineCacheDataCompatible(blob),
"a blob from the previous device is rejected after the device changes");
SetDevice(kVendor, kDevice, kUuid);
Check(Device::PipelineCacheDataCompatible(blob),
"...and accepted again once the matching device is restored");
}
if (failures != 0) {
std::println("{} check(s) failed", failures);
return EXIT_FAILURE;
}
std::println("all checks passed");
return EXIT_SUCCESS;
}