Add matrix types extension tests .

[fhahn]

Summary

This adds a set of initial tests that check that some of the matrix
types extension matches the spec.

[fhahn]

Update according to latest spec.

[fhahn]

Removed matrix-builtins-spec.cpp -> matrix-types-spec.cpp

[fhahn]

ping. This is an initial step towards adding end-to-end tests for the matrix types extensions. Subsequently I am also planning on contributing some (micro) benchmarks.

[fhahn]

ping

[rjmccall]

This looks reasonable to me, but I don't know much about this test suite.

[anemet]

LGTM.

[fhahn]

Submitted as https://github.com/llvm/llvm-test-suite/commit/60cfbf7833b8039b938ce679bed89c738b519e1d

It looks like Phab doesn't auto-close test-suite patches.

[plotfi]

Hi

@fhahn I ran into an llvm_unreachable when building matrix-types-spec.cpp as part of an llvm-test-suite build using -Oz with -flto=thin. I reduced the IR that hit the unreachable to:

target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64-unknown-linux-gnu"

define void @f(double* %Res) {
  tail call void @llvm.matrix.column.major.store.v275f64(<275 x double> undef, double* align 8 %Res, i64 25, i1 false, i32 25, i32 11)
  ret void
}

declare void @llvm.matrix.column.major.store.v275f64(<275 x double>, double* nocapture writeonly, i64, i1 immarg, i32 immarg, i32 immarg)

Repros through llc. Also repro'ed it on godbolt too: https://godbolt.org/z/rrGecn
The unreachable is in llvm::DAGTypeLegalizer::WidenVectorOperand.

Hope this is helpful.

-PL

[fhahn]

In D72770#2220012, @plotfi wrote:

Hi

@fhahn I ran into an llvm_unreachable when building matrix-types-spec.cpp as part of an llvm-test-suite build using -Oz with -flto=thin. I reduced the IR that hit the unreachable to:

Thanks for letting me know! Unfortunately the lowering pass is not enabled by default and there's no convenient way to pass the -enable-matrix flag through LTO. I hope to fix that soonish, but I'll check if it is easy to disable the test for LTO for now.

[plotfi]

Good stuff. Thanks for replying so quickly @fhahn :-)

In D72770#2222305, @fhahn wrote:

In D72770#2220012, @plotfi wrote:

Hi

@fhahn I ran into an llvm_unreachable when building matrix-types-spec.cpp as part of an llvm-test-suite build using -Oz with -flto=thin. I reduced the IR that hit the unreachable to:

Thanks for letting me know! Unfortunately the lowering pass is not enabled by default and there's no convenient way to pass the -enable-matrix flag through LTO. I hope to fix that soonish, but I'll check if it is easy to disable the test for LTO for now.

SingleSource/UnitTests/CMakeLists.txt

list(REMOVE_ITEM Source
     ms_struct-bitfield.c
     ms_struct-bitfield-1.c
     ms_struct-bitfield-init.c
     ms_struct-bitfield-init-1.c
     ms_struct_pack_layout.c
     ms_struct_pack_layout-1.c
   )
 endif()
+
+# Enable matrix types extension tests for Clang versions supporting it.
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND
+    CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 11.0)
+  set_property(SOURCE matrix-types-spec.cpp PROPERTY COMPILE_FLAGS -fenable-matrix)
+else()
+  list(REMOVE_ITEM Source matrix-types-spec.cpp)
+endif()
+
 llvm_singlesource()

SingleSource/UnitTests/matrix-types-spec.cpp

+// Runtime tests to ensure the Matrix Type extension implementation matches the
+// specification.
+
+#include <iostream>
+#include <random>
+#include <stdlib.h>
+
+#define EXPECT_MATRIX_EQ(A, B, R, C)                                           \
+  do {                                                                         \
+    for (unsigned r = 0; r < R; r++)                                           \
+      for (unsigned c = 0; c < C; c++)                                         \
+        if (A[r + c * R] != B[r + c * R]) {                                    \
+          std::cerr << "mismatch at " << r << ":" << c << "\n";                \
+          exit(1);                                                             \
+        }                                                                      \
+  } while (false)
+
+template <typename EltTy>
+void zeroMatrix(EltTy *M, unsigned Rows, unsigned Cols) {
+  for (unsigned r = 0; r < Rows; r++)
+    for (unsigned c = 0; c < Cols; c++)
+      M[r + c * Rows] = 0;
+}
+
+template <typename EltTy> void print(EltTy *X, unsigned Rows, unsigned Cols) {
+  for (int r = 0; r < Rows; r++) {
+    for (int c = 0; c < Cols; c++)
+      std::cout << X[r + c * Rows] << ", ";
+    std::cout << "\n";
+  }
+}
+
+template <typename Ty> void initRandom(Ty *A, unsigned Rows, unsigned Cols) {
+  std::default_random_engine generator;
+  std::uniform_int_distribution<double> distribution(-10.0, 10.0);
+  auto random_double = std::bind(distribution, generator);
+
+  for (unsigned i = 0; i < Rows * Cols; i++)
+    A[i] = random_double();
+}
+
+template <typename EltTy, unsigned R, unsigned C>
+void transposeBuiltin(EltTy *ResPtr, EltTy *SrcPtr) {
+  auto M = __builtin_matrix_column_major_load(SrcPtr, R, C, R);
+  __builtin_matrix_column_major_store(__builtin_matrix_transpose(M), ResPtr, C);
+}
+
+template <typename EltTy, unsigned R, unsigned C>
+void transposeSpec(EltTy *ResPtr, EltTy *SrcPtr) {
+  using matrix_trans_t = EltTy __attribute__((matrix_type(C, R)));
+  auto M = __builtin_matrix_column_major_load(SrcPtr, R, C, R);
+  matrix_trans_t Res;
+  for (int c = 0; c < C; ++c)
+    for (int r = 0; r < R; ++r)
+      Res[c][r] = M[r][c];
+  __builtin_matrix_column_major_store(Res, ResPtr, C);
+}
+
+template <typename Ty>
+static void transposeBase(Ty *Res, Ty *Src, unsigned R0, unsigned C0) {
+  for (unsigned r = 0; r < R0; r++) {
+    for (unsigned c = 0; c < C0; c++)
+      Res[c + r * C0] = Src[r + c * R0];
+  }
+}
+
+template <typename EltTy, unsigned R0, unsigned C0> void testTranspose() {
+  EltTy X[R0 * C0];
+  EltTy ResBase[R0 * C0];
+  EltTy ResSpec[R0 * C0];
+  EltTy ResBuiltin[R0 * C0];
+
+  initRandom(X, R0, C0);
+  zeroMatrix(ResBase, C0, R0);
+  zeroMatrix(ResSpec, C0, R0);
+  zeroMatrix(ResBuiltin, C0, R0);
+
+  transposeBase(ResBase, X, R0, C0);
+  transposeSpec<EltTy, R0, C0>(ResSpec, X);
+  transposeBuiltin<EltTy, R0, C0>(ResBuiltin, X);
+
+  EXPECT_MATRIX_EQ(ResBase, ResBuiltin, R0, C0);
+  EXPECT_MATRIX_EQ(ResBase, ResSpec, C0, R0);
+}
+
+template <typename EltTy, unsigned R0, unsigned C0, unsigned C1>
+void multiplyBuiltin(EltTy *Res, EltTy *Matrix1, EltTy *Matrix2) {
+  using res_t = EltTy __attribute__((matrix_type(R0, C1)));
+
+  auto A = __builtin_matrix_column_major_load(Matrix1, R0, C0, R0);
+  auto B = __builtin_matrix_column_major_load(Matrix2, C0, C1, C0);
+  res_t C = A * B;
+  __builtin_matrix_column_major_store(C, Res, R0);
+}
+
+template <typename EltTy, unsigned R0, unsigned C0, unsigned C1>
+void multiplySpec(EltTy *Res, EltTy *Matrix1, EltTy *Matrix2) {
+  using res_t = EltTy __attribute__((matrix_type(R0, C1)));
+
+  auto A = __builtin_matrix_column_major_load(Matrix1, R0, C0, R0);
+  auto B = __builtin_matrix_column_major_load(Matrix2, C0, C1, C0);
+  res_t ResM;
+  for (int C = 0; C < C1; ++C) {
+    for (int R = 0; R < R0; ++R) {
+      EltTy Elt = 0;
+      for (int K = 0; K < C0; K++)
+        Elt += A[R][K] * B[K][C];
+      ResM[R][C] = Elt;
+    }
+  }
+  __builtin_matrix_column_major_store(ResM, Res, R0);
+}
+
+template <typename Ty>
+static void BaseMatrixMult(Ty *A, Ty *B, Ty *C, unsigned R0, unsigned C0,
+                           unsigned R1, unsigned C1) {
+  for (unsigned i = 0; i < R0; i++)
+    for (unsigned j = 0; j < C1; j++)
+      for (unsigned c = 0; c < C0; c++)
+        C[i + j * R0] += A[i + c * R0] * B[c + j * R1];
+}
+
+template <typename EltTy, unsigned R0, unsigned C0, unsigned C1>
+static void multiplyBase(EltTy *C, EltTy *A, EltTy *B) {
+  for (unsigned i = 0; i < R0; i++)
+    for (unsigned j = 0; j < C1; j++)
+      for (unsigned c = 0; c < C0; c++) {
+        C[i + j * R0] += A[i + c * R0] * B[c + j * C0];
+      }
+}
+
+template <typename EltTy, unsigned R0, unsigned C0, unsigned C1>
+void testMultiply() {
+  EltTy X[R0 * C0];
+  EltTy Y[C0 * C1];
+  EltTy ResBase[R0 * C1];
+  EltTy ResSpec[R0 * C1];
+  EltTy ResBuiltin[R0 * C1];
+
+  initRandom(X, R0, C0);
+  initRandom(Y, C0, C1);
+  zeroMatrix(ResBase, R0, C1);
+  zeroMatrix(ResSpec, R0, C1);
+  zeroMatrix(ResBuiltin, R0, C1);
+
+  multiplyBase<EltTy, R0, C0, C1>(ResBase, X, Y);
+  multiplySpec<EltTy, R0, C0, C1>(ResSpec, X, Y);
+  multiplyBuiltin<EltTy, R0, C0, C1>(ResBuiltin, X, Y);
+
+  EXPECT_MATRIX_EQ(ResSpec, ResBuiltin, R0, C1);
+  EXPECT_MATRIX_EQ(ResBase, ResBuiltin, R0, C1);
+  EXPECT_MATRIX_EQ(ResBase, ResSpec, R0, C1);
+}
+
+int main(void) {
+  testTranspose<double, 3, 3>();
+  testTranspose<double, 3, 10>();
+  testTranspose<double, 4, 3>();
+  testTranspose<float, 31, 17>();
+  testTranspose<unsigned, 8, 7>();
+
+  testMultiply<double, 3, 3, 3>();
+  testMultiply<double, 10, 21, 23>();
+  testMultiply<double, 25, 19, 11>();
+
+  return 0;
+}

SingleSource/UnitTests/matrix-types-spec.reference_output

+exit 0