add new buffer match rule to work with bittracking

Author: ArberSephirotheca

example_participant_pattern_test.yaml

@@ -0,0 +1,46 @@
+# Example test case using BufferParticipantPattern rule for WaveParticipantBitTracking
+---
+Shaders:
+  - Stage: Compute
+    Entry: main
+    DispatchSize: [8, 1, 1]  # 8 threads
+Buffers:
+  # Actual output from the shader (may have patterns in any order)
+  - Name: ParticipantOutput
+    Format: UInt32
+    ZeroInitSize: 96  # Space for multiple patterns (3 uint32 per pattern)
+  
+  # Expected patterns - order doesn't matter, but pattern counts must match
+  - Name: ExpectedPatterns  
+    Format: UInt32
+    Data: [
+      # Pattern 1: Wave op ID 69, loop iteration 0, participants 0,1,2,3
+      4416, 0x000F, 0x0000,  # (69<<6)|0, mask for threads 0-3, high mask
+      4416, 0x000F, 0x0000,  # Duplicate 1
+      4416, 0x000F, 0x0000,  # Duplicate 2  
+      4416, 0x000F, 0x0000,  # Duplicate 3 (4 participants = 4 copies)
+      
+      # Pattern 2: Wave op ID 70, loop iteration 1, participants 4,5,6,7
+      4496, 0x00F0, 0x0000,  # (70<<6)|(1<<4), mask for threads 4-7, high mask
+      4496, 0x00F0, 0x0000,  # Duplicate 1
+      4496, 0x00F0, 0x0000,  # Duplicate 2
+      4496, 0x00F0, 0x0000,  # Duplicate 3 (4 participants = 4 copies)
+    ]
+
+Results:
+  - Result: ValidateParticipantPatterns
+    Rule: BufferParticipantPattern
+    GroupSize: 3  # Each pattern consists of 3 uint32 values
+    Actual: ParticipantOutput
+    Expected: ExpectedPatterns
+
+DescriptorSets:
+  - Resources:
+    - Name: ParticipantOutput
+      Kind: RWBuffer
+      DirectXBinding:
+        Register: 0
+        Space: 0
+      VulkanBinding:
+        Binding: 0
+...

include/Support/Pipeline.h

@@ -25,7 +25,7 @@ namespace offloadtest {
 
 enum class Stages { Compute };
 
-enum class Rule { BufferExact, BufferFloatULP, BufferFloatEpsilon };
+enum class Rule { BufferExact, BufferFloatULP, BufferFloatEpsilon, BufferParticipantPattern };
 
 enum class DenormMode { Any, FTZ, Preserve };
 
@@ -124,6 +124,7 @@ struct Result {
   DenormMode DM = DenormMode::Any;
   unsigned ULPT; // ULP Tolerance
   double Epsilon;
+  unsigned GroupSize = 0; // For BufferParticipantPattern rule
 };
 
 struct Resource {
@@ -319,6 +320,7 @@ template <> struct ScalarEnumerationTraits<offloadtest::Rule> {
     ENUM_CASE(BufferExact);
     ENUM_CASE(BufferFloatULP);
     ENUM_CASE(BufferFloatEpsilon);
+    ENUM_CASE(BufferParticipantPattern);
 #undef ENUM_CASE
   }
 };

lib/Support/Check.cpp

@@ -15,6 +15,8 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cmath>
+#include <map>
+#include <tuple>
 
 constexpr uint16_t Float16BitSign = 0x8000;
 constexpr uint16_t Float16BitExp = 0x7c00;
@@ -267,6 +269,53 @@ static bool testBufferFloatULP(offloadtest::Buffer *B1, offloadtest::Buffer *B2,
   return false;
 }
 
+static bool testBufferParticipantPattern(offloadtest::Buffer *B1, offloadtest::Buffer *B2,
+                                       unsigned GroupSize) {
+  // B1 is actual, B2 is expected
+  // GroupSize should be 3 for participant patterns (combinedId, maskLow, maskHigh)
+  if (GroupSize == 0 || GroupSize > B1->size() || GroupSize > B2->size())
+    return false;
+  
+  // Ensure buffer sizes are multiples of GroupSize
+  if (B1->size() % GroupSize != 0 || B2->size() % GroupSize != 0)
+    return false;
+  
+  // Parse patterns from both buffers
+  using PatternTuple = std::tuple<uint32_t, uint32_t, uint32_t>;
+  std::map<PatternTuple, unsigned> actualPatterns;
+  std::map<PatternTuple, unsigned> expectedPatterns;
+  
+  // Count patterns in actual buffer
+  const uint32_t* actualData = reinterpret_cast<const uint32_t*>(B1->Data.get());
+  for (size_t i = 0; i < B1->size() / sizeof(uint32_t); i += GroupSize) {
+    if (GroupSize == 3) {
+      PatternTuple pattern(actualData[i], actualData[i+1], actualData[i+2]);
+      actualPatterns[pattern]++;
+    }
+  }
+  
+  // Count patterns in expected buffer  
+  const uint32_t* expectedData = reinterpret_cast<const uint32_t*>(B2->Data.get());
+  for (size_t i = 0; i < B2->size() / sizeof(uint32_t); i += GroupSize) {
+    if (GroupSize == 3) {
+      PatternTuple pattern(expectedData[i], expectedData[i+1], expectedData[i+2]);
+      expectedPatterns[pattern]++;
+    }
+  }
+  
+  // Compare pattern counts
+  if (actualPatterns.size() != expectedPatterns.size())
+    return false;
+    
+  for (const auto& [pattern, count] : expectedPatterns) {
+    auto it = actualPatterns.find(pattern);
+    if (it == actualPatterns.end() || it->second != count)
+      return false;
+  }
+  
+  return true;
+}
+
 llvm::Error verifyResult(offloadtest::Result R) {
   switch (R.Rule) {
   case offloadtest::Rule::BufferExact: {
@@ -284,6 +333,11 @@ llvm::Error verifyResult(offloadtest::Result R) {
       return llvm::Error::success();
     break;
   }
+  case offloadtest::Rule::BufferParticipantPattern: {
+    if (testBufferParticipantPattern(R.ActualPtr, R.ExpectedPtr, R.GroupSize))
+      return llvm::Error::success();
+    break;
+  }
   }
   llvm::SmallString<256> Str;
   llvm::raw_svector_ostream OS(Str);

lib/Support/Pipeline.cpp

@@ -255,6 +255,10 @@ void MappingTraits<offloadtest::Result>::mapping(IO &I,
     I.mapOptional("DenormMode", R.DM);
     break;
   }
+  case Rule::BufferParticipantPattern: {
+    I.mapRequired("GroupSize", R.GroupSize);
+    break;
+  }
   default:
     break;
   }