summaryrefslogtreecommitdiffstats
path: root/tools
diff options
context:
space:
mode:
Diffstat (limited to 'tools')
-rw-r--r--tools/gfx-unit-test/shader-cache-specialization.slang2
-rw-r--r--tools/gfx-unit-test/shader-cache-tests.cpp371
-rw-r--r--tools/slang-test/test-reporter.cpp11
-rw-r--r--tools/slang-test/test-reporter.h4
-rw-r--r--tools/slang-unit-test/unit-test-lock-file.cpp34
-rw-r--r--tools/slang-unit-test/unit-test-persistent-cache.cpp60
6 files changed, 283 insertions, 199 deletions
diff --git a/tools/gfx-unit-test/shader-cache-specialization.slang b/tools/gfx-unit-test/shader-cache-specialization.slang
index 63994aee8..df9dacaa3 100644
--- a/tools/gfx-unit-test/shader-cache-specialization.slang
+++ b/tools/gfx-unit-test/shader-cache-specialization.slang
@@ -33,7 +33,7 @@ interface ITransformer
struct AddTransformer : ITransformer
{
float c;
- float transform(float x) { return x + c + 10.0f; }
+ float transform(float x) { return x + c; }
};
// Represents a transform function f(x) = x * c.
diff --git a/tools/gfx-unit-test/shader-cache-tests.cpp b/tools/gfx-unit-test/shader-cache-tests.cpp
index 4cccc726f..e1607ac59 100644
--- a/tools/gfx-unit-test/shader-cache-tests.cpp
+++ b/tools/gfx-unit-test/shader-cache-tests.cpp
@@ -15,7 +15,10 @@ using namespace Slang;
namespace gfx_test
{
-
+ // Base class for shader cache tests.
+ // Slang currently does not allow reloading shaders from modified sources.
+ // Because of this, the tests recreate a GFX device for each test step,
+ // allowing to modify shader sources in between.
struct ShaderCacheTest
{
UnitTestContext* context;
@@ -31,6 +34,7 @@ namespace gfx_test
ComPtr<IDevice> device;
ComPtr<IShaderCache> shaderCache;
ComPtr<IPipelineState> pipelineState;
+ ComPtr<IBufferResource> bufferResource;
ComPtr<IResourceView> bufferView;
String computeShaderA = String(
@@ -161,21 +165,21 @@ namespace gfx_test
bufferDesc.defaultState = ResourceState::UnorderedAccess;
bufferDesc.memoryType = MemoryType::DeviceLocal;
- ComPtr<IBufferResource> numbersBuffer;
GFX_CHECK_CALL_ABORT(device->createBufferResource(
bufferDesc,
(void*)initialData,
- numbersBuffer.writeRef()));
+ bufferResource.writeRef()));
IResourceView::Desc viewDesc = {};
viewDesc.type = IResourceView::Type::UnorderedAccess;
viewDesc.format = Format::Unknown;
GFX_CHECK_CALL_ABORT(
- device->createBufferView(numbersBuffer, nullptr, viewDesc, bufferView.writeRef()));
+ device->createBufferView(bufferResource, nullptr, viewDesc, bufferView.writeRef()));
}
void freeComputeResources()
{
+ bufferResource = nullptr;
bufferView = nullptr;
pipelineState = nullptr;
}
@@ -192,6 +196,17 @@ namespace gfx_test
device->createComputePipelineState(pipelineDesc, pipelineState.writeRef()));
}
+ void createComputePipeline(Slang::String shaderSource)
+ {
+ ComPtr<IShaderProgram> shaderProgram;
+ GFX_CHECK_CALL_ABORT(loadComputeProgramFromSource(device, shaderProgram, shaderSource));
+
+ ComputePipelineStateDesc pipelineDesc = {};
+ pipelineDesc.program = shaderProgram.get();
+ GFX_CHECK_CALL_ABORT(
+ device->createComputePipelineState(pipelineDesc, pipelineState.writeRef()));
+ }
+
void dispatchComputePipeline()
{
ComPtr<ITransientResourceHeap> transientHeap;
@@ -208,13 +223,10 @@ namespace gfx_test
auto rootObject = encoder->bindPipeline(pipelineState);
+ // Bind buffer view to the entry point.
ShaderCursor entryPointCursor(rootObject->getEntryPoint(0));
entryPointCursor.getPath("buffer").setResource(bufferView);
- // ShaderCursor rootCursor(rootObject);
- // Bind buffer view to the entry point.
- // rootCursor.getPath("buffer").setResource(bufferView);
-
encoder->dispatchCompute(4, 1, 1);
encoder->endEncoding();
commandBuffer->close();
@@ -222,12 +234,34 @@ namespace gfx_test
queue->waitOnHost();
}
- void runComputePipeline(const char* moduleName, const char* entryPointName)
+ bool checkOutput(const List<float>& expectedOutput)
+ {
+ ComPtr<ISlangBlob> bufferBlob;
+ device->readBufferResource(bufferResource, 0, 4 * sizeof(float), bufferBlob.writeRef());
+ SLANG_CHECK_ABORT(bufferBlob && bufferBlob->getBufferSize() == expectedOutput.getCount() * sizeof(float));
+ return ::memcmp(bufferBlob->getBufferPointer(), expectedOutput.getBuffer(), bufferBlob->getBufferSize()) == 0;
+ }
+
+ bool runComputePipeline(const char* moduleName, const char* entryPointName, const List<float>& expectedOutput)
{
createComputeResources();
createComputePipeline(moduleName, entryPointName);
dispatchComputePipeline();
+ bool hasExpectedOutput = checkOutput(expectedOutput);
+ SLANG_CHECK(hasExpectedOutput);
+ freeComputeResources();
+ return hasExpectedOutput;
+ }
+
+ bool runComputePipeline(Slang::String shaderSource, const List<float>& expectedOutput)
+ {
+ createComputeResources();
+ createComputePipeline(shaderSource);
+ dispatchComputePipeline();
+ bool hasExpectedOutput = checkOutput(expectedOutput);
+ SLANG_CHECK(hasExpectedOutput);
freeComputeResources();
+ return hasExpectedOutput;
}
ShaderCacheStats getStats()
@@ -249,7 +283,7 @@ namespace gfx_test
};
// Basic shader cache test using 3 different shader files stored on disk.
- struct ShaderCacheTestBasic : ShaderCacheTest
+ struct ShaderCacheSourceFile : ShaderCacheTest
{
void runTests()
{
@@ -262,9 +296,9 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-tmp-a", "main");
- runComputePipeline("shader-cache-tmp-b", "main");
- runComputePipeline("shader-cache-tmp-c", "main");
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-a", "main", { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-b", "main", { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-c", "main", { 3.f, 4.f, 5.f, 6.f }));
SLANG_CHECK(getStats().missCount == 3);
SLANG_CHECK(getStats().hitCount == 0);
@@ -276,9 +310,9 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-tmp-a", "main");
- runComputePipeline("shader-cache-tmp-b", "main");
- runComputePipeline("shader-cache-tmp-c", "main");
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-a", "main", { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-b", "main", { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-c", "main", { 3.f, 4.f, 5.f, 6.f }));
SLANG_CHECK(getStats().missCount == 0);
SLANG_CHECK(getStats().hitCount == 3);
@@ -295,9 +329,9 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-tmp-a", "main");
- runComputePipeline("shader-cache-tmp-b", "main");
- runComputePipeline("shader-cache-tmp-c", "main");
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-b", "main", { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-c", "main", { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-a", "main", { 3.f, 4.f, 5.f, 6.f }));
SLANG_CHECK(getStats().missCount == 3);
SLANG_CHECK(getStats().hitCount == 0);
@@ -309,9 +343,9 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-tmp-a", "main");
- runComputePipeline("shader-cache-tmp-b", "main");
- runComputePipeline("shader-cache-tmp-c", "main");
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-b", "main", { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-c", "main", { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-a", "main", { 3.f, 4.f, 5.f, 6.f }));
SLANG_CHECK(getStats().missCount == 0);
SLANG_CHECK(getStats().hitCount == 3);
@@ -321,6 +355,41 @@ namespace gfx_test
}
};
+ // Test caching of shaders that are compiled from source strings instead of files.
+ struct ShaderCacheTestSourceString : ShaderCacheTest
+ {
+ void runTests()
+ {
+ // Cache is cold and we expect 3 misses.
+ runStep(
+ [this]()
+ {
+ SLANG_CHECK(runComputePipeline(computeShaderA, { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline(computeShaderB, { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline(computeShaderC, { 3.f, 4.f, 5.f, 6.f }));
+
+ SLANG_CHECK(getStats().missCount == 3);
+ SLANG_CHECK(getStats().hitCount == 0);
+ SLANG_CHECK(getStats().entryCount == 3);
+ }
+ );
+
+ // Cache is hot and we expect 3 hits.
+ runStep(
+ [this]()
+ {
+ SLANG_CHECK(runComputePipeline(computeShaderA, { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline(computeShaderB, { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline(computeShaderC, { 3.f, 4.f, 5.f, 6.f }));
+
+ SLANG_CHECK(getStats().missCount == 0);
+ SLANG_CHECK(getStats().hitCount == 3);
+ SLANG_CHECK(getStats().entryCount == 3);
+ }
+ );
+ }
+ };
+
// Test one shader file on disk with multiple entry points.
struct ShaderCacheTestEntryPoint : ShaderCacheTest
{
@@ -330,9 +399,9 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-multiple-entry-points", "computeA");
- runComputePipeline("shader-cache-multiple-entry-points", "computeB");
- runComputePipeline("shader-cache-multiple-entry-points", "computeC");
+ SLANG_CHECK(runComputePipeline("shader-cache-multiple-entry-points", "computeA", { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-multiple-entry-points", "computeB", { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-multiple-entry-points", "computeC", { 3.f, 4.f, 5.f, 6.f }));
SLANG_CHECK(getStats().missCount == 3);
SLANG_CHECK(getStats().hitCount == 0);
@@ -344,9 +413,9 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-multiple-entry-points", "computeA");
- runComputePipeline("shader-cache-multiple-entry-points", "computeB");
- runComputePipeline("shader-cache-multiple-entry-points", "computeC");
+ SLANG_CHECK(runComputePipeline("shader-cache-multiple-entry-points", "computeA", { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-multiple-entry-points", "computeB", { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-multiple-entry-points", "computeC", { 3.f, 4.f, 5.f, 6.f }));
SLANG_CHECK(getStats().missCount == 0);
SLANG_CHECK(getStats().hitCount == 3);
@@ -415,8 +484,8 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-tmp-import", "main");
- runComputePipeline("shader-cache-tmp-include", "main");
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-import", "main", { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-include", "main", { 1.f, 2.f, 3.f, 4.f }));
SLANG_CHECK(getStats().missCount == 2);
SLANG_CHECK(getStats().hitCount == 0);
@@ -428,8 +497,8 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-tmp-import", "main");
- runComputePipeline("shader-cache-tmp-include", "main");
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-import", "main", { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-include", "main", { 1.f, 2.f, 3.f, 4.f }));
SLANG_CHECK(getStats().missCount == 0);
SLANG_CHECK(getStats().hitCount == 2);
@@ -444,8 +513,8 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-tmp-import", "main");
- runComputePipeline("shader-cache-tmp-include", "main");
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-import", "main", { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-include", "main", { 2.f, 3.f, 4.f, 5.f }));
SLANG_CHECK(getStats().missCount == 2);
SLANG_CHECK(getStats().hitCount == 0);
@@ -457,8 +526,8 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("shader-cache-tmp-import", "main");
- runComputePipeline("shader-cache-tmp-include", "main");
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-import", "main", { 2.f, 3.f, 4.f, 5.f }));
+ SLANG_CHECK(runComputePipeline("shader-cache-tmp-include", "main", { 2.f, 3.f, 4.f, 5.f }));
SLANG_CHECK(getStats().missCount == 0);
SLANG_CHECK(getStats().hitCount == 2);
@@ -486,28 +555,6 @@ namespace gfx_test
device->createComputePipelineState(pipelineDesc, pipelineState.writeRef()));
}
- void createAddTransformer(IShaderObject** transformer)
- {
- slang::TypeReflection* addTransformerType =
- slangReflection->findTypeByName("AddTransformer");
- GFX_CHECK_CALL_ABORT(device->createShaderObject(
- addTransformerType, ShaderObjectContainerType::None, transformer));
-
- float c = 1.0f;
- ShaderCursor(*transformer).getPath("c").setData(&c, sizeof(float));
- }
-
- void createMulTransformer(IShaderObject** transformer)
- {
- slang::TypeReflection* mulTransformerType =
- slangReflection->findTypeByName("MulTransformer");
- GFX_CHECK_CALL_ABORT(device->createShaderObject(
- mulTransformerType, ShaderObjectContainerType::None, transformer));
-
- float c = 1.0f;
- ShaderCursor(*transformer).getPath("c").setData(&c, sizeof(float));
- }
-
void dispatchComputePipeline(const char* transformerTypeName)
{
Slang::ComPtr<ITransientResourceHeap> transientHeap;
@@ -529,7 +576,7 @@ namespace gfx_test
GFX_CHECK_CALL_ABORT(device->createShaderObject(
transformerType, ShaderObjectContainerType::None, transformer.writeRef()));
- float c = 1.0f;
+ float c = 5.f;
ShaderCursor(transformer).getPath("c").setData(&c, sizeof(float));
ShaderCursor entryPointCursor(rootObject->getEntryPoint(0));
@@ -543,12 +590,15 @@ namespace gfx_test
queue->waitOnHost();
}
- void runComputePipeline(const char* transformerTypeName)
+ bool runComputePipeline(const char* transformerTypeName, const List<float>& expectedOutput)
{
createComputeResources();
createComputePipeline();
dispatchComputePipeline(transformerTypeName);
+ bool hasExpectedOutput = checkOutput(expectedOutput);
+ SLANG_CHECK(hasExpectedOutput);
freeComputeResources();
+ return hasExpectedOutput;
}
void runTests()
@@ -557,8 +607,8 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("AddTransformer");
- runComputePipeline("MulTransformer");
+ SLANG_CHECK(runComputePipeline("AddTransformer", { 5.f, 6.f, 7.f, 8.f }));
+ SLANG_CHECK(runComputePipeline("MulTransformer", { 0.f, 5.f, 10.f, 15.f }));
SLANG_CHECK(getStats().missCount == 2);
SLANG_CHECK(getStats().hitCount == 0);
@@ -570,8 +620,8 @@ namespace gfx_test
runStep(
[this]()
{
- runComputePipeline("AddTransformer");
- runComputePipeline("MulTransformer");
+ SLANG_CHECK(runComputePipeline("AddTransformer", { 5.f, 6.f, 7.f, 8.f }));
+ SLANG_CHECK(runComputePipeline("MulTransformer", { 0.f, 5.f, 10.f, 15.f }));
SLANG_CHECK(getStats().missCount == 0);
SLANG_CHECK(getStats().hitCount == 2);
@@ -581,8 +631,91 @@ namespace gfx_test
}
};
- // Same gist as the multiple entry point compute shader but with a graphics
- // shader file containing a vertex and fragment shader.
+ struct ShaderCacheTestEviction : ShaderCacheTest
+ {
+ void runTests()
+ {
+ shaderCacheDesc.maxEntryCount = 2;
+
+ // Load shader A & B. Cache is cold and we expect 2 misses.
+ runStep(
+ [this]()
+ {
+ SLANG_CHECK(runComputePipeline(computeShaderA, { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline(computeShaderB, { 2.f, 3.f, 4.f, 5.f }));
+
+ SLANG_CHECK(getStats().missCount == 2);
+ SLANG_CHECK(getStats().hitCount == 0);
+ SLANG_CHECK(getStats().entryCount == 2);
+ }
+ );
+
+ // Load shader A & B. Cache is hot and we expect 2 hits.
+ runStep(
+ [this]()
+ {
+ SLANG_CHECK(runComputePipeline(computeShaderA, { 1.f, 2.f, 3.f, 4.f }));
+ SLANG_CHECK(runComputePipeline(computeShaderB, { 2.f, 3.f, 4.f, 5.f }));
+
+ SLANG_CHECK(getStats().missCount == 0);
+ SLANG_CHECK(getStats().hitCount == 2);
+ SLANG_CHECK(getStats().entryCount == 2);
+ }
+ );
+
+ // Load shader C. Cache is cold and we expect 1 miss.
+ // This will evict the least frequently used entry (shader A).
+ // We expect 2 entries in the cache (shader B & C).
+ runStep(
+ [this]()
+ {
+ SLANG_CHECK(runComputePipeline(computeShaderC, { 3.f, 4.f, 5.f, 6.f }));
+
+ SLANG_CHECK(getStats().missCount == 1);
+ SLANG_CHECK(getStats().hitCount == 0);
+ SLANG_CHECK(getStats().entryCount == 2);
+ }
+ );
+
+ // Load shader C. Cache is hot and we expect 1 hit.
+ runStep(
+ [this]()
+ {
+ SLANG_CHECK(runComputePipeline(computeShaderC, { 3.f, 4.f, 5.f, 6.f }));
+
+ SLANG_CHECK(getStats().missCount == 0);
+ SLANG_CHECK(getStats().hitCount == 1);
+ SLANG_CHECK(getStats().entryCount == 2);
+ }
+ );
+
+ // Load shader B. Cache is hot and we expect 1 hit.
+ runStep(
+ [this]()
+ {
+ SLANG_CHECK(runComputePipeline(computeShaderB, { 2.f, 3.f, 4.f, 5.f }));
+
+ SLANG_CHECK(getStats().missCount == 0);
+ SLANG_CHECK(getStats().hitCount == 1);
+ SLANG_CHECK(getStats().entryCount == 2);
+ }
+ );
+
+ // Load shader A. Cache is cold and we expect 1 miss.
+ runStep(
+ [this]()
+ {
+ SLANG_CHECK(runComputePipeline(computeShaderA, { 1.f, 2.f, 3.f, 4.f }));
+
+ SLANG_CHECK(getStats().missCount == 1);
+ SLANG_CHECK(getStats().hitCount == 0);
+ SLANG_CHECK(getStats().entryCount == 2);
+ }
+ );
+ }
+ };
+
+ // Similar to ShaderCacheTestEntryPoint but with a source file containing a vertex and fragment shader.
struct ShaderCacheTestGraphics : ShaderCacheTest
{
struct Vertex
@@ -787,25 +920,13 @@ namespace gfx_test
}
};
- // Same as ShaderCacheTestGraphics, but instead of having a singular file containing both a vertex and fragment shader, we
- // now have two separate shader files, one containing the vertex shader and the other the fragment with the same
- // names, with the expectation that we should record cache misses for both fetches.
- //
- // This test is intended to guard against the case where vertex/fragment/geometry shaders are split across
- // multiple files with the same entry point name in each file and are loaded as three separate ComponentType objects.
- // In this case, the current method for cache key generation will hash in the exact same modules, file dependencies,
- // entry point names, and entry point name overrides, resulting in the same dependency hash being returned for all three
- // and consequently, the wrong shader code being provided when the shaders are being created.
- //
- // We do not actively test geometry shaders here, but it is simply an extension of this test and should be expected
- // to behave similarly.
+ // Similar to ShaderCacheTestGraphics but with two separate shader files for the vertex and fragment shaders.
struct ShaderCacheTestGraphicsSplit : ShaderCacheTestGraphics
{
void createGraphicsPipeline()
{
ComPtr<slang::ISession> slangSession;
GFX_CHECK_CALL_ABORT(device->getSlangSession(slangSession.writeRef()));
-
slang::IModule* vertexModule = slangSession->loadModule("shader-cache-graphics-vertex");
SLANG_CHECK_ABORT(vertexModule);
slang::IModule* fragmentModule = slangSession->loadModule("shader-cache-graphics-fragment");
@@ -889,60 +1010,6 @@ namespace gfx_test
); }
};
- // Test caching of shaders that are compiled from source strings instead of files.
- struct ShaderCacheTestSourceString : ShaderCacheTest
- {
- void createComputePipeline(Slang::String shaderSource)
- {
- ComPtr<IShaderProgram> shaderProgram;
- GFX_CHECK_CALL_ABORT(loadComputeProgramFromSource(device, shaderProgram, shaderSource));
-
- ComputePipelineStateDesc pipelineDesc = {};
- pipelineDesc.program = shaderProgram.get();
- GFX_CHECK_CALL_ABORT(
- device->createComputePipelineState(pipelineDesc, pipelineState.writeRef()));
- }
-
- void runComputePipeline(Slang::String shaderSource)
- {
- createComputeResources();
- createComputePipeline(shaderSource);
- dispatchComputePipeline();
- freeComputeResources();
- }
-
- void runTests()
- {
- // Cache is cold and we expect 3 misses.
- runStep(
- [this]()
- {
- runComputePipeline(computeShaderA);
- runComputePipeline(computeShaderB);
- runComputePipeline(computeShaderC);
-
- SLANG_CHECK(getStats().missCount == 3);
- SLANG_CHECK(getStats().hitCount == 0);
- SLANG_CHECK(getStats().entryCount == 3);
- }
- );
-
- // Cache is hot and we expect 3 hits.
- runStep(
- [this]()
- {
- runComputePipeline(computeShaderA);
- runComputePipeline(computeShaderB);
- runComputePipeline(computeShaderC);
-
- SLANG_CHECK(getStats().missCount == 0);
- SLANG_CHECK(getStats().hitCount == 3);
- SLANG_CHECK(getStats().entryCount == 3);
- }
- );
- }
- };
-
template<typename T>
void runTest(UnitTestContext* context, Slang::RenderApiFlag::Enum api)
{
@@ -950,14 +1017,24 @@ namespace gfx_test
test.run(context, api);
}
- SLANG_UNIT_TEST(shaderCacheBasicD3D12)
+ SLANG_UNIT_TEST(shaderCacheSourceFileD3D12)
{
- runTest<ShaderCacheTestBasic>(unitTestContext, Slang::RenderApiFlag::D3D12);
+ runTest<ShaderCacheSourceFile>(unitTestContext, Slang::RenderApiFlag::D3D12);
}
- SLANG_UNIT_TEST(shaderCacheBasicVulkan)
+ SLANG_UNIT_TEST(shaderCacheSourceFileVulkan)
{
- runTest<ShaderCacheTestBasic>(unitTestContext, Slang::RenderApiFlag::Vulkan);
+ runTest<ShaderCacheSourceFile>(unitTestContext, Slang::RenderApiFlag::Vulkan);
+ }
+
+ SLANG_UNIT_TEST(shaderCacheSourceStringD3D12)
+ {
+ runTest<ShaderCacheTestSourceString>(unitTestContext, Slang::RenderApiFlag::D3D12);
+ }
+
+ SLANG_UNIT_TEST(shaderCacheSourceStringVulkan)
+ {
+ runTest<ShaderCacheTestSourceString>(unitTestContext, Slang::RenderApiFlag::Vulkan);
}
SLANG_UNIT_TEST(shaderCacheEntryPointD3D12)
@@ -990,6 +1067,16 @@ namespace gfx_test
runTest<ShaderCacheTestSpecialization>(unitTestContext, Slang::RenderApiFlag::Vulkan);
}
+ SLANG_UNIT_TEST(shaderCacheEvictionD3D12)
+ {
+ runTest<ShaderCacheTestEviction>(unitTestContext, Slang::RenderApiFlag::D3D12);
+ }
+
+ SLANG_UNIT_TEST(shaderCacheEvictionVulkan)
+ {
+ runTest<ShaderCacheTestEviction>(unitTestContext, Slang::RenderApiFlag::Vulkan);
+ }
+
SLANG_UNIT_TEST(shaderCacheGraphicsD3D12)
{
runTest<ShaderCacheTestGraphics>(unitTestContext, Slang::RenderApiFlag::D3D12);
@@ -1009,14 +1096,4 @@ namespace gfx_test
{
runTest<ShaderCacheTestGraphicsSplit>(unitTestContext, Slang::RenderApiFlag::Vulkan);
}
-
- SLANG_UNIT_TEST(shaderCacheSourceStringD3D12)
- {
- runTest<ShaderCacheTestSourceString>(unitTestContext, Slang::RenderApiFlag::D3D12);
- }
-
- SLANG_UNIT_TEST(shaderCacheSourceStringVulkan)
- {
- runTest<ShaderCacheTestSourceString>(unitTestContext, Slang::RenderApiFlag::Vulkan);
- }
}
diff --git a/tools/slang-test/test-reporter.cpp b/tools/slang-test/test-reporter.cpp
index ee8421e81..b2d0d1a54 100644
--- a/tools/slang-test/test-reporter.cpp
+++ b/tools/slang-test/test-reporter.cpp
@@ -140,18 +140,25 @@ void TestReporter::addResult(TestResult result)
{
assert(m_inTest);
+ std::lock_guard<std::recursive_mutex> lock(m_mutex);
+
m_currentInfo.testResult = combine(m_currentInfo.testResult, result);
m_numCurrentResults++;
}
void TestReporter::addExecutionTime(double time)
{
+ std::lock_guard<std::recursive_mutex> lock(m_mutex);
+
m_currentInfo.executionTime = time;
}
void TestReporter::addResultWithLocation(TestResult result, const char* testText, const char* file, int line)
{
assert(m_inTest);
+
+ std::lock_guard<std::recursive_mutex> lock(m_mutex);
+
m_numCurrentResults++;
m_currentInfo.testResult = combine(m_currentInfo.testResult, result);
@@ -505,8 +512,8 @@ void TestReporter::addTest(const String& testName, TestResult testResult)
void TestReporter::message(TestMessageType type, const String& message)
{
- static std::mutex mutex;
- std::lock_guard<std::mutex> lock(mutex);
+ std::lock_guard<std::recursive_mutex> lock(m_mutex);
+
if (type == TestMessageType::Info)
{
if (m_isVerbose && canWriteStdError())
diff --git a/tools/slang-test/test-reporter.h b/tools/slang-test/test-reporter.h
index b87c5368f..a90cd6653 100644
--- a/tools/slang-test/test-reporter.h
+++ b/tools/slang-test/test-reporter.h
@@ -9,6 +9,8 @@
#include "../../source/core/slang-dictionary.h"
#include "tools/unit-test/slang-unit-test.h"
+#include <mutex>
+
enum class TestOutputMode
{
Default = 0, ///< Default mode is to write test results to the console
@@ -138,6 +140,8 @@ protected:
bool m_inTest;
+ std::recursive_mutex m_mutex;
+
static TestReporter* s_reporter;
};
diff --git a/tools/slang-unit-test/unit-test-lock-file.cpp b/tools/slang-unit-test/unit-test-lock-file.cpp
index 33e787a1d..312d9a1e2 100644
--- a/tools/slang-unit-test/unit-test-lock-file.cpp
+++ b/tools/slang-unit-test/unit-test-lock-file.cpp
@@ -10,20 +10,30 @@
using namespace Slang;
-SLANG_UNIT_TEST(lockFile)
+static const String fileName = Path::simplify(Path::getParentDirectory(Path::getExecutablePath()) + "/test_lock_file");
+
+SLANG_UNIT_TEST(lockFileOpenClose)
{
- static String fileName = Path::simplify(Path::getParentDirectory(Path::getExecutablePath()) + "/test_lock_file");
+ LockFile file;
+ SLANG_CHECK(file.isOpen() == false);
+ SLANG_CHECK_ABORT(file.open(fileName) == SLANG_OK);
+ SLANG_CHECK(file.isOpen() == true);
+ SLANG_CHECK(File::exists(fileName) == true);
+ file.close();
+ SLANG_CHECK(file.isOpen() == false);
- // Open/close lock file.
- {
- LockFile file;
- SLANG_CHECK(file.isOpen() == false);
- SLANG_CHECK_ABORT(file.open(fileName) == SLANG_OK);
- SLANG_CHECK(file.isOpen() == true);
- SLANG_CHECK(File::exists(fileName) == true);
- file.close();
- SLANG_CHECK(file.isOpen() == false);
- }
+ // Cleanup.
+ File::remove(fileName);
+ SLANG_CHECK(File::exists(fileName) == false);
+}
+
+SLANG_UNIT_TEST(lockFileSync)
+{
+ // aarch64 builds currently fail to run multi-threaded tests within the test-server.
+ // Tests work fine without the test-server, which is puzzling. For now we disable them.
+#if SLANG_PROCESSOR_ARM_64
+ SLANG_IGNORE_TEST
+#endif
// Test using multiple threads.
{
diff --git a/tools/slang-unit-test/unit-test-persistent-cache.cpp b/tools/slang-unit-test/unit-test-persistent-cache.cpp
index 55c358d77..a32215b6f 100644
--- a/tools/slang-unit-test/unit-test-persistent-cache.cpp
+++ b/tools/slang-unit-test/unit-test-persistent-cache.cpp
@@ -431,14 +431,6 @@ struct CorruptionTest : public PersistentCacheTest
}
};
-struct MultiThreadingTest : public PersistentCacheTest
-{
- void run()
- {
- }
-};
-
-
#undef ENABLE_LOGGING
#undef ENABLE_WRITE_TEST
@@ -485,10 +477,6 @@ struct StressTest : public PersistentCacheTest
Barrier *read_barrier;
Barrier *write_barrier;
- std::mutex mutex;
- std::condition_variable conditionVariable;
- uint32_t generation{0};
-
StressTest() : PersistentCacheTest(kEntryCount - kEntryShortageCount) {}
void run()
@@ -527,59 +515,58 @@ struct StressTest : public PersistentCacheTest
for (uint32_t threadIndex = 0; threadIndex < kThreadCount; ++threadIndex)
{
threads[threadIndex] = std::thread(
- [](StressTest* self, uint32_t threadIndex)
+ [this, threadIndex]()
{
LOG("Thread %u: starting\n", threadIndex);
while (true)
{
// Write to cache.
- size_t startIndex = (self->iteration * kEntryCount + (threadIndex * kBatchCount)) % (kEntryCount * 2);
+ size_t startIndex = (iteration * kEntryCount + (threadIndex * kBatchCount)) % (kEntryCount * 2);
for (size_t i = 0; i < kBatchCount; ++i)
{
- const Entry& entry = self->entries[startIndex + i];
+ const Entry& entry = entries[startIndex + i];
#ifdef ENABLE_WRITE_TEST
- self->osFileSystem->saveFileBlob(self->getEntryFileName(entry).getBuffer(), entry.data);
+ osFileSystem->saveFileBlob(getEntryFileName(entry).getBuffer(), entry.data);
#else
- self->writeEntry(entry);
+ writeEntry(entry);
#endif
- self->entriesWritten.fetch_add(1);
- self->bytesWritten.fetch_add((uint32_t)entry.data->getBufferSize());
+ entriesWritten.fetch_add(1);
+ bytesWritten.fetch_add((uint32_t)entry.data->getBufferSize());
}
- LOG("Thread %u: ended writing (iteration=%u)\n", threadIndex, self->iteration.load());
+ LOG("Thread %u: ended writing (iteration=%u)\n", threadIndex, iteration.load());
// Synchronize.
- self->read_barrier->wait();
+ read_barrier->wait();
// Read from cache.
for (size_t i = 0; i < kBatchCount; ++i)
{
- const Entry& entry = self->entries[startIndex + i];
+ const Entry& entry = entries[startIndex + i];
#ifndef ENABLE_WRITE_TEST
- if (self->readEntry(entry))
+ if (readEntry(entry))
{
- self->readSuccess.fetch_add(1);
- self->bytesRead.fetch_add((uint32_t)entry.data->getBufferSize());
+ readSuccess.fetch_add(1);
+ bytesRead.fetch_add((uint32_t)entry.data->getBufferSize());
}
#endif
- self->entriesRead.fetch_add(1);
+ entriesRead.fetch_add(1);
}
- LOG("Thread %u: ended reading (iteration=%u)\n", threadIndex, self->iteration.load());
+ LOG("Thread %u: ended reading (iteration=%u)\n", threadIndex, iteration.load());
// Synchronize.
- self->write_barrier->wait();
+ write_barrier->wait();
// Terminate.
- if (self->iteration >= kIterationCount)
+ if (iteration >= kIterationCount)
{
LOG("Thread %u: terminates\n", threadIndex);
return;
}
}
- },
- this, threadIndex);
+ });
}
for (auto& thread : threads)
@@ -616,14 +603,13 @@ SLANG_UNIT_TEST(persistentCacheCorruption)
test.run();
}
-SLANG_UNIT_TEST(persistentCacheMultiThreading)
-{
- MultiThreadingTest test;
- test.run();
-}
-
SLANG_UNIT_TEST(persistentCacheStress)
{
+ // aarch64 builds currently fail to run multi-threaded tests within the test-server.
+ // Tests work fine without the test-server, which is puzzling. For now we disable them.
+#if SLANG_PROCESSOR_ARM_64
+ SLANG_IGNORE_TEST
+#endif
StressTest test;
test.run();
}
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-01 10:52:39 +0000