Commit 650bbc56 authored by Michael Kruse's avatar Michael Kruse
Browse files

[OpenMP][OpenMPIRBuilder] Implement loop unrolling. 

Recommit of 707ce34b. Don't introduce a
dependency to the LLVMPasses component, instead register the required
passes individually.

Add methods for loop unrolling to the OpenMPIRBuilder class and use them in Clang if `-fopenmp-enable-irbuilder` is enabled. The unrolling methods are:

 * `unrollLoopFull`
 * `unrollLoopPartial`
 * `unrollLoopHeuristic`

`unrollLoopPartial` and `unrollLoopHeuristic` can use compiler heuristics to automatically determine the unroll factor. If possible, that is if no CanonicalLoopInfo is required to pass to another method, metadata for LLVM's LoopUnrollPass is added. Otherwise the unroll factor is determined using the same heurstics as user by LoopUnrollPass. Not requiring a CanonicalLoopInfo, especially with `unrollLoopHeuristic` allows greater flexibility.

With full unrolling and partial unrolling with known unroll factor, instead of duplicating instructions by the OpenMPIRBuilder, the full unroll is still delegated to the LoopUnrollPass. In case of partial unrolling the loop is first tiled using the existing `tileLoops` methods, then the inner loop fully unrolled using the same mechanism.

Reviewed By: jdoerfert, kiranchandramohan

Differential Revision: https://reviews.llvm.org/D107764
parent 37e6a27d

clang/include/clang/Sema/Sema.h

+5 −0
Original line number Diff line number Diff line
@@ -10572,6 +10572,11 @@ public: 
  /// an OpenMP loop directive.

  StmtResult ActOnOpenMPCanonicalLoop(Stmt *AStmt);













  /// Process a canonical OpenMP loop nest that can either be a canonical













  /// literal loop (ForStmt or CXXForRangeStmt), or the generated loop of an













  /// OpenMP loop transformation construct.













  StmtResult ActOnOpenMPLoopnest(Stmt *AStmt);



























  /// End of OpenMP region.















  ///















  /// \param S Statement associated with the current OpenMP region.

































clang/lib/CodeGen/CGStmtOpenMP.cpp



+57
−1






























Original line number
Diff line number
Diff line








@@ -1951,11 +1951,27 @@ llvm::CanonicalLoopInfo *













CodeGenFunction::EmitOMPCollapsedCanonicalLoopNest(const Stmt *S, int Depth) {















  assert(Depth == 1 && "Nested loops with OpenMPIRBuilder not yet implemented");





























  // The caller is processing the loop-associated directive processing the \p













  // Depth loops nested in \p S. Put the previous pending loop-associated













  // directive to the stack. If the current loop-associated directive is a loop













  // transformation directive, it will push its generated loops onto the stack













  // such that together with the loops left here they form the combined loop













  // nest for the parent loop-associated directive.













  int ParentExpectedOMPLoopDepth = ExpectedOMPLoopDepth;













  ExpectedOMPLoopDepth = Depth;





























  EmitStmt(S);















  assert(OMPLoopNestStack.size() >= (size_t)Depth && "Found too few loops");































  // The last added loop is the outermost one.













  return OMPLoopNestStack.back();













  llvm::CanonicalLoopInfo *Result = OMPLoopNestStack.back();



























  // Pop the \p Depth loops requested by the call from that stack and restore













  // the previous context.













  OMPLoopNestStack.set_size(OMPLoopNestStack.size() - Depth);













  ExpectedOMPLoopDepth = ParentExpectedOMPLoopDepth;



























  return Result;















}































void CodeGenFunction::EmitOMPCanonicalLoop(const OMPCanonicalLoop *S) {










@@ -2585,6 +2601,46 @@ void CodeGenFunction::EmitOMPTileDirective(const OMPTileDirective &S) {













}































void CodeGenFunction::EmitOMPUnrollDirective(const OMPUnrollDirective &S) {













  bool UseOMPIRBuilder = CGM.getLangOpts().OpenMPIRBuilder;



























  if (UseOMPIRBuilder) {













    auto DL = SourceLocToDebugLoc(S.getBeginLoc());













    const Stmt *Inner = S.getRawStmt();



























    // Consume nested loop. Clear the entire remaining loop stack because a













    // fully unrolled loop is non-transformable. For partial unrolling the













    // generated outer loop is pushed back to the stack.













    llvm::CanonicalLoopInfo *CLI = EmitOMPCollapsedCanonicalLoopNest(Inner, 1);













    OMPLoopNestStack.clear();



























    llvm::OpenMPIRBuilder &OMPBuilder = CGM.getOpenMPRuntime().getOMPBuilder();



























    bool NeedsUnrolledCLI = ExpectedOMPLoopDepth >= 1;













    llvm::CanonicalLoopInfo *UnrolledCLI = nullptr;



























    if (S.hasClausesOfKind<OMPFullClause>()) {













      assert(ExpectedOMPLoopDepth == 0);













      OMPBuilder.unrollLoopFull(DL, CLI);













    } else if (auto *PartialClause = S.getSingleClause<OMPPartialClause>()) {













      uint64_t Factor = 0;













      if (Expr *FactorExpr = PartialClause->getFactor()) {













        Factor = FactorExpr->EvaluateKnownConstInt(getContext()).getZExtValue();













        assert(Factor >= 1 && "Only positive factors are valid");













      }













      OMPBuilder.unrollLoopPartial(DL, CLI, Factor,













                                   NeedsUnrolledCLI ? &UnrolledCLI : nullptr);













    } else {













      OMPBuilder.unrollLoopHeuristic(DL, CLI);













    }



























    assert((!NeedsUnrolledCLI || UnrolledCLI) &&













           "NeedsUnrolledCLI implies UnrolledCLI to be set");













    if (UnrolledCLI)













      OMPLoopNestStack.push_back(UnrolledCLI);



























    return;













  }





























  // This function is only called if the unrolled loop is not consumed by any















  // other loop-associated construct. Such a loop-associated construct will have















  // used the transformed AST.

































clang/lib/CodeGen/CodeGenFunction.h



+4
−0






























Original line number
Diff line number
Diff line








@@ -291,6 +291,10 @@ public:













  /// nest would extend.















  SmallVector<llvm::CanonicalLoopInfo *, 4> OMPLoopNestStack;





























  /// Number of nested loop to be consumed by the last surrounding













  /// loop-associated directive.













  int ExpectedOMPLoopDepth = 0;





























  // CodeGen lambda for loops and support for ordered clause















  typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &,















                                  JumpDest)>

































clang/lib/Parse/ParseOpenMP.cpp



+1
−2






























Original line number
Diff line number
Diff line








@@ -2562,8 +2562,7 @@ Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {





























        if (AssociatedStmt.isUsable() && isOpenMPLoopDirective(DKind) &&















            getLangOpts().OpenMPIRBuilder)













          AssociatedStmt =













              Actions.ActOnOpenMPCanonicalLoop(AssociatedStmt.get());













          AssociatedStmt = Actions.ActOnOpenMPLoopnest(AssociatedStmt.get());















      }















      AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);















    } else if (DKind == OMPD_target_update || DKind == OMPD_target_enter_data ||

































clang/lib/Sema/SemaOpenMP.cpp



+13
−0






























Original line number
Diff line number
Diff line








@@ -5574,6 +5574,19 @@ StmtResult Sema::ActOnOpenMPCanonicalLoop(Stmt *AStmt) {













                                  LoopVarFunc, LVRef);















}



























StmtResult Sema::ActOnOpenMPLoopnest(Stmt *AStmt) {













  // Handle a literal loop.













  if (isa<ForStmt>(AStmt) || isa<CXXForRangeStmt>(AStmt))













    return ActOnOpenMPCanonicalLoop(AStmt);

























  // If not a literal loop, it must be the result of a loop transformation.













  OMPExecutableDirective *LoopTransform = cast<OMPExecutableDirective>(AStmt);













  assert(













      isOpenMPLoopTransformationDirective(LoopTransform->getDirectiveKind()) &&













      "Loop transformation directive expected");













  return LoopTransform;













}



























static ExprResult buildUserDefinedMapperRef(Sema &SemaRef, Scope *S,















                                            CXXScopeSpec &MapperIdScopeSpec,















                                            const DeclarationNameInfo &MapperId,