Add InterlockedOr tests (#1195)

This PR adds tests for the InterlockedOr HLSL function.
It tests all existing overloads of this function, including the
declarations of this function as members of resources.
It also includes a fix to texture element type processing, as there was
not a case to account for uint32 element types.
Fixes #101

Author: bob80905

lib/API/DX/DXFeatures.def

@@ -39,6 +39,7 @@ D3D_FEATURE_ENUM(directx::MeshShaderTier, MeshShaderTier)
 D3D_FEATURE_BOOL(Native16BitShaderOpsSupported)
 D3D_FEATURE_BOOL(Int64ShaderOps)
 D3D_FEATURE_BOOL(AtomicInt64OnGroupSharedSupported)
+D3D_FEATURE_BOOL(AtomicInt64OnTypedResourceSupported)
 D3D_FEATURE_BOOL(DoublePrecisionFloatShaderOps)
 D3D_FEATURE_BOOL(WaveOps)
 #undef D3D_FEATURE_BOOL

lib/API/DX/Device.cpp

@@ -107,6 +107,8 @@ static DXGI_FORMAT getDXFormat(DataFormat Format, int Channels) {
   switch (Format) {
   case DataFormat::Int32:
     DXFormats(SINT) break;
+  case DataFormat::UInt32:
+    DXFormats(UINT) break;
   case DataFormat::Float32:
     DXFormats(FLOAT) break;
   case DataFormat::UInt64:

lib/API/VK/Device.cpp

@@ -1252,6 +1252,19 @@ class VulkanDevice : public offloadtest::Device {
     VkPhysicalDeviceVulkan14Features Features14{};
     Features14.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
 #endif
+#ifdef VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME
+    // Opt-in extension features: query and enable
+    // VK_EXT_shader_image_atomic_int64 when the device advertises it so that
+    // tests using 64-bit atomics on RWBuffer / RWTexture (SPIR-V image storage
+    // class) can run.
+    const auto AvailableExts = queryDeviceExtensions(PhysicalDevice);
+    const bool HasShaderImageAtomicInt64Ext = isExtensionSupported(
+        AvailableExts, VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME);
+    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT
+        FeaturesImageAtomicInt64{};
+    FeaturesImageAtomicInt64.sType =
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+#endif
 
     Features.pNext = &Features11;
     if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 2, 0))
@@ -1261,6 +1274,24 @@ class VulkanDevice : public offloadtest::Device {
 #ifdef VK_VERSION_1_4
     if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 4, 0))
       Features13.pNext = &Features14;
+#endif
+#ifdef VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME
+    // Attach the extension features struct to the tail of the version-gated
+    // chain so vkGetPhysicalDeviceFeatures2 populates it and vkCreateDevice
+    // sees it enabled.
+    if (HasShaderImageAtomicInt64Ext) {
+#ifdef VK_VERSION_1_4
+      if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 4, 0))
+        Features14.pNext = &FeaturesImageAtomicInt64;
+      else
+#endif
+          if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 3, 0))
+        Features13.pNext = &FeaturesImageAtomicInt64;
+      else if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 2, 0))
+        Features12.pNext = &FeaturesImageAtomicInt64;
+      else
+        Features11.pNext = &FeaturesImageAtomicInt64;
+    }
 #endif
     vkGetPhysicalDeviceFeatures2(PhysicalDevice, &Features);
 
@@ -1290,6 +1321,16 @@ class VulkanDevice : public offloadtest::Device {
     DeviceInfo.pEnabledFeatures = &Features.features;
     DeviceInfo.pNext = Features.pNext;
 
+#ifdef VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME
+    llvm::SmallVector<const char *, 1> EnabledDeviceExtensions;
+    if (HasShaderImageAtomicInt64Ext &&
+        FeaturesImageAtomicInt64.shaderImageInt64Atomics)
+      EnabledDeviceExtensions.push_back(
+          VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME);
+    DeviceInfo.enabledExtensionCount = EnabledDeviceExtensions.size();
+    DeviceInfo.ppEnabledExtensionNames = EnabledDeviceExtensions.data();
+#endif
+
     VkDevice Device = VK_NULL_HANDLE;
     if (auto Err = VK::toError(
             vkCreateDevice(PhysicalDevice, &DeviceInfo, nullptr, &Device),
@@ -2197,6 +2238,14 @@ class VulkanDevice : public offloadtest::Device {
     VkPhysicalDeviceVulkan14Features Features14{};
     Features14.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
 #endif
+#ifdef VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME
+    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT
+        FeaturesImageAtomicInt64{};
+    FeaturesImageAtomicInt64.sType =
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+    const bool HasShaderImageAtomicInt64Ext = isExtensionSupported(
+        DeviceExtensions, VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME);
+#endif
 
     Features.pNext = &Features11;
     if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 2, 0))
@@ -2206,6 +2255,27 @@ class VulkanDevice : public offloadtest::Device {
 #ifdef VK_VERSION_1_4
     if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 4, 0))
       Features13.pNext = &Features14;
+#endif
+#ifdef VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME
+    // Append the VK_EXT_shader_image_atomic_int64 features struct to the
+    // pNext chain, but only if the device advertises the extension --
+    // otherwise drivers may reject the unknown sType. The chain above is
+    // built version-by-version (11 -> 12 -> 13 -> 14), so the correct
+    // attachment point is whichever Features1X struct is currently the
+    // tail for this device's apiVersion.
+    if (HasShaderImageAtomicInt64Ext) {
+#ifdef VK_VERSION_1_4
+      if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 4, 0))
+        Features14.pNext = &FeaturesImageAtomicInt64;
+      else
+#endif
+          if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 3, 0))
+        Features13.pNext = &FeaturesImageAtomicInt64;
+      else if (Props.apiVersion >= VK_MAKE_API_VERSION(0, 1, 2, 0))
+        Features12.pNext = &FeaturesImageAtomicInt64;
+      else
+        Features11.pNext = &FeaturesImageAtomicInt64;
+    }
 #endif
     vkGetPhysicalDeviceFeatures2(PhysicalDevice, &Features);
 
@@ -2239,6 +2309,12 @@ class VulkanDevice : public offloadtest::Device {
   Caps.insert(                                                                 \
       std::make_pair(#Name, makeCapability<bool>(#Name, Features14.Name)));
 #endif
+#ifdef VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME
+#define VULKAN_EXT_SHADER_IMAGE_ATOMIC_INT64_FEATURE_BOOL(Name)                \
+  Caps.insert(std::make_pair(                                                  \
+      #Name, makeCapability<bool>(#Name, HasShaderImageAtomicInt64Ext &&       \
+                                             FeaturesImageAtomicInt64.Name)));
+#endif
 #include "VKFeatures.def"
   }
 

lib/API/VK/VKFeatures.def

@@ -187,3 +187,8 @@ VULKAN14_FEATURE_BOOL(hostImageCopy)
 VULKAN14_FEATURE_BOOL(pushDescriptor)
 #undef VULKAN14_FEATURE_BOOL
 #endif
+
+#ifdef VULKAN_EXT_SHADER_IMAGE_ATOMIC_INT64_FEATURE_BOOL
+VULKAN_EXT_SHADER_IMAGE_ATOMIC_INT64_FEATURE_BOOL(shaderImageInt64Atomics)
+#undef VULKAN_EXT_SHADER_IMAGE_ATOMIC_INT64_FEATURE_BOOL
+#endif

test/Feature/HLSLLib/InterlockedAdd.int64.test

@@ -152,7 +152,7 @@ DescriptorSets:
 ...
 #--- end
 
-# REQUIRES: Int64 && Int64GroupSharedAtomics
+# REQUIRES: Int64 && Int64GroupSharedAtomics && SM_6_6
 
 # Unimplemented: https://github.com/llvm/llvm-project/issues/99122
 # XFAIL: Clang

test/Feature/HLSLLib/InterlockedOr.32.test

@@ -0,0 +1,130 @@
+#--- source.hlsl
+
+// This test exercises InterlockedOr against non-resource (groupshared)
+// destinations. A single threadgroup of 32 threads concurrently updates
+// shared counters, so the test actually exercises atomic behavior.
+//
+// Both the 2-argument and 3-argument overloads are covered for int and uint.
+//
+// Atomicity is verified by starting a counter at 0 and having each of 32
+// threads atomically set its own unique bit (OR with (1 << tid)). If any
+// read-modify-write were non-atomic, some thread's bit set would be lost
+// and the final value would not be all-ones. With true atomicity, the
+// counter must end at exactly 0xFFFFFFFF.
+//
+// For the 3-argument form we additionally verify, per-thread, that the
+// returned "original value" had this thread's bit clear when the OR was
+// performed -- this must always be true under atomic semantics, since no
+// other thread ever sets that bit.
+
+RWStructuredBuffer<uint> OutOrigBitClear : register(u0);
+RWStructuredBuffer<uint> OutFinal : register(u1);
+
+groupshared uint CounterU;          // 3-arg form, unsigned: bit-set test
+groupshared uint CounterUNoOrig;    // 2-arg form, unsigned: bit-set test
+groupshared int  CounterI;          // 3-arg form, signed: bit-set test on 0
+groupshared uint MaskedU;           // deterministic mask test (all threads
+                                    // OR with the same constant)
+
+groupshared uint OrigBitClear[32];  // per-thread: was my bit clear in the
+                                    // original value I observed?
+
+[numthreads(32, 1, 1)]
+void main(uint3 GTID : SV_GroupThreadID) {
+  if (GTID.x == 0) {
+    CounterU = 0u;
+    CounterUNoOrig = 0u;
+    CounterI = 0;
+    MaskedU = 0xAAAAAAAAu;
+  }
+  OrigBitClear[GTID.x] = 0;
+  GroupMemoryBarrierWithGroupSync();
+
+  uint ThreadBit = 1u << GTID.x;
+
+  // 3-argument form: capture original, then check our bit was clear in it.
+  uint OrigU;
+  InterlockedOr(CounterU, ThreadBit, OrigU);
+  OrigBitClear[GTID.x] = ((OrigU & ThreadBit) == 0u) ? 1u : 0u;
+
+  // 3-argument form, signed.
+  int OrigI;
+  InterlockedOr(CounterI, (int)ThreadBit, OrigI);
+
+  // 2-argument form: no original captured.
+  InterlockedOr(CounterUNoOrig, ThreadBit);
+
+  // 2-argument form: every thread ORs with the same constant. Result
+  // is deterministic regardless of ordering: 0xAAAAAAAA | 0x0F0F0F0F.
+  InterlockedOr(MaskedU, 0x0F0F0F0Fu);
+
+  GroupMemoryBarrierWithGroupSync();
+
+  OutOrigBitClear[GTID.x] = OrigBitClear[GTID.x];
+
+  if (GTID.x == 0) {
+    OutFinal[0] = CounterU;          // 0xFFFFFFFF
+    OutFinal[1] = (uint)CounterI;    // 0xFFFFFFFF
+    OutFinal[2] = CounterUNoOrig;    // 0xFFFFFFFF
+    OutFinal[3] = MaskedU;           // 0xAAAAAAAA | 0x0F0F0F0F = 0xAFAFAFAF
+  }
+}
+
+//--- pipeline.yaml
+
+---
+Shaders:
+  - Stage: Compute
+    Entry: main
+Buffers:
+  - Name: OutOrigBitClear
+    Format: UInt32
+    Stride: 4
+    FillSize: 128
+  - Name: ExpectedOrigBitClear
+    Format: UInt32
+    Stride: 4
+    Data: [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
+  - Name: OutFinal
+    Format: UInt32
+    Stride: 4
+    FillSize: 16
+  - Name: ExpectedFinal
+    Format: UInt32
+    Stride: 4
+    Data: [ 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xAFAFAFAF ]
+Results:
+  - Result: TestOrigBitClear
+    Rule: BufferExact
+    Actual: OutOrigBitClear
+    Expected: ExpectedOrigBitClear
+  - Result: TestFinal
+    Rule: BufferExact
+    Actual: OutFinal
+    Expected: ExpectedFinal
+DescriptorSets:
+  - Resources:
+    - Name: OutOrigBitClear
+      Kind: RWStructuredBuffer
+      DirectXBinding:
+        Register: 0
+        Space: 0
+      VulkanBinding:
+        Binding: 0
+    - Name: OutFinal
+      Kind: RWStructuredBuffer
+      DirectXBinding:
+        Register: 1
+        Space: 0
+      VulkanBinding:
+        Binding: 1
+...
+#--- end
+
+# Unimplemented: https://github.com/llvm/llvm-project/issues/99126
+# XFAIL: Clang
+
+# RUN: split-file %s %t
+# RUN: %dxc_target -T cs_6_5 -Fo %t.o %t/source.hlsl
+# RUN: %offloader %t/pipeline.yaml %t.o