[MLIR][Presburger] Move IntegerPolyhedron::reset to FlatAffineConstraints::reset

[Groverkss]

Summary

This patch moves IntegerPolyhedron::reset to FlatAffineConstraints::reset. This
function is not required in IntegerPolyhedron and creates ambiguity while
shifting implementations to IntegerRelation.

This patch is part of a series of patches to introduce relations in Presburger
library.

mlir/include/mlir/Analysis/Presburger/IntegerPolyhedron.h

public:
   /// Return the kind of this IntegerPolyhedron.
   virtual Kind getKind() const { return Kind::IntegerPolyhedron; }
 
   static bool classof(const IntegerPolyhedron *cst) { return true; }
 
   // Clones this object.
   std::unique_ptr<IntegerPolyhedron> clone() const;
 
-  /// Clears any existing data and reserves memory for the specified
-  /// constraints.
-  virtual void reset(unsigned numReservedInequalities,
-                     unsigned numReservedEqualities, unsigned numReservedCols,
-                     unsigned numDims, unsigned numSymbols,
-                     unsigned numLocals = 0);
-
-  void reset(unsigned numDims = 0, unsigned numSymbols = 0,
-             unsigned numLocals = 0);
-
   /// Appends constraints from `other` into `this`. This is equivalent to an
   /// intersection with no simplification of any sort attempted.
   void append(const IntegerPolyhedron &other);
 
   /// Return whether `this` and `other` are equal. This is integer-exact
   /// and somewhat expensive, since it uses the integer emptiness check
   /// (see IntegerPolyhedron::findIntegerSample()).
   bool isEqual(const IntegerPolyhedron &other) const;

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

public:
 
   /// Return the kind of this FlatAffineConstraints.
   Kind getKind() const override { return Kind::FlatAffineConstraints; }
 
   static bool classof(const IntegerPolyhedron *cst) {
     return cst->getKind() == Kind::FlatAffineConstraints;
   }
 
+  /// Clears any existing data and reserves memory for the specified
+  /// constraints.
+  virtual void reset(unsigned numReservedInequalities,
+                     unsigned numReservedEqualities, unsigned numReservedCols,
+                     unsigned numDims, unsigned numSymbols,
+                     unsigned numLocals = 0);
+  void reset(unsigned numDims = 0, unsigned numSymbols = 0,
+             unsigned numLocals = 0);
+
   // Clones this object.
   std::unique_ptr<FlatAffineConstraints> clone() const;
 
   /// Insert `num` identifiers of the specified kind at position `pos`.
   /// Positions are relative to the kind of identifier. The coefficient columns
   /// corresponding to the added identifiers are initialized to zero. Return the
   /// absolute column position (i.e., not relative to the kind of identifier)
   /// of the first added identifier.

mlir/lib/Analysis/Presburger/IntegerPolyhedron.cpp

 
 using llvm::SmallDenseMap;
 using llvm::SmallDenseSet;
 
 std::unique_ptr<IntegerPolyhedron> IntegerPolyhedron::clone() const {
   return std::make_unique<IntegerPolyhedron>(*this);
 }
 
-void IntegerPolyhedron::reset(unsigned numReservedInequalities,
-                              unsigned numReservedEqualities,
-                              unsigned newNumReservedCols, unsigned newNumDims,
-                              unsigned newNumSymbols, unsigned newNumLocals) {
-  assert(newNumReservedCols >= newNumDims + newNumSymbols + newNumLocals + 1 &&
-         "minimum 1 column");
-  *this = IntegerPolyhedron(numReservedInequalities, numReservedEqualities,
-                            newNumReservedCols, newNumDims, newNumSymbols,
-                            newNumLocals);
-}
-
-void IntegerPolyhedron::reset(unsigned newNumDims, unsigned newNumSymbols,
-                              unsigned newNumLocals) {
-  reset(0, 0, newNumDims + newNumSymbols + newNumLocals + 1, newNumDims,
-        newNumSymbols, newNumLocals);
-}
-
 void IntegerPolyhedron::append(const IntegerPolyhedron &other) {
   assert(PresburgerLocalSpace::isEqual(other) && "Spaces must be equal.");
 
   inequalities.reserveRows(inequalities.getNumRows() +
                            other.getNumInequalities());
   equalities.reserveRows(equalities.getNumRows() + other.getNumEqualities());
 
   for (unsigned r = 0, e = other.getNumInequalities(); r < e; r++) {
static BoundCmpResult compareBounds(ArrayRef<int64_t> a, ArrayRef<int64_t> b) {
   return a.back() < b.back() ? Less : Greater;
 }
 } // namespace
 
 // Returns constraints that are common to both A & B.
 static void getCommonConstraints(const IntegerPolyhedron &a,
                                  const IntegerPolyhedron &b,
                                  IntegerPolyhedron &c) {
-  c.reset(a.getNumDimIds(), a.getNumSymbolIds(), a.getNumLocalIds());
+  c = IntegerPolyhedron(a.getNumDimIds(), a.getNumSymbolIds(),
+                        a.getNumLocalIds());
   // a naive O(n^2) check should be enough here given the input sizes.
   for (unsigned r = 0, e = a.getNumInequalities(); r < e; ++r) {
     for (unsigned s = 0, f = b.getNumInequalities(); s < f; ++s) {
       if (a.getInequality(r) == b.getInequality(s)) {
         c.addInequality(a.getInequality(r));
         break;
       }
     }

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

for (int ivIdx = 0, e = nIvs; ivIdx < e; ++ivIdx) {
     AffineMap ub = AffineMap::get(/*dimCount=*/3 * nIvs, /*symbolCount=*/0,
                                   getAffineDimExpr(ubsStart + ivIdx, ctx));
     if (failed(res.addBound(BoundType::UB, ivIdx, ub)))
       llvm_unreachable("Unexpected FlatAffineValueConstraints creation error");
   }
   return res;
 }
 
+void FlatAffineConstraints::reset(unsigned numReservedInequalities,
+                                  unsigned numReservedEqualities,
+                                  unsigned newNumReservedCols,
+                                  unsigned newNumDims, unsigned newNumSymbols,
+                                  unsigned newNumLocals) {
+  assert(newNumReservedCols >= newNumDims + newNumSymbols + newNumLocals + 1 &&
+         "minimum 1 column");
+  *this = FlatAffineConstraints(numReservedInequalities, numReservedEqualities,
+                                newNumReservedCols, newNumDims, newNumSymbols,
+                                newNumLocals);
+}
+
+void FlatAffineConstraints::reset(unsigned newNumDims, unsigned newNumSymbols,
+                                  unsigned newNumLocals) {
+  reset(/*numReservedInequalities=*/0, /*numReservedEqualities=*/0,
+        /*numReservedCols=*/newNumDims + newNumSymbols + newNumLocals + 1,
+        newNumDims, newNumSymbols, newNumLocals);
+}
+
 void FlatAffineValueConstraints::reset(unsigned numReservedInequalities,
                                        unsigned numReservedEqualities,
                                        unsigned newNumReservedCols,
                                        unsigned newNumDims,
                                        unsigned newNumSymbols,
                                        unsigned newNumLocals) {
   reset(numReservedInequalities, numReservedEqualities, newNumReservedCols,
         newNumDims, newNumSymbols, newNumLocals, /*valArgs=*/{});