Test workflow run

Author: luciechoi

.github/workflows/build-and-test-callable.yaml

@@ -155,14 +155,14 @@ jobs:
             cd DXC
             mkdir build
             cd build
-            cmake -G Ninja -DCMAKE_BUILD_TYPE=${{ inputs.BuildType }} -DLLVM_ENABLE_ASSERTIONS=On -C ${{ github.workspace }}/DXC/cmake/caches/PredefinedParams.cmake -C ${{ github.workspace }}/OffloadTest/cmake/caches/sccache.cmake -DHLSL_DISABLE_SOURCE_GENERATION=On ${{ github.workspace }}/DXC/
+            cmake -G Ninja -DCMAKE_BUILD_TYPE=${{ inputs.BuildType }} -DLLVM_ENABLE_ASSERTIONS=On -C ${{ github.workspace }}/DXC/cmake/caches/PredefinedParams.cmake -C ${{ github.workspace }}/OffloadTest/cmake/caches/sccache.cmake -DHLSL_DISABLE_SOURCE_GENERATION=On -DLLVM_LIT_ARGS="--xunit-xml-output=testresults.xunit.xml -v --filter-out=Feature/MaximalReconvergence" ${{ github.workspace }}/DXC/
             ninja
       - name: Build LLVM
         run: |
             cd llvm-project
             mkdir build
             cd build
-            cmake -G Ninja ${{ inputs.LLVM-ExtraCMakeArgs }} -DCMAKE_BUILD_TYPE=${{ inputs.BuildType }} -DLLVM_ENABLE_ASSERTIONS=On -C ${{ github.workspace }}/llvm-project/clang/cmake/caches/HLSL.cmake -C ${{ github.workspace }}/OffloadTest/cmake/caches/sccache.cmake -DDXC_DIR=${{ github.workspace }}/DXC/build/bin -DLLVM_EXTERNAL_OFFLOADTEST_SOURCE_DIR=${{ github.workspace }}/OffloadTest -DLLVM_EXTERNAL_PROJECTS="OffloadTest" -DLLVM_LIT_ARGS="--xunit-xml-output=testresults.xunit.xml -v" -DOFFLOADTEST_TEST_CLANG=${{steps.Test-Clang.outputs.TEST_CLANG || 'Off' }} -DGOLDENIMAGE_DIR=${{ github.workspace }}/golden-images ${{ github.workspace }}/llvm-project/llvm/
+            cmake -G Ninja ${{ inputs.LLVM-ExtraCMakeArgs }} -DCMAKE_BUILD_TYPE=${{ inputs.BuildType }} -DLLVM_ENABLE_ASSERTIONS=On -C ${{ github.workspace }}/llvm-project/clang/cmake/caches/HLSL.cmake -C ${{ github.workspace }}/OffloadTest/cmake/caches/sccache.cmake -DDXC_DIR=${{ github.workspace }}/DXC/build/bin -DLLVM_EXTERNAL_OFFLOADTEST_SOURCE_DIR=${{ github.workspace }}/OffloadTest -DLLVM_EXTERNAL_PROJECTS="OffloadTest" -DLLVM_LIT_ARGS="--xunit-xml-output=testresults.xunit.xml -v --filter-out=Feature/MaximalReconvergence" -DOFFLOADTEST_TEST_CLANG=${{steps.Test-Clang.outputs.TEST_CLANG || 'Off' }} -DGOLDENIMAGE_DIR=${{ github.workspace }}/golden-images ${{ github.workspace }}/llvm-project/llvm/
             ninja hlsl-test-depends
       - name: Dump GPU Info
         run: |
@@ -175,12 +175,33 @@ jobs:
             cd build
             ninja check-hlsl-unit
             ninja ${{ inputs.TestTarget }}
+      - name: Generate maximal Reconvergence Tests
+        if: always()
+        run: |
+            rm -rf OffloadTest/tools/TestGenerator/reconvergence/tests/*
+            cd OffloadTest/tools/TestGenerator/reconvergence
+            cmake -G Ninja -B build/
+            ninja -C build
+      - name: Run Maximal Reconvergence Test
+        if: always()
+        env:
+            OFFLOADTEST_SUPPRESS_DIFF: 1
+        run: |
+            cd llvm-project
+            cd build
+            ./bin/llvm-lit -v --xunit-xml-output=testresults-max-reconv.xunit.xml ${{ github.workspace }}/OffloadTest/tools/TestGenerator/reconvergence/tests
       - name: Publish Test Results
         uses: EnricoMi/publish-unit-test-result-action/macos@v2
         if: always() && inputs.OS == 'macOS'
         with:
           comment_mode: off
           files: llvm-project/build/**/testresults.xunit.xml
+      - name: Publish Maximal Reconvergence Test Results
+        uses: EnricoMi/publish-unit-test-result-action/macos@v2
+        if: always() && inputs.OS == 'macOS'
+        with:
+          comment_mode: off
+          files: llvm-project/build/**/testresults-max-reconv.xunit.xml
       #- name: Publish Test Results
       #  uses: EnricoMi/publish-unit-test-result-action/windows@v2
       #  if: always() && inputs.OS == 'windows'

lib/Support/Check.cpp

@@ -16,6 +16,7 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cmath>
+#include <cstdlib>
 #include <sstream>
 
 constexpr uint16_t Float16BitSign = 0x8000;
@@ -399,5 +400,26 @@ llvm::Error verifyResult(offloadtest::Result R) {
   }
   }
 
+  if (!std::getenv("OFFLOADTEST_SUPPRESS_DIFF")) {
+    OS << "Expected:\n";
+    llvm::yaml::Output YAMLOS(OS);
+    YAMLOS << *R.ExpectedPtr;
+    OS << "Got:\n";
+    YAMLOS << *R.ActualPtr;
+
+    // Now print exact hex64 representations of each element of the
+    // actual and expected buffers.
+
+    const std::string ExpectedBufferStr =
+        getBufferStr(R.ExpectedPtr, R.ComparisonRule);
+    const std::string ActualBufferStr =
+        getBufferStr(R.ActualPtr, R.ComparisonRule);
+
+    OS << "Full Hex 64bit representation of Expected Buffer Values:\n"
+       << ExpectedBufferStr << "\n";
+    OS << "Full Hex 64bit representation of Actual Buffer Values:\n"
+       << ActualBufferStr << "\n";
+  }
+
   return llvm::createStringError(Str.c_str());
 }

tools/TestGenerator/reconvergence/Ballot.h

@@ -0,0 +1,62 @@
+#ifndef EXPERIMENTAL_USERS_CLUCIE_BALLOT_H_
+#define EXPERIMENTAL_USERS_CLUCIE_BALLOT_H_
+
+#include <bitset>
+#include <cstdint>
+#include <ostream>
+
+#include "VectorUtils.h"
+
+namespace reconvergence {
+
+struct Ballot : public std::bitset<128> {
+  typedef std::bitset<128> super;
+
+  Ballot() : super() {}
+
+  Ballot(add_cref<super> ballot, uint32_t printbits = 128u)
+      : super(ballot), m_bits(printbits) {}
+
+  Ballot(add_cref<UVec4> ballot, uint32_t printbits = 128u)
+      : super(), m_bits(printbits) {
+    *this = ballot;
+  }
+
+  Ballot(uint64_t val, uint32_t printbits = 128u)
+      : super(val), m_bits(printbits) {}
+
+  static Ballot withSetBit(uint32_t bit) {
+    Ballot b;
+    b.set(bit);
+    return b;
+  }
+
+  constexpr uint32_t size() const {
+    return static_cast<uint32_t>(super::size());
+  }
+
+  operator UVec4() const {
+    UVec4 result;
+    super ballot(*this);
+    const super mask = 0xFFFFFFFF;
+    for (uint32_t k = 0; k < 4u; ++k) {
+      result[k] = static_cast<uint32_t>((ballot & mask).to_ulong());
+      ballot >>= 32;
+    }
+    return result;
+  }
+
+  add_ref<Ballot> operator=(add_cref<UVec4> vec) {
+    for (uint32_t k = 0; k < 4u; ++k) {
+      (*this) <<= 32;
+      (*this) |= vec[3 - k];
+    }
+    return *this;
+  }
+
+protected:
+  uint32_t m_bits;
+};
+} // namespace reconvergence
+
+#endif // EXPERIMENTAL_USERS_CLUCIE_BALLOT_H_

tools/TestGenerator/reconvergence/Ballots.h

@@ -0,0 +1,203 @@
+#ifndef EXPERIMENTAL_USERS_CLUCIE_BALLOTS_H_
+#define EXPERIMENTAL_USERS_CLUCIE_BALLOTS_H_
+
+#include <bitset>
+#include <cassert>
+#include <cstdint>
+#include <vector>
+
+#include "Ballot.h"
+#include "VectorUtils.h"
+
+namespace reconvergence {
+struct Ballots : protected std::vector<std::bitset<128>> {
+  typedef std::vector<value_type> super;
+
+  static const constexpr uint32_t subgroupInvocationSize =
+      static_cast<uint32_t>(value_type().size());
+
+  Ballots() : super() {}
+
+  explicit Ballots(uint32_t subgroupCount, const value_type &ballot = {})
+      : super(subgroupCount) {
+    if (ballot.any())
+      *this = ballot;
+  }
+
+  Ballots(const Ballots &other) : super(upcast(other)) {}
+
+  using super::operator[];
+
+  using super::at;
+
+  /**
+   * @brief size method
+   * @return Returns the number of bits that the Ballots holds.
+   */
+  uint32_t size() const {
+    return static_cast<uint32_t>(super::size() * subgroupInvocationSize);
+  }
+
+  /**
+   * @brief count method
+   * @return Returns the number of bits that are set to true.
+   */
+  uint32_t count() const {
+    uint32_t n = 0u;
+    for (const value_type &b : *this)
+      n += static_cast<uint32_t>(b.count());
+    return n;
+  }
+
+  /**
+   * @brief count method
+   * @return Returns the number of bits that are set to true in given subgroup.
+   */
+  uint32_t count(uint32_t subgroup) const {
+    assert(subgroup < subgroupCount());
+    return static_cast<uint32_t>(at(subgroup).count());
+  }
+
+  uint32_t subgroupCount() const {
+    return static_cast<uint32_t>(super::size());
+  }
+
+  bool test(uint32_t bit) const {
+    assert(bit < size());
+    return at(bit / subgroupInvocationSize).test(bit % subgroupInvocationSize);
+  }
+
+  bool set(uint32_t bit, bool value = true) {
+    assert(bit <= size());
+    const bool before = test(bit);
+    at(bit / subgroupInvocationSize).set((bit % subgroupInvocationSize), value);
+    return before;
+  }
+
+  void full() {
+    const uint32_t bb = size();
+    for (uint32_t b = 0u; b < bb; ++b)
+      set(b);
+  }
+
+  Ballots &setn(uint32_t bits) {
+    for (uint32_t i = 0u; i < bits; ++i)
+      set(i);
+    return *this;
+  }
+
+  bool all() const {
+    const uint32_t gg = subgroupCount();
+    for (uint32_t g = 0u; g < gg; ++g) {
+      if (false == at(g).all())
+        return false;
+    }
+    return (gg != 0u);
+  }
+
+  bool none() const {
+    const uint32_t gg = subgroupCount();
+    for (uint32_t g = 0u; g < gg; ++g) {
+      if (false == at(g).none())
+        return false;
+    }
+    return (gg != 0u);
+  }
+
+  bool any() const {
+    bool res = false;
+    const uint32_t gg = subgroupCount();
+    for (uint32_t g = 0u; g < gg; ++g)
+      res |= super::at(g).any();
+    return res;
+  }
+
+  static uint32_t findBit(uint32_t otherFullyQualifiedInvocationID,
+                          uint32_t otherSubgroupSize) {
+    return (((otherFullyQualifiedInvocationID / otherSubgroupSize) *
+             subgroupInvocationSize) +
+            (otherFullyQualifiedInvocationID % otherSubgroupSize));
+  }
+
+  inline const super &upcast(const Ballots &other) const {
+    return static_cast<const super &>(other);
+  }
+
+  Ballots &operator&=(const Ballots &other) {
+    assert(subgroupCount() == other.subgroupCount());
+    const uint32_t gg = subgroupCount();
+    for (uint32_t g = 0u; g < gg; ++g)
+      super::at(g) = super::at(g) & upcast(other).at(g);
+    return *this;
+  }
+
+  Ballots operator&(const Ballots &other) const {
+    Ballots res(*this);
+    res &= other;
+    return res;
+  }
+
+  Ballots &operator|=(const Ballots &other) {
+    assert(subgroupCount() == other.subgroupCount());
+    const uint32_t gg = subgroupCount();
+    for (uint32_t g = 0u; g < gg; ++g)
+      super::at(g) = super::at(g) | upcast(other).at(g);
+    return *this;
+  }
+
+  Ballots operator|(const Ballots &other) const {
+    Ballots res(*this);
+    res |= other;
+    return res;
+  }
+
+  Ballots &operator<<=(uint32_t bits) { return ((*this) = ((*this) << bits)); }
+
+  Ballots operator<<(uint32_t bits) const {
+    Ballots res(subgroupCount());
+    if (bits < size() && bits != 0u) {
+      for (uint32_t b = 0; b < size() - bits; ++b)
+        res.set((b + bits), test(b));
+    }
+    return res;
+  }
+
+  Ballots operator~() const {
+    Ballots res(*this);
+    const uint32_t gg = subgroupCount();
+    for (uint32_t g = 0u; g < gg; ++g)
+      res.at(g) = super::at(g).operator~();
+    return res;
+  }
+
+  bool operator==(const Ballots &other) const {
+    if (super::size() == upcast(other).size()) {
+      const uint32_t gg = subgroupCount();
+      for (uint32_t g = 0u; g < gg; ++g) {
+        if (at(g) != other[g])
+          return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  Ballots &operator=(const Ballots &other) {
+    assert((subgroupCount() == other.subgroupCount()));
+    const uint32_t gg = subgroupCount();
+    for (uint32_t g = 0u; g < gg; ++g)
+      at(g) = other.at(g);
+    return *this;
+  }
+
+  Ballots &operator=(const value_type &forAllGroups) {
+    assert(super::size() >= 1u);
+    const uint32_t gg = subgroupCount();
+    for (uint32_t g = 0u; g < gg; ++g)
+      at(g) = forAllGroups;
+    return *this;
+  }
+};
+} // namespace reconvergence
+
+#endif // EXPERIMENTAL_USERS_CLUCIE_BALLOTS_H_

tools/TestGenerator/reconvergence/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(maximal_reconvergence_test_generator)
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_executable(generate_reconvergence_test main.cc GenerateReconvergenceTest.cc GenerateReconvergenceTest.h Ballot.h Ballots.h MaskUtils.h Op.h TestCase.h RandomProgram.h RandomUtils.h RandomUtils.cc VectorUtils.h MathUtils.h)
+
+add_custom_target(run ALL
+  COMMAND generate_reconvergence_test
+  DEPENDS generate_reconvergence_test)