update error message for testBufferParticipantPattern

Author: ArberSephirotheca

lib/Support/Check.cpp

@@ -16,7 +16,9 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cmath>
+#include <map>
 #include <sstream>
+#include <tuple>
 
 constexpr uint16_t Float16BitSign = 0x8000;
 constexpr uint16_t Float16BitExp = 0x7c00;
@@ -277,6 +279,121 @@ static bool testBufferFloatULP(offloadtest::Buffer *B1, offloadtest::Buffer *B2,
   return false;
 }
 
+static bool testBufferParticipantPattern(offloadtest::Buffer *B1, offloadtest::Buffer *B2,
+                                         unsigned GroupSize, std::string &errorMsg) {
+  // Expect 3 x uint32_t: (combinedId, maskLow, maskHigh)
+  if (GroupSize == 0) {
+    errorMsg = "Invalid GroupSize (must be > 0)";
+    return false;
+  }
+
+  // Basic structural checks similar to testBufferExact
+  if (B1->ArraySize != B2->ArraySize || B1->size() != B2->size()) {
+    errorMsg = "Mismatched buffer shape (ArraySize or per-chunk size differs)";
+    return false;
+  }
+
+  // We operate on 32-bit words
+  if ((B1->size() % sizeof(uint32_t)) != 0) {
+    errorMsg = "Chunk size is not a multiple of 4 bytes";
+    return false;
+  }
+  if ((B2->size() % sizeof(uint32_t)) != 0) {
+    errorMsg = "Expected chunk size is not a multiple of 4 bytes";
+    return false;
+  }
+
+  const uint32_t WordsPerChunk = static_cast<uint32_t>(B1->size() / sizeof(uint32_t));
+  if (WordsPerChunk % GroupSize != 0) {
+    errorMsg = "Words per chunk must be a multiple of GroupSize";
+    return false;
+  }
+
+  using PatternTuple = std::tuple<uint32_t, uint32_t, uint32_t>;
+  std::map<PatternTuple, unsigned> actualPatterns;
+  std::map<PatternTuple, unsigned> expectedPatterns;
+
+  auto read_u32 = [](const char* base, uint32_t wordIndex) -> uint32_t {
+    uint32_t v;
+    std::memcpy(&v, base + wordIndex * sizeof(uint32_t), sizeof(uint32_t));
+    return v;
+  };
+
+  // Accumulate patterns from all chunks
+  auto B1It = B1->Data.begin();
+  auto B2It = B2->Data.begin();
+  for (; B1It != B1->Data.end() && B2It != B2->Data.end(); ++B1It, ++B2It) {
+    const char* aBuf = B1It->get(); // unique_ptr<char[]> -> char*
+    const char* eBuf = B2It->get();
+
+    for (uint32_t i = 0; i + GroupSize <= WordsPerChunk; i += GroupSize) {
+      if (GroupSize == 3) {
+        // Actual
+        PatternTuple ap(read_u32(aBuf, i + 0),
+                        read_u32(aBuf, i + 1),
+                        read_u32(aBuf, i + 2));
+        ++actualPatterns[ap];
+
+        // Expected
+        PatternTuple ep(read_u32(eBuf, i + 0),
+                        read_u32(eBuf, i + 1),
+                        read_u32(eBuf, i + 2));
+        ++expectedPatterns[ep];
+      } else {
+        // If you plan to support other group sizes later, handle here.
+      }
+    }
+  }
+
+  // Compare pattern multisets
+  std::stringstream ss;
+  bool hasError = false;
+
+  if (actualPatterns.size() != expectedPatterns.size()) {
+    ss << "Pattern kind count mismatch: actual has " << actualPatterns.size()
+       << " unique patterns, expected has " << expectedPatterns.size() << " unique patterns\n";
+    hasError = true;
+  }
+
+  // Missing / count-mismatched patterns
+  for (const auto& [pattern, expCount] : expectedPatterns) {
+    auto it = actualPatterns.find(pattern);
+    if (it == actualPatterns.end()) {
+      if (!hasError) ss << "Pattern differences found:\n";
+      hasError = true;
+      ss << "  Missing pattern (combineId=" << std::get<0>(pattern)
+         << ", maskLow=0x" << std::hex << std::get<1>(pattern)
+         << ", maskHigh=0x" << std::get<2>(pattern) << std::dec
+         << ") - expected count: " << expCount << ", actual count: 0\n";
+    } else if (it->second != expCount) {
+      if (!hasError) ss << "Pattern differences found:\n";
+      hasError = true;
+      ss << "  Pattern (combineId=" << std::get<0>(pattern)
+         << ", maskLow=0x" << std::hex << std::get<1>(pattern)
+         << ", maskHigh=0x" << std::get<2>(pattern) << std::dec
+         << ") - expected count: " << expCount << ", actual count: " << it->second << "\n";
+    }
+  }
+
+  // Unexpected patterns
+  for (const auto& [pattern, actCount] : actualPatterns) {
+    if (expectedPatterns.find(pattern) == expectedPatterns.end()) {
+      if (!hasError) ss << "Pattern differences found:\n";
+      hasError = true;
+      ss << "  Unexpected pattern (combineId=" << std::get<0>(pattern)
+         << ", maskLow=0x" << std::hex << std::get<1>(pattern)
+         << ", maskHigh=0x" << std::get<2>(pattern) << std::dec
+         << ") - expected count: 0, actual count: " << actCount << "\n";
+    }
+  }
+
+  if (hasError) {
+    errorMsg = ss.str();
+    return false;
+  }
+  return true;
+}
+
 template <typename T>
 static std::string bitPatternAsHex64(const T &Val,
                                      offloadtest::Rule ComparisonRule) {
@@ -391,6 +508,16 @@ llvm::Error verifyResult(offloadtest::Result R) {
   case offloadtest::Rule::BufferFloatEpsilon: {
     if (testBufferFloatEpsilon(R.ActualPtr, R.ExpectedPtr, R.Epsilon, R.DM))
       return llvm::Error::success();
+    break;
+  }
+  case offloadtest::Rule::BufferParticipantPattern: {
+    std::string errorMsg;
+    if (testBufferParticipantPattern(R.ActualPtr, R.ExpectedPtr, R.GroupSize, errorMsg))
+      return llvm::Error::success();
+    // Return error with detailed message
+    return llvm::make_error<llvm::StringError>(
+        "BufferParticipantPattern test failed for " + R.Name + ":\n" + errorMsg,
+        std::error_code());
 
     std::ostringstream Oss;
     Oss << std::defaultfloat << R.Epsilon;