[MicroBenchmarks] Add matrix type benchmarks.

Author: fhahn

MicroBenchmarks/Builtins/CMakeLists.txt

@@ -1 +1,2 @@
 add_subdirectory(Int128)
+add_subdirectory(MatrixType)

MicroBenchmarks/Builtins/MatrixType/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Enable matrix types benchmarks for compilers supporting -fenable-matrix.
+check_c_compiler_flag(-fenable-matrix COMPILER_HAS_MATRIX_FLAG)
+if (COMPILER_HAS_MATRIX_FLAG)
+  set(CMAKE_CXX_STANDARD 20)
+  set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+  llvm_test_run()
+
+  set_property(SOURCE main.cpp PROPERTY COMPILE_FLAGS -fenable-matrix)
+
+  llvm_test_executable(MatrixType main.cpp)
+  target_link_libraries(MatrixType benchmark)
+endif()

MicroBenchmarks/Builtins/MatrixType/main.cpp

@@ -0,0 +1,157 @@
+#include <algorithm>
+#include <cstdint>
+#include <limits>
+#include <random>
+#include <ranges>
+#include <vector>
+
+#include <simd/simd.h>
+
+#include "benchmark/benchmark.h"
+#include <iostream>
+
+namespace {
+
+using m44 = double __attribute__((matrix_type(4, 4)));
+
+class MatrixMult4x4Benchmark : public benchmark::Fixture {
+public:
+  void SetUp(const benchmark::State &) override {
+    mats.clear();
+    mats2.clear();
+    mats_res.clear();
+    mats2_res.clear();
+    std::default_random_engine generator;
+    std::uniform_real_distribution<double> distribution(-10.0, 10.0);
+    for (unsigned X = 0; X < kDataSize; ++X) {
+      m44 M;
+      for (unsigned J = 0; J < 4; ++J)
+        for (unsigned I = 0; I < 4; ++I)
+          M[J][I] = distribution(generator);
+      mats.push_back(M);
+      mats_res.push_back(M);
+    }
+    for (auto &m : mats) {
+      simd_double4x4 s;
+      s.columns[0] = {m[0][0], m[1][0], m[2][0], m[3][0]};
+      s.columns[1] = {m[0][1], m[1][1], m[2][1], m[3][1]};
+      s.columns[2] = {m[0][2], m[1][2], m[2][2], m[3][2]};
+      s.columns[3] = {m[0][3], m[1][3], m[2][3], m[3][3]};
+      mats2.push_back(s);
+      mats2_res.push_back(s);
+    }
+  }
+
+protected:
+  static constexpr size_t kDataSize = 1024;
+  std::vector<m44> mats;
+  std::vector<m44> mats_res;
+  std::vector<simd_double4x4> mats2;
+  std::vector<simd_double4x4> mats2_res;
+};
+
+void benchCVAMatrixABStoreRes(std::vector<m44> &mats,
+                              std::vector<m44> &mats_res) {
+  size_t N = mats.size();
+  for (size_t i = 0u; i < N; ++i) {
+    const m44 a = mats[i];
+    const m44 b = mats[(i + 1) % N];
+    const m44 prod = a * b;
+    mats_res[i] = prod;
+  }
+}
+
+BENCHMARK_F(MatrixMult4x4Benchmark, MatrixTypeAB)(benchmark::State &state) {
+  while (state.KeepRunning()) {
+    benchCVAMatrixABStoreRes(mats, mats_res);
+  }
+}
+
+void benchSIMDMatrixABStoreRes(std::vector<simd_double4x4> &mats,
+                               std::vector<simd_double4x4> &mats_res) {
+  size_t N = mats.size();
+  for (size_t i = 0u; i < N; ++i) {
+    const simd_double4x4 a = mats[i];
+    const simd_double4x4 b = mats[(i + 1) % N];
+    const simd_double4x4 prod = matrix_multiply(a, b);
+    mats_res[i] = prod;
+    // benchmark::DoNotOptimize(prod);
+  }
+}
+
+BENCHMARK_F(MatrixMult4x4Benchmark, SIMDMatrixAB)(benchmark::State &state) {
+  while (state.KeepRunning()) {
+    benchSIMDMatrixABStoreRes(mats2, mats2_res);
+  }
+}
+
+void benchCVAMatrixAtB(const std::vector<m44> &mats) {
+  size_t N = mats.size();
+  for (size_t i = 0u; i < N; ++i) {
+    const m44 a = mats[i];
+    const m44 b = mats[(i + 1) % N];
+    const m44 prod = __builtin_matrix_transpose(a) * b;
+    benchmark::DoNotOptimize(prod);
+  }
+}
+
+BENCHMARK_F(MatrixMult4x4Benchmark, MatrixTypeAtB)(benchmark::State &state) {
+  while (state.KeepRunning()) {
+    benchCVAMatrixAtB(mats);
+  }
+}
+
+void benchSIMDMatrixAtB(const std::vector<simd_double4x4> &mats) {
+  size_t N = mats.size();
+  for (size_t i = 0u; i < N; ++i) {
+    const simd_double4x4 a = mats[i];
+    const simd_double4x4 b = mats[(i + 1) % N];
+    const simd_double4x4 prod = matrix_multiply(simd_transpose(a), b);
+    benchmark::DoNotOptimize(prod);
+  }
+}
+
+BENCHMARK_F(MatrixMult4x4Benchmark, SIMDMatrixAtB)(benchmark::State &state) {
+  while (state.KeepRunning()) {
+    benchSIMDMatrixAtB(mats2);
+  }
+}
+
+void benchCVAMatrixAtBStoreRes(std::vector<m44> &mats,
+                               std::vector<m44> &mats_res) {
+  size_t N = mats.size();
+  for (size_t i = 0u; i < N; ++i) {
+    const m44 a = mats[i];
+    const m44 b = mats[(i + 1) % N];
+    const m44 prod = __builtin_matrix_transpose(a) * b;
+    mats[i] = prod;
+  }
+}
+
+BENCHMARK_F(MatrixMult4x4Benchmark,
+            MatrixTypeAtBStoreRes)(benchmark::State &state) {
+  while (state.KeepRunning()) {
+    benchCVAMatrixAtBStoreRes(mats, mats_res);
+  }
+}
+
+void benchSIMDMatrixAtBStoreRes(std::vector<simd_double4x4> &mats,
+                                std::vector<simd_double4x4> &mats_res) {
+  size_t N = mats.size();
+  for (size_t i = 0u; i < N; ++i) {
+    const simd_double4x4 a = mats[i];
+    const simd_double4x4 b = mats[(i + 1) % N];
+    const simd_double4x4 prod = matrix_multiply(simd_transpose(a), b);
+    mats[i] = prod;
+  }
+}
+
+BENCHMARK_F(MatrixMult4x4Benchmark,
+            SIMDMatrixAtBStoreRes)(benchmark::State &state) {
+  while (state.KeepRunning()) {
+    benchSIMDMatrixAtBStoreRes(mats2, mats2_res);
+  }
+}
+} // namespace
+
+BENCHMARK_MAIN();