[flang][OpenMP] Support lowering to MLIR for ordered clause

[peixin]

Summary

This supports the lowering parse-tree to MLIR for ordered clause in
worksharing-loop directive. Also add the test case for operation
conversion.

Part of this patch is from the fir-dev branch of
https://github.com/flang-compiler/f18-llvm-project.

Co-authored-by: Sourabh Singh Tomar <[e-mail]>

[peixin]

This will fix the problem in https://github.com/llvm/llvm-project/issues/54478.

[NimishMishra]

Thank you for the patch. Lowering side LGTM, with one question for the test case you have added. Please wait for someone else's comments for convert-to-llvmir.mlir test.

flang/test/Lower/OpenMP/omp-wsloop-ordered.f90

34

Is this ordered intentionally commented out?

[kiranchandramohan]

LGTM. Have one comment. Also please respond to @NimishMishra's comments.

mlir/test/Conversion/OpenMPToLLVM/convert-to-llvmir.mlir

70

I think for clauses these conversion checks are not required in mlir.

You may add these tests in flang/test/Fir/convert-to-llvm-openmp-and-fir.fir

[peixin]

flang/test/Lower/OpenMP/omp-wsloop-ordered.f90

34

Yes. It is not supported yet. I had one patch in fir-dev to support the lowering of ordered depend directive. But it may need changes since it must be consistent with OMPIRBuilder. Michael is working on the doacross loop nest support in OMPIRBuilder. After he supports it, I will take it back from fir-dev and fix it accordingly.

mlir/test/Conversion/OpenMPToLLVM/convert-to-llvmir.mlir

70

OK. The conversion for clauses does look like not necessary. I will remove this.

[peixin]

Remove the mlir test case. Rebase before land.

flang/lib/Lower/OpenMP.cpp

auto wsLoopOp = firOpBuilder.create<mlir::omp::WsLoopOp>(
       collapseClauseOperand.dyn_cast_or_null<IntegerAttr>(),
       noWaitClauseOperand.dyn_cast_or_null<UnitAttr>(),
       orderedClauseOperand.dyn_cast_or_null<IntegerAttr>(),
       orderClauseOperand.dyn_cast_or_null<omp::ClauseOrderKindAttr>(),
       /*inclusive=*/firOpBuilder.getUnitAttr());
 
   // Handle attribute based clauses.
   for (const Fortran::parser::OmpClause &clause : wsLoopOpClauseList.v) {
-    if (const auto &scheduleClause =
-            std::get_if<Fortran::parser::OmpClause::Schedule>(&clause.u)) {
+    if (const auto &orderedClause =
+            std::get_if<Fortran::parser::OmpClause::Ordered>(&clause.u)) {
+      if (orderedClause->v.has_value()) {
+        const auto *expr = Fortran::semantics::GetExpr(orderedClause->v);
+        const std::optional<std::int64_t> orderedClauseValue =
+            Fortran::evaluate::ToInt64(*expr);
+        wsLoopOp.ordered_valAttr(
+            firOpBuilder.getI64IntegerAttr(*orderedClauseValue));
+      } else {
+        wsLoopOp.ordered_valAttr(firOpBuilder.getI64IntegerAttr(0));
+      }
+    } else if (const auto &scheduleClause =
+                   std::get_if<Fortran::parser::OmpClause::Schedule>(
+                       &clause.u)) {
       mlir::MLIRContext *context = firOpBuilder.getContext();
       const auto &scheduleType = scheduleClause->v;
       const auto &scheduleKind =
           std::get<Fortran::parser::OmpScheduleClause::ScheduleType>(
               scheduleType.t);
       switch (scheduleKind) {
       case Fortran::parser::OmpScheduleClause::ScheduleType::Static:
         wsLoopOp.schedule_valAttr(omp::ClauseScheduleKindAttr::get(

flang/test/Lower/OpenMP/omp-wsloop-ordered.f90

+! This test checks lowering of worksharing-loop construct with ordered clause.
+
+! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s
+
+! This checks lowering ordered clause specified without parameter
+subroutine wsloop_ordered_no_para()
+  integer :: a(10), i
+
+! CHECK:  omp.wsloop ordered(0) for (%{{.*}}) : i32 = (%{{.*}}) to (%{{.*}}) inclusive step (%{{.*}}) {
+! CHECK:    omp.yield
+! CHECK:  }
+
+  !$omp do ordered
+  do i = 2, 10
+    !$omp ordered
+    a(i) = a(i-1) + 1
+    !$omp end ordered
+  end do
+  !$omp end do
+
+end
+
+! This checks lowering ordered clause specified with a parameter
+subroutine wsloop_ordered_with_para()
+  integer :: a(10), i
+
+! CHECK: func @_QPwsloop_ordered_with_para() {
+! CHECK:  omp.wsloop ordered(1) for (%{{.*}}) : i32 = (%{{.*}}) to (%{{.*}}) inclusive step (%{{.*}}) {
+! CHECK:    omp.yield
+! CHECK:  }
+
+  !$omp do ordered(1)
+  do i = 2, 10
+    !!$omp ordered depend(sink: i-1)
+    a(i) = a(i-1) + 1
+    !!$omp ordered depend(source)
+  end do
+  !$omp end do
+
+end

mlir/test/Conversion/OpenMPToLLVM/convert-to-llvmir.mlir

-// RUN: mlir-opt -convert-openmp-to-llvm %s  -split-input-file | FileCheck %s
+// RUN: mlir-opt -convert-openmp-to-llvm -split-input-file %s | FileCheck %s
 
 // CHECK-LABEL: llvm.func @master_block_arg
 func.func @master_block_arg() {
   // CHECK: omp.master
   omp.master {
   // CHECK-NEXT: ^[[BB0:.*]](%[[ARG1:.*]]: i64, %[[ARG2:.*]]: i64):
   ^bb0(%arg1: index, %arg2: index):
     // CHECK-DAG: %[[CAST_ARG1:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : i64 to index
     // CHECK-DAG: %[[CAST_ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2]] : i64 to index
     // CHECK-NEXT: "test.payload"(%[[CAST_ARG1]], %[[CAST_ARG2]]) : (index, index) -> ()
     "test.payload"(%arg1, %arg2) : (index, index) -> ()
     omp.terminator
   }
   return
 }
 
+// -----
+
 // CHECK-LABEL: llvm.func @branch_loop
 func.func @branch_loop() {
   %start = arith.constant 0 : index
   %end = arith.constant 0 : index
   // CHECK: omp.parallel
   omp.parallel {
     // CHECK-NEXT: llvm.br ^[[BB1:.*]](%{{[0-9]+}}, %{{[0-9]+}} : i64, i64
     cf.br ^bb1(%start, %end : index, index)
^bb3:
     omp.barrier
     omp.taskwait
     omp.taskyield
     omp.terminator
   }
   return
 }
 
+// -----
+
 // CHECK-LABEL: @wsloop
 // CHECK: (%[[ARG0:.*]]: i64, %[[ARG1:.*]]: i64, %[[ARG2:.*]]: i64, %[[ARG3:.*]]: i64, %[[ARG4:.*]]: i64, %[[ARG5:.*]]: i64)
 func.func @wsloop(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index, %arg5: index) {
   // CHECK: omp.parallel
   omp.parallel {
     // CHECK: omp.wsloop for (%[[ARG6:.*]], %[[ARG7:.*]]) : i64 = (%[[ARG0]], %[[ARG1]]) to (%[[ARG2]], %[[ARG3]]) step (%[[ARG4]], %[[ARG5]]) {
     "omp.wsloop"(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) ({
     ^bb0(%arg6: index, %arg7: index):  
       // CHECK-DAG: %[[CAST_ARG6:.*]] = builtin.unrealized_conversion_cast %[[ARG6]] : i64 to index
       // CHECK-DAG: %[[CAST_ARG7:.*]] = builtin.unrealized_conversion_cast %[[ARG7]] : i64 to index
       // CHECK: "test.payload"(%[[CAST_ARG6]], %[[CAST_ARG7]]) : (index, index) -> ()
       "test.payload"(%arg6, %arg7) : (index, index) -> ()
       omp.yield
     }) {operand_segment_sizes = dense<[2, 2, 2, 0, 0, 0, 0]> : vector<7xi32>} : (index, index, index, index, index, index) -> ()
     omp.terminator
   }
   return
 }
+
+// -----
+
+// CHECK-LABEL: @wsloop_ordered_no_para
+// CHECK: %[[VAL0:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK: %[[VAL1:.*]] = llvm.mlir.constant(10 : i32) : i32
+// CHECK: %[[VAL2:.*]] = llvm.mlir.constant(2 : i32) : i32
+// CHECK: omp.wsloop ordered(0) for (%[[ARG0:.*]]) : i32 = (%[[VAL2]]) to (%[[VAL1]]) inclusive step (%[[VAL0]]) {
+// CHECK:   omp.yield
+// CHECK: }
+// CHECK: llvm.return
+func.func @wsloop_ordered_no_para() {
+  %c1_i32 = arith.constant 1 : i32
+  %c10_i32 = arith.constant 10 : i32
+  %c2_i32 = arith.constant 2 : i32
+  omp.wsloop ordered(0) for (%arg0) : i32 = (%c2_i32) to (%c10_i32) inclusive step (%c1_i32) {
+    omp.yield
+  }
+  return
+}
+
+// -----
+
+// CHECK-LABEL: @wsloop_ordered_with_para
+// CHECK: %[[VAL0:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK: %[[VAL1:.*]] = llvm.mlir.constant(10 : i32) : i32
+// CHECK: %[[VAL2:.*]] = llvm.mlir.constant(2 : i32) : i32
+// CHECK: omp.wsloop ordered(1) for (%[[ARG0:.*]]) : i32 = (%[[VAL2]]) to (%[[VAL1]]) inclusive step (%[[VAL0]]) {
+// CHECK:   omp.yield
+// CHECK: }
+// CHECK: llvm.return
+func.func @wsloop_ordered_with_para() {
+  %c1_i32 = arith.constant 1 : i32
+  %c10_i32 = arith.constant 10 : i32
+  %c2_i32 = arith.constant 2 : i32
+  omp.wsloop ordered(1) for (%arg0) : i32 = (%c2_i32) to (%c10_i32) inclusive step (%c1_i32) {
+    omp.yield
+  }
+  return
+}