[IRCE] Use the same min runtime iteration threshold for BPI and BFI checks

[skatkov]

Summary

In the last change to IRCE the BPI is ignored if BFI is present, however
BFI and BPI have a different thresholds. Specifically BPI approach checks only
latch exit probability so it is expected if the loop has only one exit block (latch)
the behavior with BFI and BPI should be the same,

BPI approach by default uses threshold 10, so it considers the loop with estimated
number of iterations less then 10 should not be considered for IRCE optimization.
BFI approach uses the default value 3 and this is inconsistent.

The CL modifies the code to use the same threshold for both approaches..

The test is updated due to it has two side-exits (except latch) and each of them has a
probability 1/16, so BFI estimates the number of runtime iteration is about to 7
(1/16 + 1/16 + some for latch) and test fails.

[mkazantsev]

It looks like the threshold 10 you are referring is coming from some option. Can we use the same option in both places instead?

[skatkov]

In D91230#2387803, @mkazantsev wrote:

It looks like the threshold 10 you are referring is coming from some option. Can we use the same option in both places instead?

you mean to combine
static cl::opt<int> MaxExitProbReciprocal("irce-max-exit-prob-reciprocal",

cl::Hidden, cl::init(10));

and
static cl::opt<unsigned> MinRuntimeIterations("min-runtime-iterations",

cl::Hidden, cl::init(10));

into one option?
Are you ok with the name min-runtime-iterations?

[mkazantsev]

Yes, it's what I mean. This name would be fine.

[mkazantsev]

LGTM, thanks!

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

115–116

Please rename into irce-min-runtime-itetarions

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

static cl::opt<unsigned> LoopSizeCutoff("irce-loop-size-cutoff", cl::Hidden,
                                         cl::init(64));
 
 static cl::opt<bool> PrintChangedLoops("irce-print-changed-loops", cl::Hidden,
                                        cl::init(false));
 
 static cl::opt<bool> PrintRangeChecks("irce-print-range-checks", cl::Hidden,
                                       cl::init(false));
 
-static cl::opt<int> MaxExitProbReciprocal("irce-max-exit-prob-reciprocal",
-                                          cl::Hidden, cl::init(10));
-
 static cl::opt<bool> SkipProfitabilityChecks("irce-skip-profitability-checks",
                                              cl::Hidden, cl::init(false));
 
-static cl::opt<unsigned> MinRuntimeIterations("min-runtime-iterations",
-                                              cl::Hidden, cl::init(3));
+static cl::opt<unsigned> MinRuntimeIterations("irce-min-runtime-iterations",
+                                              cl::Hidden, cl::init(10));
 
 static cl::opt<bool> AllowUnsignedLatchCondition("irce-allow-unsigned-latch",
                                                  cl::Hidden, cl::init(true));
 
 static cl::opt<bool> AllowNarrowLatchCondition(
     "irce-allow-narrow-latch", cl::Hidden, cl::init(true),
     cl::desc("If set to true, IRCE may eliminate wide range checks in loops "
              "with narrow latch condition."));
if (GetBFI.hasValue()) {
     }
     return true;
   }
 
   if (!BPI)
     return true;
   BranchProbability ExitProbability =
       BPI->getEdgeProbability(LS.Latch, LS.LatchBrExitIdx);
-  if (ExitProbability > BranchProbability(1, MaxExitProbReciprocal)) {
+  if (ExitProbability > BranchProbability(1, MinRuntimeIterations)) {
     LLVM_DEBUG(dbgs() << "irce: could not prove profitability: "
                       << "the exit probability is too big " << ExitProbability
                       << "\n";);
     return false;
   }
   return true;
 }
 

llvm/test/Transforms/IRCE/low-iterations.ll

-; RUN: opt -verify-loop-info -irce-print-changed-loops -passes=irce -min-runtime-iterations=3 < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-NO
-; RUN: opt -verify-loop-info -irce-print-changed-loops -passes=irce -min-runtime-iterations=0 < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-YES
+; RUN: opt -verify-loop-info -irce-print-changed-loops -passes=irce -irce-min-runtime-iterations=3 < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-NO
+; RUN: opt -verify-loop-info -irce-print-changed-loops -passes=irce -irce-min-runtime-iterations=0 < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-YES
 
 ; CHECK-YES: constrained Loop
 ; CHECK-NO-NOT: constrained Loop
 
 define i32 @multiple_access_no_preloop(
   i32* %arr_a, i32* %a_len_ptr, i32* %arr_b, i32* %b_len_ptr, i32 %n) {
 
   entry:

llvm/test/Transforms/IRCE/multiple-access-no-preloop.ll

 ; CHECK: [[main_loop_cond:[^ ]+]] = icmp slt i32 %idx.next, [[upper_limit]]
 ; CHECK: br i1 [[main_loop_cond]], label %loop, label %main.exit.selector
 
 ; CHECK: in.bounds.b.postloop:
 ; CHECK: %next.postloop = icmp slt i32 %idx.next.postloop, %n
 ; CHECK: br i1 %next.postloop, label %loop.postloop, label %exit.loopexit
 
 !0 = !{i32 0, i32 2147483647}
-!1 = !{!"branch_weights", i32 64, i32 4}
+!1 = !{!"branch_weights", i32 128, i32 4}