[mlir][arith] Add initial files for (runtime) integration tests

[kuhar]

Summary

The goal is to have a set of runtime tests for further extercise the wide integer emulation pass and its conversion patterns. This was suggested by @Mogball in D133629.

Add a minimal runtime test to demonstrate that printing and pass pipeline works as expected.

[Mogball]

mlir/lib/Dialect/Arithmetic/Transforms/EmulateWideInt.cpp

373

Why is this pattern needed?

[kuhar]

mlir/lib/Dialect/Arithmetic/Transforms/EmulateWideInt.cpp

373

Without this, vector.print %x : i2N would be considered illegal and the mlir-opt invocation would fail.

The high-level idea behind future integration test is to run the same module with and without emulation, so that we can generate the expected emulated values based on whatever mlir-cpu-runner prints for wide operations without emulation.

As an alternative, I think we might be able to always print vector<2xiN>, but this would require us to bitcast from i2N to vector<2xiN. I don't think that arith.bitcast supports that but llvm.bitcast should. But then I'm not sure if this wouldn't defer the same problem to the missing conversion/legality check for llvm.bitcast.

[Mogball]

Thanks for adding these. Especially with how complicated some of the emulation patterns are, these will add confidence to the implementation.

mlir/lib/Dialect/Arithmetic/Transforms/EmulateWideInt.cpp

373

You're right that arith.bitcast doesn't do vector bitcasting -- it sounds like we need a vector.bitcast op that does that (which also maps to llvm.bitcast). That being said, if this pattern is only needed for testing, I would suggest moving it into a test pass.

But I wouldn't say that this pattern is "test only". It's legalizing vector.print to use wide integer emulation (even though that just means it rewrites the operand types). So I think you can drop the comment about that.

[kuhar]

mlir/lib/Dialect/Arithmetic/Transforms/EmulateWideInt.cpp

373

Yeah, the comment was meant to justify the unusual placement of the pattern: I'd expect to see it in a vector transform or dedicated test pass. But in the interest of incremental changes, I added it to the main arith pass for the time being.

mlir/lib/Dialect/Arithmetic/Transforms/EmulateWideInt.cpp

matchAndRewrite(arith::TruncIOp op, OpAdaptor adaptor,
     Value truncated =
         rewriter.createOrFold<arith::TruncIOp>(loc, op.getType(), extracted);
     rewriter.replaceOp(op, truncated);
     return success();
   }
 };
 
 //===----------------------------------------------------------------------===//
+// ConvertVectorPrint
+//===----------------------------------------------------------------------===//
+
+// This is a convenience conversion pattern for integration tests with
+// `mlir-cpu-runner` only.
+struct ConvertVectorPrint final : OpConversionPattern<vector::PrintOp> {
+  using OpConversionPattern::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(vector::PrintOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<vector::PrintOp>(op, adaptor.getSource());
+    return success();
+  }
+};
+
+//===----------------------------------------------------------------------===//
 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 struct EmulateWideIntPass final
     : arith::impl::ArithmeticEmulateWideIntBase<EmulateWideIntPass> {
   using ArithmeticEmulateWideIntBase::ArithmeticEmulateWideIntBase;
 
   void runOnOperation() override {
void arith::populateWideIntEmulationPatterns(
   populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(patterns,
                                                                  typeConverter);
   populateCallOpTypeConversionPattern(patterns, typeConverter);
   populateReturnOpTypeConversionPattern(patterns, typeConverter);
 
   // Populate `arith.*` conversion patterns.
   patterns.add<
       // Misc ops.
-      ConvertConstant,
+      ConvertConstant, ConvertVectorPrint,
       // Binary ops.
       ConvertAddI,
       // Extension and truncation ops.
       ConvertExtSI, ConvertExtUI, ConvertTruncI>(typeConverter,
                                                  patterns.getContext());
 }

mlir/test/Integration/Dialect/Arithmetic/CPU/lit.local.cfg

+import sys
+
+# No JIT on win32.
+if sys.platform == 'win32':
+    config.unsupported = True

mlir/test/Integration/Dialect/Arithmetic/CPU/test-wide-int-emulation-constants-i16.mlir

+// Check that the wide integer constant emulation produces the same result as wide
+// constants and that printing works. Emulate i16 ops with i8 ops.
+
+// RUN: mlir-opt %s --arith-emulate-wide-int="widest-int-supported=8" \
+// RUN:             --convert-scf-to-cf --convert-cf-to-llvm --convert-vector-to-llvm \
+// RUN:             --convert-func-to-llvm --convert-arith-to-llvm | \
+// RUN:   mlir-cpu-runner -e entry -entry-point-result=void \
+// RUN:                   --shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
+// RUN:   FileCheck %s --match-full-lines --check-prefix=EMULATED
+
+func.func @entry() {
+  %cst0 = arith.constant 0 : i16
+  %cst1 = arith.constant 1 : i16
+  %cst_1 = arith.constant -1 : i16
+  %cst_3 = arith.constant -3 : i16
+
+  %cst13 = arith.constant 13 : i16
+  %cst256 = arith.constant 256 : i16
+
+  %cst_i16_max = arith.constant 32767 : i16
+  %cst_i16_min = arith.constant -32768 : i16
+
+  // EMULATED: ( 0, 0 )
+  vector.print %cst0 : i16
+  // EMULATED-NEXT: ( 1, 0 )
+  vector.print %cst1 : i16
+
+  // EMULATED-NEXT: ( -1, -1 )
+  vector.print %cst_1 : i16
+  // EMULATED-NEXT: ( -3, -1 )
+  vector.print %cst_3 : i16
+
+  // EMULATED-NEXT: ( 13, 0 )
+  vector.print %cst13 : i16
+  // EMULATED-NEXT: ( 0, 1 )
+  vector.print %cst256 : i16
+
+  // EMULATED-NEXT: ( -1, 127 )
+  vector.print %cst_i16_max : i16
+  // EMULATED-NEXT: ( 0, -128 )
+  vector.print %cst_i16_min : i16
+
+  return
+}