[flang][openacc] Add lowering for min operator

[clementval]

Summary

Add lowering support for the min operator
in reduction clause.

Depends on D151565

[razvanlupusoru]

flang/lib/Lower/OpenACC.cpp

597

I think there's a way to check for signedness on integer type. It might make sense to add assert here and ensure that F18 marks that flag on integer type it produces. I am okay doing it in a separate patch. I just don't feel right to try to get the max signed value without additional checking.

608

Spacing problem for this line and a few others below.

646

Is there a way to ensure the use of ordered/unordered compare is consistent with other parts of F18?

[clementval]

flang/lib/Lower/OpenACC.cpp

597

Sure I can add that in the follow up patch.

608

This is not showing tab vs space AFIAK

646

Easiest way would be to use the FirOpBuilder and use the same helper here and in the intrinsic lowering.

[jeanPerier]

flang/lib/Lower/OpenACC.cpp

646

They are actually even more variants of MIN/MAX behaviors (at least 5 listed at [1]) You could also use fir::genMin()/fir::genMax() [2] to get the same behavior.

[1] https://github.com/llvm/llvm-project/blob/e96648a9bd347c832fd43cb81014df804a127832/flang/include/flang/Optimizer/Builder/IntrinsicCall.h#L38

https://github.com/llvm/llvm-project/blob/e96648a9bd347c832fd43cb81014df804a127832/flang/include/flang/Optimizer/Builder/IntrinsicCall.h#L585

[clementval]

Use genMin as recommend by reviewer

[jeanPerier]

Thanks, LGTM

flang/lib/Lower/OpenACC.cpp

getReductionOperator(const Fortran::parser::AccReductionOperator &op) {
   }
   llvm_unreachable("unexpected reduction operator");
 }
 
 static mlir::Value genReductionInitValue(mlir::OpBuilder &builder,
                                          mlir::Location loc, mlir::Type ty,
                                          mlir::acc::ReductionOperator op) {
   if (op != mlir::acc::ReductionOperator::AccAdd &&
-      op != mlir::acc::ReductionOperator::AccMul)
+      op != mlir::acc::ReductionOperator::AccMul &&
+      op != mlir::acc::ReductionOperator::AccMin)
     TODO(loc, "reduction operator");
 
+  // min -> largest
+  if (op == mlir::acc::ReductionOperator::AccMin) {
+    if (ty.isIntOrIndex()) {
+      unsigned bits = ty.getIntOrFloatBitWidth();
+      return builder.create<mlir::arith::ConstantOp>(
+          loc, ty,
+          builder.getIntegerAttr(
+              ty, llvm::APInt::getSignedMaxValue(bits).getSExtValue()));
+    }
+    if (auto floatTy = mlir::dyn_cast_or_null<mlir::FloatType>(ty)) {
+      const llvm::fltSemantics &sem = floatTy.getFloatSemantics();
+      return builder.create<mlir::arith::ConstantOp>(
+          loc, ty,
+          builder.getFloatAttr(
+              ty, llvm::APFloat::getLargest(sem, /*negative=*/false)));
+    }
+  } else {
     // 0 for +, ior, ieor
     // 1 for *
-  unsigned initValue = op == mlir::acc::ReductionOperator::AccMul ? 1 : 0;
-
+    int64_t initValue = op == mlir::acc::ReductionOperator::AccMul ? 1 : 0;
     if (ty.isIntOrIndex())
       return builder.create<mlir::arith::ConstantOp>(
           loc, ty, builder.getIntegerAttr(ty, initValue));
     if (mlir::isa<mlir::FloatType>(ty))
       return builder.create<mlir::arith::ConstantOp>(
           loc, ty, builder.getFloatAttr(ty, initValue));
+  }
   TODO(loc, "reduction type");
 }
 
 static mlir::Value genCombiner(mlir::OpBuilder &builder, mlir::Location loc,
                                mlir::acc::ReductionOperator op, mlir::Type ty,
                                mlir::Value value1, mlir::Value value2) {
   if (op == mlir::acc::ReductionOperator::AccAdd) {
     if (ty.isIntOrIndex())
       return builder.create<mlir::arith::AddIOp>(loc, value1, value2);
     if (mlir::isa<mlir::FloatType>(ty))
       return builder.create<mlir::arith::AddFOp>(loc, value1, value2);
     TODO(loc, "reduction add type");
   }
 
   if (op == mlir::acc::ReductionOperator::AccMul) {
     if (ty.isIntOrIndex())
       return builder.create<mlir::arith::MulIOp>(loc, value1, value2);
     if (mlir::isa<mlir::FloatType>(ty))
       return builder.create<mlir::arith::MulFOp>(loc, value1, value2);
     TODO(loc, "reduction mul type");
   }
+
+  if (op == mlir::acc::ReductionOperator::AccMin) {
+    mlir::Value cmp;
+    if (ty.isIntOrIndex())
+      cmp = builder.create<mlir::arith::CmpIOp>(
+          loc, mlir::arith::CmpIPredicate::slt, value1, value2);
+    if (mlir::isa<mlir::FloatType>(ty))
+      cmp = builder.create<mlir::arith::CmpFOp>(
+          loc, mlir::arith::CmpFPredicate::OLT, value1, value2);
+    if (cmp)
+      return builder.create<mlir::arith::SelectOp>(loc, cmp, value1, value2);
+
+    TODO(loc, "reduction mul type");
+  }
+
   TODO(loc, "reduction operator");
 }
 
 mlir::acc::ReductionRecipeOp Fortran::lower::createOrGetReductionRecipe(
     mlir::OpBuilder &builder, llvm::StringRef recipeName, mlir::Location loc,
     mlir::Type ty, mlir::acc::ReductionOperator op) {
   mlir::ModuleOp mod =
       builder.getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();

flang/test/Lower/OpenACC/acc-reduction.f90

 ! This test checks lowering of OpenACC reduction clause.
 
 ! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
 
+! CHECK-LABEL: acc.reduction.recipe @reduction_min_f32 : f32 reduction_operator <min> init {
+! CHECK: ^bb0(%{{.*}}: f32):
+! CHECK:   %[[INIT:.*]] = arith.constant 3.40282347E+38 : f32
+! CHECK:   acc.yield %[[INIT]] : f32
+! CHECK: } combiner {
+! CHECK: ^bb0(%[[ARG0:.*]]: f32, %[[ARG1:.*]]: f32):
+! CHECK:   %[[CMP:.*]] = arith.cmpf olt, %[[ARG0]], %[[ARG1]] : f32
+! CHECK:   %[[SELECT:.*]] = arith.select %[[CMP]], %[[ARG0]], %[[ARG1]] : f32
+! CHECK:   acc.yield %[[SELECT]] : f32
+! CHECK: }
+
+! CHECK-LABEL: acc.reduction.recipe @reduction_min_i32 : i32 reduction_operator <min> init {
+! CHECK: ^bb0(%arg0: i32):
+! CHECK:   %[[INIT:.*]] = arith.constant 2147483647 : i32
+! CHECK:   acc.yield %[[INIT]] : i32
+! CHECK: } combiner {
+! CHECK: ^bb0(%[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32):
+! CHECK:   %[[CMP:.*]] = arith.cmpi slt, %[[ARG0]], %[[ARG1]] : i32
+! CHECK:   %[[SELECT:.*]] = arith.select %[[CMP]], %[[ARG0]], %[[ARG1]] : i32
+! CHECK:   acc.yield %[[SELECT]] : i32
+! CHECK: }
+
 ! CHECK-LABEL: acc.reduction.recipe @reduction_mul_f32 : f32 reduction_operator <mul> init {
 ! CHECK: ^bb0(%{{.*}}: f32):
 ! CHECK:   %[[INIT:.*]] = arith.constant 1.000000e+00 : f32
 ! CHECK:   acc.yield %[[INIT]] : f32
 ! CHECK: } combiner {
 ! CHECK: ^bb0(%[[ARG0:.*]]: f32, %[[ARG1:.*]]: f32):
 ! CHECK:   %[[COMBINED:.*]] = arith.mulf %[[ARG0]], %[[ARG1]] {{.*}} : f32
 ! CHECK:   acc.yield %[[COMBINED]] : f32
subroutine acc_reduction_mul_float(a, b)
   do i = 1, 100
     b = b * a(i)
   end do
 end subroutine
 
 ! CHECK-LABEL: func.func @_QPacc_reduction_mul_float(
 ! CHECK-SAME:  %{{.*}}: !fir.ref<!fir.array<100xf32>> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref<f32> {fir.bindc_name = "b"})
 ! CHECK:       acc.loop reduction(@reduction_mul_f32 -> %[[B]] : !fir.ref<f32>)
+
+
+subroutine acc_reduction_min_int(a, b)
+  integer :: a(100)
+  integer :: i, b
+
+  !$acc loop reduction(min:b)
+  do i = 1, 100
+    b = min(b, a(i))
+  end do
+end subroutine
+
+! CHECK-LABEL: func.func @_QPacc_reduction_min_int(
+! CHECK-SAME:  %{{.*}}: !fir.ref<!fir.array<100xi32>> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref<i32> {fir.bindc_name = "b"})
+! CHECK:       acc.loop reduction(@reduction_min_i32 -> %[[B]] : !fir.ref<i32>)
+
+subroutine acc_reduction_min_float(a, b)
+  real :: a(100), b
+  integer :: i
+
+  !$acc loop reduction(min:b)
+  do i = 1, 100
+    b = min(b, a(i))
+  end do
+end subroutine
+
+! CHECK-LABEL: func.func @_QPacc_reduction_min_float(
+! CHECK-SAME:  %{{.*}}: !fir.ref<!fir.array<100xf32>> {fir.bindc_name = "a"}, %[[B:.*]]: !fir.ref<f32> {fir.bindc_name = "b"})
+! CHECK:       acc.loop reduction(@reduction_min_f32 -> %[[B]] : !fir.ref<f32>)