[flang-commits] [flang] d7e561b - [flang][OpenMP] Support `bind` clause code-gen for standalone `loop`s (#122674)
via flang-commits
flang-commits at lists.llvm.org
Mon Jan 27 06:02:43 PST 2025
Author: Kareem Ergawy
Date: 2025-01-27T15:02:38+01:00
New Revision: d7e561b913d2a75c7c1807bf1c1e0bddc270a2b3
URL: https://github.com/llvm/llvm-project/commit/d7e561b913d2a75c7c1807bf1c1e0bddc270a2b3
DIFF: https://github.com/llvm/llvm-project/commit/d7e561b913d2a75c7c1807bf1c1e0bddc270a2b3.diff
LOG: [flang][OpenMP] Support `bind` clause code-gen for standalone `loop`s (#122674)
Extends rewriting of `loop` directives by supporting `bind` clause for
standalone directives. This follows both the spec and the current state
of clang as follows:
* No `bind` or `bind(thread)`: the `loop` is rewritten to `simd`.
* `bind(parallel)`: the `loop` is rewritten to `do`.
* `bind(teams)`: the `loop` is rewritten to `distribute`.
This is a follow-up PR for
https://github.com/llvm/llvm-project/pull/122632, only the latest commit
in this PR is relevant to the PR.
Added:
Modified:
flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp
flang/test/Lower/OpenMP/loop-directive.f90
Removed:
################################################################################
diff --git a/flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp b/flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp
index 555601c5e92df6..c95d625d7240b4 100644
--- a/flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp
+++ b/flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp
@@ -53,7 +53,7 @@ class GenericLoopConversionPattern
switch (combinedInfo) {
case GenericLoopCombinedInfo::Standalone:
- rewriteToSimdLoop(loopOp, rewriter);
+ rewriteStandaloneLoop(loopOp, rewriter);
break;
case GenericLoopCombinedInfo::TargetParallelLoop:
llvm_unreachable("not yet implemented: `parallel loop` direcitve");
@@ -87,7 +87,10 @@ class GenericLoopConversionPattern
<< loopOp->getName() << " operation";
};
- if (loopOp.getBindKind())
+ // For standalone directives, `bind` is already supported. Other combined
+ // forms will be supported in a follow-up PR.
+ if (combinedInfo != GenericLoopCombinedInfo::Standalone &&
+ loopOp.getBindKind())
return todo("bind");
if (loopOp.getOrder())
@@ -119,7 +122,27 @@ class GenericLoopConversionPattern
return result;
}
- /// Rewrites standalone `loop` directives to equivalent `simd` constructs.
+ void rewriteStandaloneLoop(mlir::omp::LoopOp loopOp,
+ mlir::ConversionPatternRewriter &rewriter) const {
+ using namespace mlir::omp;
+ std::optional<ClauseBindKind> bindKind = loopOp.getBindKind();
+
+ if (!bindKind.has_value())
+ return rewriteToSimdLoop(loopOp, rewriter);
+
+ switch (*loopOp.getBindKind()) {
+ case ClauseBindKind::Parallel:
+ return rewriteToWsloop(loopOp, rewriter);
+ case ClauseBindKind::Teams:
+ return rewriteToDistrbute(loopOp, rewriter);
+ case ClauseBindKind::Thread:
+ return rewriteToSimdLoop(loopOp, rewriter);
+ }
+ }
+
+ /// Rewrites standalone `loop` (without `bind` clause or with
+ /// `bind(parallel)`) directives to equivalent `simd` constructs.
+ ///
/// The reasoning behind this decision is that according to the spec (version
/// 5.2, section 11.7.1):
///
@@ -147,30 +170,57 @@ class GenericLoopConversionPattern
/// the directive.
void rewriteToSimdLoop(mlir::omp::LoopOp loopOp,
mlir::ConversionPatternRewriter &rewriter) const {
- loopOp.emitWarning("Detected standalone OpenMP `loop` directive, the "
- "associated loop will be rewritten to `simd`.");
- mlir::omp::SimdOperands simdClauseOps;
- simdClauseOps.privateVars = loopOp.getPrivateVars();
+ loopOp.emitWarning(
+ "Detected standalone OpenMP `loop` directive with thread binding, "
+ "the associated loop will be rewritten to `simd`.");
+ rewriteToSingleWrapperOp<mlir::omp::SimdOp, mlir::omp::SimdOperands>(
+ loopOp, rewriter);
+ }
+
+ void rewriteToDistrbute(mlir::omp::LoopOp loopOp,
+ mlir::ConversionPatternRewriter &rewriter) const {
+ rewriteToSingleWrapperOp<mlir::omp::DistributeOp,
+ mlir::omp::DistributeOperands>(loopOp, rewriter);
+ }
+
+ void rewriteToWsloop(mlir::omp::LoopOp loopOp,
+ mlir::ConversionPatternRewriter &rewriter) const {
+ rewriteToSingleWrapperOp<mlir::omp::WsloopOp, mlir::omp::WsloopOperands>(
+ loopOp, rewriter);
+ }
+
+ // TODO Suggestion by Sergio: tag auto-generated operations for constructs
+ // that weren't part of the original program, that would be useful
+ // information for debugging purposes later on. This new attribute could be
+ // used for `omp.loop`, but also for `do concurrent` transformations,
+ // `workshare`, `workdistribute`, etc. The tag could be used for all kinds of
+ // auto-generated operations using a dialect attribute (named something like
+ // `omp.origin` or `omp.derived`) and perhaps hold the name of the operation
+ // it was derived from, the reason it was transformed or something like that
+ // we could use when emitting any messages related to it later on.
+ template <typename OpTy, typename OpOperandsTy>
+ void
+ rewriteToSingleWrapperOp(mlir::omp::LoopOp loopOp,
+ mlir::ConversionPatternRewriter &rewriter) const {
+ OpOperandsTy clauseOps;
+ clauseOps.privateVars = loopOp.getPrivateVars();
auto privateSyms = loopOp.getPrivateSyms();
if (privateSyms)
- simdClauseOps.privateSyms.assign(privateSyms->begin(),
- privateSyms->end());
+ clauseOps.privateSyms.assign(privateSyms->begin(), privateSyms->end());
- Fortran::common::openmp::EntryBlockArgs simdArgs;
- simdArgs.priv.vars = simdClauseOps.privateVars;
+ Fortran::common::openmp::EntryBlockArgs args;
+ args.priv.vars = clauseOps.privateVars;
- auto simdOp =
- rewriter.create<mlir::omp::SimdOp>(loopOp.getLoc(), simdClauseOps);
- mlir::Block *simdBlock =
- genEntryBlock(rewriter, simdArgs, simdOp.getRegion());
+ auto wrapperOp = rewriter.create<OpTy>(loopOp.getLoc(), clauseOps);
+ mlir::Block *opBlock = genEntryBlock(rewriter, args, wrapperOp.getRegion());
mlir::IRMapping mapper;
mlir::Block &loopBlock = *loopOp.getRegion().begin();
- for (auto [loopOpArg, simdopArg] :
- llvm::zip_equal(loopBlock.getArguments(), simdBlock->getArguments()))
- mapper.map(loopOpArg, simdopArg);
+ for (auto [loopOpArg, opArg] :
+ llvm::zip_equal(loopBlock.getArguments(), opBlock->getArguments()))
+ mapper.map(loopOpArg, opArg);
rewriter.clone(*loopOp.begin(), mapper);
}
diff --git a/flang/test/Lower/OpenMP/loop-directive.f90 b/flang/test/Lower/OpenMP/loop-directive.f90
index 9fa0de3bfe171a..845905da0fcba2 100644
--- a/flang/test/Lower/OpenMP/loop-directive.f90
+++ b/flang/test/Lower/OpenMP/loop-directive.f90
@@ -92,7 +92,7 @@ subroutine test_reduction()
! CHECK-LABEL: func.func @_QPtest_bind
subroutine test_bind()
integer :: i, dummy = 1
- ! CHECK: omp.loop bind(thread) private(@{{.*}} %{{.*}}#0 -> %{{.*}} : {{.*}}) {
+ ! CHECK: omp.simd private(@{{.*}} %{{.*}}#0 -> %{{.*}} : {{.*}}) {
! CHECK: }
!$omp loop bind(thread)
do i=1,10
@@ -139,3 +139,43 @@ subroutine test_nested_directives
end do
!$omp end target teams
end subroutine
+
+! CHECK-LABEL: func.func @_QPtest_standalone_bind_teams
+subroutine test_standalone_bind_teams
+ implicit none
+ integer, parameter :: N = 100000
+ integer a(N), b(N), c(N)
+ integer j,i, num, flag;
+ num = N
+
+ ! CHECK: omp.distribute
+ ! CHECK-SAME: private(@{{.*}}Ea_private_ref_100000xi32 {{[^,]*}},
+ ! CHECK-SAME: @{{.*}}Ei_private_ref_i32 {{.*}} : {{.*}}) {
+ ! CHECK: omp.loop_nest {{.*}} {
+ ! CHECK: }
+ ! CHECK: }
+ !$omp loop bind(teams) private(a)
+ do i=1,N
+ c(i) = a(i) * b(i)
+ end do
+end subroutine
+
+! CHECK-LABEL: func.func @_QPtest_standalone_bind_parallel
+subroutine test_standalone_bind_parallel
+ implicit none
+ integer, parameter :: N = 100000
+ integer a(N), b(N), c(N)
+ integer j,i, num, flag;
+ num = N
+
+ ! CHECK: omp.wsloop
+ ! CHECK-SAME: private(@{{.*}}Ea_private_ref_100000xi32 {{[^,]*}},
+ ! CHECK-SAME: @{{.*}}Ei_private_ref_i32 {{.*}} : {{.*}}) {
+ ! CHECK: omp.loop_nest {{.*}} {
+ ! CHECK: }
+ ! CHECK: }
+ !$omp loop bind(parallel) private(a)
+ do i=1,N
+ c(i) = a(i) * b(i)
+ end do
+end subroutine
More information about the flang-commits
mailing list