[core] Update some of the terms and comments in loop analysis. (#3351)

Signed-off-by: Eric Schweitz <[email protected]>

Author: schweitzpgi

lib/Optimizer/Transforms/LoopAnalysis.cpp

@@ -30,10 +30,10 @@ using namespace mlir;
 /// A \em monotonic loop: a loop that counts from $i$ up to (down to) $j$
 /// stepping by positive (negative) integral values; mathematically, it is a
 /// strictly monotonic sequence. If the step is a compile-time constant, $k$,
-/// then a closed iterval monotonic loop must execute exactly $\max(0, \floor{(j
-/// - i + k) / k})$ iterations. By normalizing a monotonic loop and constant
-/// folding and propagation, we may be able to convert it to static control
-/// flow.
+/// then a closed iterval definite monotonic loop must execute exactly $\max(0,
+/// \floor{(j - i + k) / k})$ iterations. By normalizing a monotonic loop and
+/// constant folding and propagation, we may be able to convert it to static
+/// control flow.
 ///
 /// For completeness, a \em{conditionally iterated} loop is a monotonic loop
 /// that has a second auxilliary condition to determine if a given loop
@@ -309,10 +309,9 @@ bool opt::isaCountedLoop(cc::LoopOp loop, bool allowClosedInterval) {
          isaConstant(c.compareValue);
 }
 
-bool opt::isaConstantUpperBoundLoop(cc::LoopOp loop, bool allowClosedInterval) {
+bool opt::isaIndefiniteCountedLoop(cc::LoopOp loop, bool allowClosedInterval) {
   LoopComponents c;
-  return isaInvariantLoop(loop, allowClosedInterval, /*allowEarlyExit=*/true,
-                          &c) &&
+  return isaIndefiniteInvariantLoop(loop, allowClosedInterval, &c) &&
          isaConstant(c.compareValue);
 }
 

lib/Optimizer/Transforms/LoopAnalysis.h

@@ -74,7 +74,9 @@ bool isSignedPredicate(mlir::arith::CmpIPredicate p);
 bool isaCountedLoop(cc::LoopOp op, bool allowClosedInterval = true);
 
 bool loopContainsBreak(cc::LoopOp op);
-bool isaConstantUpperBoundLoop(cc::LoopOp op, bool allowClosedInterval = true);
+
+/// An indefinite counted loop is a counted loop which may have early exits.
+bool isaIndefiniteCountedLoop(cc::LoopOp op, bool allowClosedInterval = true);
 
 /// An invariant loop is defined to be a loop that will execute some run-time
 /// invariant number of iterations. We recognize a normalized, semi-open
@@ -88,6 +90,23 @@ bool isaInvariantLoop(cc::LoopOp op, bool allowClosedInterval = true,
                       bool allowEarlyExit = false, LoopComponents *c = nullptr);
 bool isaInvariantLoop(const LoopComponents &c, bool allowClosedInterval);
 
+/// An indefinite invariant loop is an invariant loop which may have early
+/// exits. The number of iterations will be at most the upper bound expression.
+/// We recognize the normalized, semi-open interval loop such as
+/// ```
+///   for(i = 0; i < invariant_expression; ++i) {
+///     ...
+///       break;
+///     ...
+///   }
+/// ```
+/// is a canonical indefinite loop.
+inline bool isaIndefiniteInvariantLoop(cc::LoopOp op,
+                                       bool allowClosedInterval = true,
+                                       LoopComponents *c = nullptr) {
+  return isaInvariantLoop(op, allowClosedInterval, /*allowEarlyExit=*/true, c);
+}
+
 // We expect the loop control value to have the following form.
 //
 //   %final = cc.loop while ((%iter = %initial) -> (iN)) {
@@ -118,8 +137,9 @@ bool hasMonotonicControlInduction(cc::LoopOp loop, LoopComponents *c = nullptr);
 /// ```
 ///   for(i = start; i < stop; i += step)
 /// ```
-/// is a monotonic loop that must execute a number of iterations as given
-/// by the following equation. Early exits (break statements) are not permitted.
+/// is a (definite) monotonic loop that must execute a number of iterations as
+/// given by the following equation. Early exits (break statements) are
+/// permitted in \e indefinite monotonic loops.
 /// ```
 ///   let iterations = (stop - 1 - start + step) / step
 ///      iterations : if iterations > 0
@@ -130,6 +150,12 @@ bool hasMonotonicControlInduction(cc::LoopOp loop, LoopComponents *c = nullptr);
 bool isaMonotonicLoop(mlir::Operation *op, bool allowEarlyExit = false,
                       LoopComponents *c = nullptr);
 
+/// An indefinite monotonic loop is a monotonic loop that may have early exits.
+inline bool isaIndefiniteMonotonicLoop(mlir::Operation *op,
+                                       LoopComponents *c = nullptr) {
+  return isaMonotonicLoop(op, /*allowEarlyExit=*/true, c);
+}
+
 /// Recover the different subexpressions from the loop if it conforms to the
 /// pattern. Given a LoopOp where induction is in a register:
 /// ```

lib/Optimizer/Transforms/LoopUnrollPatterns.inc

@@ -72,7 +72,7 @@ struct UnrollCountedLoop : public OpRewritePattern<cudaq::cc::LoopOp> {
         loop.emitOpError("not a simple counted loop");
       return failure();
     }
-    if (allowBreak && !cudaq::opt::isaConstantUpperBoundLoop(loop)) {
+    if (allowBreak && !cudaq::opt::isaIndefiniteCountedLoop(loop)) {
       if (signalFailure)
         loop.emitOpError("not a constant upper bound loop");
       return failure();