[LoopUnroll] allow customization of threshold for new-pm

[wenju]

Summary

Legacy createLoopUnrollPass provides threshold parameter. This patch
brings the support to new-pm LoopUnrollPass.

Our downstream uses LoopUnroll pass with small threshold for fine tuning, so we want the support for new pm.

[fhahn]

Do you have any plans to add a user of the new Threshold option upstream

[wenju]

In D124355#3471091, @fhahn wrote:

Do you have any plans to add a user of the new Threshold option upstream

I don't have this plan. createLoopUnrollPass in standard pipeline uses default threshold parameter.

[dmgreen]

Can you just have getUnrollingPreferences override the UP.Threshold for your target? Or is it that you want a specific run of the unroll pass to have a lower threshold than other runs?

[wenju]

In D124355#3471198, @dmgreen wrote:

Can you just have getUnrollingPreferences override the UP.Threshold for your target?

Thanks for the suggestion.

Or is it that you want a specific run of the unroll pass to have a lower threshold than other runs?

Yes, our pipeline contains several calls of LoopUnroll pass with different thresholds, so I think getUnrollingPreferences or overriding command line option wouldn't work.

[wenju]

rebase

llvm/include/llvm/Transforms/Scalar/LoopUnrollPass.h

 /// additional setters and then pass it to LoopUnrollPass.
 ///
 struct LoopUnrollOptions {
   Optional<bool> AllowPartial;
   Optional<bool> AllowPeeling;
   Optional<bool> AllowRuntime;
   Optional<bool> AllowUpperBound;
   Optional<bool> AllowProfileBasedPeeling;
+  Optional<unsigned> Threshold;
   Optional<unsigned> FullUnrollMaxCount;
   int OptLevel;
 
   /// If false, use a cost model to determine whether unrolling of a loop is
   /// profitable. If true, only loops that explicitly request unrolling via
   /// metadata are considered. All other loops are skipped.
   bool OnlyWhenForced;
 
struct LoopUnrollOptions {
   }
 
   // Enables or disables loop peeling basing on profile.
   LoopUnrollOptions &setProfileBasedPeeling(int O) {
     AllowProfileBasedPeeling = O;
     return *this;
   }
 
+  // Sets "cost threshold" tuning parameter for loop unrolling.
+  LoopUnrollOptions &setThreshold(unsigned T) {
+    Threshold = T;
+    return *this;
+  }
+
   // Sets the max full unroll count.
   LoopUnrollOptions &setFullUnrollMaxCount(unsigned O) {
     FullUnrollMaxCount = O;
     return *this;
   }
 };
 
 /// Loop unroll pass that will support both full and partial unrolling.

llvm/lib/Passes/PassBuilder.cpp

int OptLevel = StringSwitch<int>(ParamName)
                        .Case("O1", 1)
                        .Case("O2", 2)
                        .Case("O3", 3)
                        .Default(-1);
     if (OptLevel >= 0) {
       UnrollOpts.setOptLevel(OptLevel);
       continue;
     }
+    if (ParamName.consume_front("threshold=")) {
+      unsigned Threshold;
+      if (ParamName.getAsInteger(0, Threshold))
+        return make_error<StringError>(
+            formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
+            inconvertibleErrorCode());
+      UnrollOpts.setThreshold(Threshold);
+      continue;
+    }
     if (ParamName.consume_front("full-unroll-max=")) {
       int Count;
       if (ParamName.getAsInteger(0, Count))
         return make_error<StringError>(
             formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
             inconvertibleErrorCode());
       UnrollOpts.setFullUnrollMaxCount(Count);
       continue;

llvm/lib/Passes/PassRegistry.def

FUNCTION_PASS_WITH_PARAMS("lower-matrix-intrinsics",
                           parseLowerMatrixIntrinsicsPassOptions,
                           "minimal")
 FUNCTION_PASS_WITH_PARAMS("loop-unroll",
                           "LoopUnrollPass",
                            [](LoopUnrollOptions Opts) {
                              return LoopUnrollPass(Opts);
                            },
                           parseLoopUnrollOptions,
-                          "O0;O1;O2;O3;full-unroll-max=N;"
+                          "O0;O1;O2;O3;threshold=N;full-unroll-max=N;"
                           "no-partial;partial;"
                           "no-peeling;peeling;"
                           "no-profile-peeling;profile-peeling;"
                           "no-runtime;runtime;"
                           "no-upperbound;upperbound")
 FUNCTION_PASS_WITH_PARAMS("msan",
                           "MemorySanitizerPass",
                            [](MemorySanitizerOptions Opts) {

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

#endif
     if (PSI && PSI->hasHugeWorkingSetSize())
       LocalAllowPeeling = false;
     std::string LoopName = std::string(L.getName());
     // The API here is quite complex to call and we allow to select some
     // flavors of unrolling during construction time (by setting UnrollOpts).
     LoopUnrollResult Result = tryToUnrollLoop(
         &L, DT, &LI, SE, TTI, AC, ORE, BFI, PSI,
         /*PreserveLCSSA*/ true, UnrollOpts.OptLevel, UnrollOpts.OnlyWhenForced,
-        UnrollOpts.ForgetSCEV, /*Count*/ None,
-        /*Threshold*/ None, UnrollOpts.AllowPartial, UnrollOpts.AllowRuntime,
+        UnrollOpts.ForgetSCEV, /*Count*/ None, UnrollOpts.Threshold,
+        UnrollOpts.AllowPartial, UnrollOpts.AllowRuntime,
         UnrollOpts.AllowUpperBound, LocalAllowPeeling,
         UnrollOpts.AllowProfileBasedPeeling, UnrollOpts.FullUnrollMaxCount);
     Changed |= Result != LoopUnrollResult::Unmodified;
 
     // The parent must not be damaged by unrolling!
 #ifndef NDEBUG
     if (Result != LoopUnrollResult::Unmodified && ParentL)
       ParentL->verifyLoop();
if (UnrollOpts.AllowPeeling != None)
     OS << (UnrollOpts.AllowPeeling.getValue() ? "" : "no-") << "peeling;";
   if (UnrollOpts.AllowRuntime != None)
     OS << (UnrollOpts.AllowRuntime.getValue() ? "" : "no-") << "runtime;";
   if (UnrollOpts.AllowUpperBound != None)
     OS << (UnrollOpts.AllowUpperBound.getValue() ? "" : "no-") << "upperbound;";
   if (UnrollOpts.AllowProfileBasedPeeling != None)
     OS << (UnrollOpts.AllowProfileBasedPeeling.getValue() ? "" : "no-")
        << "profile-peeling;";
+  if (UnrollOpts.Threshold != None)
+    OS << "threshold=" << UnrollOpts.Threshold << ";";
   if (UnrollOpts.FullUnrollMaxCount != None)
     OS << "full-unroll-max=" << UnrollOpts.FullUnrollMaxCount << ";";
   OS << "O" << UnrollOpts.OptLevel;
   OS << ">";
 }

llvm/test/Other/new-pm-print-pipeline.ll

 ; CHECK-7: function(loop(simple-loop-unswitch<nontrivial;trivial>,simple-loop-unswitch<no-nontrivial;no-trivial>))
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(mldst-motion<split-footer-bb>,mldst-motion<no-split-footer-bb>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-8
 ; CHECK-8: function(mldst-motion<split-footer-bb>,mldst-motion<no-split-footer-bb>)
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(lower-matrix-intrinsics<>,lower-matrix-intrinsics<minimal>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-9
 ; CHECK-9: function(lower-matrix-intrinsics<>,lower-matrix-intrinsics<minimal>)
 
-; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(loop-unroll<>,loop-unroll<partial;peeling;runtime;upperbound;profile-peeling;full-unroll-max=5;O1>,loop-unroll<no-partial;no-peeling;no-runtime;no-upperbound;no-profile-peeling;full-unroll-max=7;O1>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-10
-; CHECK-10: function(loop-unroll<O2>,loop-unroll<partial;peeling;runtime;upperbound;profile-peeling;full-unroll-max=5;O1>,loop-unroll<no-partial;no-peeling;no-runtime;no-upperbound;no-profile-peeling;full-unroll-max=7;O1>)
+; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(loop-unroll<>,loop-unroll<partial;peeling;runtime;upperbound;profile-peeling;threshold=32;full-unroll-max=5;O1>,loop-unroll<no-partial;no-peeling;no-runtime;no-upperbound;no-profile-peeling;threshold=32;full-unroll-max=7;O1>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-10
+; CHECK-10: function(loop-unroll<O2>,loop-unroll<partial;peeling;runtime;upperbound;profile-peeling;threshold=32;full-unroll-max=5;O1>,loop-unroll<no-partial;no-peeling;no-runtime;no-upperbound;no-profile-peeling;threshold=32;full-unroll-max=7;O1>)
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(gvn<>,gvn<pre;load-pre;split-backedge-load-pre;memdep>,gvn<no-pre;no-load-pre;no-split-backedge-load-pre;no-memdep>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-11
 ; CHECK-11: function(gvn<>,gvn<pre;load-pre;split-backedge-load-pre;memdep>,gvn<no-pre;no-load-pre;no-split-backedge-load-pre;no-memdep>)
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='function(early-cse<>,early-cse<memssa>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-12
 ; CHECK-12: function(early-cse<>,early-cse<memssa>)
 
 ; RUN: opt -disable-output -disable-verify -print-pipeline-passes -passes='msan-module,function(msan,msan<>,msan<recover;kernel;eager-checks;track-origins=5>)' < %s | FileCheck %s --match-full-lines --check-prefixes=CHECK-13

llvm/test/Other/print-passes.ll

 ; RUN: opt --print-passes | FileCheck %s
 
 ; CHECK: Module passes:
 ; CHECK: no-op-module
 ; CHECK: Module analyses:
 ; CHECK: no-op-module
 ; CHECK: Module alias analyses:
 ; CHECK: globals-aa
 ; CHECK: CGSCC passes:
 ; CHECK: no-op-cgscc
 ; CHECK: CGSCC analyses:
 ; CHECK: no-op-cgscc
 ; CHECK: Function passes:
 ; CHECK: no-op-function
 ; CHECK: Function passes with params:
-; CHECK: loop-unroll<O0;O1;O2;O3;full-unroll-max=N;no-partial;partial;no-peeling;peeling;no-profile-peeling;profile-peeling;no-runtime;runtime;no-upperbound;upperbound>
+; CHECK: loop-unroll<O0;O1;O2;O3;threshold=N;full-unroll-max=N;no-partial;partial;no-peeling;peeling;no-profile-peeling;profile-peeling;no-runtime;runtime;no-upperbound;upperbound>
 ; CHECK: Function analyses:
 ; CHECK: no-op-function
 ; CHECK: Function alias analyses:
 ; CHECK: basic-aa
 ; CHECK: LoopNest passes:
 ; CHECK: no-op-loopnest
 ; CHECK: Loop passes:
 ; CHECK: no-op-loop
 ; CHECK: Loop passes with params:
 ; CHECK: simple-loop-unswitch<nontrivial;no-nontrivial;trivial;no-trivial>
 ; CHECK: Loop analyses:
 ; CHECK: no-op-loop