Clarify naming

Author: mgehre-amd

mlir/include/mlir/IR/AffineExpr.h

@@ -110,10 +110,10 @@ class AffineExpr {
   /// floordiv, ceildiv, and mod is only allowed w.r.t constants.
   bool isPureAffine() const;
 
-  /// Returns true if this expression is monotonic with respect to the
-  /// AffineDimExpr, i.e. increasing the value of any AffineDimExpr will never
-  /// decrease the value of the result.
-  bool isMonotonic() const;
+  /// Returns true if this expression is monotonicically increasing with respect
+  /// to the AffineDimExprs, i.e. increasing the value of any AffineDimExpr will
+  /// never decrease the value of the result.
+  bool isMonotonicallyIncreasing() const;
 
   /// Returns the greatest known integral divisor of this affine expression. The
   /// result is always positive.

mlir/include/mlir/IR/AffineMap.h

@@ -364,8 +364,9 @@ class AffineMap {
   /// Returns true if the AffineMap represents a symbol-less permutation map.
   bool isPermutation() const;
 
-  // Returns true if every result is monotonic.
-  bool isMonotonic() const;
+  // Returns true if every result is monotonically increasing.
+  // See AffineExpr::isMonotonicallyIncreasing().
+  bool isComponentWiseMonotonicallyIncreasing() const;
 
   /// Returns the map consisting of the `resultPos` subset.
   AffineMap getSubMap(ArrayRef<unsigned> resultPos) const;

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

@@ -620,7 +620,7 @@ computeSliceParameters(OpBuilder &builder, Location loc, Value valueToTile,
     // The offset & size computation below only handles the case when
     // the map is monotonic, i.e. the min and max values are attained at the
     // lower and upper bounds of the iteration domain.
-    if (!isTiled(m, tileSizes) || !m.isMonotonic()) {
+    if (!isTiled(m, tileSizes) || !m.isComponentWiseMonotonicallyIncreasing()) {
       sliceParams.offsets.push_back(builder.getIndexAttr(0));
       OpFoldResult dim = createFoldedDimOp(builder, loc, valueToTile, r);
       sliceParams.sizes.push_back(dim);

mlir/lib/IR/AffineExpr.cpp

@@ -244,27 +244,30 @@ static bool isNonNegativeConstant(AffineExpr expr) {
   return constant && constant.getValue() >= 0;
 }
 
-bool AffineExpr::isMonotonic() const {
+bool AffineExpr::isMonotonicallyIncreasing() const {
   switch (getKind()) {
   case AffineExprKind::SymbolId:
   case AffineExprKind::DimId:
   case AffineExprKind::Constant:
     return true;
   case AffineExprKind::Add: {
     auto op = llvm::cast<AffineBinaryOpExpr>(*this);
-    return op.getLHS().isMonotonic() && op.getRHS().isMonotonic();
+    return op.getLHS().isMonotonicallyIncreasing() &&
+           op.getRHS().isMonotonicallyIncreasing();
   }
   case AffineExprKind::Mul: {
     // One operand must be a non-negative constant.
     auto op = llvm::cast<AffineBinaryOpExpr>(*this);
-    return op.getLHS().isMonotonic() && op.getRHS().isMonotonic() &&
+    return op.getLHS().isMonotonicallyIncreasing() &&
+           op.getRHS().isMonotonicallyIncreasing() &&
            (isNonNegativeConstant(op.getLHS()) ||
             isNonNegativeConstant(op.getRHS()));
   }
   case AffineExprKind::FloorDiv:
   case AffineExprKind::CeilDiv: {
     auto op = llvm::cast<AffineBinaryOpExpr>(*this);
-    return op.getLHS().isMonotonic() && isNonNegativeConstant(op.getRHS());
+    return op.getLHS().isMonotonicallyIncreasing() &&
+           isNonNegativeConstant(op.getRHS());
   }
   case AffineExprKind::Mod:
     return false;

mlir/lib/IR/AffineMap.cpp

@@ -628,8 +628,9 @@ bool AffineMap::isPermutation() const {
   return isProjectedPermutation();
 }
 
-bool AffineMap::isMonotonic() const {
-  return all_of(getResults(), [](auto expr) { return expr.isMonotonic(); });
+bool AffineMap::isComponentWiseMonotonicallyIncreasing() const {
+  return all_of(getResults(),
+                [](auto expr) { return expr.isMonotonicallyIncreasing(); });
 }
 
 AffineMap AffineMap::getSubMap(ArrayRef<unsigned> resultPos) const {