Add tanh lowering from Standard dialect to NVVM and ROCDL.

[dfki-jugr]

Summary

The tanh lowering from Standard dialect to NVVM and ROCDL was not working.
The conversion pattern are inserted in the lowering files.
The test cases for the lowerings were added in the test files.

[ftynse]

Please update the commit message from "fixed tanh lowering" to "add tanh lowering". It was not broken (which would mandate a fix), it was never implemented to start with. Good to go otherwise.

[merge_guards_bot]

Unit tests: pass. 62198 tests passed, 0 failed and 815 were skipped.

clang-tidy: pass.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[dfki-jugr]

Fixed clang format issue.

[merge_guards_bot]

Unit tests: pass. 62198 tests passed, 0 failed and 815 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[herhut]

Thank you for adding this!

[stella.stamenova]

These two tests are failing on Windows like so:

##[error]mlir\test\Conversion\GPUToROCDL\gpu-to-rocdl.mlir(87,12): Error GDC2C77F0: CHECK: expected string not found in input
     1>E:\agent\_work\4\s\mlir\test\Conversion\GPUToROCDL\gpu-to-rocdl.mlir(87,12): error GDC2C77F0: CHECK: expected string not found in input [e:\agent\_work\4\b\check-all.vcxproj]
         
          // CHECK: llvm.func @_ocml_tanh_f32(!llvm.float) -> !llvm.float
         
                    ^
         
         <stdin>:66:2: note: scanning from here
         
          llvm.return
         
          ^
         
         <stdin>:73:2: note: possible intended match here
         
          llvm.func @tanhf(!llvm.float) -> !llvm.float
         
          ^

It looks like the fix is fairly straightforward at least.

[dfki-jugr]

We built the project on a Windows machine and were able to reproduce the failed test. We figured out that the tests are right, but the error was caused by a non-deterministic pattern rewriter step. We fixed the issue in another PR: https://reviews.llvm.org/D73713.
This fix should work on all platforms (Windows/Linux).

[nicolasvasilache]

mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir

174

@stella.stamenova is the determinism issue resolved by replacing all the new introduced CHECK by CHECK-DAG ?

@rriddle @mehdi_amini this is the original root cause of the benefit twiddling revision.
I can't tell offhand whether all the pieces involved in rewriting and lowering to LLVM are supposed to be deterministic across targets?

[stella.stamenova]

CHECK-DAG makes no difference. The output simply does not contain the expected values as written. The test expects to find @_ocml_tanh_f32 (e.g. llvm.func @_ocml_tanh_f32(!llvm.float) -> !llvm.float), but the output is:

module {
  llvm.func @tanh(!llvm.double) -> !llvm.double
  llvm.func @tanhf(!llvm.float) -> !llvm.float
  gpu.module @kernel_module {
    llvm.func @gpu_tanh(%arg0: !llvm.float, %arg1: !llvm.double) {
      %0 = llvm.call @tanhf(%arg0) : (!llvm.float) -> !llvm.float
      %1 = llvm.call @tanh(%arg1) : (!llvm.double) -> !llvm.double
      llvm.return
    }
  }
}

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

void mlir::populateGpuToNVVMConversionPatterns(
   patterns.insert<OpToFuncCallLowering<AbsFOp>>(converter, "__nv_fabsf",
                                                "__nv_fabs");
   patterns.insert<OpToFuncCallLowering<CeilFOp>>(converter, "__nv_ceilf",
                                                "__nv_ceil");
   patterns.insert<OpToFuncCallLowering<CosOp>>(converter, "__nv_cosf",
                                                "__nv_cos");
   patterns.insert<OpToFuncCallLowering<ExpOp>>(converter, "__nv_expf",
                                                "__nv_exp");
+  patterns.insert<OpToFuncCallLowering<TanhOp>>(converter, "__nv_tanhf",
+                                               "__nv_tanh");
 }
 
 std::unique_ptr<OpPassBase<gpu::GPUModuleOp>>
 mlir::createLowerGpuOpsToNVVMOpsPass() {
   return std::make_unique<LowerGpuOpsToNVVMOpsPass>();
 }
 
 static PassRegistration<LowerGpuOpsToNVVMOpsPass>
     pass("convert-gpu-to-nvvm", "Generate NVVM operations for gpu operations");

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

void runOnOperation() override {
     patterns.insert<OpToFuncCallLowering<AbsFOp>>(converter, "_ocml_fabs_f32",
                                                  "_ocml_fabs_f64");
     patterns.insert<OpToFuncCallLowering<CeilFOp>>(converter, "_ocml_ceil_f32",
                                                  "_ocml_ceil_f64");
     patterns.insert<OpToFuncCallLowering<CosOp>>(converter, "_ocml_cos_f32",
                                                  "_ocml_cos_f64");
     patterns.insert<OpToFuncCallLowering<ExpOp>>(converter, "_ocml_exp_f32",
                                                  "_ocml_exp_f64");
+    patterns.insert<OpToFuncCallLowering<TanhOp>>(converter, "_ocml_tanh_f32",
+                                                 "_ocml_tanh_f64");
 
     ConversionTarget target(getContext());
     target.addLegalDialect<LLVM::LLVMDialect, ROCDL::ROCDLDialect>();
     target.addIllegalOp<LLVM::FAbsOp, LLVM::FCeilOp, LLVM::CosOp,
                         LLVM::ExpOp>();
     target.addDynamicallyLegalOp<FuncOp>(
         [&](FuncOp op) { return converter.isSignatureLegal(op.getType()); });
     if (failed(applyPartialConversion(m, target, patterns, &converter)))

mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir

func @gpu_cos(%arg_f32 : f32, %arg_f64 : f64) {
     // CHECK: llvm.call @__nv_cos(%{{.*}}) : (!llvm.double) -> !llvm.double
     std.return
   }
 }
 
 // -----
 
 gpu.module @test_module {
+  // CHECK: llvm.func @__nv_tanhf(!llvm.float) -> !llvm.float
+  // CHECK: llvm.func @__nv_tanh(!llvm.double) -> !llvm.double
+  // CHECK-LABEL: func @gpu_tanh
+  func @gpu_tanh(%arg_f32 : f32, %arg_f64 : f64) {
+    %result32 = std.tanh %arg_f32 : f32
+    // CHECK: llvm.call @__nv_tanhf(%{{.*}}) : (!llvm.float) -> !llvm.float
+    %result64 = std.tanh %arg_f64 : f64
+    // CHECK: llvm.call @__nv_tanh(%{{.*}}) : (!llvm.double) -> !llvm.double
+    std.return
+  }
+}
+
+// -----
+gpu.module @test_module {
   // CHECK: llvm.func @__nv_expf(!llvm.float) -> !llvm.float
   // CHECK: llvm.func @__nv_exp(!llvm.double) -> !llvm.double
   // CHECK-LABEL: func @gpu_exp
   func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) {
     %exp_f32 = std.exp %arg_f32 : f32
     // CHECK: llvm.call @__nv_expf(%{{.*}}) : (!llvm.float) -> !llvm.float
     %result_f32 = std.exp %exp_f32 : f32
     // CHECK: llvm.call @__nv_expf(%{{.*}}) : (!llvm.float) -> !llvm.float
     %result64 = std.exp %arg_f64 : f64

mlir/test/Conversion/GPUToROCDL/gpu-to-rocdl.mlir

func @gpu_cos(%arg_f32 : f32, %arg_f64 : f64) {
     // CHECK: llvm.call @_ocml_cos_f64(%{{.*}}) : (!llvm.double) -> !llvm.double
     std.return
   }
 }
 
 // -----
 
 gpu.module @kernel_module {
+  // CHECK: llvm.func @_ocml_tanh_f32(!llvm.float) -> !llvm.float
+  // CHECK: llvm.func @_ocml_tanh_f64(!llvm.double) -> !llvm.double
+  // CHECK-LABEL: func @gpu_tanh
+  func @gpu_tanh(%arg_f32 : f32, %arg_f64 : f64) {
+    %result32 = std.tanh %arg_f32 : f32
+    // CHECK: llvm.call @_ocml_tanh_f32(%{{.*}}) : (!llvm.float) -> !llvm.float
+    %result64 = std.tanh %arg_f64 : f64
+    // CHECK: llvm.call @_ocml_tanh_f64(%{{.*}}) : (!llvm.double) -> !llvm.double
+    std.return
+  }
+}
+
+// -----
+gpu.module @kernel_module {
   // CHECK: llvm.func @_ocml_exp_f32(!llvm.float) -> !llvm.float
   // CHECK: llvm.func @_ocml_exp_f64(!llvm.double) -> !llvm.double
   // CHECK-LABEL: func @gpu_exp
   func @gpu_exp(%arg_f32 : f32, %arg_f64 : f64) {
     %exp_f32 = std.exp %arg_f32 : f32
     // CHECK: llvm.call @_ocml_exp_f32(%{{.*}}) : (!llvm.float) -> !llvm.float
     %result_f32 = std.exp %exp_f32 : f32
     // CHECK: llvm.call @_ocml_exp_f32(%{{.*}}) : (!llvm.float) -> !llvm.float