Introduce a new Buffer type with DX,VK,MTL implementations. (#976)

A first small step towards creating a Render Backend API layer on top of
DX12, Vulkan, and Metal.

This introduces a new Buffer type with an implementation for each API as
well as a function on the Device class to create one.

The change is smaller than it looks due to a naming conflict that needed
to be resolved. The type previously called `Buffer` has been renamed to
`CPUBuffer`.

Author: manon-traverse

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

@@ -169,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,
@@ -277,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;
@@ -362,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;
@@ -576,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,
@@ -1234,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,
@@ -1316,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"))
@@ -1358,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,
@@ -1412,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 =
@@ -1549,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(
@@ -1562,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,

lib/API/MTL/MTLDevice.cpp

@@ -83,6 +83,23 @@ class MTLQueue : public offloadtest::Queue {
   }
 };
 
+class MTLBuffer : public offloadtest::Buffer {
+public:
+  MTL::Buffer *Buf;
+  std::string Name;
+  BufferCreateDesc Desc;
+  size_t SizeInBytes;
+
+  MTLBuffer(MTL::Buffer *Buf, llvm::StringRef Name, BufferCreateDesc Desc,
+            size_t SizeInBytes)
+      : Buf(Buf), Name(Name), Desc(Desc), SizeInBytes(SizeInBytes) {}
+
+  ~MTLBuffer() override {
+    if (Buf)
+      Buf->release();
+  }
+};
+
 class MTLDevice : public offloadtest::Device {
   Capabilities Caps;
   MTL::Device *Device;
@@ -424,7 +441,7 @@ class MTLDevice : public offloadtest::Device {
         MTL::RenderPassDescriptor::alloc()->init();
 
     // Setup the render target texture.
-    Buffer *RTarget = P.Bindings.RTargetBufferPtr;
+    CPUBuffer *RTarget = P.Bindings.RTargetBufferPtr;
 
     const MTL::PixelFormat Format =
         getMTLFormat(RTarget->Format, RTarget->Channels);
@@ -510,7 +527,7 @@ class MTLDevice : public offloadtest::Device {
       }
     }
     if (P.isGraphics()) {
-      Buffer *RTarget = P.Bindings.RTargetBufferPtr;
+      CPUBuffer *RTarget = P.Bindings.RTargetBufferPtr;
       const uint64_t Width = RTarget->OutputProps.Width;
       const uint64_t Height = RTarget->OutputProps.Height;
       const size_t ElemSize = RTarget->getElementSize();
@@ -547,6 +564,27 @@ class MTLDevice : 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 {
+    MTL::ResourceOptions StorageMode;
+    switch (Desc.Location) {
+    case MemoryLocation::GpuOnly:
+      StorageMode = MTL::ResourceStorageModePrivate;
+      break;
+    case MemoryLocation::CpuToGpu:
+    case MemoryLocation::GpuToCpu:
+      StorageMode = MTL::ResourceStorageModeManaged;
+      break;
+    }
+
+    MTL::Buffer *Buf = Device->newBuffer(SizeInBytes, StorageMode);
+    if (!Buf)
+      return llvm::createStringError(std::errc::not_enough_memory,
+                                     "Failed to create Metal buffer.");
+    return std::make_shared<MTLBuffer>(Buf, Name, Desc, SizeInBytes);
+  }
+
   llvm::Error executeProgram(Pipeline &P) override {
     InvocationState IS;