Add YAML-driven acceleration structure definitions for .test files

Add AccelerationStructure to ResourceKind and introduce pipeline structs
(TriangleGeometry, AABBGeometry, BLASDesc, InstanceDesc, TLASDesc) with
YAML parsing and name resolution for buffer/BLAS/TLAS references. Backend
switch statements are updated to handle the new enum value. Includes three
placeholder InlineRT test files exercising the new YAML format (gated
behind REQUIRES: raytracing).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: MarijnS95

include/API/Enums.h

@@ -23,6 +23,7 @@ enum class ResourceKind {
   ConstantBuffer,
   Sampler,
   SampledTexture2D,
+  AccelerationStructure,
 };
 
 enum ShaderContainerType {

include/API/Resources.h

@@ -25,6 +25,8 @@ enum class MemoryLocation {
   GpuToCpu,
 };
 
+enum class IndexFormat { Uint16, Uint32 };
+
 // TODO: Add Unorm types (e.g. R8Unorm, RGBA8Unorm) which can be sampled as
 // floats.
 // TODO: Add SRGB types (e.g. RGBA8Srgb) once needed.

include/Support/Pipeline.h

@@ -14,6 +14,7 @@
 #define OFFLOADTEST_SUPPORT_PIPELINE_H
 
 #include "API/Enums.h"
+#include "API/Resources.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
@@ -80,6 +81,7 @@ static inline DescriptorKind getDescriptorKind(ResourceKind RK) {
   case ResourceKind::StructuredBuffer:
   case ResourceKind::ByteAddressBuffer:
   case ResourceKind::Texture2D:
+  case ResourceKind::AccelerationStructure:
     return DescriptorKind::SRV;
 
   case ResourceKind::RWStructuredBuffer:
@@ -221,6 +223,8 @@ struct Result {
   double Epsilon;
 };
 
+struct TLASDesc;
+
 struct Resource {
   ResourceKind Kind;
   std::string Name;
@@ -231,6 +235,11 @@ struct Resource {
   bool HasCounter;
   std::optional<uint32_t> TilesMapped;
   bool IsReserved = false;
+  TLASDesc *TLASPtr = nullptr;
+
+  bool isAccelerationStructure() const {
+    return Kind == ResourceKind::AccelerationStructure;
+  }
 
   bool isRaw() const {
     switch (Kind) {
@@ -240,6 +249,7 @@ struct Resource {
     case ResourceKind::RWTexture2D:
     case ResourceKind::Sampler:
     case ResourceKind::SampledTexture2D:
+    case ResourceKind::AccelerationStructure:
       return false;
     case ResourceKind::StructuredBuffer:
     case ResourceKind::RWStructuredBuffer:
@@ -265,6 +275,7 @@ struct Resource {
     case ResourceKind::Texture2D:
     case ResourceKind::RWTexture2D:
     case ResourceKind::SampledTexture2D:
+    case ResourceKind::AccelerationStructure:
       return false;
     }
     llvm_unreachable("All cases handled");
@@ -280,6 +291,7 @@ struct Resource {
     case ResourceKind::RWByteAddressBuffer:
     case ResourceKind::ConstantBuffer:
     case ResourceKind::Sampler:
+    case ResourceKind::AccelerationStructure:
       return false;
     case ResourceKind::Texture2D:
     case ResourceKind::RWTexture2D:
@@ -319,18 +331,22 @@ struct Resource {
   }
 
   uint32_t getElementSize() const {
-    assert(!isSampler() && "Samplers do not have element size");
+    assert(!isSampler() && !isAccelerationStructure() &&
+           "Samplers and AS do not have element size");
     // ByteAddressBuffers are treated as 4-byte elements to match their memory
     // format.
     return isByteAddressBuffer() ? 4 : BufferPtr->getElementSize();
   }
 
   uint32_t getArraySize() const {
-    return isSampler() ? 1 : BufferPtr->ArraySize;
+    if (isSampler() || isAccelerationStructure())
+      return 1;
+    return BufferPtr->ArraySize;
   }
 
   uint32_t size() const {
-    assert(!isSampler() && "Samplers do not have size");
+    assert(!isSampler() && !isAccelerationStructure() &&
+           "Samplers and AS do not have size");
     return BufferPtr->size();
   }
 
@@ -343,6 +359,7 @@ struct Resource {
     case ResourceKind::ConstantBuffer:
     case ResourceKind::Sampler:
     case ResourceKind::SampledTexture2D:
+    case ResourceKind::AccelerationStructure:
       return false;
     case ResourceKind::RWBuffer:
     case ResourceKind::RWStructuredBuffer:
@@ -465,6 +482,51 @@ struct DispatchParametersSet {
   std::optional<uint32_t> VertexCount;
 };
 
+struct TriangleGeometry {
+  std::string VertexBuffer;
+  CPUBuffer *VertexBufferPtr = nullptr;
+  Format VertexFormat = Format::RGB32Float;
+  uint32_t VertexStride = 12;
+  uint32_t VertexCount = 0;
+  std::string IndexBuffer;
+  CPUBuffer *IndexBufferPtr = nullptr;
+  IndexFormat IdxFormat = IndexFormat::Uint32;
+  uint32_t IndexCount = 0;
+  bool Opaque = true;
+};
+
+struct AABBGeometry {
+  std::string AABBBuffer;
+  CPUBuffer *AABBBufferPtr = nullptr;
+  uint32_t AABBCount = 0;
+  uint32_t AABBStride = 24;
+  bool Opaque = true;
+};
+
+struct BLASDesc {
+  std::string Name;
+  llvm::SmallVector<TriangleGeometry> Triangles;
+  llvm::SmallVector<AABBGeometry> AABBs;
+};
+
+struct InstanceDesc {
+  std::string BLAS;
+  int BLASIdx = -1;
+  float Transform[12] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0};
+  uint32_t InstanceID = 0;
+  uint8_t InstanceMask = 0xFF;
+};
+
+struct TLASDesc {
+  std::string Name;
+  llvm::SmallVector<InstanceDesc> Instances;
+};
+
+struct AccelerationStructureDescs {
+  llvm::SmallVector<BLASDesc> BLAS;
+  llvm::SmallVector<TLASDesc> TLAS;
+};
+
 struct Pipeline {
   ShaderPipelineKind Kind;
   llvm::SmallVector<Shader> Shaders;
@@ -477,6 +539,7 @@ struct Pipeline {
   llvm::SmallVector<Result> Results;
   llvm::SmallVector<DescriptorSet> Sets;
   DispatchParametersSet DispatchParameters;
+  AccelerationStructureDescs AccelStructs;
 
   uint32_t getVertexCount() const {
     if (DispatchParameters.VertexCount)
@@ -517,6 +580,20 @@ struct Pipeline {
     return nullptr;
   }
 
+  BLASDesc *getBLAS(llvm::StringRef Name) {
+    for (auto &B : AccelStructs.BLAS)
+      if (Name == B.Name)
+        return &B;
+    return nullptr;
+  }
+
+  TLASDesc *getTLAS(llvm::StringRef Name) {
+    for (auto &T : AccelStructs.TLAS)
+      if (Name == T.Name)
+        return &T;
+    return nullptr;
+  }
+
   llvm::Error validatePipelineKind();
   llvm::Error validateDispatchParameters();
 
@@ -545,6 +622,11 @@ LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::SpecializationConstant)
 LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::PushConstantBlock)
 LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::PushConstantValue)
 LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::DispatchParametersSet)
+LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::TriangleGeometry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::AABBGeometry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::BLASDesc)
+LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::InstanceDesc)
+LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::TLASDesc)
 
 namespace llvm {
 namespace yaml {
@@ -629,6 +711,30 @@ template <> struct MappingTraits<offloadtest::SpecializationConstant> {
   static void mapping(IO &I, offloadtest::SpecializationConstant &C);
 };
 
+template <> struct MappingTraits<offloadtest::TriangleGeometry> {
+  static void mapping(IO &I, offloadtest::TriangleGeometry &G);
+};
+
+template <> struct MappingTraits<offloadtest::AABBGeometry> {
+  static void mapping(IO &I, offloadtest::AABBGeometry &G);
+};
+
+template <> struct MappingTraits<offloadtest::BLASDesc> {
+  static void mapping(IO &I, offloadtest::BLASDesc &D);
+};
+
+template <> struct MappingTraits<offloadtest::InstanceDesc> {
+  static void mapping(IO &I, offloadtest::InstanceDesc &D);
+};
+
+template <> struct MappingTraits<offloadtest::TLASDesc> {
+  static void mapping(IO &I, offloadtest::TLASDesc &D);
+};
+
+template <> struct MappingTraits<offloadtest::AccelerationStructureDescs> {
+  static void mapping(IO &I, offloadtest::AccelerationStructureDescs &D);
+};
+
 template <> struct ScalarEnumerationTraits<offloadtest::Rule> {
   static void enumeration(IO &I, offloadtest::Rule &V) {
 #define ENUM_CASE(Val) I.enumCase(V, #Val, offloadtest::Rule::Val)
@@ -730,6 +836,41 @@ template <> struct ScalarEnumerationTraits<offloadtest::ResourceKind> {
     ENUM_CASE(ConstantBuffer);
     ENUM_CASE(Sampler);
     ENUM_CASE(SampledTexture2D);
+    ENUM_CASE(AccelerationStructure);
+#undef ENUM_CASE
+  }
+};
+
+template <> struct ScalarEnumerationTraits<offloadtest::Format> {
+  static void enumeration(IO &I, offloadtest::Format &V) {
+#define ENUM_CASE(Val) I.enumCase(V, #Val, offloadtest::Format::Val)
+    ENUM_CASE(R16Sint);
+    ENUM_CASE(R16Uint);
+    ENUM_CASE(RG16Sint);
+    ENUM_CASE(RG16Uint);
+    ENUM_CASE(RGBA16Sint);
+    ENUM_CASE(RGBA16Uint);
+    ENUM_CASE(R32Sint);
+    ENUM_CASE(R32Uint);
+    ENUM_CASE(R32Float);
+    ENUM_CASE(RG32Sint);
+    ENUM_CASE(RG32Uint);
+    ENUM_CASE(RG32Float);
+    ENUM_CASE(RGB32Float);
+    ENUM_CASE(RGBA32Sint);
+    ENUM_CASE(RGBA32Uint);
+    ENUM_CASE(RGBA32Float);
+    ENUM_CASE(D32Float);
+    ENUM_CASE(D32FloatS8Uint);
+#undef ENUM_CASE
+  }
+};
+
+template <> struct ScalarEnumerationTraits<offloadtest::IndexFormat> {
+  static void enumeration(IO &I, offloadtest::IndexFormat &V) {
+#define ENUM_CASE(Val) I.enumCase(V, #Val, offloadtest::IndexFormat::Val)
+    ENUM_CASE(Uint16);
+    ENUM_CASE(Uint32);
 #undef ENUM_CASE
   }
 };

lib/API/DX/DXFeatures.cpp

@@ -43,6 +43,15 @@ static ArrayRef<EnumEntry<MeshShaderTier>> getMeshShaderTiers() {
   return ArrayRef(MeshShaderTierNames);
 }
 
+#define RAYTRACING_TIER_ENUM(NewCase, Str, Value) {#Str, NewCase},
+static const EnumEntry<directx::RaytracingTier> RaytracingTierNames[]{
+#include "DXFeatures.def"
+};
+
+static ArrayRef<EnumEntry<RaytracingTier>> getRaytracingTiers() {
+  return ArrayRef(RaytracingTierNames);
+}
+
 template <typename T>
 static std::string enumEntryToString(ArrayRef<EnumEntry<T>> EnumValues,
                                      T Value) {
@@ -66,3 +75,8 @@ std::string CapabilityPrinter<directx::MeshShaderTier>::toString(
     const directx::MeshShaderTier &V) {
   return enumEntryToString(getMeshShaderTiers(), V);
 }
+
+std::string CapabilityPrinter<directx::RaytracingTier>::toString(
+    const directx::RaytracingTier &V) {
+  return enumEntryToString(getRaytracingTiers(), V);
+}

lib/API/DX/DXFeatures.def

@@ -28,10 +28,19 @@ MESH_SHADER_TIER_ENUM(MeshShaderTier1, Tier1,10)
 #undef MESH_SHADER_TIER_ENUM
 #endif
 
+#ifdef RAYTRACING_TIER_ENUM
+RAYTRACING_TIER_ENUM(RT_NotSupported, NotSupported, 0)
+RAYTRACING_TIER_ENUM(RT_1_0, 1.0, 10)
+RAYTRACING_TIER_ENUM(RT_1_1, 1.1, 11)
+RAYTRACING_TIER_ENUM(RT_1_2, 1.2, 12)
+#undef RAYTRACING_TIER_ENUM
+#endif
+
 #ifdef D3D_FEATURE_ENUM
 D3D_FEATURE_ENUM(directx::ShaderModel, HighestShaderModel)
 D3D_FEATURE_ENUM(directx::RootSignature, HighestRootSignatureVersion)
 D3D_FEATURE_ENUM(directx::MeshShaderTier, MeshShaderTier)
+D3D_FEATURE_ENUM(directx::RaytracingTier, RaytracingTier)
 #undef D3D_FEATURE_ENUM
 #endif
 

lib/API/DX/DXFeatures.h

@@ -37,6 +37,11 @@ enum MeshShaderTier {
 #include "DXFeatures.def"
 };
 
+#define RAYTRACING_TIER_ENUM(NewCase, Str, Value) NewCase = Value,
+enum RaytracingTier {
+#include "DXFeatures.def"
+};
+
 } // namespace directx
 
 template <> struct CapabilityPrinter<directx::ShaderModel> {
@@ -51,6 +56,10 @@ template <> struct CapabilityPrinter<directx::MeshShaderTier> {
   static std::string toString(const directx::MeshShaderTier &V);
 };
 
+template <> struct CapabilityPrinter<directx::RaytracingTier> {
+  static std::string toString(const directx::RaytracingTier &V);
+};
+
 } // namespace offloadtest
 
 #endif // OFFLOADTEST_API_DXFEATURES_H

lib/API/DX/Device.cpp

@@ -64,6 +64,7 @@ using ID3D12GraphicsCommandListX = ID3D12GraphicsCommandList6;
 template <> char CapabilityValueEnum<directx::ShaderModel>::ID = 0;
 template <> char CapabilityValueEnum<directx::RootSignature>::ID = 0;
 template <> char CapabilityValueEnum<directx::MeshShaderTier>::ID = 0;
+template <> char CapabilityValueEnum<directx::RaytracingTier>::ID = 0;
 
 static std::mutex SignalHandlerMutex;
 static llvm::SmallVector<ID3D12DeviceX *> SignalHandlerDevices;
@@ -220,6 +221,7 @@ static D3D12_RESOURCE_DIMENSION getDXDimension(ResourceKind RK) {
   case ResourceKind::RWBuffer:
   case ResourceKind::RWByteAddressBuffer:
   case ResourceKind::ConstantBuffer:
+  case ResourceKind::AccelerationStructure:
     return D3D12_RESOURCE_DIMENSION_BUFFER;
   case ResourceKind::Texture2D:
   case ResourceKind::RWTexture2D:
@@ -301,6 +303,8 @@ static D3D12_SHADER_RESOURCE_VIEW_DESC getSRVDescription(const Resource &R) {
     llvm_unreachable("Not an SRV type!");
   case ResourceKind::SampledTexture2D:
     llvm_unreachable("Sampled textures aren't supported in DirectX!");
+  case ResourceKind::AccelerationStructure:
+    llvm_unreachable("Acceleration structures use a separate descriptor path!");
   }
   return Desc;
 }
@@ -340,6 +344,8 @@ static D3D12_UNORDERED_ACCESS_VIEW_DESC getUAVDescription(const Resource &R) {
     llvm_unreachable("Not a UAV type!");
   case ResourceKind::SampledTexture2D:
     llvm_unreachable("Sampled textures aren't supported in DirectX!");
+  case ResourceKind::AccelerationStructure:
+    llvm_unreachable("Acceleration structures use a separate descriptor path!");
   }
   return Desc;
 }

lib/API/MTL/MTLDevice.cpp

@@ -1102,6 +1102,8 @@ class MTLDevice : public offloadtest::Device {
       case ResourceKind::RWByteAddressBuffer:
       case ResourceKind::ConstantBuffer:
         llvm_unreachable("Raw is checked above");
+      case ResourceKind::AccelerationStructure:
+        llvm_unreachable("Acceleration structures use a separate path!");
       }
 
       MTL::Texture *NewTex = Device->newTexture(Desc);
@@ -2091,6 +2093,10 @@ class MTLDevice : public offloadtest::Device {
         Device->supportsFamily(MTL::GPUFamilyMetal3);
     Caps.insert(std::make_pair(
         "MeshShader", makeCapability<bool>("MeshShader", MeshShaderSupported)));
+    Caps.insert(
+        std::make_pair("supportsRaytracing",
+                       makeCapability<bool>("supportsRaytracing",
+                                            Device->supportsRaytracing())));
   }
 };
 } // namespace