[mlir][linalg] Fix neutral element value for minf/maxf

[ThomasRaoux]

Summary

The neutral element got minf/maxf should be respectively +inf and -inf.

Bug reported by @Hardcode84.

[Hardcode84]

LGTM

mlir/test/Dialect/Linalg/transform-op-split-reduction.mlir

115

Side question: Does anyone know why they are printed as hex instead of +/-inf? Doesn't look very user-friendly.

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

Optional<Attribute> getNeutralElement(Operation *op) {
   if (auto floatType = resultType.dyn_cast<FloatType>()) {
     const llvm::fltSemantics &semantic = floatType.getFloatSemantics();
     if (isa<arith::AddFOp>(op))
       return b.getFloatAttr(resultType, llvm::APFloat::getZero(semantic));
     if (isa<arith::MulFOp>(op))
       return b.getFloatAttr(resultType, llvm::APFloat(semantic, 1));
     if (isa<arith::MaxFOp>(op))
       return b.getFloatAttr(resultType,
-                            llvm::APFloat::getLargest(semantic, true));
+                            llvm::APFloat::getInf(semantic, /*Negative=*/true));
     if (isa<arith::MinFOp>(op))
-      return b.getFloatAttr(resultType,
-                            llvm::APFloat::getLargest(semantic, true));
+      return b.getFloatAttr(
+          resultType, llvm::APFloat::getInf(semantic, /*Negative=*/false));
     return Attribute();
   }
   if (isa<arith::AddIOp, arith::OrIOp, arith::XOrIOp>(op))
     return b.getIntegerAttr(resultType, 0);
   if (isa<arith::AndIOp>(op))
     return b.getIntegerAttr(resultType, -1);
   if (isa<arith::MaxSIOp>(op))
     return b.getIntegerAttr(resultType, std::numeric_limits<int64_t>::min());

mlir/test/Dialect/Linalg/transform-op-split-reduction.mlir

 }
 
 //  CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d2, d1, d0)>
 //  CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d3, d2, d1)>
 //  CHECK-DAG: #[[$MAP2:.*]] = affine_map<(d0, d1, d2, d3) -> (d3, d0, d2)>
 //  CHECK-DAG: #[[$MAP3:.*]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
 //  CHECK-DAG: #[[$MAP4:.*]] = affine_map<(d0, d1, d2) -> (d0, d1)>
 // CHECK-LABEL:  func @generic_split_3d
-//  CHECK-DAG: %[[ID:.*]] = arith.constant -3.40282347E+38 : f32
+//  CHECK-DAG: %[[ID:.*]] = arith.constant 0xFF800000 : f32
 //  CHECK-DAG: %[[I1:.*]] = tensor.expand_shape %{{.*}}[0, 1], [2]] : tensor<32x2xf32> into tensor<4x8x2xf32>
 //  CHECK-DAG: %[[I2:.*]] = tensor.expand_shape %{{.*}}[0], [1, 2]] : tensor<5x32xf32> into tensor<5x4x8xf32>
 //  CHECK-DAG: %[[INI:.*]] = tensor.empty() : tensor<5x2x4xf32>
 //      CHECK: %[[F:.*]] = linalg.fill ins(%[[ID]] : f32) outs(%[[INI]] : tensor<5x2x4xf32>) -> tensor<5x2x4xf32>
 //      CHECK: %[[G:.*]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "reduction", "parallel", "parallel"]}
 // CHECK-SAME:   ins(%[[I1]], %[[I2]] : tensor<4x8x2xf32>, tensor<5x4x8xf32>) outs(%[[F]] : tensor<5x2x4xf32>) {
 //      CHECK:   arith.addf
 //      CHECK:   arith.maxf
%0 = linalg.generic {
         affine_map<(d0, d1, d2) -> (d1, d0)>,
         affine_map<(d0, d1, d2) -> (d2, d1)>,
         affine_map<(d0, d1, d2) -> (d2, d0)>
       ],
       iterator_types = ["parallel", "reduction", "parallel"]
     } ins(%input, %input_2 : tensor<32x2xf32>, tensor<5x32xf32>) outs(%output : tensor<5x2xf32>) {
     ^bb0(%arg0: f32, %arg1: f32, %arg2: f32):
       %3 = arith.addf %arg0, %arg1 : f32
-      %4 = arith.maxf %3, %arg2 : f32
+      %4 = arith.minf %3, %arg2 : f32
       linalg.yield %4 : f32
     } -> tensor<5x2xf32>
   return %0 : tensor<5x2xf32>
 }
 
 //  CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d1, d2, d0)>  
 //  CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d3, d1, d2)>  
 //  CHECK-DAG: #[[$MAP2:.*]] = affine_map<(d0, d1, d2, d3) -> (d3, d0, d2)>  
 //  CHECK-DAG: #[[$MAP3:.*]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>  
 //  CHECK-DAG: #[[$MAP4:.*]] = affine_map<(d0, d1, d2) -> (d0, d1)>  
 // CHECK-LABEL:  func @generic_split_3d 
-//  CHECK-DAG: %[[ID:.*]] = arith.constant -3.40282347E+38 : f32  
+//  CHECK-DAG: %[[ID:.*]] = arith.constant 0x7F800000 : f32 
 //  CHECK-DAG: %[[I1:.*]] = tensor.expand_shape %{{.*}}[0, 1], [2]] : tensor<32x2xf32> into tensor<8x4x2xf32> 
 //  CHECK-DAG: %[[I2:.*]] = tensor.expand_shape %{{.*}}[0], [1, 2]] : tensor<5x32xf32> into tensor<5x8x4xf32> 
 //  CHECK-DAG: %[[INI:.*]] = tensor.empty() : tensor<5x2x4xf32> 
 //      CHECK: %[[F:.*]] = linalg.fill ins(%[[ID]] : f32) outs(%[[INI]] : tensor<5x2x4xf32>) -> tensor<5x2x4xf32>  
 //      CHECK: %[[G:.*]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "reduction", "parallel", "parallel"]}  
 // CHECK-SAME:   ins(%[[I1]], %[[I2]] : tensor<8x4x2xf32>, tensor<5x8x4xf32>) outs(%[[F]] : tensor<5x2x4xf32>) {  
 //      CHECK:   arith.addf 
-//      CHECK:   arith.maxf 
+//      CHECK:   arith.minf 
 //      CHECK:   linalg.yield 
 //      CHECK: } -> tensor<5x2x4xf32>  
 //      CHECK: %[[R:.*]] = linalg.generic {indexing_maps = [#[[$MAP3]], #[[$MAP4]]], iterator_types = ["parallel", "parallel", "reduction"]}  
 // CHECK-SAME:   ins(%[[G]] : tensor<5x2x4xf32>) outs(%{{.*}} : tensor<5x2xf32>) {  
-//      CHECK:   arith.maxf 
+//      CHECK:   arith.minf 
 //      CHECK:   linalg.yield 
 //      CHECK:  } -> tensor<5x2xf32> 
 //      CHECK: return %[[R]] : tensor<5x2xf32>  
 
 transform.sequence failures(propagate) {
 ^bb1(%arg1: !pdl.operation):
   %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
   %1:4 = transform.structured.split_reduction %0 { split_factor = 4, insert_split_dimension = 2, inner_parallel}
 }