[mlir][Analysis] Add batched version of FlatAffineConstraints::addId

[springerm]

Summary

• Add batched version of all addId variants, so that multiple IDs can be added at a time.
• Rename addId and variants to insertId and appendId. Most external users call appendId. Splitting addId into two functions also makes it possible to provide batched version for both. (Otherwise, the overloads are ambigious when calling addId.)

[ftynse]

mlir/include/mlir/Analysis/AffineStructures.h

248

256

Nit: "at the end of the table" sounds a bit misleading. Do you actually mean insert them after the last identifier of the same kind?

mlir/lib/Analysis/AffineAnalysis.cpp

860

Shouldn't this be appendDimId?

[springerm]

address comments

[springerm]

mlir/lib/Analysis/AffineAnalysis.cpp

860

The original code inserts numCommonLoops many dims at positions 0, 1, 2, ... (i.e., at the beginning). If dependenceDomain does not have any dims yet, this could be rewritten as appendDimId.

[bondhugula]

Thanks for improving the API. A couple of minor comments.

mlir/include/mlir/Analysis/AffineStructures.h

246–262

-> ... num identifiers ...

671

It is odd to see these using declarations in a header file. I'm trying to understand the purpose.

[ftynse]

mlir/include/mlir/Analysis/AffineStructures.h

671

These declarations are not in the header file but in the class. They make overloaded methods of parent class available in the derived class. Otherwise, overload resolution may ignore them when calling a method on the derived class.

[springerm]

mlir/include/mlir/Analysis/AffineStructures.h

671

E.g., it is needed to be able to call appendDimId(/*num=*/5) on FlatAffineValueConstraints. Without the using decl, we get a warning/compile error.

[springerm]

rebase

[springerm]

update

[springerm]

update

mlir/lib/Analysis/AffineStructures.cpp

422

I'm wondering if this is correct.

According to the comment: Local identifiers of each system are by design separate/local and are placed one after other (A's followed by B's).

So I would expect:

a->appendLocalId(/*num=*/b->getNumLocalIds());

[ftynse]

mlir/lib/Analysis/AffineStructures.cpp

471

This error looks relevant.

[springerm]

fix typo

[springerm]

fix test

mlir/include/mlir/Analysis/AffineStructures.h

public:
   /// respect to a positive constant `divisor`. Two constraints are added to the
   /// system to capture equivalence with the floordiv:
   /// q = dividend floordiv c    <=>   c*q <= dividend <= c*q + c - 1.
   void addLocalFloorDiv(ArrayRef<int64_t> dividend, int64_t divisor);
 
   /// Swap the posA^th identifier with the posB^th identifier.
   virtual void swapId(unsigned posA, unsigned posB);
 
-  /// Add identifiers of the specified kind - specified positions are relative
-  /// to the kind of identifier. The coefficient column corresponding to the
-  /// added identifier is initialized to zero.
-  void addDimId(unsigned pos);
-  void addSymbolId(unsigned pos);
-  void addLocalId(unsigned pos);
-  virtual unsigned addId(IdKind kind, unsigned pos);
-  /// Add identifiers of the specified kind at the end of the table. Return the
-  /// position of the column. The coefficient column corresponding to the
-  /// added identifier is initialized to zero.
-  unsigned addDimId();
-  unsigned addSymbolId();
-  unsigned addLocalId();
+  /// 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.
+  unsigned insertDimId(unsigned pos, unsigned num = 1);
+  unsigned insertSymbolId(unsigned pos, unsigned num = 1);
+  unsigned insertLocalId(unsigned pos, unsigned num = 1);
+  virtual unsigned insertId(IdKind kind, unsigned pos, unsigned num = 1);
+
+  /// Append `num` identifiers of the specified kind after the last identifier.
+  /// of that kind. Return the position of the first appended column. The
+  /// coefficient columns corresponding to the added identifiers are initialized
+  /// to zero.
+  unsigned appendDimId(unsigned num = 1);
+  unsigned appendSymbolId(unsigned num = 1);
+  unsigned appendLocalId(unsigned num = 1);
 
   /// Composes an affine map whose dimensions and symbols match one to one with
   /// the dimensions and symbols of this FlatAffineConstraints. The results of
   /// the map `other` are added as the leading dimensions of this constraint
   /// system. Returns failure if `other` is a semi-affine map.
   LogicalResult composeMatchingMap(AffineMap other);
 
   /// Projects out (aka eliminates) `num` identifiers starting at position
public:
 
   /// Returns true if an identifier with the specified Value exists, false
   /// otherwise.
   bool containsId(Value val) const;
 
   /// Swap the posA^th identifier with the posB^th identifier.
   void swapId(unsigned posA, unsigned posB) override;
 
-  /// Add identifiers of the specified kind - specified positions are relative
-  /// to the kind of identifier. The coefficient column corresponding to the
-  /// added identifier is initialized to zero. `val` is the Value corresponding
-  /// to the identifier that can optionally be provided.
-  void addDimId(unsigned pos, Value val);
-  using FlatAffineConstraints::addDimId;
-  void addSymbolId(unsigned pos, Value val);
-  using FlatAffineConstraints::addSymbolId;
-  unsigned addId(IdKind kind, unsigned pos) override;
-  unsigned addId(IdKind kind, unsigned pos, Value val);
-  /// Add identifiers of the specified kind at the end of the table. Return the
-  /// position of the column. The coefficient column corresponding to the
-  /// added identifier is initialized to zero. `val` is the Value corresponding
-  /// to the identifier that can optionally be provided.
-  unsigned addDimId(Value val);
-  unsigned addSymbolId(Value val);
+  /// Insert 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. `vals` are the Values
+  /// corresponding to the identifiers. Return the absolute column position
+  /// (i.e., not relative to the kind of identifier) of the first added
+  /// identifier.
+  ///
+  /// Note: Empty Values are allowed in `vals`.
+  unsigned insertDimId(unsigned pos, ValueRange vals);
+  using FlatAffineConstraints::insertDimId;
+  unsigned insertSymbolId(unsigned pos, ValueRange vals);
+  using FlatAffineConstraints::insertSymbolId;
+  unsigned insertId(IdKind kind, unsigned pos, unsigned num = 1) override;
+  unsigned insertId(IdKind kind, unsigned pos, ValueRange vals);
+
+  /// Append identifiers of the specified kind after the last identifier of that
+  /// kind. The coefficient columns corresponding to the added identifiers are
+  /// initialized to zero. `vals` are the Values corresponding to the
+  /// identifiers. Return the position of the first added column.
+  ///
+  /// Note: Empty Values are allowed in `vals`.
+  unsigned appendDimId(ValueRange vals);
+  using FlatAffineConstraints::appendDimId;
+  unsigned appendSymbolId(ValueRange vals);
+  using FlatAffineConstraints::appendSymbolId;
 
   /// Add the specified values as a dim or symbol id depending on its nature, if
   /// it already doesn't exist in the system. `val` has to be either a terminal
   /// symbol or a loop IV, i.e., it cannot be the result affine.apply of any
   /// symbols or loop IVs. The identifier is added to the end of the existing
   /// dims or symbols. Additional information on the identifier is extracted
   /// from the IR and added to the constraint system.
   void addInductionVarOrTerminalSymbol(Value val);
public:
   /// Merge and align the identifiers of `this` and `other` starting at
   /// `offset`, so that both constraint systems get the union of the contained
   /// identifiers that is dimension-wise and symbol-wise unique; both
   /// constraint systems are updated so that they have the union of all
   /// identifiers, with `this`'s original identifiers appearing first followed
   /// by any of `other`'s identifiers that didn't appear in `this`. Local
   /// identifiers of each system are by design separate/local and are placed
   /// one after other (`this`'s followed by `other`'s).
-  //  Eg: Input: `this`  has (%i %j) [%M %N]
-  //             `other` has (%k, %j) [%P, %N, %M]
-  //      Output: both `this`, `other` have (%i, %j, %k) [%M, %N, %P]
+  //  E.g.: Input: `this`  has (%i, %j) [%M, %N]
+  //               `other` has (%k, %j) [%P, %N, %M]
+  //        Output: both `this`, `other` have (%i, %j, %k) [%M, %N, %P]
   //
   void mergeAndAlignIdsWithOther(unsigned offset,
                                  FlatAffineValueConstraints *other);
 
   /// Returns true if this constraint system and `other` are in the same
   /// space, i.e., if they are associated with the same set of identifiers,
   /// appearing in the same order. Returns false otherwise.
   bool areIdsAlignedWithOther(const FlatAffineValueConstraints &other);

mlir/lib/Analysis/AffineAnalysis.cpp

addMemRefAccessConstraints(const AffineValueMap &srcAccessMap,
   if (failed(getFlattenedAffineExprs(srcMap, &srcFlatExprs, &srcLocalVarCst)) ||
       failed(getFlattenedAffineExprs(dstMap, &destFlatExprs, &destLocalVarCst)))
     return failure();
 
   unsigned domNumLocalIds = dependenceDomain->getNumLocalIds();
   unsigned srcNumLocalIds = srcLocalVarCst.getNumLocalIds();
   unsigned dstNumLocalIds = destLocalVarCst.getNumLocalIds();
   unsigned numLocalIdsToAdd = srcNumLocalIds + dstNumLocalIds;
-  for (unsigned i = 0; i < numLocalIdsToAdd; i++) {
-    dependenceDomain->addLocalId(dependenceDomain->getNumLocalIds());
-  }
+  dependenceDomain->appendLocalId(numLocalIdsToAdd);
 
   unsigned numDims = dependenceDomain->getNumDimIds();
   unsigned numSymbols = dependenceDomain->getNumSymbolIds();
   unsigned numSrcLocalIds = srcLocalVarCst.getNumLocalIds();
   unsigned newLocalIdOffset = numDims + numSymbols + domNumLocalIds;
 
   // Equality to add.
   SmallVector<int64_t, 8> eq(dependenceDomain->getNumCols());
static void computeDirectionVector(
   unsigned numCommonLoops =
       getNumCommonLoops(srcDomain, dstDomain, &commonLoops);
   if (numCommonLoops == 0)
     return;
   // Compute direction vectors for requested loop depth.
   unsigned numIdsToEliminate = dependenceDomain->getNumIds();
   // Add new variables to 'dependenceDomain' to represent the direction
   // constraints for each shared loop.
-  for (unsigned j = 0; j < numCommonLoops; ++j) {
-    dependenceDomain->addDimId(j);
-  }
+  dependenceDomain->insertDimId(/*pos=*/0, /*num=*/numCommonLoops);
 
   // Add equality constraints for each common loop, setting newly introduced
   // variable at column 'j' to the 'dst' IV minus the 'src IV.
   SmallVector<int64_t, 4> eq;
   eq.resize(dependenceDomain->getNumCols());
   unsigned numSrcDims = srcDomain.getNumDimIds();
   // Constraint variables format:
   // [num-common-loops][num-src-dim-ids][num-dst-dim-ids][num-symbols][constant]

mlir/lib/Analysis/AffineStructures.cpp

FlatAffineConstraints::FlatAffineConstraints(IntegerSet set)
   // Flatten expressions and add them to the constraint system.
   std::vector<SmallVector<int64_t, 8>> flatExprs;
   FlatAffineConstraints localVarCst;
   if (failed(getFlattenedAffineExprs(set, &flatExprs, &localVarCst))) {
     assert(false && "flattening unimplemented for semi-affine integer sets");
     return;
   }
   assert(flatExprs.size() == set.getNumConstraints());
-  for (unsigned l = 0, e = localVarCst.getNumLocalIds(); l < e; l++) {
-    addLocalId(getNumLocalIds());
-  }
+  appendLocalId(/*num=*/localVarCst.getNumLocalIds());
 
   for (unsigned i = 0, e = flatExprs.size(); i < e; ++i) {
     const auto &flatExpr = flatExprs[i];
     assert(flatExpr.size() == getNumCols());
     if (set.getEqFlags()[i]) {
       addEquality(flatExpr);
     } else {
       addInequality(flatExpr);
void FlatAffineConstraints::append(const FlatAffineConstraints &other) {
   for (unsigned r = 0, e = other.getNumInequalities(); r < e; r++) {
     addInequality(other.getInequality(r));
   }
   for (unsigned r = 0, e = other.getNumEqualities(); r < e; r++) {
     addEquality(other.getEquality(r));
   }
 }
 
-void FlatAffineConstraints::addLocalId(unsigned pos) {
-  addId(IdKind::Local, pos);
+unsigned FlatAffineConstraints::appendDimId(unsigned num) {
+  unsigned pos = getNumDimIds();
+  insertId(IdKind::Dimension, pos, num);
+  return pos;
 }
 
-unsigned FlatAffineConstraints::addLocalId() {
-  unsigned pos = getNumLocalIds();
-  addId(IdKind::Local, pos);
+unsigned FlatAffineValueConstraints::appendDimId(ValueRange vals) {
+  unsigned pos = getNumDimIds();
+  insertId(IdKind::Dimension, pos, vals);
   return pos;
 }
 
-void FlatAffineConstraints::addDimId(unsigned pos) {
-  addId(IdKind::Dimension, pos);
+unsigned FlatAffineConstraints::appendSymbolId(unsigned num) {
+  unsigned pos = getNumSymbolIds();
+  insertId(IdKind::Symbol, pos, num);
+  return pos;
 }
 
-unsigned FlatAffineConstraints::addDimId() {
-  unsigned pos = getNumDimIds();
-  addId(IdKind::Dimension, pos);
+unsigned FlatAffineValueConstraints::appendSymbolId(ValueRange vals) {
+  unsigned pos = getNumSymbolIds();
+  insertId(IdKind::Symbol, pos, vals);
   return pos;
 }
 
-void FlatAffineValueConstraints::addDimId(unsigned pos, Value val) {
-  addId(IdKind::Dimension, pos, val);
+unsigned FlatAffineConstraints::appendLocalId(unsigned num) {
+  unsigned pos = getNumLocalIds();
+  insertId(IdKind::Local, pos, num);
+  return pos;
 }
 
-unsigned FlatAffineValueConstraints::addDimId(Value val) {
-  unsigned pos = getNumDimIds();
-  addId(IdKind::Dimension, pos, val);
-  return pos;
+unsigned FlatAffineConstraints::insertDimId(unsigned pos, unsigned num) {
+  return insertId(IdKind::Dimension, pos, num);
 }
 
-void FlatAffineConstraints::addSymbolId(unsigned pos) {
-  addId(IdKind::Symbol, pos);
+unsigned FlatAffineValueConstraints::insertDimId(unsigned pos,
+                                                 ValueRange vals) {
+  return insertId(IdKind::Dimension, pos, vals);
 }
 
-unsigned FlatAffineConstraints::addSymbolId() {
-  unsigned pos = getNumSymbolIds();
-  addId(IdKind::Symbol, pos);
-  return pos;
+unsigned FlatAffineConstraints::insertSymbolId(unsigned pos, unsigned num) {
+  return insertId(IdKind::Symbol, pos, num);
 }
 
-void FlatAffineValueConstraints::addSymbolId(unsigned pos, Value val) {
-  addId(IdKind::Symbol, pos, val);
+unsigned FlatAffineValueConstraints::insertSymbolId(unsigned pos,
+                                                    ValueRange vals) {
+  return insertId(IdKind::Symbol, pos, vals);
 }
 
-unsigned FlatAffineValueConstraints::addSymbolId(Value val) {
-  unsigned pos = getNumSymbolIds();
-  addId(IdKind::Symbol, pos, val);
-  return pos;
+unsigned FlatAffineConstraints::insertLocalId(unsigned pos, unsigned num) {
+  return insertId(IdKind::Local, pos, num);
 }
 
-unsigned FlatAffineConstraints::addId(IdKind kind, unsigned pos) {
+unsigned FlatAffineConstraints::insertId(IdKind kind, unsigned pos,
+                                         unsigned num) {
   if (kind == IdKind::Dimension)
     assert(pos <= getNumDimIds());
   else if (kind == IdKind::Symbol)
     assert(pos <= getNumSymbolIds());
   else
     assert(pos <= getNumLocalIds());
 
   unsigned absolutePos;
   if (kind == IdKind::Dimension) {
     absolutePos = pos;
-    numDims++;
+    numDims += num;
   } else if (kind == IdKind::Symbol) {
     absolutePos = pos + getNumDimIds();
-    numSymbols++;
+    numSymbols += num;
   } else {
     absolutePos = pos + getNumDimIds() + getNumSymbolIds();
   }
-  numIds++;
+  numIds += num;
 
-  inequalities.insertColumn(absolutePos);
-  equalities.insertColumn(absolutePos);
+  inequalities.insertColumns(absolutePos, num);
+  equalities.insertColumns(absolutePos, num);
 
   return absolutePos;
 }
 
-unsigned FlatAffineValueConstraints::addId(IdKind kind, unsigned pos) {
-  return addId(kind, pos, /*val=*/{});
+unsigned FlatAffineValueConstraints::insertId(IdKind kind, unsigned pos,
+                                              unsigned num) {
+  unsigned absolutePos = FlatAffineConstraints::insertId(kind, pos, num);
+  values.insert(values.begin() + absolutePos, num, None);
+  assert(values.size() == getNumIds());
+  return absolutePos;
 }
 
-unsigned FlatAffineValueConstraints::addId(IdKind kind, unsigned pos,
-                                           Value val) {
-  unsigned absolutePos = FlatAffineConstraints::addId(kind, pos);
+unsigned FlatAffineValueConstraints::insertId(IdKind kind, unsigned pos,
+                                              ValueRange vals) {
+  assert(!vals.empty() && "expected ValueRange with Values");
+  unsigned num = vals.size();
+  unsigned absolutePos = FlatAffineConstraints::insertId(kind, pos, num);
+
+  // If a Value is provided, insert it; otherwise use None.
+  for (unsigned i = 0; i < num; ++i)
+    values.insert(values.begin() + absolutePos + i,
+                  vals[i] ? Optional<Value>(vals[i]) : None);
 
-  // If an 'id' is provided, insert it; otherwise use None.
-  if (val)
-    values.insert(values.begin() + absolutePos, val);
-  else
-    values.insert(values.begin() + absolutePos, None);
   assert(values.size() == getNumIds());
-
   return absolutePos;
 }
 
 bool FlatAffineValueConstraints::hasValues() const {
   return llvm::find_if(values, [](Optional<Value> id) {
            return id.hasValue();
          }) != values.end();
 }

 
 /// Merge and align the identifiers of A and B starting at 'offset', so that
 /// both constraint systems get the union of the contained identifiers that is
 /// dimension-wise and symbol-wise unique; both constraint systems are updated
 /// so that they have the union of all identifiers, with A's original
 /// identifiers appearing first followed by any of B's identifiers that didn't
 /// appear in A. Local identifiers of each system are by design separate/local
 /// and are placed one after other (A's followed by B's).
-//  Eg: Input: A has ((%i %j) [%M %N]) and B has (%k, %j) [%P, %N, %M])
-//      Output: both A, B have (%i, %j, %k) [%M, %N, %P]
+//  E.g.: Input: A has ((%i, %j) [%M, %N]) and B has (%k, %j) [%P, %N, %M])
+//        Output: both A, B have (%i, %j, %k) [%M, %N, %P]
 static void mergeAndAlignIds(unsigned offset, FlatAffineValueConstraints *a,
                              FlatAffineValueConstraints *b) {
   assert(offset <= a->getNumDimIds() && offset <= b->getNumDimIds());
   // A merge/align isn't meaningful if a cst's ids aren't distinct.
   assert(areIdsUnique(*a) && "A's values aren't unique");
   assert(areIdsUnique(*b) && "B's values aren't unique");
 
   assert(std::all_of(a->getMaybeValues().begin() + offset,
                      a->getMaybeValues().begin() + a->getNumDimAndSymbolIds(),
                      [](Optional<Value> id) { return id.hasValue(); }));
 
   assert(std::all_of(b->getMaybeValues().begin() + offset,
                      b->getMaybeValues().begin() + b->getNumDimAndSymbolIds(),
                      [](Optional<Value> id) { return id.hasValue(); }));
 
   // Place local id's of A after local id's of B.
-  for (unsigned l = 0, e = a->getNumLocalIds(); l < e; l++) {
-    b->addLocalId(0);
-  }
-  for (unsigned t = 0, e = b->getNumLocalIds() - a->getNumLocalIds(); t < e;
-       t++) {
-    a->addLocalId(a->getNumLocalIds());
-  }
+  b->insertLocalId(/*pos=*/0, /*num=*/a->getNumLocalIds());
+  a->appendLocalId(/*num=*/b->getNumLocalIds() - a->getNumLocalIds());
 
   SmallVector<Value, 4> aDimValues, aSymValues;
   a->getValues(offset, a->getNumDimIds(), &aDimValues);
   a->getValues(a->getNumDimIds(), a->getNumDimAndSymbolIds(), &aSymValues);
+
   {
     // Merge dims from A into B.
     unsigned d = offset;
     for (auto aDimValue : aDimValues) {
       unsigned loc;
       if (b->findId(aDimValue, &loc)) {
         assert(loc >= offset && "A's dim appears in B's aligned range");
         assert(loc < b->getNumDimIds() &&
                "A's dim appears in B's non-dim position");
         b->swapId(d, loc);
       } else {
-        b->addDimId(d);
-        b->setValue(d, aDimValue);
+        b->insertDimId(d, aDimValue);
       }
       d++;
     }
-
     // Dimensions that are in B, but not in A, are added at the end.
     for (unsigned t = a->getNumDimIds(), e = b->getNumDimIds(); t < e; t++) {
-      a->addDimId(a->getNumDimIds());
-      a->setValue(a->getNumDimIds() - 1, b->getValue(t));
+      a->appendDimId(b->getValue(t));
     }
+    assert(a->getNumDimIds() == b->getNumDimIds() &&
+           "expected same number of dims");
   }
+
   {
     // Merge symbols: merge A's symbols into B first.
-    unsigned s = b->getNumDimIds();
+    unsigned s = 0;
     for (auto aSymValue : aSymValues) {
       unsigned loc;
       if (b->findId(aSymValue, &loc)) {
         assert(loc >= b->getNumDimIds() && loc < b->getNumDimAndSymbolIds() &&
                "A's symbol appears in B's non-symbol position");
         b->swapId(s, loc);
       } else {
-        b->addSymbolId(s - b->getNumDimIds());
-        b->setValue(s, aSymValue);
+        b->insertSymbolId(s, aSymValue);
       }
       s++;
     }
     // Symbols that are in B, but not in A, are added at the end.
     for (unsigned t = a->getNumDimAndSymbolIds(),
                   e = b->getNumDimAndSymbolIds();
          t < e; t++) {
-      a->addSymbolId(a->getNumSymbolIds());
-      a->setValue(a->getNumDimAndSymbolIds() - 1, b->getValue(t));
+      a->appendSymbolId(b->getValue(t));
     }
+    assert(a->getNumDimAndSymbolIds() == b->getNumDimAndSymbolIds() &&
+           "expected same number of dims and symbols");
   }
+
   assert(areIdsAligned(*a, *b) && "IDs expected to be aligned");
 }
 
 // Call 'mergeAndAlignIds' to align constraint systems of 'this' and 'other'.
 void FlatAffineValueConstraints::mergeAndAlignIdsWithOther(
     unsigned offset, FlatAffineValueConstraints *other) {
   mergeAndAlignIds(offset, this, other);
 }
LogicalResult FlatAffineConstraints::composeMatchingMap(AffineMap other) {
   assert(other.getNumSymbols() == getNumSymbolIds() && "symbol mismatch");
 
   std::vector<SmallVector<int64_t, 8>> flatExprs;
   if (failed(flattenAlignedMapAndMergeLocals(other, &flatExprs)))
     return failure();
   assert(flatExprs.size() == other.getNumResults());
 
   // Add dimensions corresponding to the map's results.
-  for (unsigned t = 0, e = other.getNumResults(); t < e; t++) {
-    addDimId(0);
-  }
+  insertDimId(/*pos=*/0, /*num=*/other.getNumResults());
 
   // We add one equality for each result connecting the result dim of the map to
   // the other identifiers.
   // E.g.: if the expression is 16*i0 + i1, and this is the r^th
   // iteration/result of the value map, we are adding the equality:
   // d_r - 16*i0 - i1 = 0. Similarly, when flattening (i0 + 1, i0 + 8*i2), we
   // add two equalities: d_0 - i0 - 1 == 0, d1 - i0 - 8*i2 == 0.
   for (unsigned r = 0, e = flatExprs.size(); r < e; r++) {
void FlatAffineValueConstraints::addInductionVarOrTerminalSymbol(Value val) {
   if (containsId(val))
     return;
 
   // Caller is expected to fully compose map/operands if necessary.
   assert((isTopLevelValue(val) || isForInductionVar(val)) &&
          "non-terminal symbol / loop IV expected");
   // Outer loop IVs could be used in forOp's bounds.
   if (auto loop = getForInductionVarOwner(val)) {
-    addDimId(getNumDimIds(), val);
+    appendDimId(val);
     if (failed(this->addAffineForOpDomain(loop)))
       LLVM_DEBUG(
           loop.emitWarning("failed to add domain info to constraint system"));
     return;
   }
   // Add top level symbol.
-  addSymbolId(getNumSymbolIds(), val);
+  appendSymbolId(val);
   // Check if the symbol is a constant.
   if (auto constOp = val.getDefiningOp<ConstantIndexOp>())
     addBound(BoundType::EQ, val, constOp.getValue());
 }
 
 LogicalResult
 FlatAffineValueConstraints::addAffineForOpDomain(AffineForOp forOp) {
   unsigned pos;
LLVM_DEBUG(llvm::dbgs()
                << "composition unimplemented for semi-affine maps\n");
     return failure();
   }
 
   // Add localCst information.
   if (localCst.getNumLocalIds() > 0) {
     unsigned numLocalIds = getNumLocalIds();
     // Insert local dims of localCst at the beginning.
-    for (unsigned l = 0, e = localCst.getNumLocalIds(); l < e; ++l)
-      addLocalId(0);
+    insertLocalId(/*pos=*/0, /*num=*/localCst.getNumLocalIds());
     // Insert local dims of `this` at the end of localCst.
-    for (unsigned l = 0; l < numLocalIds; ++l)
-      localCst.addLocalId(localCst.getNumLocalIds());
+    localCst.appendLocalId(/*num=*/numLocalIds);
     // Dimensions of localCst and this constraint set match. Append localCst to
     // this constraint set.
     append(localCst);
   }
 
   return success();
 }
 

 /// respect to a positive constant 'divisor'. Two constraints are added to the
 /// system to capture equivalence with the floordiv.
 ///      q = expr floordiv c    <=>   c*q <= expr <= c*q + c - 1.
 void FlatAffineConstraints::addLocalFloorDiv(ArrayRef<int64_t> dividend,
                                              int64_t divisor) {
   assert(dividend.size() == getNumCols() && "incorrect dividend size");
   assert(divisor > 0 && "positive divisor expected");
 
-  addLocalId(getNumLocalIds());
+  appendLocalId();
 
   // Add two constraints for this new identifier 'q'.
   SmallVector<int64_t, 8> bound(dividend.size() + 1);
 
   // dividend - q * divisor >= 0
   std::copy(dividend.begin(), dividend.begin() + dividend.size() - 1,
             bound.begin());
   bound.back() = dividend.back();

mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp

 
 /// Given a set of loops, assumed to be scf::ForOp, create a constraint set
 /// containing the inequalities `iv - lb >= 0` and `-iv + ub - 1 >= 0` for each
 /// loop.
 static FlatAffineValueConstraints
 initLoopIvsAndBounds(ArrayRef<Operation *> loops) {
   FlatAffineValueConstraints constraints;
   for (Operation *op : loops)
-    constraints.addDimId(constraints.getNumDimIds(),
-                         cast<scf::ForOp>(op).getInductionVar());
+    constraints.appendDimId(cast<scf::ForOp>(op).getInductionVar());
   for (Operation *op : loops)
-    constraints.addDimId(constraints.getNumDimIds(),
-                         cast<scf::ForOp>(op).lowerBound());
+    constraints.appendDimId(cast<scf::ForOp>(op).lowerBound());
   for (Operation *op : loops)
-    constraints.addDimId(constraints.getNumDimIds(),
-                         cast<scf::ForOp>(op).upperBound());
+    constraints.appendDimId(cast<scf::ForOp>(op).upperBound());
   unsigned numLoops = loops.size();
   for (unsigned ivIdx = 0, e = numLoops; ivIdx < e; ++ivIdx) {
     // iv - lb >= 0
     SmallVector<int64_t, 8> ineqLb(constraints.getNumCols(), 0);
     ineqLb[ivIdx] = 1;
     ineqLb[ivIdx + numLoops] = -1;
     // -iv + ub >= 0
     SmallVector<int64_t, 8> ineqUb(constraints.getNumCols(), 0);
for (Operation *op : llvm::reverse(backwardSlice)) {
         continue;
       // Ensure there is a
       auto ensureIdFailed = [&](Value v) {
         if (constraints.containsId(v)) {
           unsigned pos;
           constraints.findId(v, &pos);
           return pos >= constraints.getNumDimIds();
         }
-        constraints.addDimId(constraints.getNumDimIds(), v);
+        constraints.appendDimId(v);
         return false;
       };
 
       // Ensure all ids exist and add results for later projection.
       if (llvm::any_of(op->getResults(), ensureIdFailed) ||
           llvm::any_of(op->getOperands(), ensureIdFailed))
         return failure();
 

mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp

static LogicalResult alignAndAddBound(FlatAffineValueConstraints &constraints,
                                       ValueRange operands) {
   SmallVector<Value> dims, syms, newSyms;
   unpackOptionalValues(constraints.getMaybeDimValues(), dims);
   unpackOptionalValues(constraints.getMaybeSymbolValues(), syms);
 
   AffineMap alignedMap =
       alignAffineMapWithValues(map, operands, dims, syms, &newSyms);
   for (unsigned i = syms.size(); i < newSyms.size(); ++i)
-    constraints.addSymbolId(constraints.getNumSymbolIds(), newSyms[i]);
+    constraints.appendSymbolId(newSyms[i]);
   return constraints.addBound(type, pos, alignedMap);
 }
 
 /// This function tries to canonicalize min/max operations by proving that their
 /// value is bounded by the same lower and upper bound. In that case, the
 /// operation can be folded away.
 ///
 /// Bounds are computed by FlatAffineValueConstraints. Invariants required for

 static LogicalResult
 canonicalizeMinMaxOp(RewriterBase &rewriter, Operation *op, AffineMap map,
                      ValueRange operands, bool isMin,
                      FlatAffineValueConstraints constraints) {
   RewriterBase::InsertionGuard guard(rewriter);
   unsigned numResults = map.getNumResults();
 
   // Add a few extra dimensions.
-  unsigned dimOp = constraints.addDimId();      // `op`
-  unsigned dimOpBound = constraints.addDimId(); // `op` lower/upper bound
-  unsigned resultDimStart = constraints.getNumDimIds();
-  for (unsigned i = 0; i < numResults; ++i)
-    constraints.addDimId();
+  unsigned dimOp = constraints.appendDimId();      // `op`
+  unsigned dimOpBound = constraints.appendDimId(); // `op` lower/upper bound
+  unsigned resultDimStart = constraints.appendDimId(/*num=*/numResults);
 
   // 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;
   if (failed(alignAndAddBound(constraints, boundType, dimOp, map, operands)))
     return failure();
 

 /// affine.min ops inside the scf.for op. For an explanation of the other
 /// parameters, see comment of `canonicalizeMinMaxOpInLoop`.
 static LogicalResult rewritePeeledMinMaxOp(RewriterBase &rewriter,
                                            Operation *op, AffineMap map,
                                            ValueRange operands, bool isMin,
                                            Value iv, Value ub, Value step,
                                            bool insideLoop) {
   FlatAffineValueConstraints constraints;
-  constraints.addDimId(0, iv);
-  constraints.addDimId(1, ub);
-  constraints.addDimId(2, step);
+  constraints.appendDimId({iv, ub, step});
   if (auto constUb = getConstantIntValue(ub))
     constraints.addBound(FlatAffineConstraints::EQ, 1, *constUb);
   if (auto constStep = getConstantIntValue(step))
     constraints.addBound(FlatAffineConstraints::EQ, 2, *constStep);
 
   // Add loop peeling invariant. This is the main piece of knowledge that
   // enables AffineMinOp simplification.
   if (insideLoop) {
for (Value operand : operands) {
     allIvs.insert(iv);
 
     // FlatAffineConstraints does not support semi-affine expressions.
     // Therefore, only constant step values are supported.
     auto stepInt = getConstantIntValue(step);
     if (!stepInt)
       continue;
 
-    unsigned dimIv = constraints.addDimId(iv);
-    unsigned dimLb = constraints.addDimId(lb);
-    unsigned dimUb = constraints.addDimId(ub);
+    unsigned dimIv = constraints.appendDimId(iv);
+    unsigned dimLb = constraints.appendDimId(lb);
+    unsigned dimUb = constraints.appendDimId(ub);
 
     // If loop lower/upper bounds are constant: Add EQ constraint.
     Optional<int64_t> lbInt = getConstantIntValue(lb);
     Optional<int64_t> ubInt = getConstantIntValue(ub);
     if (lbInt)
       constraints.addBound(FlatAffineConstraints::EQ, dimLb, *lbInt);
     if (ubInt)
       constraints.addBound(FlatAffineConstraints::EQ, dimUb, *ubInt);