From 43d0c2100ef1a5df4b54525e50eb29fe7c39ec16 Mon Sep 17 00:00:00 2001 From: Gangzheng Tong Date: Tue, 8 Jul 2025 23:44:56 -0700 Subject: Convert gfx unit tests and examples to use slang-rhi (#7577) * Port first gfx unit test to slang-rhi * port triangle example to use slang-rhi * port platform-test to slang-rhi * Update platform-test to throttle mouse move events * port gpu-printing example to use slang-rhi * port model-viewer example to use slang-rhi * port ray-tracing example to use slang-rhi * port ray-tracing pipeline example to use slang-rhi * port reflection parameter blocks example to use slang-rhi * port shader-object example to use slang-rhi * port shader-toy example to use slang-rhi * Port most of tests to slang-rhi * port link-time-constant-array-size to use slang-rhi * Fix tests and find matching tests in slang-rhi * port autodiff-texture * remove gfx target; port nv-aftermath-example * update include path for shader-cursor.h * Disabled 2 more ported tests * fix build error * remove gfx test * put slang-rhi (static-lib) before slang (shared) * format code (#7621) Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com> * add debug callback * format code (#7649) Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com> * Address review comments; revert back to use SLANG_CHECK_MSG --------- Co-authored-by: slangbot Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com> --- tools/gfx-unit-test/buffer-barrier-test.cpp | 187 ++++++++++------------------ 1 file changed, 69 insertions(+), 118 deletions(-) (limited to 'tools/gfx-unit-test/buffer-barrier-test.cpp') diff --git a/tools/gfx-unit-test/buffer-barrier-test.cpp b/tools/gfx-unit-test/buffer-barrier-test.cpp index b128448d2..1d965628a 100644 --- a/tools/gfx-unit-test/buffer-barrier-test.cpp +++ b/tools/gfx-unit-test/buffer-barrier-test.cpp @@ -1,10 +1,11 @@ #include "core/slang-basic.h" #include "gfx-test-util.h" -#include "gfx-util/shader-cursor.h" -#include "slang-gfx.h" +#include "slang-rhi.h" #include "unit-test/slang-unit-test.h" -using namespace gfx; +#include + +using namespace rhi; namespace gfx_test { @@ -12,58 +13,40 @@ struct Shader { ComPtr program; slang::ProgramLayout* reflection = nullptr; - ComputePipelineStateDesc pipelineDesc = {}; - ComPtr pipelineState; + ComputePipelineDesc pipelineDesc = {}; + ComPtr pipeline; }; struct Buffer { - IBufferResource::Desc desc; - ComPtr buffer; - ComPtr view; + BufferDesc desc; + ComPtr buffer; + ComPtr view; }; -void createFloatBuffer( +ComPtr createFloatBuffer( IDevice* device, - Buffer& outBuffer, bool unorderedAccess, - float* initialData, - size_t elementCount) + size_t elementCount, + float* initialData = nullptr) { - outBuffer = {}; - IBufferResource::Desc& bufferDesc = outBuffer.desc; - bufferDesc.sizeInBytes = elementCount * sizeof(float); - bufferDesc.format = gfx::Format::Unknown; - bufferDesc.elementSize = sizeof(float); - bufferDesc.defaultState = - unorderedAccess ? ResourceState::UnorderedAccess : ResourceState::ShaderResource; - bufferDesc.memoryType = MemoryType::DeviceLocal; - bufferDesc.allowedStates = ResourceStateSet( - ResourceState::ShaderResource, - ResourceState::CopyDestination, - ResourceState::CopySource); + BufferDesc desc = {}; + desc.size = elementCount * sizeof(float); + desc.elementSize = sizeof(float); + desc.format = Format::Undefined; + desc.memoryType = MemoryType::DeviceLocal; + desc.usage = + BufferUsage::ShaderResource | BufferUsage::CopyDestination | BufferUsage::CopySource; if (unorderedAccess) - bufferDesc.allowedStates.add(ResourceState::UnorderedAccess); - - GFX_CHECK_CALL_ABORT( - device->createBufferResource(bufferDesc, (void*)initialData, outBuffer.buffer.writeRef())); + desc.usage |= BufferUsage::UnorderedAccess; - IResourceView::Desc viewDesc = {}; - viewDesc.type = unorderedAccess ? IResourceView::Type::UnorderedAccess - : IResourceView::Type::ShaderResource; - viewDesc.format = Format::Unknown; - GFX_CHECK_CALL_ABORT( - device->createBufferView(outBuffer.buffer, nullptr, viewDesc, outBuffer.view.writeRef())); + ComPtr buffer; + GFX_CHECK_CALL_ABORT(device->createBuffer(desc, (void*)initialData, buffer.writeRef())); + return buffer; } void barrierTestImpl(IDevice* device, UnitTestContext* context) { - Slang::ComPtr transientHeap; - ITransientResourceHeap::Desc transientHeapDesc = {}; - transientHeapDesc.constantBufferSize = 4096; - GFX_CHECK_CALL_ABORT( - device->createTransientResourceHeap(transientHeapDesc, transientHeap.writeRef())); - Shader programA; Shader programB; GFX_CHECK_CALL_ABORT(loadComputeProgram( @@ -80,106 +63,74 @@ void barrierTestImpl(IDevice* device, UnitTestContext* context) programB.reflection)); programA.pipelineDesc.program = programA.program.get(); programB.pipelineDesc.program = programB.program.get(); - GFX_CHECK_CALL_ABORT(device->createComputePipelineState( - programA.pipelineDesc, - programA.pipelineState.writeRef())); - GFX_CHECK_CALL_ABORT(device->createComputePipelineState( - programB.pipelineDesc, - programB.pipelineState.writeRef())); - - float initialData[] = {1.0f, 2.0f, 3.0f, 4.0f}; - Buffer inputBuffer; - createFloatBuffer(device, inputBuffer, false, initialData, 4); + GFX_CHECK_CALL_ABORT( + device->createComputePipeline(programA.pipelineDesc, programA.pipeline.writeRef())); - Buffer intermediateBuffer; - createFloatBuffer(device, intermediateBuffer, true, nullptr, 4); + GFX_CHECK_CALL_ABORT( + device->createComputePipeline(programB.pipelineDesc, programB.pipeline.writeRef())); - Buffer outputBuffer; - createFloatBuffer(device, outputBuffer, true, nullptr, 4); + float initialData[] = {1.0f, 2.0f, 3.0f, 4.0f}; + ComPtr inputBuffer = createFloatBuffer(device, false, 4, initialData); + ComPtr intermediateBuffer = createFloatBuffer(device, true, 4, nullptr); + ComPtr outputBuffer = createFloatBuffer(device, true, 4, nullptr); // We have done all the set up work, now it is time to start recording a command buffer for // GPU execution. { - ICommandQueue::Desc queueDesc = {ICommandQueue::QueueType::Graphics}; - auto queue = device->createCommandQueue(queueDesc); - - auto commandBuffer = transientHeap->createCommandBuffer(); - auto encoder = commandBuffer->encodeComputeCommands(); - auto resourceEncoder = commandBuffer->encodeResourceCommands(); + auto queue = device->getQueue(QueueType::Graphics); + auto commandEncoder = queue->createCommandEncoder(); // Write inputBuffer data to intermediateBuffer - auto rootObjectA = encoder->bindPipeline(programA.pipelineState); - ShaderCursor entryPointCursorA(rootObjectA->getEntryPoint(0)); - entryPointCursorA.getPath("inBuffer").setResource(inputBuffer.view); - entryPointCursorA.getPath("outBuffer").setResource(intermediateBuffer.view); - - encoder->dispatchCompute(1, 1, 1); - - // Insert barrier to ensure writes to intermediateBuffer are complete before the next shader - // starts executing - auto bufferPtr = intermediateBuffer.buffer.get(); - resourceEncoder->bufferBarrier( - 1, - &bufferPtr, - ResourceState::UnorderedAccess, - ResourceState::ShaderResource); - resourceEncoder->endEncoding(); - - // Write intermediateBuffer to outputBuffer - auto rootObjectB = encoder->bindPipeline(programB.pipelineState); - ShaderCursor entryPointCursorB(rootObjectB->getEntryPoint(0)); - entryPointCursorB.getPath("inBuffer").setResource(intermediateBuffer.view); - entryPointCursorB.getPath("outBuffer").setResource(outputBuffer.view); - - encoder->dispatchCompute(1, 1, 1); - encoder->endEncoding(); - commandBuffer->close(); - queue->executeCommandBuffer(commandBuffer); + { + auto passEncoder = commandEncoder->beginComputePass(); + auto rootObject = passEncoder->bindPipeline(programA.pipeline); + + ShaderCursor cursor(rootObject->getEntryPoint(0)); + cursor["inBuffer"].setBinding(inputBuffer); + cursor["outBuffer"].setBinding(intermediateBuffer); + passEncoder->dispatchCompute(1, 1, 1); + passEncoder->end(); + } + + // Resource transition is automatically handled. + + // Write intermediateBuffer data to outputBuffer + + { + auto passEncoder = commandEncoder->beginComputePass(); + auto rootObject = passEncoder->bindPipeline(programB.pipeline); + ShaderCursor cursor(rootObject->getEntryPoint(0)); + cursor["inBuffer"].setBinding(intermediateBuffer); + cursor["outBuffer"].setBinding(outputBuffer); + passEncoder->dispatchCompute(1, 1, 1); + passEncoder->end(); + } + + + queue->submit(commandEncoder->finish()); queue->waitOnHost(); } - compareComputeResult( - device, - outputBuffer.buffer, - Slang::makeArray(11.0f, 12.0f, 13.0f, 14.0f)); + + compareComputeResult(device, outputBuffer, makeArray(11.0f, 12.0f, 13.0f, 14.0f)); } -void barrierTestAPI(UnitTestContext* context, Slang::RenderApiFlag::Enum api) +void barrierTestAPI(UnitTestContext* context, DeviceType deviceType) { - gfxEnableDebugLayer(context->enableDebugLayers); - if ((api & context->enabledApis) == 0) - { - SLANG_IGNORE_TEST - } - Slang::ComPtr device; - IDevice::Desc deviceDesc = {}; - switch (api) - { - case Slang::RenderApiFlag::D3D12: - deviceDesc.deviceType = gfx::DeviceType::DirectX12; - break; - case Slang::RenderApiFlag::Vulkan: - deviceDesc.deviceType = gfx::DeviceType::Vulkan; - break; - default: - SLANG_IGNORE_TEST - } - deviceDesc.slang.slangGlobalSession = context->slangGlobalSession; - const char* searchPaths[] = {"", "../../tools/gfx-unit-test", "tools/gfx-unit-test"}; - deviceDesc.slang.searchPathCount = (SlangInt)SLANG_COUNT_OF(searchPaths); - deviceDesc.slang.searchPaths = searchPaths; - auto createDeviceResult = gfxCreateDevice(&deviceDesc, device.writeRef()); - if (SLANG_FAILED(createDeviceResult)) + Slang::List searchPaths = {"", "../../tools/gfx-unit-test", "tools/gfx-unit-test"}; + auto device = createTestingDevice(context, deviceType, searchPaths); + + if (!device) { SLANG_IGNORE_TEST } - barrierTestImpl(device, context); + barrierTestImpl(device.get(), context); } SLANG_UNIT_TEST(bufferBarrierVulkan) { - barrierTestAPI(unitTestContext, Slang::RenderApiFlag::Vulkan); + barrierTestAPI(unitTestContext, DeviceType::Vulkan); } } // namespace gfx_test -- cgit v1.2.3