[SPIR-V] Support vk::SampledTexture2D in offload test suite.

include/Support/Pipeline.h

@@ -59,6 +59,7 @@ enum class ResourceKind {
   ConstantBuffer,
   Sampler,
   SamplerComparison,
+  CombinedImageSampler,
 };
 
 enum class FilterMode { Nearest, Linear };
@@ -153,6 +154,14 @@ struct Buffer {
   }
 };
 
+struct CombinedImageSampler {
+  std::string Name;
+  std::string Buffer;
+  std::string Sampler;
+  offloadtest::Buffer *BufferPtr = nullptr;
+  offloadtest::Sampler *SamplerPtr = nullptr;
+};
+
 struct Result {
   std::string Name;
   Rule ComparisonRule;
@@ -172,6 +181,7 @@ struct Resource {
   std::optional<VulkanBinding> VKBinding;
   Buffer *BufferPtr = nullptr;
   Sampler *SamplerPtr = nullptr;
+  CombinedImageSampler *CombinedImageSamplerPtr = nullptr;
   bool HasCounter;
   std::optional<uint32_t> TilesMapped;
   bool IsReserved = false;
@@ -184,6 +194,7 @@ struct Resource {
     case ResourceKind::RWTexture2D:
     case ResourceKind::Sampler:
     case ResourceKind::SamplerComparison:
+    case ResourceKind::CombinedImageSampler:
       return false;
     case ResourceKind::StructuredBuffer:
     case ResourceKind::RWStructuredBuffer:
@@ -199,6 +210,7 @@ struct Resource {
     switch (Kind) {
     case ResourceKind::Sampler:
     case ResourceKind::SamplerComparison:
+    case ResourceKind::CombinedImageSampler:
       return true;
     case ResourceKind::Buffer:
     case ResourceKind::RWBuffer:
@@ -227,6 +239,7 @@ struct Resource {
       return false;
     case ResourceKind::Texture2D:
     case ResourceKind::RWTexture2D:
+    case ResourceKind::CombinedImageSampler:
       return true;
     }
     llvm_unreachable("All cases handled");
@@ -277,6 +290,7 @@ struct Resource {
     case ResourceKind::ConstantBuffer:
     case ResourceKind::Sampler:
     case ResourceKind::SamplerComparison:
+    case ResourceKind::CombinedImageSampler:
       return false;
     case ResourceKind::RWBuffer:
     case ResourceKind::RWStructuredBuffer:
@@ -400,6 +414,7 @@ struct Pipeline {
   llvm::SmallVector<PushConstantBlock> PushConstants;
   llvm::SmallVector<Buffer> Buffers;
   llvm::SmallVector<Sampler> Samplers;
+  llvm::SmallVector<CombinedImageSampler> CombinedImageSamplers;
   llvm::SmallVector<Result> Results;
   llvm::SmallVector<DescriptorSet> Sets;
 
@@ -432,6 +447,13 @@ struct Pipeline {
     return nullptr;
   }
 
+  CombinedImageSampler *getCombinedImageSampler(llvm::StringRef Name) {
+    for (auto &CIS : CombinedImageSamplers)
+      if (Name == CIS.Name)
+        return &CIS;
+    return nullptr;
+  }
+
   bool isGraphics() const { return !isCompute(); }
 
   bool isCompute() const {
@@ -451,6 +473,7 @@ LLVM_YAML_IS_SEQUENCE_VECTOR(offloadtest::VertexAttribute)
 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::CombinedImageSampler)
 
 namespace llvm {
 namespace yaml {
@@ -479,6 +502,10 @@ template <> struct MappingTraits<offloadtest::Resource> {
   static void mapping(IO &I, offloadtest::Resource &R);
 };
 
+template <> struct MappingTraits<offloadtest::CombinedImageSampler> {
+  static void mapping(IO &I, offloadtest::CombinedImageSampler &S);
+};
+
 template <> struct MappingTraits<offloadtest::DirectXBinding> {
   static void mapping(IO &I, offloadtest::DirectXBinding &B);
 };
@@ -622,6 +649,7 @@ template <> struct ScalarEnumerationTraits<offloadtest::ResourceKind> {
     ENUM_CASE(ConstantBuffer);
     ENUM_CASE(Sampler);
     ENUM_CASE(SamplerComparison);
+    ENUM_CASE(CombinedImageSampler);
 #undef ENUM_CASE
   }
 };

lib/API/DX/Device.cpp

@@ -126,6 +126,8 @@ static D3D12_RESOURCE_DIMENSION getDXDimension(ResourceKind RK) {
   case ResourceKind::Sampler:
   case ResourceKind::SamplerComparison:
     return D3D12_RESOURCE_DIMENSION_UNKNOWN;
+  case ResourceKind::CombinedImageSampler:
+    llvm_unreachable("Combined image samplers aren't supported in DirectX!");
   }
   llvm_unreachable("All cases handled");
 }
@@ -152,6 +154,8 @@ static DXResourceKind getDXKind(offloadtest::ResourceKind RK) {
   case ResourceKind::Sampler:
   case ResourceKind::SamplerComparison:
     return SAMPLER;
+  case ResourceKind::CombinedImageSampler:
+    llvm_unreachable("Combined image samplers aren't supported in DirectX!");
   }
   llvm_unreachable("All cases handled");
 }
@@ -216,6 +220,8 @@ static D3D12_SHADER_RESOURCE_VIEW_DESC getSRVDescription(const Resource &R) {
   case ResourceKind::Sampler:
   case ResourceKind::SamplerComparison:
     llvm_unreachable("Not an SRV type!");
+  case ResourceKind::CombinedImageSampler:
+    llvm_unreachable("Combined image samplers aren't supported in DirectX!");
   }
   return Desc;
 }
@@ -254,6 +260,8 @@ static D3D12_UNORDERED_ACCESS_VIEW_DESC getUAVDescription(const Resource &R) {
   case ResourceKind::Sampler:
   case ResourceKind::SamplerComparison:
     llvm_unreachable("Not a UAV type!");
+  case ResourceKind::CombinedImageSampler:
+    llvm_unreachable("Combined image samplers aren't supported in DirectX!");
   }
   return Desc;
 }

lib/API/MTL/MTLDevice.cpp

@@ -292,6 +292,8 @@ class MTLDevice : public offloadtest::Device {
       case ResourceKind::Sampler:
       case ResourceKind::SamplerComparison:
         llvm_unreachable("Not implemented yet.");
+      case ResourceKind::CombinedImageSampler:
+        llvm_unreachable("Combined image samplers aren't supported in Metal.");
       case ResourceKind::StructuredBuffer:
       case ResourceKind::RWStructuredBuffer:
       case ResourceKind::ByteAddressBuffer:

lib/API/VK/Device.cpp

@@ -74,6 +74,8 @@ static VkDescriptorType getDescriptorType(const ResourceKind RK) {
   case ResourceKind::Sampler:
   case ResourceKind::SamplerComparison:
     return VK_DESCRIPTOR_TYPE_SAMPLER;
+  case ResourceKind::CombinedImageSampler:
+    return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
   }
   llvm_unreachable("All cases handled");
 }
@@ -143,6 +145,7 @@ static VkBufferUsageFlagBits getFlagBits(const ResourceKind RK) {
   case ResourceKind::RWTexture2D:
   case ResourceKind::Sampler:
   case ResourceKind::SamplerComparison:
+  case ResourceKind::CombinedImageSampler:
     llvm_unreachable("Textures and samplers don't have buffer usage bits!");
   }
   llvm_unreachable("All cases handled");
@@ -152,6 +155,7 @@ static VkImageViewType getImageViewType(const ResourceKind RK) {
   switch (RK) {
   case ResourceKind::Texture2D:
   case ResourceKind::RWTexture2D:
+  case ResourceKind::CombinedImageSampler:
     return VK_IMAGE_VIEW_TYPE_2D;
   case ResourceKind::Buffer:
   case ResourceKind::RWBuffer:
@@ -304,12 +308,12 @@ class VKDevice : public offloadtest::Device {
 
     bool isImage() const {
       return DescriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ||
-             DescriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+             DescriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE ||
+             DescriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     }
 
     bool isSampler() const {
-      return DescriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
-             DescriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+      return DescriptorType == VK_DESCRIPTOR_TYPE_SAMPLER;
     }
 
     bool isBuffer() const {
@@ -788,6 +792,46 @@ class VKDevice : public offloadtest::Device {
   }
 
   llvm::Error createResource(Resource &R, InvocationState &IS) {
+    if (R.Kind == ResourceKind::CombinedImageSampler) {
+      auto *Buf = R.CombinedImageSamplerPtr->BufferPtr;
+      auto *Samp = R.CombinedImageSamplerPtr->SamplerPtr;
+
+      Resource ReusedRes;
+      ReusedRes.Kind = Samp->ComparisonOp != CompareFunction::Never
+                           ? ResourceKind::SamplerComparison
+                           : ResourceKind::Sampler;
+      ReusedRes.SamplerPtr = Samp;
+
+      BufferRef HostBuf = {0, 0};
+      auto ExSamplerRef = createSampler(IS, ReusedRes, HostBuf);
+      if (!ExSamplerRef)
+        return ExSamplerRef.takeError();
+      VkSampler Sampler = ExSamplerRef->Image.Sampler;
+
+      ReusedRes.Kind = ResourceKind::Texture2D;
+      ReusedRes.BufferPtr = Buf;
+
+      ResourceBundle Bundle{getDescriptorType(R.Kind), Buf->size(), Buf};
+      for (auto &ResData : Buf->Data) {
+        auto ExHostBuf = createBuffer(
+            IS,
+            VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, Buf->size(), ResData.get());
+        if (!ExHostBuf)
+          return ExHostBuf.takeError();
+
+        auto ExImageRef = createImage(IS, ReusedRes, *ExHostBuf);
+        if (!ExImageRef)
+          return ExImageRef.takeError();
+
+        ResourceRef RR = *ExImageRef;
+        RR.Image.Sampler = Sampler;
+        Bundle.ResourceRefs.push_back(RR);
+      }
+      IS.Resources.push_back(Bundle);
+      return llvm::Error::success();
+    }
+
     // Samplers don't have backing data buffers, so handle them separately
     if (R.isSampler()) {
       ResourceBundle Bundle{getDescriptorType(R.Kind), 0, nullptr};
@@ -921,6 +965,7 @@ class VKDevice : public offloadtest::Device {
                               {},
                               P.Bindings.RTargetBufferPtr,
                               nullptr,
+                              nullptr,
                               false,
                               std::nullopt,
                               false};
@@ -955,6 +1000,7 @@ class VKDevice : public offloadtest::Device {
                                      {},
                                      P.Bindings.VertexBufferPtr,
                                      nullptr,
+                                     nullptr,
                                      false,
                                      std::nullopt,
                                      false};
@@ -1181,7 +1227,8 @@ class VKDevice : public offloadtest::Device {
            ++RIdx, ++OverallResIdx) {
         const Resource &R = P.Sets[SetIdx].Resources[RIdx];
         uint32_t IndexOfFirstBufferDataInArray;
-        if (R.isSampler()) {
+        if (R.Kind == ResourceKind::Sampler ||
+            R.Kind == ResourceKind::SamplerComparison) {
           IndexOfFirstBufferDataInArray = ImageInfos.size();
           for (auto &ResRef : IS.Resources[OverallResIdx].ResourceRefs) {
             const VkDescriptorImageInfo ImageInfo = {ResRef.Image.Sampler, 0,
@@ -1192,8 +1239,11 @@ class VKDevice : public offloadtest::Device {
           VkImageViewCreateInfo ViewCreateInfo = {};
           ViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
           ViewCreateInfo.viewType = getImageViewType(R.Kind);
-          ViewCreateInfo.format =
-              getVKFormat(R.BufferPtr->Format, R.BufferPtr->Channels);
+          const auto *Buf = R.Kind == ResourceKind::CombinedImageSampler
+                                ? R.CombinedImageSamplerPtr->BufferPtr
+                                : R.BufferPtr;
+
+          ViewCreateInfo.format = getVKFormat(Buf->Format, Buf->Channels);
           ViewCreateInfo.components = {
               VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G,
               VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A};
@@ -2049,6 +2099,11 @@ class VKDevice : public offloadtest::Device {
           vkFreeMemory(IS.Device, ResRef.Device.Memory, nullptr);
         } else if (R.isSampler()) {
           vkDestroySampler(IS.Device, ResRef.Image.Sampler, nullptr);
+        } else if (R.DescriptorType ==
+                   VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
+          vkDestroySampler(IS.Device, ResRef.Image.Sampler, nullptr);
+          vkDestroyImage(IS.Device, ResRef.Image.Image, nullptr);
+          vkFreeMemory(IS.Device, ResRef.Image.Memory, nullptr);
         } else {
           assert(R.isImage());
           vkDestroyImage(IS.Device, ResRef.Image.Image, nullptr);

lib/Support/Pipeline.cpp

@@ -36,6 +36,14 @@ uint32_t PushConstantBlock::size() const {
 
 namespace llvm {
 namespace yaml {
+
+void MappingTraits<offloadtest::CombinedImageSampler>::mapping(
+    IO &I, offloadtest::CombinedImageSampler &C) {
+  I.mapRequired("Name", C.Name);
+  I.mapRequired("Buffer", C.Buffer);
+  I.mapRequired("Sampler", C.Sampler);
+}
+
 void MappingTraits<offloadtest::Pipeline>::mapping(IO &I,
                                                    offloadtest::Pipeline &P) {
   I.mapRequired("Shaders", P.Shaders);
@@ -44,15 +52,30 @@ void MappingTraits<offloadtest::Pipeline>::mapping(IO &I,
 
   I.mapRequired("Buffers", P.Buffers);
   I.mapOptional("Samplers", P.Samplers);
+  I.mapOptional("CombinedImageSamplers", P.CombinedImageSamplers);
   I.mapOptional("Results", P.Results);
   I.mapRequired("DescriptorSets", P.Sets);
   I.mapOptional("Bindings", P.Bindings);
   I.mapOptional("PushConstants", P.PushConstants);
 
   if (!I.outputting()) {
+    for (auto &CIS : P.CombinedImageSamplers) {
+      CIS.BufferPtr = P.getBuffer(CIS.Buffer);
+      if (!CIS.BufferPtr)
+        I.setError(Twine("Referenced buffer ") + CIS.Buffer + " not found!");
+      CIS.SamplerPtr = P.getSampler(CIS.Sampler);
+      if (!CIS.SamplerPtr)
+        I.setError(Twine("Referenced sampler ") + CIS.Sampler + " not found!");
+    }
+
     for (auto &D : P.Sets) {
       for (auto &R : D.Resources) {
-        if (R.isSampler()) {
+        if (R.Kind == ResourceKind::CombinedImageSampler) {
+          R.CombinedImageSamplerPtr = P.getCombinedImageSampler(R.Name);
+          if (!R.CombinedImageSamplerPtr)
+            I.setError(Twine("Referenced combined image sampler ") + R.Name +
+                       " not found!");
+        } else if (R.isSampler()) {
           R.SamplerPtr = P.getSampler(R.Name);
           if (!R.SamplerPtr)
             I.setError(Twine("Referenced sampler ") + R.Name + " not found!");