Add descriptor handle support to render test framework

jkiviluoto-nv · jkiviluoto-nv · commit 19290eea4beb · 2025-10-27T16:28:37.000+02:00
Fixes #8631 Implements automatic detection and binding of descriptor handle types (.Handle) in the slang-test framework, enabling execution tests for bindless descriptor features. Detection Strategy: Descriptor handles are lowered to uint2 (SPIRV/DX12) stored in uniform data. The detector specifically matches this pattern and excludes uint64 (device addresses) and Resource types (Metal/CUDA pointers) to avoid false positives. If getDescriptorHandle() fails, falls back to regular binding. Changes: - Add isDescriptorHandleType() detecting uint2 in UNIFORM category - Modify assignBuffer/Texture/Sampler to allocate and bind descriptor handles - Determine access mode via getResourceAccess() reflection - Fix resource lifetime by adding all resources to TestResourceContext - Add test cases requiring -render-feature bindless and -emit-spirv-directly This fixes Vulkan validation errors (VUID-vkDestroyBuffer-buffer-00922) where buffers were destroyed while still in use by command buffers when using bindless descriptors
diff --git a/tests/language-feature/descriptor-handle/desc-handle-debug.slang b/tests/language-feature/descriptor-handle/desc-handle-debug.slang
@@ -0,0 +1,19 @@
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-vk -output-using-type -render-feature bindless -emit-spirv-directly
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-dx12 -output-using-type -profile sm_6_6 -render-feature bindless
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-mtl -output-using-type
+
+// CHECK: type: uint
+// CHECK-NEXT: 42
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<uint> outputBuffer;
+
+//TEST_INPUT:ubuffer(data=[42], stride=4):name=input
+uniform RWStructuredBuffer<uint>.Handle input;
+
+[numthreads(1, 1, 1)]
+void computeMain()
+{
+    // Just read one value
+    outputBuffer[0] = input[0];
+}
diff --git a/tests/language-feature/descriptor-handle/desc-handle-test-input.slang b/tests/language-feature/descriptor-handle/desc-handle-test-input.slang
@@ -0,0 +1,21 @@
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-vk -output-using-type -render-feature bindless -emit-spirv-directly
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-dx12 -output-using-type -profile sm_6_6 -render-feature bindless
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-mtl -output-using-type
+
+// CHECK: type: float
+// CHECK-NEXT: 1.0
+// CHECK-NEXT: 2.0
+// CHECK-NEXT: 3.0
+
+//TEST_INPUT:ubuffer(data=[0 0 0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+//TEST_INPUT:ubuffer(data=[1.0 2.0 3.0], stride=4):name=input
+uniform RWStructuredBuffer<float>.Handle input;
+
+[numthreads(1, 1, 1)]
+void computeMain()
+{
+    for(int i = 0; i < 3; i++)
+        outputBuffer[i] = input[i];
+}
diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp
@@ -330,6 +330,62 @@ struct AssignValsFromLayoutContext
         return SLANG_OK;
     }
 
+    static bool isDescriptorHandleType(const ShaderCursor& cursor)
+    {
+        // Descriptor handles in SPIRV/DX12 with bindless are lowered to uint2
+        // stored in uniform data.
+        //
+        // IMPORTANT: We only check for uint2, NOT uint64!
+        // - uint64 in uniform data = device address (buffer pointer)
+        // - uint2 in uniform data = descriptor handle (index into bindless heap)
+        //
+        // Note: We DON'T check for Kind::Resource in uniform data because:
+        // - On Metal/CUDA, regular resources appear as pointers in uniform data
+        // - Those work fine with regular setBinding(), not descriptor handles
+
+        auto typeLayout = cursor.getTypeLayout();
+
+        // Check if this parameter is stored in uniform data (not descriptor table)
+        auto uniformSize = typeLayout->getSize(SLANG_PARAMETER_CATEGORY_UNIFORM);
+        auto descriptorSlotSize =
+            typeLayout->getSize(SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT);
+
+        if (uniformSize == 8 && descriptorSlotSize == 0)
+        {
+            auto type = typeLayout->getType();
+            auto kind = type->getKind();
+
+            // Check for uint2 (SPIRV/DX12 descriptor handle)
+            // This is the ONLY pattern we detect as descriptor handles
+            if (kind == slang::TypeReflection::Kind::Vector && type->getElementCount() == 2 &&
+                type->getElementType()->getScalarType() ==
+                    slang::TypeReflection::ScalarType::UInt32)
+                return true;
+        }
+
+        return false;
+    }
+
+    static DescriptorHandleAccess getDescriptorHandleAccess(SlangResourceAccess resourceAccess)
+    {
+        // Map Slang resource access to descriptor handle access
+        // Most write-capable resources map to ReadWrite
+        switch (resourceAccess)
+        {
+        case SLANG_RESOURCE_ACCESS_READ:
+            return DescriptorHandleAccess::Read;
+        case SLANG_RESOURCE_ACCESS_READ_WRITE:
+        case SLANG_RESOURCE_ACCESS_WRITE:
+        case SLANG_RESOURCE_ACCESS_RASTER_ORDERED:
+        case SLANG_RESOURCE_ACCESS_APPEND:
+        case SLANG_RESOURCE_ACCESS_CONSUME:
+        case SLANG_RESOURCE_ACCESS_FEEDBACK:
+            return DescriptorHandleAccess::ReadWrite;
+        default:
+            return DescriptorHandleAccess::ReadWrite;
+        }
+    }
+
     SlangResult assignBuffer(ShaderCursor const& dstCursor, ShaderInputLayout::BufferVal* srcVal)
     {
         const InputBufferDesc& srcBuffer = srcVal->bufferDesc;
@@ -350,6 +406,38 @@ struct AssignValsFromLayoutContext
             device,
             bufferResource));
 
+        // Keep buffer alive in resource context
+        resourceContext.resources.add(ComPtr<IResource>(bufferResource.get()));
+
+        // Check if this is a descriptor handle type
+        if (isDescriptorHandleType(dstCursor))
+        {
+            // Try to allocate descriptor handle for bindless access
+            DescriptorHandle handle;
+
+            // Determine access mode from the shader parameter's resource type
+            auto handleType = dstCursor.getTypeLayout()->getType();
+            auto resourceType = handleType->getElementType();
+            auto resourceAccess =
+                resourceType ? resourceType->getResourceAccess() : SLANG_RESOURCE_ACCESS_READ_WRITE;
+            DescriptorHandleAccess access = getDescriptorHandleAccess(resourceAccess);
+
+            // Try to get descriptor handle - will fail on backends that don't support it
+            auto result = bufferResource->getDescriptorHandle(
+                access,
+                srcBuffer.format,
+                BufferRange{0, bufferSize},
+                &handle);
+
+            if (SLANG_SUCCEEDED(result))
+            {
+                SLANG_RETURN_ON_FAIL(dstCursor.setDescriptorHandle(handle));
+                maybeAddOutput(dstCursor, srcVal, bufferResource);
+                return SLANG_OK;
+            }
+            // If getDescriptorHandle fails, fall through to regular binding
+        }
+
         if ((dstCursor.getTypeLayout()->getType()->getKind() ==
                  slang::TypeReflection::Kind::Scalar &&
              dstCursor.getTypeLayout()->getType()->getScalarType() ==
@@ -360,7 +448,6 @@ struct AssignValsFromLayoutContext
             // we should write bufferResource as a pointer.
             uint64_t addr = bufferResource->getDeviceAddress();
             dstCursor.setData(&addr, sizeof(addr));
-            resourceContext.resources.add(ComPtr<IResource>(bufferResource.get()));
             maybeAddOutput(dstCursor, srcVal, bufferResource);
             return SLANG_OK;
         }
@@ -405,6 +492,8 @@ struct AssignValsFromLayoutContext
 
         if (counterResource)
         {
+            // Keep counter buffer alive
+            resourceContext.resources.add(ComPtr<IResource>(counterResource.get()));
             dstCursor.setBinding(Binding(bufferResource, counterResource));
         }
         else
@@ -430,8 +519,14 @@ struct AssignValsFromLayoutContext
             device,
             texture));
 
+        // Keep texture alive in resource context
+        resourceContext.resources.add(ComPtr<IResource>(texture.get()));
+
         auto sampler = _createSampler(device, samplerEntry->samplerDesc);
 
+        // Keep sampler alive in resource context
+        resourceContext.resources.add(ComPtr<IResource>(sampler.get()));
+
         dstCursor.setBinding(Binding(texture, sampler));
         maybeAddOutput(dstCursor, srcVal, texture);
 
@@ -451,6 +546,36 @@ struct AssignValsFromLayoutContext
             device,
             texture));
 
+        // Keep texture alive in resource context
+        resourceContext.resources.add(ComPtr<IResource>(texture.get()));
+
+        // Check if this is a descriptor handle type
+        if (isDescriptorHandleType(dstCursor))
+        {
+            // Try to allocate descriptor handle for bindless access
+            // Get default texture view first, as handles are allocated from views
+            ComPtr<ITextureView> textureView;
+            SLANG_RETURN_ON_FAIL(texture->getDefaultView(textureView.writeRef()));
+
+            // Determine access mode from the shader parameter's resource type
+            auto handleType = dstCursor.getTypeLayout()->getType();
+            auto resourceType = handleType->getElementType();
+            auto resourceAccess =
+                resourceType ? resourceType->getResourceAccess() : SLANG_RESOURCE_ACCESS_READ_WRITE;
+            DescriptorHandle handle;
+            DescriptorHandleAccess access = getDescriptorHandleAccess(resourceAccess);
+
+            // Try to get descriptor handle - will fail on backends that don't support it
+            auto result = textureView->getDescriptorHandle(access, &handle);
+            if (SLANG_SUCCEEDED(result))
+            {
+                SLANG_RETURN_ON_FAIL(dstCursor.setDescriptorHandle(handle));
+                maybeAddOutput(dstCursor, srcVal, texture);
+                return SLANG_OK;
+            }
+            // If getDescriptorHandle fails, fall through to regular binding
+        }
+
         dstCursor.setBinding(texture);
         maybeAddOutput(dstCursor, srcVal, texture);
         return SLANG_OK;
@@ -460,6 +585,23 @@ struct AssignValsFromLayoutContext
     {
         auto sampler = _createSampler(device, srcVal->samplerDesc);
 
+        // Keep sampler alive in resource context
+        resourceContext.resources.add(ComPtr<IResource>(sampler.get()));
+
+        // Check if this is a descriptor handle type
+        if (isDescriptorHandleType(dstCursor))
+        {
+            // Try to allocate descriptor handle for bindless access
+            DescriptorHandle handle;
+            auto result = sampler->getDescriptorHandle(&handle);
+            if (SLANG_SUCCEEDED(result))
+            {
+                SLANG_RETURN_ON_FAIL(dstCursor.setDescriptorHandle(handle));
+                return SLANG_OK;
+            }
+            // If getDescriptorHandle fails, fall through to regular binding
+        }
+
         dstCursor.setBinding(sampler);
         return SLANG_OK;
     }
