Merge branch 'llvm:main' into remove-pWaitDstStageMask

Author: MarijnS95

README.md

@@ -34,12 +34,28 @@ pip3 install pyyaml
 
 On Windows, the [Graphics Tools](https://learn.microsoft.com/en-us/windows/win32/direct3d12/directx-12-programming-environment-set-up#debug-layer) optional feature is additionally required to run the test suite.
 
-# Adding to LLVM Build
+# Building
 
-Add the following to the CMake options:
+The LLVM project provides a CMake cache file,
+[`clang/cmake/caches/HLSL.cmake`](https://github.com/llvm/llvm-project/blob/main/clang/cmake/caches/HLSL.cmake),
+that configures the required projects and targets for HLSL development. You can
+use it with `-C` to set up a build that includes the offload test suite:
 
 ```shell
--DLLVM_EXTERNAL_OFFLOADTEST_SOURCE_DIR=${workspaceRoot}\..\OffloadTest -DLLVM_EXTERNAL_PROJECTS="OffloadTest"
+cmake -G Ninja -Bbuild \
+  -C <path to llvm-project>/clang/cmake/caches/HLSL.cmake \
+  -C <path to OffloadTest>/cmake/caches/OffloadTest.cmake \
+  <path to llvm-project>/llvm
+```
+
+The `OffloadTest.cmake` cache file automatically sets
+`LLVM_EXTERNAL_OFFLOADTEST_SOURCE_DIR` and `LLVM_EXTERNAL_PROJECTS` based on its
+location in the source tree. If you already have an LLVM build configured, you
+can add the offload test suite to it by passing the same `-C` flag or by adding
+the following to your CMake options:
+
+```shell
+-DLLVM_EXTERNAL_OFFLOADTEST_SOURCE_DIR=<path to OffloadTest> -DLLVM_EXTERNAL_PROJECTS="OffloadTest"
 ```
 
 If you do not have a build of dxc on your path you'll need to specify the shader
@@ -49,6 +65,20 @@ compiler to use by passing:
 -DDXC_DIR=<path to folder containing dxc & dxv>
 ```
 
+## Running Tests
+
+```shell
+cmake --build build --target check-hlsl
+```
+
+The `check-hlsl` target builds all required tools and runs the full test suite.
+You can also run tests for a specific platform with `check-hlsl-<platform>`
+(e.g. `check-hlsl-vk`, `check-hlsl-d3d12`). To only run `clang`-based tests
+(without requiring DXC), use `check-hlsl-clang-<platform>` (e.g.
+`check-hlsl-clang-mtl`). Subdirectories of the test suite are also available as
+targets with `check-hlsl-<platform>-<path>` where the path is lowercased with
+directory separators replaced by `-` (e.g. `check-hlsl-d3d12-feature-hlsllib`).
+
 ## Enabling clang-tidy
 
 The offload test suite's code is clang-tidy clean for a limited ruleset.

cmake/caches/OffloadTest.cmake

@@ -0,0 +1,2 @@
+set(LLVM_EXTERNAL_OFFLOADTEST_SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../../ CACHE STRING "")
+set(LLVM_EXTERNAL_PROJECTS "${LLVM_EXTERNAL_PROJECTS};OffloadTest" CACHE STRING "")

include/API/Device.h

@@ -35,6 +35,27 @@ struct DeviceConfig {
   bool EnableValidationLayer = false;
 };
 
+enum class MemoryLocation {
+  GpuOnly,
+  CpuToGpu,
+  GpuToCpu,
+};
+
+struct BufferCreateDesc {
+  MemoryLocation Location;
+};
+
+class Buffer {
+public:
+  virtual ~Buffer() = default;
+
+  Buffer(const Buffer &) = delete;
+  Buffer &operator=(const Buffer &) = delete;
+
+protected:
+  Buffer() = default;
+};
+
 class Queue {
 public:
   virtual ~Queue() = 0;
@@ -56,6 +77,9 @@ class Device {
 
   virtual Queue &getGraphicsQueue() = 0;
 
+  virtual llvm::Expected<std::shared_ptr<Buffer>>
+  createBuffer(std::string Name, BufferCreateDesc &Desc,
+               size_t SizeInBytes) = 0;
   virtual void printExtra(llvm::raw_ostream &OS) {}
 
   virtual ~Device() = 0;

include/Image/Image.h

@@ -85,7 +85,7 @@ class ImageRef {
     assert(Data.size() == size() && "Data size does not match properties");
   }
 
-  ImageRef(const Buffer &B)
+  ImageRef(const CPUBuffer &B)
       : ImageRef(B.OutputProps.Height, B.OutputProps.Width,
                  B.getSingleElementSize(), B.Channels,
                  B.Format == DataFormat::Float32 ||

include/Support/Pipeline.h

@@ -130,7 +130,7 @@ static inline uint32_t getFormatSize(DataFormat Format) {
   llvm_unreachable("All cases covered.");
 }
 
-struct Buffer {
+struct CPUBuffer {
   std::string Name;
   DataFormat Format;
   int Channels;
@@ -161,8 +161,8 @@ struct Result {
   Rule ComparisonRule;
   std::string Actual;
   std::string Expected;
-  Buffer *ActualPtr = nullptr;
-  Buffer *ExpectedPtr = nullptr;
+  CPUBuffer *ActualPtr = nullptr;
+  CPUBuffer *ExpectedPtr = nullptr;
   DenormMode DM = DenormMode::Any;
   unsigned ULPT; // ULP Tolerance
   double Epsilon;
@@ -173,7 +173,7 @@ struct Resource {
   std::string Name;
   DirectXBinding DXBinding;
   std::optional<VulkanBinding> VKBinding;
-  Buffer *BufferPtr = nullptr;
+  CPUBuffer *BufferPtr = nullptr;
   Sampler *SamplerPtr = nullptr;
   bool HasCounter;
   std::optional<uint32_t> TilesMapped;
@@ -306,7 +306,7 @@ enum class RootParamKind {
 struct RootResource : public Resource {};
 
 struct RootConstant {
-  Buffer *BufferPtr;
+  CPUBuffer *BufferPtr;
   std::string Name;
 };
 
@@ -335,11 +335,11 @@ struct VertexAttribute {
 
 struct IOBindings {
   std::string VertexBuffer;
-  Buffer *VertexBufferPtr;
+  CPUBuffer *VertexBufferPtr;
   llvm::SmallVector<VertexAttribute> VertexAttributes;
 
   std::string RenderTarget;
-  Buffer *RTargetBufferPtr;
+  CPUBuffer *RTargetBufferPtr;
 
   uint32_t getVertexStride() const {
     uint32_t Stride = 0;
@@ -402,7 +402,7 @@ struct Pipeline {
 
   IOBindings Bindings;
   llvm::SmallVector<PushConstantBlock> PushConstants;
-  llvm::SmallVector<Buffer> Buffers;
+  llvm::SmallVector<CPUBuffer> Buffers;
   llvm::SmallVector<Sampler> Samplers;
   llvm::SmallVector<Result> Results;
   llvm::SmallVector<DescriptorSet> Sets;
@@ -422,7 +422,7 @@ struct Pipeline {
     return DescriptorCount;
   }
 
-  Buffer *getBuffer(llvm::StringRef Name) {
+  CPUBuffer *getBuffer(llvm::StringRef Name) {
     for (auto &B : Buffers)
       if (Name == B.Name)
         return &B;
@@ -446,7 +446,7 @@ struct Pipeline {
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::DescriptorSet)
 LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::Resource)
-LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::Buffer)
+LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::CPUBuffer)
 LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::Sampler)
 LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::Shader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::dx::RootParameter)
@@ -467,8 +467,8 @@ template <> struct MappingTraits<offloadtest::DescriptorSet> {
   static void mapping(IO &I, offloadtest::DescriptorSet &D);
 };
 
-template <> struct MappingTraits<offloadtest::Buffer> {
-  static void mapping(IO &I, offloadtest::Buffer &R);
+template <> struct MappingTraits<offloadtest::CPUBuffer> {
+  static void mapping(IO &I, offloadtest::CPUBuffer &R);
 };
 
 template <> struct MappingTraits<offloadtest::Sampler> {

lib/API/DX/Device.cpp

@@ -67,6 +67,13 @@ static DXGI_FORMAT getDXFormat(DataFormat Format, int Channels) {
     DXFormats(SINT) break;
   case DataFormat::Float32:
     DXFormats(FLOAT) break;
+  case DataFormat::UInt64:
+  case DataFormat::Int64:
+    if (Channels == 1)
+      return DXGI_FORMAT_R32G32_UINT;
+    if (Channels == 2)
+      return DXGI_FORMAT_R32G32B32A32_UINT;
+    llvm_unreachable("Unsupported channel count for 64-bit format");
   case DataFormat::Depth32:
     llvm_unreachable(
         "Depth32 format is not yet supported in the DirectX backend.");
@@ -162,7 +169,7 @@ static DXResourceKind getDXKind(offloadtest::ResourceKind RK) {
 static llvm::Expected<D3D12_RESOURCE_DESC>
 getResourceDescription(const Resource &R) {
   const D3D12_RESOURCE_DIMENSION Dimension = getDXDimension(R.Kind);
-  const offloadtest::Buffer &B = *R.BufferPtr;
+  const offloadtest::CPUBuffer &B = *R.BufferPtr;
 
   if (B.OutputProps.MipLevels != 1)
     return llvm::createStringError(std::errc::not_supported,
@@ -270,6 +277,18 @@ static D3D12_UNORDERED_ACCESS_VIEW_DESC getUAVDescription(const Resource &R) {
 
 namespace {
 
+class DXBuffer : public offloadtest::Buffer {
+public:
+  ComPtr<ID3D12Resource> Buffer;
+  std::string Name;
+  BufferCreateDesc Desc;
+  size_t SizeInBytes;
+
+  DXBuffer(ComPtr<ID3D12Resource> Buffer, llvm::StringRef Name,
+           BufferCreateDesc Desc, size_t SizeInBytes)
+      : Buffer(Buffer), Name(Name), Desc(Desc), SizeInBytes(SizeInBytes) {}
+};
+
 class DXQueue : public offloadtest::Queue {
 public:
   ComPtr<ID3D12CommandQueue> Queue;
@@ -355,6 +374,41 @@ class DXDevice : public offloadtest::Device {
 
   Queue &getGraphicsQueue() override { return GraphicsQueue; }
 
+  llvm::Expected<std::shared_ptr<offloadtest::Buffer>>
+  createBuffer(std::string Name, BufferCreateDesc &Desc,
+               size_t SizeInBytes) override {
+
+    D3D12_HEAP_TYPE HeapType = D3D12_HEAP_TYPE_DEFAULT;
+    switch (Desc.Location) {
+    case MemoryLocation::GpuOnly:
+      HeapType = D3D12_HEAP_TYPE_DEFAULT;
+      break;
+    case MemoryLocation::CpuToGpu:
+      HeapType = D3D12_HEAP_TYPE_UPLOAD;
+      break;
+    case MemoryLocation::GpuToCpu:
+      HeapType = D3D12_HEAP_TYPE_READBACK;
+      break;
+    }
+
+    const D3D12_RESOURCE_FLAGS Flags =
+        D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+
+    const D3D12_HEAP_PROPERTIES HeapProps = CD3DX12_HEAP_PROPERTIES(HeapType);
+    const D3D12_RESOURCE_DESC BufferDesc =
+        CD3DX12_RESOURCE_DESC::Buffer(SizeInBytes, Flags);
+
+    ComPtr<ID3D12Resource> DeviceBuffer;
+    if (auto Err = HR::toError(Device->CreateCommittedResource(
+                                   &HeapProps, D3D12_HEAP_FLAG_NONE,
+                                   &BufferDesc, D3D12_RESOURCE_STATE_COMMON,
+                                   nullptr, IID_PPV_ARGS(&DeviceBuffer)),
+                               "Failed to create buffer."))
+      return Err;
+
+    return std::make_shared<DXBuffer>(DeviceBuffer, Name, Desc, SizeInBytes);
+  }
+
   static llvm::Expected<DXDevice> create(ComPtr<IDXCoreAdapter> Adapter,
                                          const DeviceConfig &Config) {
     ComPtr<ID3D12Device> Device;
@@ -569,7 +623,7 @@ class DXDevice : public offloadtest::Device {
                                  ComPtr<ID3D12Resource> Source) {
     addUploadBeginBarrier(IS, Destination);
     if (R.isTexture()) {
-      const offloadtest::Buffer &B = *R.BufferPtr;
+      const offloadtest::CPUBuffer &B = *R.BufferPtr;
       const D3D12_PLACED_SUBRESOURCE_FOOTPRINT Footprint{
           0, CD3DX12_SUBRESOURCE_FOOTPRINT(
                  getDXFormat(B.Format, B.Channels), B.OutputProps.Width,
@@ -1227,7 +1281,7 @@ class DXDevice : public offloadtest::Device {
 
     auto CopyBackResource = [&IS, this](ResourcePair &R) {
       if (R.first->isTexture()) {
-        const offloadtest::Buffer &B = *R.first->BufferPtr;
+        const offloadtest::CPUBuffer &B = *R.first->BufferPtr;
         const D3D12_PLACED_SUBRESOURCE_FOOTPRINT Footprint{
             0, CD3DX12_SUBRESOURCE_FOOTPRINT(
                    getDXFormat(B.Format, B.Channels), B.OutputProps.Width,
@@ -1309,7 +1363,7 @@ class DXDevice : public offloadtest::Device {
     // Map readback and copy into host buffer, accounting for row pitch and
     // flipping vertical orientation. DirectX render target origin is top-left,
     // while our image writer expects bottom-left.
-    const Buffer &B = *P.Bindings.RTargetBufferPtr;
+    const CPUBuffer &B = *P.Bindings.RTargetBufferPtr;
     void *Mapped = nullptr;
     if (auto Err = HR::toError(IS.RTReadback->Map(0, nullptr, &Mapped),
                                "Failed to map render target readback"))
@@ -1351,7 +1405,7 @@ class DXDevice : public offloadtest::Device {
       return llvm::createStringError(
           std::errc::invalid_argument,
           "No render target bound for graphics pipeline.");
-    const Buffer &OutBuf = *P.Bindings.RTargetBufferPtr;
+    const CPUBuffer &OutBuf = *P.Bindings.RTargetBufferPtr;
     if (OutBuf.OutputProps.MipLevels != 1)
       return llvm::createStringError(
           std::errc::not_supported,
@@ -1405,7 +1459,7 @@ class DXDevice : public offloadtest::Device {
       return llvm::createStringError(
           std::errc::invalid_argument,
           "No vertex buffer bound for graphics pipeline.");
-    const Buffer &VB = *P.Bindings.VertexBufferPtr;
+    const CPUBuffer &VB = *P.Bindings.VertexBufferPtr;
     const uint64_t VBSize = VB.size();
     D3D12_RESOURCE_DESC const Desc = CD3DX12_RESOURCE_DESC::Buffer(VBSize);
     CD3DX12_HEAP_PROPERTIES HeapProps =
@@ -1542,7 +1596,7 @@ class DXDevice : public offloadtest::Device {
         D3D12_RESOURCE_STATE_COPY_SOURCE);
     IS.CmdList->ResourceBarrier(1, &Barrier);
 
-    const Buffer &B = *P.Bindings.RTargetBufferPtr;
+    const CPUBuffer &B = *P.Bindings.RTargetBufferPtr;
     const D3D12_PLACED_SUBRESOURCE_FOOTPRINT Footprint{
         0,
         CD3DX12_SUBRESOURCE_FOOTPRINT(
@@ -1555,7 +1609,7 @@ class DXDevice : public offloadtest::Device {
 
     auto CopyBackResource = [&IS, this](ResourcePair &R) {
       if (R.first->isTexture()) {
-        const offloadtest::Buffer &B = *R.first->BufferPtr;
+        const offloadtest::CPUBuffer &B = *R.first->BufferPtr;
         const D3D12_PLACED_SUBRESOURCE_FOOTPRINT Footprint{
             0, CD3DX12_SUBRESOURCE_FOOTPRINT(
                    getDXFormat(B.Format, B.Channels), B.OutputProps.Width,