[mlir] add support for verification in integration tests

[gysit]

Summary

The patch extends the runner utils by verification methods that compare two memrefs. The methods compare the content of the two memrefs and print success if the data is identical up to a small numerical error. The methods are meant to simplify the development of integration tests that for example compare optimized and unoptimized code paths (cf. the updates to the linalg matmul integration tests).

[nicolasvasilache]

Thanks for adding this @gysit !
Can you please also address the lints?

mlir/include/mlir/ExecutionEngine/RunnerUtils.h

294

We should probably avoid printing to stdout in general.
How about we make this return an error code i8 and just print that in MLIR.
We can print errors to stderr.

mlir/integration_test/Dialect/Linalg/CPU/benchmark_matmul.mlir

61

Can we move this closer to its uses and "scope it" more tightly?

alloc
fill
run
test
print
dealloc

98

let's please make this return an i8 that we just vector.print and //CHECK: 0

[gysit]

Avoid std::cout and return number of errors instead of printing success or failure. Restructured the unit tests to limit the scope of the verification code. Also tried to address the lint issues. Howerever the _mlir_ciface_ perfix is fix as far as I understand.

[gysit]

@nicolasvasilache the updated revision should address your comments. The linter may not be happy with the function naming (_mlir_ciface) and I somewhat prefer the older function names.

[NathanielMcVicar]

Could you please add #include<algorithm> for RunnerUtils.h? MSVC requires it for std::max/min, resulting in this http://lab.llvm.org:8011/#/builders/13/builds/4283/steps/6/logs/stdio failure. Thanks!

[stella.stamenova]

To be clear, the windows mlir buildbot is broken because of this change:

http://lab.llvm.org:8011/#/builders/13/builds/4284

Perhaps you are not getting the notifications?

[gysit]

In D96326#2551811, @stella.stamenova wrote:

To be clear, the windows mlir buildbot is broken because of this change:

http://lab.llvm.org:8011/#/builders/13/builds/4284

Perhaps you are not getting the notifications?

sorry did not see it immediately. Reverted the commit for now.

[gysit]

Added missing algorithms header to fix Windows build.

mlir/include/mlir/ExecutionEngine/RunnerUtils.h

 #define MLIR_RUNNERUTILS_EXPORT __declspec(dllimport)
 #endif // mlir_runner_utils_EXPORTS
 #endif // MLIR_RUNNERUTILS_EXPORT
 #else
 #define MLIR_RUNNERUTILS_EXPORT
 #endif // _WIN32
 
 #include <assert.h>
+#include <cmath>
 #include <iostream>
 
 #include "mlir/ExecutionEngine/CRunnerUtils.h"
 
 template <typename T, typename StreamType>
 void printMemRefMetaData(StreamType &os, const DynamicMemRefType<T> &V) {
   os << "base@ = " << reinterpret_cast<void *>(V.data) << " rank = " << V.rank
      << " offset = " << V.offset;

 
 ////////////////////////////////////////////////////////////////////////////////
 // Templated instantiation follows.
 ////////////////////////////////////////////////////////////////////////////////
 namespace impl {
 template <typename T, int M, int... Dims>
 std::ostream &operator<<(std::ostream &os, const Vector<T, M, Dims...> &v);
 
-template <int... Dims> struct StaticSizeMult {
+template <int... Dims>
+struct StaticSizeMult {
   static constexpr int value = 1;
 };
 
-template <int N, int... Dims> struct StaticSizeMult<N, Dims...> {
+template <int N, int... Dims>
+struct StaticSizeMult<N, Dims...> {
   static constexpr int value = N * StaticSizeMult<Dims...>::value;
 };
 
 static inline void printSpace(std::ostream &os, int count) {
   for (int i = 0; i < count; ++i) {
     os << ' ';
   }
 }
 
-template <typename T, int M, int... Dims> struct VectorDataPrinter {
+template <typename T, int M, int... Dims>
+struct VectorDataPrinter {
   static void print(std::ostream &os, const Vector<T, M, Dims...> &val);
 };
 
 template <typename T, int M, int... Dims>
 void VectorDataPrinter<T, M, Dims...>::print(std::ostream &os,
                                              const Vector<T, M, Dims...> &val) {
   static_assert(M > 0, "0 dimensioned tensor");
   static_assert(sizeof(val) == M * StaticSizeMult<Dims...>::value * sizeof(T),
void printMemRef(StridedMemRefType<T, N> &M) {
   printMemRef(DynamicMemRefType<T>(M));
 }
 
 template <typename T>
 void printMemRef(UnrankedMemRefType<T> &M) {
   std::cout << "Unranked Memref ";
   printMemRef(DynamicMemRefType<T>(M));
 }
+
+/// Verify the results of two computations are equivalent up to a small
+/// numerical error.
+template <typename T>
+struct MemRefDataVerifier {
+  /// Maximum number of errors printed by the verifier.
+  static constexpr int errorLimit = 10;
+
+  /// Verify the relative difference of the values is smaller than epsilon.
+  static bool verifyRelErrorSmallerThan(T val1, T val2, T epsilon);
+
+  /// Verify the values are equivalent (integers) or are close (floating-point).
+  static bool verifyElem(T val1, T val2);
+
+  /// Verify the data element-by-element.
+  static void verify(std::ostream &os, T *base1, T *base2, int64_t dim,
+                     int64_t offset, const int64_t *sizes,
+                     const int64_t *strides, int64_t &errors);
+};
+
+template <typename T>
+bool MemRefDataVerifier<T>::verifyRelErrorSmallerThan(T val1, T val2,
+                                                      T epsilon) {
+  // Return an error if one of the values is infinite or NaN.
+  if (!std::isfinite(val1) || !std::isfinite(val2))
+    return false;
+  // Return true if the relative error is smaller than epsilon.
+  T delta = std::abs(val1 - val2);
+  T maximum = std::max(std::abs(val1), std::abs(val2));
+  if (delta > epsilon * maximum)
+    return false;
+  return true;
+}
+
+template <typename T>
+bool MemRefDataVerifier<T>::verifyElem(T val1, T val2) {
+  return val1 == val2;
+}
+
+template <>
+inline bool MemRefDataVerifier<double>::verifyElem(double val1, double val2) {
+  return verifyRelErrorSmallerThan(val1, val2, 1e-12);
+}
+
+template <>
+inline bool MemRefDataVerifier<float>::verifyElem(float val1, float val2) {
+  return verifyRelErrorSmallerThan(val1, val2, 1e-6);
+}
+
+template <typename T>
+void MemRefDataVerifier<T>::verify(std::ostream &os, T *base1, T *base2,
+                                   int64_t dim, int64_t offset,
+                                   const int64_t *sizes, const int64_t *strides,
+                                   int64_t &errors) {
+  // Verify the elements at the current offset.
+  if (dim == 0) {
+    if (!verifyElem(base1[offset], base2[offset])) {
+      if (errors < errorLimit) {
+        os << base1[offset] << " != " << base2[offset] << " offset = " << offset
+           << "\n";
+      } else if (errors == errorLimit) {
+        os << "...\n";
+      }
+      errors++;
+    }
+    return;
+  }
+  // Iterate the current dimension and verify recursively.
+  for (int64_t i = 0; i < sizes[0]; ++i) {
+    verify(os, base1, base2, dim - 1, offset + i * strides[0], sizes + 1,
+           strides + 1, errors);
+  }
+}
+
+/// Verify the equivalence of two dynamic memrefs.
+template <typename T>
+void verifyMemRef(const DynamicMemRefType<T> &M1,
+                  const DynamicMemRefType<T> &M2) {
+  // Check the shapes of the MemRefs match.
+  for (int64_t i = 0; i < M1.rank; ++i) {
+    if (M2.rank != M1.rank || M1.offset != M2.offset ||
+        M1.sizes[i] != M2.sizes[i] || M1.strides[i] != M2.strides[i]) {
+      printMemRefMetaData(std::cout, M1);
+      printMemRefMetaData(std::cout, M2);
+      std::cout << "FAILED: MemRef shape missmatch!\n";
+      return;
+    }
+  }
+  // Count the errors and print the verification result.
+  int64_t errors = 0;
+  MemRefDataVerifier<T>::verify(std::cout, M1.basePtr, M2.basePtr, M1.rank,
+                                M1.offset, M1.sizes, M1.strides, errors);
+  if (errors != 0) {
+    std::cout << "FAILED: " << errors << " errors in total!\n";
+    return;
+  }
+  std::cout << "SUCCESS\n";
+}
+
+/// Verify the equivalence of two unranked memrefs.
+template <typename T>
+void verifyMemRef(UnrankedMemRefType<T> &M1, UnrankedMemRefType<T> &M2) {
+  verifyMemRef(DynamicMemRefType<T>(M1), DynamicMemRefType<T>(M2));
+}
+
 } // namespace impl
 
 ////////////////////////////////////////////////////////////////////////////////
 // Currently exposed C API.
 ////////////////////////////////////////////////////////////////////////////////
 extern "C" MLIR_RUNNERUTILS_EXPORT void
 _mlir_ciface_print_memref_i8(UnrankedMemRefType<int8_t> *M);
 extern "C" MLIR_RUNNERUTILS_EXPORT void

 _mlir_ciface_print_memref_3d_f32(StridedMemRefType<float, 3> *M);
 extern "C" MLIR_RUNNERUTILS_EXPORT void
 _mlir_ciface_print_memref_4d_f32(StridedMemRefType<float, 4> *M);
 
 extern "C" MLIR_RUNNERUTILS_EXPORT void
 _mlir_ciface_print_memref_vector_4x4xf32(
     StridedMemRefType<Vector2D<4, 4, float>, 2> *M);
 
+extern "C" MLIR_RUNNERUTILS_EXPORT void
+_mlir_ciface_verify_memref_i32(UnrankedMemRefType<int32_t> *M1,
+                               UnrankedMemRefType<int32_t> *M2);
+extern "C" MLIR_RUNNERUTILS_EXPORT void
+_mlir_ciface_verify_memref_f32(UnrankedMemRefType<float> *M1,
+                               UnrankedMemRefType<float> *M2);
+extern "C" MLIR_RUNNERUTILS_EXPORT void
+_mlir_ciface_verify_memref_f64(UnrankedMemRefType<double> *M1,
+                               UnrankedMemRefType<double> *M2);
+
+extern "C" MLIR_RUNNERUTILS_EXPORT void
+verify_memref_i32(int64_t rank, void *ptr1, void *ptr2);
+extern "C" MLIR_RUNNERUTILS_EXPORT void
+verify_memref_f32(int64_t rank, void *ptr1, void *ptr2);
+extern "C" MLIR_RUNNERUTILS_EXPORT void
+verify_memref_f64(int64_t rank, void *ptr1, void *ptr2);
+
 #endif // EXECUTIONENGINE_RUNNERUTILS_H_

mlir/integration_test/Dialect/Linalg/CPU/benchmark_matmul.mlir

 // RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \
 // RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \
-// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \
+// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \
 // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \
 // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.copy register-tile-sizes=4,32 vectorize" | \
 
 // RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \
 // RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \
 // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
 // Activate to dump assembly
 // R_UN:   -dump-object-file -object-filename=/tmp/a.o \
+// RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // Use tee to both print to stderr and FileCheck
 // RUN: tee -a /dev/stderr | FileCheck %s
 
 
 !elem_type_a = type f32
 !elem_type_b = type f32
 !elem_type_c = type f32

 
 func @main() {
   %v0 = constant 0.0 : !elem_type_a
   %v1 = constant 1.0 : !elem_type_a
 
   %A = alloc() : !row_major_A
   %B = alloc() : !row_major_B
   %C = alloc() : !row_major_C
+  %C_ref = alloc() : !row_major_C
 
   linalg.fill(%A, %v1) : !row_major_A, !elem_type_a
   linalg.fill(%B, %v1) : !row_major_B, !elem_type_b
   linalg.fill(%C, %v0) : !row_major_C, !elem_type_c
+  linalg.fill(%C_ref, %v0) : !row_major_C, !elem_type_c
 
   %c0 = constant 0: index
   %c1 = constant 1: index
   %iters = constant ${ITERS}: index
 
   /// Run and dump performance for matmul.
   /// Preheating run:
   scf.for %arg0 = %c0 to %iters step %c1 {
scf.for %arg0 = %c0 to %iters step %c1 {
     %z = constant 0.0 : !elem_type_c
     linalg.fill(%C, %z) : !row_major_C, !elem_type_c
     call @matmul(%A, %B, %C) : (!row_major_A, !row_major_B, !row_major_C) -> ()
   }
   %t_end_matmul = call @rtclock() : () -> f64
   %tmatmul = subf %t_end_matmul, %t_start_matmul: f64
   call @print_perf(%iters, %tmatmul) : (index, f64) -> ()
 
-  %res = load %C[%c0, %c0]: !row_major_C
-  // CHECK: 64
-  vector.print %res: f32
+  // CHECK: SUCCESS
+  linalg.matmul ins(%A, %B : !row_major_A, !row_major_B)
+    outs(%C_ref: !row_major_C)
+  %res = memref_cast %C : !row_major_C to memref<*xf32>
+  %exp = memref_cast %C_ref : !row_major_C to memref<*xf32>
+  call @verify_memref_f32(%res, %exp) : (memref<*xf32>, memref<*xf32>) -> ()
 
   dealloc %A : !row_major_A
   dealloc %B : !row_major_B
   dealloc %C : !row_major_C
+  dealloc %C_ref : !row_major_C
 
   return
 }
 
 func private @rtclock() -> f64
+func private @verify_memref_f32(memref<*xf32>, memref<*xf32>) attributes { llvm.emit_c_interface }
 
 // TODO: init with random, run and check output.
 // func private @fill_random_f32(memref<*xf32>)

mlir/integration_test/Dialect/Linalg/CPU/benchmark_matmul_column_major.mlir

 // RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \
 // RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \
-// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.matmul_column_major register-tile-sizes=16,0,32 vectorize" | \
+// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul_column_major anchor-op=linalg.matmul_column_major register-tile-sizes=16,0,32 vectorize" | \
 // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.fill register-tile-sizes=4,16 vectorize" | \
 
 // TODO: linalg.copy vectorization in the presence of permutation map fails. Enable when addressed.
 // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.copy register-tile-sizes=4,16 vectorize" | \
 
 // RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \
 // RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \
 // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
 // Activate to dump assembly
 // R_UN:   -dump-object-file -object-filename=/tmp/a.o \
+// RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // Use tee to both print to stderr and FileCheck
 // RUN: tee -a /dev/stderr | FileCheck %s
 
 !elem_type_a = type f32
 !elem_type_b = type f32
 !elem_type_c = type f32
 !row_major_A = type memref<${M}x${K}x!elem_type_a>

 
 func @main() {
   %f0 = constant 0.0 : !elem_type_c
   %f1 = constant 1.0 : !elem_type_a
 
   %cA = alloc() : !column_major_A
   %cB = alloc() : !column_major_B
   %cC = alloc() : !column_major_C
+  %cC_ref = alloc() : !column_major_C
 
   linalg.fill(%cA, %f1) : !column_major_A, !elem_type_a
   linalg.fill(%cB, %f1) : !column_major_B, !elem_type_b
   linalg.fill(%cC, %f0) : !column_major_C, !elem_type_c
+  linalg.fill(%cC_ref, %f0) : !column_major_C, !elem_type_c
 
   %c0 = constant 0: index
   %c1 = constant 1: index
   %iters = constant ${ITERS}: index
 
   /// Run and dump performance for matmul_column_major.
   %t_start_matmul_column_major = call @rtclock() : () -> f64
   scf.for %arg0 = %c0 to %iters step %c1 {
     // linalg.matmul writes %C in place, need to reset it to zero every time.
     // This is accounts for about 10-15% perf hit on small sizes.
     // Once linalg on tensors is ready, fusing fill at the register level will
     // be easy.
     linalg.fill(%cC, %f0) : !column_major_C, !elem_type_c
     call @matmul_column_major(%cA, %cB, %cC) : (!column_major_A, !column_major_B, !column_major_C) -> ()
   }
   %t_end_matmul_column_major = call @rtclock() : () -> f64
   %tmatmul_column_major = subf %t_end_matmul_column_major, %t_start_matmul_column_major: f64
   call @print_perf(%iters, %tmatmul_column_major) : (index, f64) -> ()
 
-  %res = load %cC[%c0, %c0]: !column_major_C
-  // CHECK: 64
-  vector.print %res: !elem_type_c
+  // CHECK: SUCCESS
+  linalg.matmul_column_major ins(%cA, %cB : !column_major_A, !column_major_B)
+    outs(%cC_ref: !column_major_C)
+  %res = memref_cast %cC : !column_major_C to memref<*xf32>
+  %exp = memref_cast %cC_ref : !column_major_C to memref<*xf32>
+  call @verify_memref_f32(%res, %exp) : (memref<*xf32>, memref<*xf32>) -> ()
 
   dealloc %cA : !column_major_A
   dealloc %cB : !column_major_B
   dealloc %cC : !column_major_C
+  dealloc %cC_ref : !column_major_C
 
   return
 }
 
 func private @rtclock() -> f64
+func private @verify_memref_f32(memref<*xf32>, memref<*xf32>) attributes { llvm.emit_c_interface }
 
 // TODO: init with random, run and check output.
 // func private @fill_random_f32(memref<*xf32>)

mlir/integration_test/Dialect/Linalg/CPU/benchmark_matmul_column_major_as_row_major.mlir

 // RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \
 // RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \
-// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.matmul_column_major register-tile-sizes=16,0,32 vectorize" | \
-// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \
+// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul_column_major_as_row_major anchor-op=linalg.matmul_column_major register-tile-sizes=16,0,32 vectorize" | \
+// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul_column_major_as_row_major anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \
 // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.fill register-tile-sizes=4,16 vectorize" | \
 
 // TODO: linalg.copy vectorization in the presence of permutation map fails. Enable when addressed.
 // R_UN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.copy register-tile-sizes=4,16 vectorize" | \
 
 // RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \
 // RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \
 // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
 // Activate to dump assembly
 // R_UN:   -dump-object-file -object-filename=/tmp/a.o \
+// RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // Use tee to both print to stderr and FileCheck
 // RUN: tee -a /dev/stderr | FileCheck %s
 
 !elem_type_a = type f32
 !elem_type_b = type f32
 !elem_type_c = type f32
 !row_major_A = type memref<${M}x${K}x!elem_type_a>
func @print_perf(%iters: index, %total_time: f64) {
   vector.print %flops_per_s : f64
 
   return
 }
 
 func @main() {
   %f0 = constant 0.0 : !elem_type_c
   %f1 = constant 1.0 : !elem_type_a
   
   %cA = alloc() : !column_major_A
   %cB = alloc() : !column_major_B
   %cC = alloc() : !column_major_C
+  %cC_ref = alloc() : !column_major_C
+  %C_ref = alloc() : !row_major_C
+  
 
   linalg.fill(%cA, %f1) : !column_major_A, !elem_type_a
   linalg.fill(%cB, %f1) : !column_major_B, !elem_type_b
   linalg.fill(%cC, %f0) : !column_major_C, !elem_type_c
+  linalg.fill(%cC_ref, %f0) : !column_major_C, !elem_type_c
+  linalg.fill(%C_ref, %f0) : !row_major_C, !elem_type_c
 
   %c0 = constant 0: index
   %c1 = constant 1: index
   %iters = constant ${ITERS}: index
 
   /// Run and dump performance for matmul_column_major as a row-major
   %A = alloc() : !row_major_A
   %B = alloc() : !row_major_B
   %C = alloc() : !row_major_C
   %t_start_matmul_column_major_as_row_major = call @rtclock() : () -> f64
   scf.for %arg0 = %c0 to %iters step %c1 {
     // linalg.matmul writes %C in place, need to reset it to zero every time.
     // This is accounts for about 10-15% perf hit on small sizes.
     // Once linalg on tensors is ready, fusing fill at the register level will
     // be easy.
     linalg.fill(%C, %f0) : !row_major_C, !elem_type_c
     call @matmul_column_major_as_row_major(%cA, %cB, %cC, %A, %B, %C) :
       (!column_major_A, !column_major_B, !column_major_C,
        !row_major_A, !row_major_B, !row_major_C) -> ()
   }
   %t_end_matmul_column_major_as_row_major = call @rtclock() : () -> f64
   %tmatmul_column_major_as_row_major = subf %t_end_matmul_column_major_as_row_major, %t_start_matmul_column_major_as_row_major: f64
   call @print_perf(%iters, %tmatmul_column_major_as_row_major) : (index, f64) -> ()
 
-  %res = load %cC[%c0, %c0]: !column_major_C
-  // CHECK: 64
-  vector.print %res: !elem_type_c
-  %res2 = load %C[%c0, %c0]: !row_major_C
-  // CHECK: 64
-  vector.print %res2: !elem_type_c
+  // CHECK: SUCCESS
+  linalg.matmul_column_major ins(%cA, %cB : !column_major_A, !column_major_B)
+    outs(%cC_ref: !column_major_C)
+  %res1 = memref_cast %cC : !column_major_C to memref<*xf32>
+  %exp1 = memref_cast %cC_ref : !column_major_C to memref<*xf32>
+  call @verify_memref_f32(%res1, %exp1) : (memref<*xf32>, memref<*xf32>) -> ()
+  // CHECK: SUCCESS
+  linalg.matmul ins(%A, %B : !row_major_A, !row_major_B)
+    outs(%C_ref: !row_major_C)
+  %res2 = memref_cast %C : !row_major_C to memref<*xf32>
+  %exp2 = memref_cast %C_ref : !row_major_C to memref<*xf32>
+  call @verify_memref_f32(%res2, %exp2) : (memref<*xf32>, memref<*xf32>) -> ()
 
   dealloc %A : !row_major_A
   dealloc %B : !row_major_B
   dealloc %C : !row_major_C
+  dealloc %C_ref : !row_major_C
 
   dealloc %cA : !column_major_A
   dealloc %cB : !column_major_B
   dealloc %cC : !column_major_C
+  dealloc %cC_ref : !column_major_C
 
   return
 }
 
 func private @rtclock() -> f64
+func private @verify_memref_f32(memref<*xf32>, memref<*xf32>) attributes { llvm.emit_c_interface }
 
 // TODO: init with random, run and check output.
 // func private @fill_random_f32(memref<*xf32>)

mlir/integration_test/Dialect/Linalg/CPU/benchmark_matmul_i8_i8_i32.mlir

 // RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \
 // RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \
 // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul_i8_i8_i32 register-tile-sizes=12,32,16 vectorize" | \
 // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \
 // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.copy register-tile-sizes=4,32 vectorize" | \
 // RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \
 
 // RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm -mlir-disable-threading | \
 // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
 // Activate to dump assembly
 // R_UN:   -dump-object-file -object-filename=/tmp/a.o \
+// RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // Use tee to both print to stderr and FileCheck
 // RUN: tee -a /dev/stderr | FileCheck %s
 
 
 !elem_type_a = type i8
 !elem_type_b = type i8
 !elem_type_c = type i32

 
 func @main() {
   %v0 = constant 0 : !elem_type_c
   %v1 = constant 1 : !elem_type_a
 
   %A = alloc() : !row_major_A
   %B = alloc() : !row_major_B
   %C = alloc() : !row_major_C
+  %C_ref = alloc() : !row_major_C
 
   linalg.fill(%A, %v1) : !row_major_A, !elem_type_a
   linalg.fill(%B, %v1) : !row_major_B, !elem_type_b
   linalg.fill(%C, %v0) : !row_major_C, !elem_type_c
+  linalg.fill(%C_ref, %v0) : !row_major_C, !elem_type_c
 
   %c0 = constant 0: index
   %c1 = constant 1: index
   %iters = constant 100: index
 
   /// Run and dump performance for matmul.
   /// Preheating run:
   scf.for %arg0 = %c0 to %iters step %c1 {
     linalg.fill(%C, %v0) : !row_major_C, !elem_type_c
     call @matmul(%A, %B, %C) : (!row_major_A, !row_major_B, !row_major_C) -> ()
   }
   %t_start_matmul = call @rtclock() : () -> f64
   scf.for %arg0 = %c0 to %iters step %c1 {
     // linalg.matmul writes %C in place, need to reset it to zero every time.
     // This is accounts for about 10-15% perf hit on small sizes.
     // Once linalg on tensors is ready, fusing fill at the register level will
     // be easy.
     linalg.fill(%C, %v0) : !row_major_C, !elem_type_c
     call @matmul(%A, %B, %C) : (!row_major_A, !row_major_B, !row_major_C) -> ()
   }
   %t_end_matmul = call @rtclock() : () -> f64
   %tmatmul = subf %t_end_matmul, %t_start_matmul: f64
   call @print_perf(%iters, %tmatmul) : (index, f64) -> ()
 
-  %res = load %C[%c0, %c0]: !row_major_C
-  // CHECK: 64
-  vector.print %res: !elem_type_c
+  // CHECK: SUCCESS
+  linalg.matmul_i8_i8_i32 ins(%A, %B : !row_major_A, !row_major_B)
+    outs(%C_ref: !row_major_C)
+  %res = memref_cast %C : !row_major_C to memref<*xi32>
+  %exp = memref_cast %C_ref : !row_major_C to memref<*xi32>
+  call @verify_memref_i32(%res, %exp) : (memref<*xi32>, memref<*xi32>) -> ()
 
   dealloc %A : !row_major_A
   dealloc %B : !row_major_B
   dealloc %C : !row_major_C
+  dealloc %C_ref : !row_major_C
 
   return
 }
 
 func private @rtclock() -> f64
+func private @verify_memref_i32(memref<*xi32>, memref<*xi32>) attributes { llvm.emit_c_interface }
 
 // TODO: init with random, run and check output.
 // func private @fill_random_f32(memref<*xf32>)

mlir/lib/ExecutionEngine/RunnerUtils.cpp

 extern "C" void
 _mlir_ciface_print_memref_3d_f32(StridedMemRefType<float, 3> *M) {
   impl::printMemRef(*M);
 }
 extern "C" void
 _mlir_ciface_print_memref_4d_f32(StridedMemRefType<float, 4> *M) {
   impl::printMemRef(*M);
 }
+
+extern "C" void
+_mlir_ciface_verify_memref_i32(UnrankedMemRefType<int32_t> *M1,
+                               UnrankedMemRefType<int32_t> *M2) {
+  impl::verifyMemRef(*M1, *M2);
+}
+
+extern "C" void _mlir_ciface_verify_memref_f32(UnrankedMemRefType<float> *M1,
+                                               UnrankedMemRefType<float> *M2) {
+  impl::verifyMemRef(*M1, *M2);
+}
+
+extern "C" void _mlir_ciface_verify_memref_f64(UnrankedMemRefType<double> *M1,
+                                               UnrankedMemRefType<double> *M2) {
+  impl::verifyMemRef(*M1, *M2);
+}
+
+extern "C" void verify_memref_i32(int64_t rank, void *ptr1, void *ptr2) {
+  UnrankedMemRefType<int32_t> descriptor1 = {rank, ptr1};
+  UnrankedMemRefType<int32_t> descriptor2 = {rank, ptr2};
+  _mlir_ciface_verify_memref_i32(&descriptor1, &descriptor2);
+}
+
+extern "C" void verify_memref_f32(int64_t rank, void *ptr1, void *ptr2) {
+  UnrankedMemRefType<float> descriptor1 = {rank, ptr1};
+  UnrankedMemRefType<float> descriptor2 = {rank, ptr2};
+  _mlir_ciface_verify_memref_f32(&descriptor1, &descriptor2);
+}
+
+extern "C" void verify_memref_f64(int64_t rank, void *ptr1, void *ptr2) {
+  UnrankedMemRefType<double> descriptor1 = {rank, ptr1};
+  UnrankedMemRefType<double> descriptor2 = {rank, ptr2};
+  _mlir_ciface_verify_memref_f64(&descriptor1, &descriptor2);
+}
 No newline at end of file