[MLIR][Affine][Analysis] Merge FAC and FACV

With the introduction of IntegerPolyhedron and IntegerRelation in Presburger
directory, the purpose of FlatAffineConstraints becomes redundant. For users
requiring Presburger arithmetic without IR information, Presburger library can
directly be used. For users requiring IR information,
FlatAffineValueConstraints can be used.

This patch merges FAC and FACV to remove redundancy of FAC.

Reviewed By: arjunp

Differential Revision: https://reviews.llvm.org/D122476

Author: Groverkss

mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h

@@ -29,6 +29,7 @@
 #define DEBUG_TYPE "affine-analysis"
 
 using namespace mlir;
+using namespace presburger;
 
 /// Get the value that is being reduced by `pos`-th reduction in the loop if
 /// such a reduction can be performed by affine parallel loops. This assumes
@@ -445,12 +446,10 @@ static void computeDirectionVector(
   dependenceComponents->resize(numCommonLoops);
   for (unsigned j = 0; j < numCommonLoops; ++j) {
     (*dependenceComponents)[j].op = commonLoops[j].getOperation();
-    auto lbConst =
-        dependenceDomain->getConstantBound(FlatAffineConstraints::LB, j);
+    auto lbConst = dependenceDomain->getConstantBound(IntegerPolyhedron::LB, j);
     (*dependenceComponents)[j].lb =
         lbConst.getValueOr(std::numeric_limits<int64_t>::min());
-    auto ubConst =
-        dependenceDomain->getConstantBound(FlatAffineConstraints::UB, j);
+    auto ubConst = dependenceDomain->getConstantBound(IntegerPolyhedron::UB, j);
     (*dependenceComponents)[j].ub =
         ubConst.getValueOr(std::numeric_limits<int64_t>::max());
   }

mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp

@@ -100,7 +100,7 @@ ComputationSliceState::getAsConstraints(FlatAffineValueConstraints *cst) {
     if (isValidSymbol(value)) {
       // Check if the symbol is a constant.
       if (auto cOp = value.getDefiningOp<arith::ConstantIndexOp>())
-        cst->addBound(FlatAffineConstraints::EQ, value, cOp.value());
+        cst->addBound(FlatAffineValueConstraints::EQ, value, cOp.value());
     } else if (auto loop = getForInductionVarOwner(value)) {
       if (failed(cst->addAffineForOpDomain(loop)))
         return failure();
@@ -357,13 +357,13 @@ Optional<int64_t> MemRefRegion::getConstantBoundingSizeAndShape(
   // over-approximation from projection or union bounding box. We may not add
   // this on the region itself since they might just be redundant constraints
   // that will need non-trivials means to eliminate.
-  FlatAffineConstraints cstWithShapeBounds(cst);
+  FlatAffineValueConstraints cstWithShapeBounds(cst);
   for (unsigned r = 0; r < rank; r++) {
-    cstWithShapeBounds.addBound(FlatAffineConstraints::LB, r, 0);
+    cstWithShapeBounds.addBound(FlatAffineValueConstraints::LB, r, 0);
     int64_t dimSize = memRefType.getDimSize(r);
     if (ShapedType::isDynamic(dimSize))
       continue;
-    cstWithShapeBounds.addBound(FlatAffineConstraints::UB, r, dimSize - 1);
+    cstWithShapeBounds.addBound(FlatAffineValueConstraints::UB, r, dimSize - 1);
   }
 
   // Find a constant upper bound on the extent of this memref region along each
@@ -440,7 +440,7 @@ LogicalResult MemRefRegion::unionBoundingBox(const MemRefRegion &other) {
 //    }
 //
 // region:  {memref = %A, write = false, {%i <= m0 <= %i + 7} }
-// The last field is a 2-d FlatAffineConstraints symbolic in %i.
+// The last field is a 2-d FlatAffineValueConstraints symbolic in %i.
 //
 // TODO: extend this to any other memref dereferencing ops
 // (dma_start, dma_wait).
@@ -520,7 +520,7 @@ LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,
       // Check if the symbol is a constant.
       if (auto *op = symbol.getDefiningOp()) {
         if (auto constOp = dyn_cast<arith::ConstantIndexOp>(op)) {
-          cst.addBound(FlatAffineConstraints::EQ, symbol, constOp.value());
+          cst.addBound(FlatAffineValueConstraints::EQ, symbol, constOp.value());
         }
       }
     }
@@ -585,10 +585,10 @@ LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,
   if (addMemRefDimBounds) {
     auto memRefType = memref.getType().cast<MemRefType>();
     for (unsigned r = 0; r < rank; r++) {
-      cst.addBound(FlatAffineConstraints::LB, /*pos=*/r, /*value=*/0);
+      cst.addBound(FlatAffineValueConstraints::LB, /*pos=*/r, /*value=*/0);
       if (memRefType.isDynamicDim(r))
         continue;
-      cst.addBound(FlatAffineConstraints::UB, /*pos=*/r,
+      cst.addBound(FlatAffineValueConstraints::UB, /*pos=*/r,
                    memRefType.getDimSize(r) - 1);
     }
   }
@@ -677,7 +677,7 @@ LogicalResult mlir::boundCheckLoadOrStoreOp(LoadOrStoreOp loadOrStoreOp,
 
   // For each dimension, check for out of bounds.
   for (unsigned r = 0; r < rank; r++) {
-    FlatAffineConstraints ucst(*region.getConstraints());
+    FlatAffineValueConstraints ucst(*region.getConstraints());
 
     // Intersect memory region with constraint capturing out of bounds (both out
     // of upper and out of lower), and check if the constraint system is
@@ -689,18 +689,18 @@ LogicalResult mlir::boundCheckLoadOrStoreOp(LoadOrStoreOp loadOrStoreOp,
       continue;
 
     // Check for overflow: d_i >= memref dim size.
-    ucst.addBound(FlatAffineConstraints::LB, r, dimSize);
+    ucst.addBound(FlatAffineValueConstraints::LB, r, dimSize);
     outOfBounds = !ucst.isEmpty();
     if (outOfBounds && emitError) {
       loadOrStoreOp.emitOpError()
           << "memref out of upper bound access along dimension #" << (r + 1);
     }
 
     // Check for a negative index.
-    FlatAffineConstraints lcst(*region.getConstraints());
+    FlatAffineValueConstraints lcst(*region.getConstraints());
     std::fill(ineq.begin(), ineq.end(), 0);
     // d_i <= -1;
-    lcst.addBound(FlatAffineConstraints::UB, r, -1);
+    lcst.addBound(FlatAffineValueConstraints::UB, r, -1);
     outOfBounds = !lcst.isEmpty();
     if (outOfBounds && emitError) {
       loadOrStoreOp.emitOpError()
@@ -1356,7 +1356,7 @@ void mlir::getSequentialLoops(AffineForOp forOp,
 }
 
 IntegerSet mlir::simplifyIntegerSet(IntegerSet set) {
-  FlatAffineConstraints fac(set);
+  FlatAffineValueConstraints fac(set);
   if (fac.isEmpty())
     return IntegerSet::getEmptySet(set.getNumDims(), set.getNumSymbols(),
                                    set.getContext());

mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp

@@ -34,6 +34,7 @@
 #define DEBUG_TYPE "LoopUtils"
 
 using namespace mlir;
+using namespace presburger;
 using llvm::SmallMapVector;
 
 namespace {
@@ -2364,8 +2365,8 @@ static bool getFullMemRefAsRegion(Operation *op, unsigned numParamLoopIVs,
   for (unsigned d = 0; d < rank; d++) {
     auto dimSize = memRefType.getDimSize(d);
     assert(dimSize > 0 && "filtered dynamic shapes above");
-    regionCst->addBound(FlatAffineConstraints::LB, d, 0);
-    regionCst->addBound(FlatAffineConstraints::UB, d, dimSize - 1);
+    regionCst->addBound(IntegerPolyhedron::LB, d, 0);
+    regionCst->addBound(IntegerPolyhedron::UB, d, dimSize - 1);
   }
   return true;
 }

mlir/lib/Dialect/Affine/Analysis/Utils.cpp

@@ -28,6 +28,7 @@
 #define DEBUG_TYPE "affine-utils"
 
 using namespace mlir;
+using namespace presburger;
 
 namespace {
 /// Visit affine expressions recursively and build the sequence of operations
@@ -1757,14 +1758,14 @@ MemRefType mlir::normalizeMemRefType(MemRefType memrefType, OpBuilder b,
   // We have a single map that is not an identity map. Create a new memref
   // with the right shape and an identity layout map.
   ArrayRef<int64_t> shape = memrefType.getShape();
-  // FlatAffineConstraint may later on use symbolicOperands.
-  FlatAffineConstraints fac(rank, numSymbolicOperands);
+  // FlatAffineValueConstraint may later on use symbolicOperands.
+  FlatAffineValueConstraints fac(rank, numSymbolicOperands);
   SmallVector<unsigned, 4> memrefTypeDynDims;
   for (unsigned d = 0; d < rank; ++d) {
     // Use constraint system only in static dimensions.
     if (shape[d] > 0) {
-      fac.addBound(FlatAffineConstraints::LB, d, 0);
-      fac.addBound(FlatAffineConstraints::UB, d, shape[d] - 1);
+      fac.addBound(IntegerPolyhedron::LB, d, 0);
+      fac.addBound(IntegerPolyhedron::UB, d, shape[d] - 1);
     } else {
       memrefTypeDynDims.emplace_back(d);
     }
@@ -1786,7 +1787,7 @@ MemRefType mlir::normalizeMemRefType(MemRefType memrefType, OpBuilder b,
       newShape[d] = -1;
     } else {
       // The lower bound for the shape is always zero.
-      auto ubConst = fac.getConstantBound(FlatAffineConstraints::UB, d);
+      auto ubConst = fac.getConstantBound(IntegerPolyhedron::UB, d);
       // For a static memref and an affine map with no symbols, this is
       // always bounded.
       assert(ubConst.hasValue() && "should always have an upper bound");

mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp

@@ -37,6 +37,7 @@
 #define DEBUG_TYPE "linalg-utils"
 
 using namespace mlir;
+using namespace presburger;
 using namespace mlir::linalg;
 using namespace mlir::scf;
 
@@ -237,7 +238,7 @@ void getUpperBoundForIndex(Value value, AffineMap &boundMap,
     auto minOp = cast<AffineMinOp>(op);
     AffineMap map = constraints.computeAlignedMap(minOp.getAffineMap(),
                                                   minOp.getOperands());
-    if (failed(constraints.addBound(FlatAffineConstraints::UB,
+    if (failed(constraints.addBound(IntegerPolyhedron::UB,
                                     getPosition(minOp.getResult()), map)))
       return;
   }

mlir/lib/Dialect/Affine/Utils/Utils.cpp

@@ -23,6 +23,7 @@
 #define DEBUG_TYPE "mlir-scf-affine-utils"
 
 using namespace mlir;
+using namespace presburger;
 
 static void unpackOptionalValues(ArrayRef<Optional<Value>> source,
                                  SmallVector<Value> &target) {
@@ -38,7 +39,7 @@ static void unpackOptionalValues(ArrayRef<Optional<Value>> source,
 /// Note: This function adds a new symbol column to the `constraints` for each
 /// dimension/symbol that exists in the affine map but not in `constraints`.
 static LogicalResult alignAndAddBound(FlatAffineValueConstraints &constraints,
-                                      FlatAffineConstraints::BoundType type,
+                                      IntegerPolyhedron::BoundType type,
                                       unsigned pos, AffineMap map,
                                       ValueRange operands) {
   SmallVector<Value> dims, syms, newSyms;
@@ -113,8 +114,7 @@ canonicalizeMinMaxOp(RewriterBase &rewriter, Operation *op, AffineMap map,
 
   // Add an inequality for each result expr_i of map:
   // isMin: op <= expr_i, !isMin: op >= expr_i
-  auto boundType =
-      isMin ? FlatAffineConstraints::UB : FlatAffineConstraints::LB;
+  auto boundType = isMin ? IntegerPolyhedron::UB : IntegerPolyhedron::LB;
   // Upper bounds are exclusive, so add 1. (`affine.min` ops are inclusive.)
   AffineMap mapLbUb = isMin ? addConstToResults(map, 1) : map;
   if (failed(
@@ -136,7 +136,7 @@ canonicalizeMinMaxOp(RewriterBase &rewriter, Operation *op, AffineMap map,
   // Add an equality: Set dimOpBound to computed bound.
   // Add back dimension for op. (Was removed by `getSliceBounds`.)
   AffineMap alignedBoundMap = boundMap.shiftDims(/*shift=*/1, /*offset=*/dimOp);
-  if (failed(constraints.addBound(FlatAffineConstraints::EQ, dimOpBound,
+  if (failed(constraints.addBound(IntegerPolyhedron::EQ, dimOpBound,
                                   alignedBoundMap)))
     return failure();
 
@@ -162,7 +162,7 @@ canonicalizeMinMaxOp(RewriterBase &rewriter, Operation *op, AffineMap map,
     // Note: These equalities could have been added earlier and used to express
     // minOp <= expr_i. However, then we run the risk that `getSliceBounds`
     // computes minOpUb in terms of r_i dims, which is not desired.
-    if (failed(alignAndAddBound(newConstr, FlatAffineConstraints::EQ, i,
+    if (failed(alignAndAddBound(newConstr, IntegerPolyhedron::EQ, i,
                                 map.getSubMap({i - resultDimStart}), operands)))
       return failure();
 
@@ -189,7 +189,7 @@ canonicalizeMinMaxOp(RewriterBase &rewriter, Operation *op, AffineMap map,
     // Skip unused operands and operands that are already constants.
     if (!newOperands[i] || getConstantIntValue(newOperands[i]))
       continue;
-    if (auto bound = constraints.getConstantBound(FlatAffineConstraints::EQ, i))
+    if (auto bound = constraints.getConstantBound(IntegerPolyhedron::EQ, i))
       newOperands[i] =
           rewriter.create<arith::ConstantIndexOp>(op->getLoc(), *bound);
   }
@@ -203,7 +203,7 @@ static LogicalResult
 addLoopRangeConstraints(FlatAffineValueConstraints &constraints, Value iv,
                         Value lb, Value ub, Value step,
                         RewriterBase &rewriter) {
-  // FlatAffineConstraints does not support semi-affine expressions.
+  // IntegerPolyhedron does not support semi-affine expressions.
   // Therefore, only constant step values are supported.
   auto stepInt = getConstantIntValue(step);
   if (!stepInt)
@@ -217,9 +217,9 @@ addLoopRangeConstraints(FlatAffineValueConstraints &constraints, Value iv,
   Optional<int64_t> lbInt = getConstantIntValue(lb);
   Optional<int64_t> ubInt = getConstantIntValue(ub);
   if (lbInt)
-    constraints.addBound(FlatAffineConstraints::EQ, dimLb, *lbInt);
+    constraints.addBound(IntegerPolyhedron::EQ, dimLb, *lbInt);
   if (ubInt)
-    constraints.addBound(FlatAffineConstraints::EQ, dimUb, *ubInt);
+    constraints.addBound(IntegerPolyhedron::EQ, dimUb, *ubInt);
 
   // Lower bound: iv >= lb (equiv.: iv - lb >= 0)
   SmallVector<int64_t> ineqLb(constraints.getNumCols(), 0);
@@ -248,7 +248,7 @@ addLoopRangeConstraints(FlatAffineValueConstraints &constraints, Value iv,
       /*dimCount=*/constraints.getNumDimIds(),
       /*symbolCount=*/constraints.getNumSymbolIds(), /*result=*/ivUb);
 
-  return constraints.addBound(FlatAffineConstraints::UB, dimIv, map);
+  return constraints.addBound(IntegerPolyhedron::UB, dimIv, map);
 }
 
 /// Canonicalize min/max operations in the context of for loops with a known
@@ -258,7 +258,7 @@ addLoopRangeConstraints(FlatAffineValueConstraints &constraints, Value iv,
 /// * iv >= lb
 /// * iv < lb + step * ((ub - lb - 1) floorDiv step) + 1
 ///
-/// Note: Due to limitations of FlatAffineConstraints, only constant step sizes
+/// Note: Due to limitations of IntegerPolyhedron, only constant step sizes
 /// are currently supported.
 LogicalResult scf::canonicalizeMinMaxOpInLoop(RewriterBase &rewriter,
                                               Operation *op, AffineMap map,
@@ -321,9 +321,9 @@ LogicalResult scf::rewritePeeledMinMaxOp(RewriterBase &rewriter, Operation *op,
   FlatAffineValueConstraints constraints;
   constraints.appendDimId({iv, ub, step});
   if (auto constUb = getConstantIntValue(ub))
-    constraints.addBound(FlatAffineConstraints::EQ, 1, *constUb);
+    constraints.addBound(IntegerPolyhedron::EQ, 1, *constUb);
   if (auto constStep = getConstantIntValue(step))
-    constraints.addBound(FlatAffineConstraints::EQ, 2, *constStep);
+    constraints.addBound(IntegerPolyhedron::EQ, 2, *constStep);
 
   // Add loop peeling invariant. This is the main piece of knowledge that
   // enables AffineMinOp simplification.

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

@@ -11,14 +11,15 @@
 #include "mlir/Parser/Parser.h"
 
 using namespace mlir;
+using namespace presburger;
 
-FailureOr<FlatAffineConstraints>
+FailureOr<IntegerPolyhedron>
 mlir::parseIntegerSetToFAC(llvm::StringRef str, MLIRContext *context,
                            bool printDiagnosticInfo) {
   IntegerSet set = parseIntegerSet(str, context, printDiagnosticInfo);
 
   if (!set)
     return failure();
 
-  return FlatAffineConstraints(set);
+  return FlatAffineValueConstraints(set);
 }

mlir/lib/Dialect/SCF/Utils/AffineCanonicalizationUtils.cpp

@@ -20,12 +20,12 @@
 namespace mlir {
 
 /// This parses a single IntegerSet to an MLIR context and transforms it to
-/// FlatAffineConstraints if it was valid. If not, a failure is returned. If the
+/// IntegerPolyhedron if it was valid. If not, a failure is returned. If the
 /// passed `str` has additional tokens that were not part of the IntegerSet, a
 /// failure is returned. Diagnostics are printed on failure if
 /// `printDiagnosticInfo` is true.
 
-FailureOr<FlatAffineConstraints>
+FailureOr<presburger::IntegerPolyhedron>
 parseIntegerSetToFAC(llvm::StringRef, MLIRContext *context,
                      bool printDiagnosticInfo = true);