Merge branch 'main' into active-ballot

Author: tcorringham

CMakeLists.txt

@@ -43,7 +43,7 @@ endmacro()
 
 find_package(Vulkan)
 message(STATUS "Vulkan Include Dirs: ${Vulkan_INCLUDE_DIRS}")
-if (Vulkan_INCLUDE_DIRS)
+if (Vulkan_INCLUDE_DIRS AND NOT OFFLOADTEST_WARP_ONLY)
   set(OFFLOADTEST_ENABLE_VULKAN On)
 endif ()
 

README.md

@@ -85,6 +85,19 @@ Buffers:
   - Name: In2
     Format: Hex16
     Data: [ 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]
+  - Name: Tex
+    Format: Float32
+    Channels: 4
+    OutputProps:
+      Width: 2
+      Height: 2
+      Depth: 1
+      MipLevels: 2
+    Data: [ 1.0, 0.0, 0.0, 1.0,  # Mip 0 (2x2)
+            0.0, 1.0, 0.0, 1.0,
+            0.0, 0.0, 1.0, 1.0,
+            1.0, 1.0, 1.0, 1.0,
+            1.0, 1.0, 0.0, 1.0 ] # Mip 1 (1x1)
   - Name: Out1 # Buffer where our output will go
     Format: Float32
     Stride: 4

docs/MipMappedTextures.md

@@ -0,0 +1,93 @@
+# Mipmapped Textures
+
+The test suite supports textures with multiple mipmap levels. This allows
+verifying that the compiler correctly generates code for
+`CalculateLevelOfDetail`, `SampleGrad` (explicit gradients), and direct access
+via `mips[level][coords]`.
+
+## Defining Mip Levels
+
+To define a texture with multiple mips, specify the `MipLevels` field in
+`OutputProps`.
+
+**Example:**
+```yaml
+Buffers:
+  - Name: Tex
+    Format: Float32
+    Channels: 4
+    OutputProps:
+      Width: 4
+      Height: 4
+      Depth: 1
+      MipLevels: 3  # Defines Mip 0 (4x4), Mip 1 (2x2), and Mip 2 (1x1)
+```
+
+## Dimension Calculation
+
+The dimensions of each mip level are calculated automatically based on the base
+`Width`, `Height`, and `Depth` provided in `OutputProps`. Following standard
+graphics API conventions (Vulkan, DirectX, Metal), each subsequent mip level is
+half the size of the previous level, rounded down, with a minimum of 1.
+
+For Mip Level $N$:
+*   $\text{Width}_N = \max(1, \lfloor \text{Width}_0 / 2^N \rfloor)$
+*   $\text{Height}_N = \max(1, \lfloor \text{Height}_0 / 2^N \rfloor)$
+*   $\text{Depth}_N = \max(1, \lfloor \text{Depth}_0 / 2^N \rfloor)$
+
+## Data Layout
+
+The `Data` array in the YAML must contain the texel data for **all mip levels
+sequentially**, packed tightly without padding.
+
+For a 4x4 texture with 3 mip levels, the `Data` array structure is:
+
+1.  **Mip 0 (4x4 = 16 texels):** Indices 0 - 15.
+2.  **Mip 1 (2x2 = 4 texels):** Indices 16 - 19.
+3.  **Mip 2 (1x1 = 1 texel):** Index 20.
+
+**Total Size:** 21 texels.
+
+### Example YAML
+
+```yaml
+  - Name: Tex
+    Format: Float32
+    Channels: 4 # RGBA
+    OutputProps: { Width: 4, Height: 4, Depth: 1, MipLevels: 3 }
+    Data: [
+            # --- Mip 0 (4x4) ---
+            1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1,  # Row 0 (Red)
+            1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1,  # Row 1
+            1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1,  # Row 2
+            1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1,  # Row 3
+
+            # --- Mip 1 (2x2) ---
+            0,1,0,1, 0,1,0,1,                    # Row 0 (Green)
+            0,1,0,1, 0,1,0,1,                    # Row 1
+
+            # --- Mip 2 (1x1) ---
+            0,0,1,1                              # Single Pixel (Blue)
+          ]
+```
+
+## Usage in Tests
+
+This structure allows you to verify explicit mip selection in shaders:
+
+```hlsl
+// Should return Green (Mip 1)
+float4 val = Tex.mips[1][int2(0,0)];
+
+// Should return Blue (Mip 2)
+float4 val2 = Tex.Load(int3(0,0,2));
+```
+
+## Implementation Notes
+
+### Mipmap Filtering
+
+Currently, the test suite hardcodes the mipmap sampling mode to **Nearest**
+(`VK_SAMPLER_MIPMAP_MODE_NEAREST` in Vulkan). This ensures deterministic results
+for tests that verify specific mip level selection without requiring linear
+interpolation between levels. Linear mip filtering is not configurable via YAML.

docs/WARP.md

@@ -11,9 +11,9 @@ will generate test targets for `check-hlsl-warp-d3d12` and
 There are some useful CMake options to tweak the configuration to better utilize
 WARP:
 
-* **OFFLOADTEST_WARP_ONLY** - Skips generating d3d test configurations for
-  non-WARP configurations. This is useful if you're running Windows in a VM and
-  do not have a physical GPU.
+* **OFFLOADTEST_WARP_ONLY** - Skips generating non-WRAP test configurations
+  and backends. This is useful if you're running Windows in a VM and only
+  have a working WARP implementation.
 
 * **WARP_VERSION** - Defaults to `LKG` which uses a Known-Good version of WARP.
   This is the default version tested in the GitHub actions. Alternatively this

include/Support/Pipeline.h

@@ -101,6 +101,7 @@ struct OutputProperties {
   int Height;
   int Width;
   int Depth;
+  int MipLevels = 1;
 };
 
 static inline uint32_t getFormatSize(DataFormat Format) {

lib/API/DX/Device.cpp

@@ -156,9 +156,16 @@ static DXResourceKind getDXKind(offloadtest::ResourceKind RK) {
   llvm_unreachable("All cases handled");
 }
 
-static D3D12_RESOURCE_DESC getResourceDescription(const Resource &R) {
+static llvm::Expected<D3D12_RESOURCE_DESC>
+getResourceDescription(const Resource &R) {
   const D3D12_RESOURCE_DIMENSION Dimension = getDXDimension(R.Kind);
   const offloadtest::Buffer &B = *R.BufferPtr;
+
+  if (B.OutputProps.MipLevels != 1)
+    return llvm::createStringError(std::errc::not_supported,
+                                   "Multiple mip levels are not yet supported "
+                                   "for DirectX textures.");
+
   const DXGI_FORMAT Format =
       R.isTexture() ? getDXFormat(B.Format, B.Channels) : DXGI_FORMAT_UNKNOWN;
   const uint32_t Width =
@@ -611,7 +618,10 @@ class DXDevice : public offloadtest::Device {
   llvm::Expected<ResourceBundle> createSRV(Resource &R, InvocationState &IS) {
     ResourceBundle Bundle;
 
-    const D3D12_RESOURCE_DESC ResDesc = getResourceDescription(R);
+    auto ResDescOrErr = getResourceDescription(R);
+    if (!ResDescOrErr)
+      return ResDescOrErr.takeError();
+    const D3D12_RESOURCE_DESC ResDesc = *ResDescOrErr;
     const D3D12_HEAP_PROPERTIES UploadHeapProp =
         CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD);
     const D3D12_RESOURCE_DESC UploadResDesc =
@@ -708,7 +718,10 @@ class DXDevice : public offloadtest::Device {
     ResourceBundle Bundle;
     const uint32_t BufferSize = getUAVBufferSize(R);
 
-    const D3D12_RESOURCE_DESC ResDesc = getResourceDescription(R);
+    auto ResDescOrErr = getResourceDescription(R);
+    if (!ResDescOrErr)
+      return ResDescOrErr.takeError();
+    const D3D12_RESOURCE_DESC ResDesc = *ResDescOrErr;
 
     const D3D12_HEAP_PROPERTIES ReadBackHeapProp =
         CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK);
@@ -1314,6 +1327,11 @@ class DXDevice : public offloadtest::Device {
           std::errc::invalid_argument,
           "No render target bound for graphics pipeline.");
     const Buffer &OutBuf = *P.Bindings.RTargetBufferPtr;
+    if (OutBuf.OutputProps.MipLevels != 1)
+      return llvm::createStringError(
+          std::errc::not_supported,
+          "Multiple mip levels are not yet supported for DirectX render "
+          "targets.");
     D3D12_RESOURCE_DESC Desc = {};
     Desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
     Desc.Width = OutBuf.OutputProps.Width;
@@ -1465,13 +1483,13 @@ class DXDevice : public offloadtest::Device {
         IS.RTVHeap->GetCPUDescriptorHandleForHeapStart();
     Device->CreateRenderTargetView(IS.RT.Get(), nullptr, RTVHandle);
 
+    IS.CmdList->SetGraphicsRootSignature(IS.RootSig.Get());
     if (IS.DescHeap) {
       ID3D12DescriptorHeap *const Heaps[] = {IS.DescHeap.Get()};
       IS.CmdList->SetDescriptorHeaps(1, Heaps);
       IS.CmdList->SetGraphicsRootDescriptorTable(
           0, IS.DescHeap->GetGPUDescriptorHandleForHeapStart());
     }
-    IS.CmdList->SetGraphicsRootSignature(IS.RootSig.Get());
     IS.CmdList->SetPipelineState(IS.PSO.Get());
 
     IS.CmdList->OMSetRenderTargets(1, &RTVHandle, false, nullptr);
@@ -1509,6 +1527,43 @@ class DXDevice : public offloadtest::Device {
     const CD3DX12_TEXTURE_COPY_LOCATION SrcLoc(IS.RT.Get(), 0);
 
     IS.CmdList->CopyTextureRegion(&DstLoc, 0, 0, 0, &SrcLoc, nullptr);
+
+    auto CopyBackResource = [&IS, this](ResourcePair &R) {
+      if (R.first->isTexture()) {
+        const offloadtest::Buffer &B = *R.first->BufferPtr;
+        const D3D12_PLACED_SUBRESOURCE_FOOTPRINT Footprint{
+            0, CD3DX12_SUBRESOURCE_FOOTPRINT(
+                   getDXFormat(B.Format, B.Channels), B.OutputProps.Width,
+                   B.OutputProps.Height, 1,
+                   B.OutputProps.Width * B.getElementSize())};
+        for (const ResourceSet &RS : R.second) {
+          if (RS.Readback == nullptr)
+            continue;
+          addReadbackBeginBarrier(IS, RS.Buffer);
+          const CD3DX12_TEXTURE_COPY_LOCATION DstLoc(RS.Readback.Get(),
+                                                     Footprint);
+          const CD3DX12_TEXTURE_COPY_LOCATION SrcLoc(RS.Buffer.Get(), 0);
+          IS.CmdList->CopyTextureRegion(&DstLoc, 0, 0, 0, &SrcLoc, nullptr);
+          addReadbackEndBarrier(IS, RS.Buffer);
+        }
+        return;
+      }
+      for (const ResourceSet &RS : R.second) {
+        if (RS.Readback == nullptr)
+          continue;
+        addReadbackBeginBarrier(IS, RS.Buffer);
+        IS.CmdList->CopyResource(RS.Readback.Get(), RS.Buffer.Get());
+        addReadbackEndBarrier(IS, RS.Buffer);
+      }
+    };
+
+    for (auto &Table : IS.DescTables)
+      for (auto &R : Table.Resources)
+        CopyBackResource(R);
+
+    for (auto &R : IS.RootResources)
+      CopyBackResource(R);
+
     return llvm::Error::success();
   }