Add texture creation to all backends

Author: EmilioLaiso

include/API/Device.h

@@ -17,6 +17,7 @@
 #include "API/API.h"
 #include "API/Buffer.h"
 #include "API/Capabilities.h"
+#include "API/Texture.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 
@@ -60,6 +61,10 @@ class Device {
   virtual llvm::Expected<std::shared_ptr<Buffer>>
   createBuffer(std::string Name, BufferCreateDesc &Desc,
                size_t SizeInBytes) = 0;
+
+  virtual llvm::Expected<std::shared_ptr<Texture>>
+  createTexture(llvm::StringRef Name, TextureCreateDesc &Desc) = 0;
+
   virtual void printExtra(llvm::raw_ostream &OS) {}
 
   virtual ~Device() = 0;

include/API/Texture.h

@@ -24,8 +24,9 @@ namespace offloadtest {
 
 // TODO: Add Unorm types (e.g. R8Unorm, RGBA8Unorm) which can be sampled as
 // floats.
-//
 // TODO: Add SRGB types (e.g. RGBA8Srgb) once needed.
+//
+// Note: No 3-channel formats due to lack of Metal support.
 enum class TextureFormat {
   R16Sint,
   R16Uint,
@@ -39,9 +40,6 @@ enum class TextureFormat {
   RG32Sint,
   RG32Uint,
   RG32Float,
-  RGB32Sint,
-  RGB32Uint,
-  RGB32Float,
   RGBA32Sint,
   RGBA32Uint,
   RGBA32Float,
@@ -82,12 +80,6 @@ inline llvm::StringRef getTextureFormatName(TextureFormat Format) {
     return "RG32Uint";
   case TextureFormat::RG32Float:
     return "RG32Float";
-  case TextureFormat::RGB32Sint:
-    return "RGB32Sint";
-  case TextureFormat::RGB32Uint:
-    return "RGB32Uint";
-  case TextureFormat::RGB32Float:
-    return "RGB32Float";
   case TextureFormat::RGBA32Sint:
     return "RGBA32Sint";
   case TextureFormat::RGBA32Uint:

lib/API/DX/DXResources.h

@@ -0,0 +1,85 @@
+//===- DXResources.h - DirectX Resource Helpers ---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OFFLOADTEST_API_DXRESOURCES_H
+#define OFFLOADTEST_API_DXRESOURCES_H
+
+#include "API/Device.h"
+
+#include <d3d12.h>
+#include <dxgiformat.h>
+
+namespace offloadtest {
+
+inline D3D12_HEAP_TYPE getDXHeapType(MemoryLocation Location) {
+  switch (Location) {
+  case MemoryLocation::GpuOnly:
+    return D3D12_HEAP_TYPE_DEFAULT;
+  case MemoryLocation::CpuToGpu:
+    return D3D12_HEAP_TYPE_UPLOAD;
+  case MemoryLocation::GpuToCpu:
+    return D3D12_HEAP_TYPE_READBACK;
+  }
+  llvm_unreachable("All MemoryLocation cases handled");
+}
+
+inline DXGI_FORMAT getDXGIFormat(TextureFormat Format) {
+  switch (Format) {
+  case TextureFormat::R16Sint:
+    return DXGI_FORMAT_R16_SINT;
+  case TextureFormat::R16Uint:
+    return DXGI_FORMAT_R16_UINT;
+  case TextureFormat::RG16Sint:
+    return DXGI_FORMAT_R16G16_SINT;
+  case TextureFormat::RG16Uint:
+    return DXGI_FORMAT_R16G16_UINT;
+  case TextureFormat::RGBA16Sint:
+    return DXGI_FORMAT_R16G16B16A16_SINT;
+  case TextureFormat::RGBA16Uint:
+    return DXGI_FORMAT_R16G16B16A16_UINT;
+  case TextureFormat::R32Sint:
+    return DXGI_FORMAT_R32_SINT;
+  case TextureFormat::R32Uint:
+    return DXGI_FORMAT_R32_UINT;
+  case TextureFormat::R32Float:
+    return DXGI_FORMAT_R32_FLOAT;
+  case TextureFormat::RG32Sint:
+    return DXGI_FORMAT_R32G32_SINT;
+  case TextureFormat::RG32Uint:
+    return DXGI_FORMAT_R32G32_UINT;
+  case TextureFormat::RG32Float:
+    return DXGI_FORMAT_R32G32_FLOAT;
+  case TextureFormat::RGBA32Sint:
+    return DXGI_FORMAT_R32G32B32A32_SINT;
+  case TextureFormat::RGBA32Uint:
+    return DXGI_FORMAT_R32G32B32A32_UINT;
+  case TextureFormat::RGBA32Float:
+    return DXGI_FORMAT_R32G32B32A32_FLOAT;
+  case TextureFormat::D32Float:
+    return DXGI_FORMAT_D32_FLOAT;
+  }
+  llvm_unreachable("All TextureFormat cases handled");
+}
+
+inline D3D12_RESOURCE_FLAGS getDXResourceFlags(TextureUsage Usage) {
+  D3D12_RESOURCE_FLAGS Flags = D3D12_RESOURCE_FLAG_NONE;
+  if ((Usage & TextureUsage::Storage) != 0)
+    Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+  if ((Usage & TextureUsage::RenderTarget) != 0)
+    Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+  if ((Usage & TextureUsage::DepthStencil) != 0)
+    Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+  return Flags;
+}
+
+} // namespace offloadtest
+
+#endif // OFFLOADTEST_API_DXRESOURCES_H

lib/API/DX/Device.cpp

@@ -37,6 +37,8 @@
 #include "Support/Pipeline.h"
 #include "Support/WinError.h"
 
+#include "DXResources.h"
+
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Object/DXContainer.h"
 #include "llvm/Support/Error.h"
@@ -282,6 +284,17 @@ class DXBuffer : public offloadtest::Buffer {
       : Buffer(Buffer), Name(Name), Desc(Desc), SizeInBytes(SizeInBytes) {}
 };
 
+class DXTexture : public offloadtest::Texture {
+public:
+  ComPtr<ID3D12Resource> Resource;
+  std::string Name;
+  TextureCreateDesc Desc;
+
+  DXTexture(ComPtr<ID3D12Resource> Resource, llvm::StringRef Name,
+            TextureCreateDesc Desc)
+      : Resource(Resource), Name(Name), Desc(Desc) {}
+};
+
 class DXQueue : public offloadtest::Queue {
 public:
   ComPtr<ID3D12CommandQueue> Queue;
@@ -370,19 +383,7 @@ class DXDevice : public offloadtest::Device {
   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_HEAP_TYPE HeapType = getDXHeapType(Desc.Location);
 
     const D3D12_RESOURCE_FLAGS Flags =
         D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
@@ -402,6 +403,40 @@ class DXDevice : public offloadtest::Device {
     return std::make_shared<DXBuffer>(DeviceBuffer, Name, Desc, SizeInBytes);
   }
 
+  llvm::Expected<std::shared_ptr<offloadtest::Texture>>
+  createTexture(llvm::StringRef Name, TextureCreateDesc &Desc) override {
+    if (!isValidTextureUsageAndFormat(Desc.Usage, Desc.Format))
+      return llvm::createStringError(
+          std::errc::invalid_argument,
+          "Invalid texture usage/format combination: usage '%s' is not "
+          "compatible with format '%s'.",
+          getTextureUsageName(Desc.Usage).c_str(),
+          getTextureFormatName(Desc.Format).data());
+
+    const D3D12_HEAP_PROPERTIES HeapProps =
+        CD3DX12_HEAP_PROPERTIES(getDXHeapType(Desc.Location));
+
+    D3D12_RESOURCE_DESC TexDesc = {};
+    TexDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+    TexDesc.Width = Desc.Width, TexDesc.Height = Desc.Height,
+    TexDesc.DepthOrArraySize = 1;
+    TexDesc.MipLevels = static_cast<UINT16>(Desc.MipLevels);
+    TexDesc.Format = getDXGIFormat(Desc.Format);
+    TexDesc.SampleDesc.Count = 1;
+    TexDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+    TexDesc.Flags = getDXResourceFlags(Desc.Usage);
+
+    ComPtr<ID3D12Resource> DeviceTexture;
+    if (auto Err = HR::toError(Device->CreateCommittedResource(
+                                   &HeapProps, D3D12_HEAP_FLAG_NONE, &TexDesc,
+                                   D3D12_RESOURCE_STATE_COMMON, nullptr,
+                                   IID_PPV_ARGS(&DeviceTexture)),
+                               "Failed to create texture."))
+      return Err;
+
+    return std::make_shared<DXTexture>(DeviceTexture, Name, Desc);
+  }
+
   static llvm::Expected<DXDevice> create(ComPtr<IDXCoreAdapter> Adapter,
                                          const DeviceConfig &Config) {
     ComPtr<ID3D12Device> Device;

lib/API/MTL/MTLDevice.cpp

@@ -10,6 +10,7 @@
 #include "metal_irconverter_runtime.h"
 
 #include "API/Device.h"
+#include "MTLResources.h"
 #include "Support/Pipeline.h"
 
 #include "llvm/ADT/SmallString.h"
@@ -100,6 +101,21 @@ class MTLBuffer : public offloadtest::Buffer {
   }
 };
 
+class MTLTexture : public offloadtest::Texture {
+public:
+  MTL::Texture *Tex;
+  std::string Name;
+  TextureCreateDesc Desc;
+
+  MTLTexture(MTL::Texture *Tex, llvm::StringRef Name, TextureCreateDesc Desc)
+      : Tex(Tex), Name(Name), Desc(Desc) {}
+
+  ~MTLTexture() override {
+    if (Tex)
+      Tex->release();
+  }
+};
+
 class MTLDevice : public offloadtest::Device {
   Capabilities Caps;
   MTL::Device *Device;
@@ -567,24 +583,39 @@ class MTLDevice : public offloadtest::Device {
   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);
+    MTL::Buffer *Buf =
+        Device->newBuffer(SizeInBytes, getMetalResourceOptions(Desc.Location));
     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::Expected<std::shared_ptr<offloadtest::Texture>>
+  createTexture(llvm::StringRef Name, TextureCreateDesc &Desc) override {
+    if (!isValidTextureUsageAndFormat(Desc.Usage, Desc.Format))
+      return llvm::createStringError(
+          std::errc::invalid_argument,
+          "Invalid texture usage/format combination: usage '%s' is not "
+          "compatible with format '%s'.",
+          getTextureUsageName(Desc.Usage).c_str(),
+          getTextureFormatName(Desc.Format).data());
+
+    MTL::TextureDescriptor *TDesc =
+        MTL::TextureDescriptor::texture2DDescriptor(
+            getMetalFormat(Desc.Format), Desc.Width, Desc.Height,
+            Desc.MipLevels > 1);
+    TDesc->setMipmapLevelCount(Desc.MipLevels);
+    TDesc->setStorageMode(getMetalStorageMode(Desc.Location));
+    TDesc->setUsage(getMetalTextureUsage(Desc.Usage));
+
+    MTL::Texture *Tex = Device->newTexture(TDesc);
+    if (!Tex)
+      return llvm::createStringError(std::errc::not_enough_memory,
+                                     "Failed to create Metal texture.");
+    return std::make_shared<MTLTexture>(Tex, Name, Desc);
+  }
+
   llvm::Error executeProgram(Pipeline &P) override {
     InvocationState IS;