[mlir][affine][analysis][NFC] Simplify FlatAffineValueConstraints API

[springerm]

Summary

• Remove reset function. Use copy assignment directly (instead of within reset).
• Fix potential nullptr dereference in getFlattenedAffineExprs.
• Make constraint set optional in checkMemrefAccessDependence.

[arjunp]

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

63–67

I would prefer to just add an FAVC constructor.

[springerm]

address comments

[arjunp]

Thanks, SGTM with a few nits below

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

51

I think I would slightly prefer just adding another overload that maps to optional like you were doing earlier, since I only see two versions being used.

If keeping the template version, ArrayRef<ValArgTy> would give better error messages.

69

Same here.

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

674–675

Why return dependenceConstraints when there is no dependence? Is the specific set of constraints ever relevant when there was no dependence?

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

enum ResultEnum {
     NoDependence,  // No dependence exists between 'srcAccess' and 'dstAccess'.
     Failure,       // Dependence check failed due to unsupported cases.
   } value;
   DependenceResult(ResultEnum v) : value(v) {}
 };
 
 DependenceResult checkMemrefAccessDependence(
     const MemRefAccess &srcAccess, const MemRefAccess &dstAccess,
-    unsigned loopDepth, FlatAffineValueConstraints *dependenceConstraints,
-    SmallVector<DependenceComponent, 2> *dependenceComponents,
+    unsigned loopDepth,
+    FlatAffineValueConstraints *dependenceConstraints = nullptr,
+    SmallVector<DependenceComponent, 2> *dependenceComponents = nullptr,
     bool allowRAR = false);
 
 /// Utility function that returns true if the provided DependenceResult
 /// corresponds to a dependence result.
 inline bool hasDependence(DependenceResult result) {
   return result.value == DependenceResult::HasDependence;
 }
 

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

 class FlatAffineValueConstraints : public presburger::IntegerPolyhedron {
 public:
   /// Constructs a constraint system reserving memory for the specified number
   /// of constraints and variables.
   FlatAffineValueConstraints(unsigned numReservedInequalities,
                              unsigned numReservedEqualities,
                              unsigned numReservedCols, unsigned numDims,
                              unsigned numSymbols, unsigned numLocals,
                              ArrayRef<std::optional<Value>> valArgs = {})
       : IntegerPolyhedron(numReservedInequalities, numReservedEqualities,
                           numReservedCols,
                           presburger::PresburgerSpace::getSetSpace(
                               numDims, numSymbols, numLocals)) {
     assert(numReservedCols >= getNumVars() + 1);
     assert(valArgs.empty() || valArgs.size() == getNumDimAndSymbolVars());
     values.reserve(numReservedCols);
     if (valArgs.empty())
       values.resize(getNumDimAndSymbolVars(), std::nullopt);
     else
       values.append(valArgs.begin(), valArgs.end());
   }
 
   /// Constructs a constraint system with the specified number of
   /// dimensions and symbols.
   FlatAffineValueConstraints(unsigned numDims = 0, unsigned numSymbols = 0,
                              unsigned numLocals = 0,
                              ArrayRef<std::optional<Value>> valArgs = {})
       : FlatAffineValueConstraints(/*numReservedInequalities=*/0,
                                    /*numReservedEqualities=*/0,
                                    /*numReservedCols=*/numDims + numSymbols +
                                        numLocals + 1,
                                    numDims, numSymbols, numLocals, valArgs) {}
 
   FlatAffineValueConstraints(const IntegerPolyhedron &fac,
                              ArrayRef<std::optional<Value>> valArgs = {})
public:
 
   /// Return the kind of this FlatAffineConstraints.
   Kind getKind() const override { return Kind::FlatAffineValueConstraints; }
 
   static bool classof(const IntegerRelation *cst) {
     return cst->getKind() == Kind::FlatAffineValueConstraints;
   }
 
-  /// Clears any existing data and reserves memory for the specified
-  /// constraints.
-  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);
-  void reset(unsigned numReservedInequalities, unsigned numReservedEqualities,
-             unsigned numReservedCols, unsigned numDims, unsigned numSymbols,
-             unsigned numLocals, ArrayRef<Value> valArgs);
-  void reset(unsigned numDims, unsigned numSymbols, unsigned numLocals,
-             ArrayRef<Value> valArgs);
-
   /// Clones this object.
   std::unique_ptr<FlatAffineValueConstraints> clone() const;
 
   /// Adds constraints (lower and upper bounds) for the specified 'affine.for'
   /// operation's Value using IR information stored in its bound maps. The
   /// right variable is first looked up using `forOp`'s Value. Asserts if the
   /// Value corresponding to the 'affine.for' operation isn't found in the
   /// constraint system. Returns failure for the yet unimplemented/unsupported

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

bool mlir::isLoopMemoryParallel(AffineForOp forOp) {
   // Dep check depth would be number of enclosing loops + 1.
   unsigned depth = getNestingDepth(forOp) + 1;
 
   // Check dependences between all pairs of ops in 'loadAndStoreOps'.
   for (auto *srcOp : loadAndStoreOps) {
     MemRefAccess srcAccess(srcOp);
     for (auto *dstOp : loadAndStoreOps) {
       MemRefAccess dstAccess(dstOp);
-      FlatAffineValueConstraints dependenceConstraints;
-      DependenceResult result = checkMemrefAccessDependence(
-          srcAccess, dstAccess, depth, &dependenceConstraints,
-          /*dependenceComponents=*/nullptr);
+      DependenceResult result =
+          checkMemrefAccessDependence(srcAccess, dstAccess, depth);
       if (result.value != DependenceResult::NoDependence)
         return false;
     }
   }
   return true;
 }
 
 /// Returns the sequence of AffineApplyOp Operations operation in
if (state.operandIndex < opInst->getNumOperands()) {
       worklist.push_back({nextOperand, 0});
     } else {
       // Post-visit: done visiting operands AffineApplyOp, pop off stack.
       worklist.pop_back();
     }
   }
 }
 
+static SmallVector<std::optional<Value>>
+wrapInOptional(ArrayRef<Value> values) {
+  return llvm::to_vector(llvm::map_range(
+      values, [](Value v) -> std::optional<Value> { return v; }));
+}
+
 // Builds a system of constraints with dimensional variables corresponding to
 // the loop IVs of the forOps appearing in that order. Any symbols founds in
 // the bound operands are added as symbols in the system. Returns failure for
 // the yet unimplemented cases.
 // TODO: Handle non-unit steps through local variables or stride information in
 // FlatAffineValueConstraints. (For eg., by using iv - lb % step = 0 and/or by
 // introducing a method in FlatAffineValueConstraints
 // setExprStride(ArrayRef<int64_t> expr, int64_t stride)
if (AffineForOp forOp = dyn_cast<AffineForOp>(op)) {
       numDims += 1;
     } else if (AffineParallelOp parallelOp = dyn_cast<AffineParallelOp>(op)) {
       loopOps.push_back(parallelOp);
       numDims += parallelOp.getNumDims();
     }
   }
   extractInductionVars(loopOps, indices);
   // Reset while associating Values in 'indices' to the domain.
-  domain->reset(numDims, /*numSymbols=*/0, /*numLocals=*/0, indices);
+  *domain =
+      FlatAffineValueConstraints(numDims, /*numSymbols=*/0,
+                                 /*numLocals=*/0, wrapInOptional(indices));
   for (Operation *op : ops) {
     // Add constraints from forOp's bounds.
     if (AffineForOp forOp = dyn_cast<AffineForOp>(op)) {
       if (failed(domain->addAffineForOpDomain(forOp)))
         return failure();
     } else if (auto ifOp = dyn_cast<AffineIfOp>(op)) {
       domain->addAffineIfOpDomain(ifOp);
     } else if (auto parallelOp = dyn_cast<AffineParallelOp>(op))
DependenceResult mlir::checkMemrefAccessDependence(
   }
 
   // Compute the dependence relation by composing `srcRel` with the inverse of
   // `dstRel`. Doing this builds a relation between iteration domain of
   // `srcAccess` to the iteration domain of `dstAccess` which access the same
   // memory locations.
   dstRel.inverse();
   dstRel.compose(srcRel);
-  *dependenceConstraints = dstRel;
 
   // Add 'src' happens before 'dst' ordering constraints.
-  addOrderingConstraints(srcDomain, dstDomain, loopDepth,
-                         dependenceConstraints);
+  addOrderingConstraints(srcDomain, dstDomain, loopDepth, &dstRel);
 
   // Return 'NoDependence' if the solution space is empty: no dependence.
-  if (dependenceConstraints->isEmpty())
+  if (dstRel.isEmpty()) {
+    if (dependenceConstraints)
+      *dependenceConstraints = dstRel;
     return DependenceResult::NoDependence;
+  }
 
   // Compute dependence direction vector and return true.
   if (dependenceComponents != nullptr)
-    computeDirectionVector(srcDomain, dstDomain, loopDepth,
-                           dependenceConstraints, dependenceComponents);
+    computeDirectionVector(srcDomain, dstDomain, loopDepth, &dstRel,
+                           dependenceComponents);
 
   LLVM_DEBUG(llvm::dbgs() << "Dependence polyhedron:\n");
-  LLVM_DEBUG(dependenceConstraints->dump());
+  LLVM_DEBUG(dstRel.dump());
+
+  if (dependenceConstraints)
+    *dependenceConstraints = dstRel;
   return DependenceResult::HasDependence;
 }
 
 /// Gathers dependence components for dependences between all ops in loop nest
 /// rooted at 'forOp' at loop depths in range [1, maxLoopDepth].
 void mlir::getDependenceComponents(
     AffineForOp forOp, unsigned maxLoopDepth,
     std::vector<SmallVector<DependenceComponent, 2>> *depCompsVec) {
   // Collect all load and store ops in loop nest rooted at 'forOp'.
   SmallVector<Operation *, 8> loadAndStoreOps;
   forOp->walk([&](Operation *op) {
     if (isa<AffineReadOpInterface, AffineWriteOpInterface>(op))
       loadAndStoreOps.push_back(op);
   });
 
   unsigned numOps = loadAndStoreOps.size();
   for (unsigned d = 1; d <= maxLoopDepth; ++d) {
     for (unsigned i = 0; i < numOps; ++i) {
       auto *srcOp = loadAndStoreOps[i];
       MemRefAccess srcAccess(srcOp);
       for (unsigned j = 0; j < numOps; ++j) {
         auto *dstOp = loadAndStoreOps[j];
         MemRefAccess dstAccess(dstOp);
 
-        FlatAffineValueConstraints dependenceConstraints;
         SmallVector<DependenceComponent, 2> depComps;
         // TODO: Explore whether it would be profitable to pre-compute and store
         // deps instead of repeatedly checking.
         DependenceResult result = checkMemrefAccessDependence(
-            srcAccess, dstAccess, d, &dependenceConstraints, &depComps);
+            srcAccess, dstAccess, d, /*dependenceConstraints=*/nullptr,
+            &depComps);
         if (hasDependence(result))
           depCompsVec->push_back(depComps);
       }
     }
   }
 }

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

 // Flattens the expressions in map. Returns failure if 'expr' was unable to be
 // flattened (i.e., semi-affine expressions not handled yet).
 static LogicalResult
 getFlattenedAffineExprs(ArrayRef<AffineExpr> exprs, unsigned numDims,
                         unsigned numSymbols,
                         std::vector<SmallVector<int64_t, 8>> *flattenedExprs,
                         FlatAffineValueConstraints *localVarCst) {
   if (exprs.empty()) {
-    localVarCst->reset(numDims, numSymbols);
+    if (localVarCst)
+      *localVarCst = FlatAffineValueConstraints(numDims, numSymbols);
     return success();
   }
 
   AffineExprFlattener flattener(numDims, numSymbols);
   // Use the same flattener to simplify each expression successively. This way
   // local variables / expressions are shared.
   for (auto expr : exprs) {
     if (!expr.isPureAffine())

 }
 
 /// Flattens the expressions in map. Returns failure if 'expr' was unable to be
 /// flattened (i.e., semi-affine expressions not handled yet).
 LogicalResult mlir::getFlattenedAffineExprs(
     AffineMap map, std::vector<SmallVector<int64_t, 8>> *flattenedExprs,
     FlatAffineValueConstraints *localVarCst) {
   if (map.getNumResults() == 0) {
-    localVarCst->reset(map.getNumDims(), map.getNumSymbols());
+    if (localVarCst)
+      *localVarCst =
+          FlatAffineValueConstraints(map.getNumDims(), map.getNumSymbols());
     return success();
   }
   return ::getFlattenedAffineExprs(map.getResults(), map.getNumDims(),
                                    map.getNumSymbols(), flattenedExprs,
                                    localVarCst);
 }
 
 LogicalResult mlir::getFlattenedAffineExprs(
     IntegerSet set, std::vector<SmallVector<int64_t, 8>> *flattenedExprs,
     FlatAffineValueConstraints *localVarCst) {
   if (set.getNumConstraints() == 0) {
-    localVarCst->reset(set.getNumDims(), set.getNumSymbols());
+    if (localVarCst)
+      *localVarCst =
+          FlatAffineValueConstraints(set.getNumDims(), set.getNumSymbols());
     return success();
   }
   return ::getFlattenedAffineExprs(set.getConstraints(), set.getNumDims(),
                                    set.getNumSymbols(), flattenedExprs,
                                    localVarCst);
 }
 
 //===----------------------------------------------------------------------===//
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 FlatAffineValueConstraints::reset(unsigned numReservedInequalities,
-                                       unsigned numReservedEqualities,
-                                       unsigned newNumReservedCols,
-                                       unsigned newNumDims,
-                                       unsigned newNumSymbols,
-                                       unsigned newNumLocals) {
-  assert(newNumReservedCols >= newNumDims + newNumSymbols + newNumLocals + 1 &&
-         "minimum 1 column");
-  *this = FlatAffineValueConstraints(numReservedInequalities,
-                                     numReservedEqualities, newNumReservedCols,
-                                     newNumDims, newNumSymbols, newNumLocals);
-}
-
-void FlatAffineValueConstraints::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, ArrayRef<Value> valArgs) {
-  assert(newNumReservedCols >= newNumDims + newNumSymbols + newNumLocals + 1 &&
-         "minimum 1 column");
-  SmallVector<std::optional<Value>, 8> newVals;
-  if (!valArgs.empty())
-    newVals.assign(valArgs.begin(), valArgs.end());
-
-  *this = FlatAffineValueConstraints(
-      numReservedInequalities, numReservedEqualities, newNumReservedCols,
-      newNumDims, newNumSymbols, newNumLocals, newVals);
-}
-
-void FlatAffineValueConstraints::reset(unsigned newNumDims,
-                                       unsigned newNumSymbols,
-                                       unsigned newNumLocals,
-                                       ArrayRef<Value> valArgs) {
-  reset(0, 0, newNumDims + newNumSymbols + newNumLocals + 1, newNumDims,
-        newNumSymbols, newNumLocals, valArgs);
-}
-
 unsigned FlatAffineValueConstraints::appendDimVar(ValueRange vals) {
   unsigned pos = getNumDimVars();
   return insertVar(VarKind::SetDim, pos, vals);
 }
 
 unsigned FlatAffineValueConstraints::appendSymbolVar(ValueRange vals) {
   unsigned pos = getNumSymbolVars();
   return insertVar(VarKind::Symbol, pos, vals);

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

void mlir::getEnclosingAffineOps(Operation &op,
   while (currOp) {
     if (isa<AffineIfOp, AffineForOp, AffineParallelOp>(currOp))
       ops->push_back(currOp);
     currOp = currOp->getParentOp();
   }
   std::reverse(ops->begin(), ops->end());
 }
 
+static SmallVector<std::optional<Value>>
+wrapInOptional(ArrayRef<Value> values) {
+  return llvm::to_vector(llvm::map_range(
+      values, [](Value v) -> std::optional<Value> { return v; }));
+}
+
 // Populates 'cst' with FlatAffineValueConstraints which represent original
 // domain of the loop bounds that define 'ivs'.
 LogicalResult
 ComputationSliceState::getSourceAsConstraints(FlatAffineValueConstraints &cst) {
   assert(!ivs.empty() && "Cannot have a slice without its IVs");
-  cst.reset(/*numDims=*/ivs.size(), /*numSymbols=*/0, /*numLocals=*/0, ivs);
+  cst = FlatAffineValueConstraints(/*numDims=*/ivs.size(), /*numSymbols=*/0,
+                                   /*numLocals=*/0, wrapInOptional(ivs));
   for (Value iv : ivs) {
     AffineForOp loop = getForInductionVarOwner(iv);
     assert(loop && "Expected affine for");
     if (failed(cst.addAffineForOpDomain(loop)))
       return failure();
   }
   return success();
 }
 
 // Populates 'cst' with FlatAffineValueConstraints which represent slice bounds.
 LogicalResult
 ComputationSliceState::getAsConstraints(FlatAffineValueConstraints *cst) {
   assert(!lbOperands.empty());
   // Adds src 'ivs' as dimension variables in 'cst'.
   unsigned numDims = ivs.size();
   // Adds operands (dst ivs and symbols) as symbols in 'cst'.
   unsigned numSymbols = lbOperands[0].size();
 
   SmallVector<Value, 4> values(ivs);
   // Append 'ivs' then 'operands' to 'values'.
   values.append(lbOperands[0].begin(), lbOperands[0].end());
-  cst->reset(numDims, numSymbols, 0, values);
+  *cst = FlatAffineValueConstraints(numDims, numSymbols, 0,
+                                    wrapInOptional(values));
 
   // Add loop bound constraints for values which are loop IVs of the destination
   // of fusion and equality constraints for symbols which are constants.
   for (unsigned i = numDims, end = values.size(); i < end; ++i) {
     Value value = values[i];
     assert(cst->containsVar(value) && "value expected to be present");
     if (isValidSymbol(value)) {
       // Check if the symbol is a constant.

 std::optional<bool> ComputationSliceState::isMaximal() const {
   // Fast check to determine if the computation slice is maximal. If the result
   // is inconclusive, we proceed with a more expensive analysis.
   std::optional<bool> isMaximalFastCheck = isSliceMaximalFastCheck();
   if (isMaximalFastCheck)
     return isMaximalFastCheck;
 
   // Create constraints for the src loop nest being sliced.
-  FlatAffineValueConstraints srcConstraints;
-  srcConstraints.reset(/*numDims=*/ivs.size(), /*numSymbols=*/0,
-                       /*numLocals=*/0, ivs);
+  FlatAffineValueConstraints srcConstraints(/*numDims=*/ivs.size(),
+                                            /*numSymbols=*/0,
+                                            /*numLocals=*/0,
+                                            wrapInOptional(ivs));
   for (Value iv : ivs) {
     AffineForOp loop = getForInductionVarOwner(iv);
     assert(loop && "Expected affine for");
     if (failed(srcConstraints.addAffineForOpDomain(loop)))
       return std::nullopt;
   }
 
   // Create constraints for the slice using the dst loop nest information. We
   // retrieve existing dst loops from the lbOperands.
-  SmallVector<Value, 8> consumerIVs;
+  SmallVector<Value> consumerIVs;
   for (Value lbOp : lbOperands[0])
     if (getForInductionVarOwner(lbOp))
       consumerIVs.push_back(lbOp);
 
   // Add empty IV Values for those new loops that are not equalities and,
   // therefore, are not yet materialized in the IR.
   for (int i = consumerIVs.size(), end = ivs.size(); i < end; ++i)
     consumerIVs.push_back(Value());
 
-  FlatAffineValueConstraints sliceConstraints;
-  sliceConstraints.reset(/*numDims=*/consumerIVs.size(), /*numSymbols=*/0,
-                         /*numLocals=*/0, consumerIVs);
+  FlatAffineValueConstraints sliceConstraints(/*numDims=*/consumerIVs.size(),
+                                              /*numSymbols=*/0,
+                                              /*numLocals=*/0,
+                                              wrapInOptional(consumerIVs));
 
   if (failed(sliceConstraints.addDomainFromSliceMaps(lbs, ubs, lbOperands[0])))
     return std::nullopt;
 
   if (srcConstraints.getNumDimVars() != sliceConstraints.getNumDimVars())
     // Constraint dims are different. The integer set difference can't be
     // computed so we don't know if the slice is maximal.
     return std::nullopt;
LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,
 
   // 0-d memrefs.
   if (rank == 0) {
     SmallVector<AffineForOp, 4> ivs;
     getAffineForIVs(*op, &ivs);
     assert(loopDepth <= ivs.size() && "invalid 'loopDepth'");
     // The first 'loopDepth' IVs are symbols for this region.
     ivs.resize(loopDepth);
-    SmallVector<Value, 4> regionSymbols;
+    SmallVector<Value> regionSymbols;
     extractForInductionVars(ivs, &regionSymbols);
     // A 0-d memref has a 0-d region.
-    cst.reset(rank, loopDepth, /*numLocals=*/0, regionSymbols);
+    cst = FlatAffineValueConstraints(rank, loopDepth, /*numLocals=*/0,
+                                     wrapInOptional(regionSymbols));
     return success();
   }
 
   // Build the constraints for this region.
   AffineValueMap accessValueMap;
   access.getAccessMap(&accessValueMap);
   AffineMap accessMap = accessValueMap.getAffineMap();
 
for (auto extraOperand : sliceState->lbOperands[0]) {
         operands.push_back(extraOperand);
         numSymbols++;
       }
     }
   }
   // We'll first associate the dims and symbols of the access map to the dims
   // and symbols resp. of cst. This will change below once cst is
   // fully constructed out.
-  cst.reset(numDims, numSymbols, 0, operands);
+  cst = FlatAffineValueConstraints(numDims, numSymbols, 0,
+                                   wrapInOptional(operands));
 
   // Add equality constraints.
   // Add inequalities for loop lower/upper bounds.
   for (unsigned i = 0; i < numDims + numSymbols; ++i) {
     auto operand = operands[i];
     if (auto loop = getForInductionVarOwner(operand)) {
       // Note that cst can now have more dimensions than accessMap if the
       // bounds expressions involve outer loops or other symbols.

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

for (unsigned i = 0, e = targetDstOps.size(); i < e; ++i) {
     MemRefAccess srcAccess(srcOpInst);
     for (unsigned j = 0; j < e; ++j) {
       auto *dstOpInst = targetDstOps[j];
       MemRefAccess dstAccess(dstOpInst);
 
       unsigned numCommonLoops =
           getNumCommonSurroundingLoops(*srcOpInst, *dstOpInst);
       for (unsigned d = 1; d <= numCommonLoops + 1; ++d) {
-        FlatAffineValueConstraints dependenceConstraints;
         // TODO: Cache dependence analysis results, check cache here.
-        DependenceResult result = checkMemrefAccessDependence(
-            srcAccess, dstAccess, d, &dependenceConstraints,
-            /*dependenceComponents=*/nullptr);
+        DependenceResult result =
+            checkMemrefAccessDependence(srcAccess, dstAccess, d);
         if (hasDependence(result)) {
           // Store minimum loop depth and break because we want the min 'd' at
           // which there is a dependence.
           loopDepth = std::min(loopDepth, d - 1);
           break;
         }
       }
     }

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

checkTilingLegalityImpl(MutableArrayRef<mlir::AffineForOp> origLoops) {
   SmallVector<Operation *, 8> loadAndStoreOps;
   origLoops[0]->walk([&](Operation *op) {
     if (isa<AffineReadOpInterface, AffineWriteOpInterface>(op))
       loadAndStoreOps.push_back(op);
   });
 
   unsigned numOps = loadAndStoreOps.size();
   unsigned numLoops = origLoops.size();
-  FlatAffineValueConstraints dependenceConstraints;
   for (unsigned d = 1; d <= numLoops + 1; ++d) {
     for (unsigned i = 0; i < numOps; ++i) {
       Operation *srcOp = loadAndStoreOps[i];
       MemRefAccess srcAccess(srcOp);
       for (unsigned j = 0; j < numOps; ++j) {
         Operation *dstOp = loadAndStoreOps[j];
         MemRefAccess dstAccess(dstOp);
 
         SmallVector<DependenceComponent, 2> depComps;
-        dependenceConstraints.reset();
         DependenceResult result = checkMemrefAccessDependence(
-            srcAccess, dstAccess, d, &dependenceConstraints, &depComps);
+            srcAccess, dstAccess, d, /*dependenceConstraints=*/nullptr,
+            &depComps);
 
         // Skip if there is no dependence in this case.
         if (!hasDependence(result))
           continue;
 
         // Check whether there is any negative direction vector in the
         // dependence components found above, which means that dependence is
         // violated by the default hyper-rect tiling method.
static bool getFullMemRefAsRegion(Operation *op, unsigned numParamLoopIVs,
 
   // Just get the first numSymbols IVs, which the memref region is parametric
   // on.
   SmallVector<AffineForOp, 4> ivs;
   getAffineForIVs(*op, &ivs);
   ivs.resize(numParamLoopIVs);
   SmallVector<Value, 4> symbols;
   extractForInductionVars(ivs, &symbols);
-  regionCst->reset(rank, numParamLoopIVs, 0);
+  *regionCst = FlatAffineValueConstraints(rank, numParamLoopIVs, 0);
   regionCst->setValues(rank, rank + numParamLoopIVs, symbols);
 
   // Memref dim sizes provide the bounds.
   for (unsigned d = 0; d < rank; d++) {
     auto dimSize = memRefType.getDimSize(d);
     assert(dimSize > 0 && "filtered dynamic shapes above");
     regionCst->addBound(IntegerPolyhedron::LB, d, 0);
     regionCst->addBound(IntegerPolyhedron::UB, d, dimSize - 1);

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

static bool mustReachAtInnermost(const MemRefAccess &srcAccess,
                                  const MemRefAccess &destAccess) {
   // Affine dependence analysis is possible only if both ops in the same
   // AffineScope.
   if (getAffineScope(srcAccess.opInst) != getAffineScope(destAccess.opInst))
     return false;
 
   unsigned nsLoops =
       getNumCommonSurroundingLoops(*srcAccess.opInst, *destAccess.opInst);
-  FlatAffineValueConstraints dependenceConstraints;
-  DependenceResult result = checkMemrefAccessDependence(
-      srcAccess, destAccess, nsLoops + 1, &dependenceConstraints,
-      /*dependenceComponents=*/nullptr);
+  DependenceResult result =
+      checkMemrefAccessDependence(srcAccess, destAccess, nsLoops + 1);
   return hasDependence(result);
 }
 
 /// Returns true if `srcMemOp` may have an effect on `destMemOp` within the
 /// scope of the outermost `minSurroundingLoops` loops that surround them.
 /// `srcMemOp` and `destMemOp` are expected to be affine read/write ops.
 static bool mayHaveEffect(Operation *srcMemOp, Operation *destMemOp,
                           unsigned minSurroundingLoops) {

mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp

for (unsigned i = 0, e = loadsAndStores.size(); i < e; ++i) {
     MemRefAccess srcAccess(srcOpInst);
     for (unsigned j = 0; j < e; ++j) {
       auto *dstOpInst = loadsAndStores[j];
       MemRefAccess dstAccess(dstOpInst);
 
       unsigned numCommonLoops =
           getNumCommonSurroundingLoops(*srcOpInst, *dstOpInst);
       for (unsigned d = 1; d <= numCommonLoops + 1; ++d) {
-        FlatAffineValueConstraints dependenceConstraints;
         SmallVector<DependenceComponent, 2> dependenceComponents;
         DependenceResult result = checkMemrefAccessDependence(
-            srcAccess, dstAccess, d, &dependenceConstraints,
+            srcAccess, dstAccess, d, /*dependenceConstraints=*/nullptr,
             &dependenceComponents);
         if (result.value == DependenceResult::Failure) {
           srcOpInst->emitError("dependence check failed");
         } else {
           bool ret = hasDependence(result);
           // TODO: Print dependence type (i.e. RAW, etc) and print
           // distance vectors as: ([2, 3], [0, 10]). Also, shorten distance
           // vectors from ([1, 1], [3, 3]) to (1, 3).