[MLIR] Fix affine analysis methods for affine.parallel

[bondhugula]

Summary

Drop unnecessary bailout in checkMemRefAccessDependence in the presence of
surrounding affine.parallel ops. When the affine.parallel op was added, affine
analysis methods weren't extended to account for it. Fix this and allow memref
dependence check to work in the presence of affine.parallel ops in the mix.

Rename isForInductionVar -> isAffineForInductionVar, getLoopIVs ->
getAffineForIVs to avoid confusion since that's what they were.

[bondhugula]

Drop unrelated NFC.

[Lewuathe]

mlir/test/Transforms/memref-dependence-check.mlir

1068–1069

nit: The function name should be like dependent_parallel or something like that.

[bondhugula]

Update test case func name.

mlir/test/Transforms/memref-dependence-check.mlir

1068–1069

Thanks for noticing, done.

[Groverkss]

The test coverage for the addition of an affine.parallel does not seem enough to me. Could you please add tests for cases with more than 1 induction vars in affine.parallel?

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

308–313

If a affine.parallel has multiple induction variables, is the operation counted multiple times? The expected behavior is non-obvious to me and should be documented according to me.

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

 class AffineForOp;
 class AffineValueMap;
 class Block;
 class Location;
 struct MemRefAccess;
 class Operation;
 class Value;
 
-/// Populates 'loops' with IVs of the loops surrounding 'op' ordered from
-/// the outermost 'affine.for' operation to the innermost one.
-//  TODO: handle 'affine.if' ops.
-void getLoopIVs(Operation &op, SmallVectorImpl<AffineForOp> *loops);
+/// Populates 'loops' with IVs of the affine.for ops surrounding 'op' ordered
+/// from the outermost 'affine.for' operation to the innermost one.
+void getAffineForIVs(Operation &op, SmallVectorImpl<AffineForOp> *loops);
 
 /// Populates 'ops' with affine operations enclosing `op` ordered from outermost
 /// to innermost. affine.for, affine.if, or affine.parallel ops comprise such
 /// surrounding affine ops.
 /// TODO: Change this to return a list of enclosing ops up until the op that
 /// starts an `AffineScope`. In such a case, `ops` is guaranteed by design to
 /// have a successive chain of affine parent ops, and this is primarily what is
 /// needed for most analyses.

mlir/include/mlir/Dialect/Affine/IR/AffineOps.h

void fullyComposeAffineMapAndOperands(AffineMap *map,
                                       SmallVectorImpl<Value> *operands);
 } // namespace mlir
 #include "mlir/Dialect/Affine/IR/AffineOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Affine/IR/AffineOps.h.inc"
 
 namespace mlir {
-/// Returns true if the provided value is the induction variable of a
+/// Returns true if the provided value is the induction variable of an
 /// AffineForOp.
-bool isForInductionVar(Value val);
+bool isAffineForInductionVar(Value val);
 
 /// Returns the loop parent of an induction variable. If the provided value is
 /// not an induction variable, then return nullptr.
 AffineForOp getForInductionVarOwner(Value val);
 
 /// Extracts the induction variables from a list of AffineForOps and places them
 /// in the output argument `ivs`.
 void extractForInductionVars(ArrayRef<AffineForOp> forInsts,

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

 /// innermost.
 static LogicalResult getOpIndexSet(Operation *op,
                                    FlatAffineValueConstraints *indexSet) {
   SmallVector<Operation *, 4> ops;
   getEnclosingAffineOps(*op, &ops);
   return getIndexSet(ops, indexSet);
 }
 
+/// Returns true if `val` is an induction of an affine.parallel op.
+static bool isAffineParallelInductionVar(Value val) {
+  auto ivArg = val.dyn_cast<BlockArgument>();
+  if (!ivArg)
+    return false;
+  return isa<AffineParallelOp>(ivArg.getOwner()->getParentOp());
+}
+
 // Returns the number of outer loop common to 'src/dstDomain'.
 // Loops common to 'src/dst' domains are added to 'commonLoops' if non-null.
 static unsigned
 getNumCommonLoops(const FlatAffineValueConstraints &srcDomain,
                   const FlatAffineValueConstraints &dstDomain,
                   SmallVectorImpl<AffineForOp> *commonLoops = nullptr) {
   // Find the number of common loops shared by src and dst accesses.
   unsigned minNumLoops =
       std::min(srcDomain.getNumDimVars(), dstDomain.getNumDimVars());
   unsigned numCommonLoops = 0;
   for (unsigned i = 0; i < minNumLoops; ++i) {
-    if (!isForInductionVar(srcDomain.getValue(i)) ||
-        !isForInductionVar(dstDomain.getValue(i)) ||
+    if ((!isAffineForInductionVar(srcDomain.getValue(i)) &&
+         !isAffineParallelInductionVar(srcDomain.getValue(i))) ||
+        (!isAffineForInductionVar(dstDomain.getValue(i)) &&
+         !isAffineParallelInductionVar(dstDomain.getValue(i))) ||
         srcDomain.getValue(i) != dstDomain.getValue(i))
       break;
     if (commonLoops != nullptr)
       commonLoops->push_back(getForInductionVarOwner(srcDomain.getValue(i)));
     ++numCommonLoops;
   }
   if (commonLoops != nullptr)
     assert(commonLoops->size() == numCommonLoops);
   return numCommonLoops;
 }
LLVM_DEBUG(llvm::dbgs() << "Checking for dependence at depth: "
                           << Twine(loopDepth) << " between:\n";);
   LLVM_DEBUG(srcAccess.opInst->dump(););
   LLVM_DEBUG(dstAccess.opInst->dump(););
 
   // Return 'NoDependence' if these accesses do not access the same memref.
   if (srcAccess.memref != dstAccess.memref)
     return DependenceResult::NoDependence;
 
-  // TODO: Support affine.parallel which does not specify the ordering.
-  auto srcParent = srcAccess.opInst->getParentOfType<AffineParallelOp>();
-  auto dstParent = dstAccess.opInst->getParentOfType<AffineParallelOp>();
-  if (srcParent || dstParent)
-    return DependenceResult::Failure;
-
   // Return 'NoDependence' if one of these accesses is not an
   // AffineWriteOpInterface.
   if (!allowRAR && !isa<AffineWriteOpInterface>(srcAccess.opInst) &&
       !isa<AffineWriteOpInterface>(dstAccess.opInst))
     return DependenceResult::NoDependence;
 
   // We can't analyze further if the ops lie in different affine scopes.
   if (getAffineScope(srcAccess.opInst) != getAffineScope(dstAccess.opInst))

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

void FlatAffineValueConstraints::convertLoopIVSymbolsToDims() {
   }
 }
 
 void FlatAffineValueConstraints::addInductionVarOrTerminalSymbol(Value val) {
   if (containsVar(val))
     return;
 
   // Caller is expected to fully compose map/operands if necessary.
-  assert((isTopLevelValue(val) || isForInductionVar(val)) &&
+  assert((isTopLevelValue(val) || isAffineForInductionVar(val)) &&
          "non-terminal symbol / loop IV expected");
   // Outer loop IVs could be used in forOp's bounds.
   if (auto loop = getForInductionVarOwner(val)) {
     appendDimVar(val);
     if (failed(this->addAffineForOpDomain(loop)))
       LLVM_DEBUG(
           loop.emitWarning("failed to add domain info to constraint system"));
     return;

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

 ///
 /// Prerequisites:
 ///   1. `iv` and `index` of the proper type;
 ///   2. at most one reachable AffineApplyOp from index;
 ///
 /// Returns false in cases with more than one AffineApplyOp, this is
 /// conservative.
 static bool isAccessIndexInvariant(Value iv, Value index) {
-  assert(isForInductionVar(iv) && "iv must be a AffineForOp");
+  assert(isAffineForInductionVar(iv) && "iv must be a AffineForOp");
   assert(index.getType().isa<IndexType>() && "index must be of IndexType");
   SmallVector<Operation *, 4> affineApplyOps;
   getReachableAffineApplyOps({index}, affineApplyOps);
 
   if (affineApplyOps.empty()) {
     // Pointer equality test because of Value pointer semantics.
     return index != iv;
   }

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

 
 #define DEBUG_TYPE "analysis-utils"
 
 using namespace mlir;
 using namespace presburger;
 
 using llvm::SmallDenseMap;
 
-/// Populates 'loops' with IVs of the loops surrounding 'op' ordered from
-/// the outermost 'affine.for' operation to the innermost one.
-void mlir::getLoopIVs(Operation &op, SmallVectorImpl<AffineForOp> *loops) {
+void mlir::getAffineForIVs(Operation &op, SmallVectorImpl<AffineForOp> *loops) {
   auto *currOp = op.getParentOp();
   AffineForOp currAffineForOp;
   // Traverse up the hierarchy collecting all 'affine.for' operation while
   // skipping over 'affine.if' operations.
   while (currOp) {
     if (AffineForOp currAffineForOp = dyn_cast<AffineForOp>(currOp))
       loops->push_back(currAffineForOp);
     currOp = currOp->getParentOp();
LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,
   unsigned rank = access.getRank();
 
   LLVM_DEBUG(llvm::dbgs() << "MemRefRegion::compute: " << *op
                           << "depth: " << loopDepth << "\n";);
 
   // 0-d memrefs.
   if (rank == 0) {
     SmallVector<AffineForOp, 4> ivs;
-    getLoopIVs(*op, &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;
     extractForInductionVars(ivs, &regionSymbols);
     // A 0-d memref has a 0-d region.
     cst.reset(rank, loopDepth, /*numLocals=*/0, regionSymbols);
     return success();
LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,
   // Set all variables appearing after the first 'rank' variables as
   // symbolic variables - so that the ones corresponding to the memref
   // dimensions are the dimensional variables for the memref region.
   cst.setDimSymbolSeparation(cst.getNumDimAndSymbolVars() - rank);
 
   // Eliminate any loop IVs other than the outermost 'loopDepth' IVs, on which
   // this memref region is symbolic.
   SmallVector<AffineForOp, 4> enclosingIVs;
-  getLoopIVs(*op, &enclosingIVs);
+  getAffineForIVs(*op, &enclosingIVs);
   assert(loopDepth <= enclosingIVs.size() && "invalid loop depth");
   enclosingIVs.resize(loopDepth);
   SmallVector<Value, 4> vars;
   cst.getValues(cst.getNumDimVars(), cst.getNumDimAndSymbolVars(), &vars);
   for (auto var : vars) {
     AffineForOp iv;
     if ((iv = getForInductionVarOwner(var)) &&
         !llvm::is_contained(enclosingIVs, iv)) {

 }
 
 // Adds loop IV bounds to 'cst' for loop IVs not found in 'ivs'.
 static LogicalResult addMissingLoopIVBounds(SmallPtrSet<Value, 8> &ivs,
                                             FlatAffineValueConstraints *cst) {
   for (unsigned i = 0, e = cst->getNumDimVars(); i < e; ++i) {
     auto value = cst->getValue(i);
     if (ivs.count(value) == 0) {
-      assert(isForInductionVar(value));
+      assert(isAffineForInductionVar(value));
       auto loop = getForInductionVarOwner(value);
       if (failed(cst->addAffineForOpDomain(loop)))
         return failure();
     }
   }
   return success();
 }
 
 /// Returns the innermost common loop depth for the set of operations in 'ops'.
 // TODO: Move this to LoopUtils.
 unsigned mlir::getInnermostCommonLoopDepth(
     ArrayRef<Operation *> ops, SmallVectorImpl<AffineForOp> *surroundingLoops) {
   unsigned numOps = ops.size();
   assert(numOps > 0 && "Expected at least one operation");
 
   std::vector<SmallVector<AffineForOp, 4>> loops(numOps);
   unsigned loopDepthLimit = std::numeric_limits<unsigned>::max();
   for (unsigned i = 0; i < numOps; ++i) {
-    getLoopIVs(*ops[i], &loops[i]);
+    getAffineForIVs(*ops[i], &loops[i]);
     loopDepthLimit =
         std::min(loopDepthLimit, static_cast<unsigned>(loops[i].size()));
   }
 
   unsigned loopDepth = 0;
   for (unsigned d = 0; d < loopDepthLimit; ++d) {
     unsigned i;
     for (i = 1; i < numOps; ++i) {

 // bounds in 'sliceState' which represent the one loop nest's IVs in terms of
 // the other loop nest's IVs, symbols and constants (using 'isBackwardsSlice').
 void mlir::getComputationSliceState(
     Operation *depSourceOp, Operation *depSinkOp,
     FlatAffineValueConstraints *dependenceConstraints, unsigned loopDepth,
     bool isBackwardSlice, ComputationSliceState *sliceState) {
   // Get loop nest surrounding src operation.
   SmallVector<AffineForOp, 4> srcLoopIVs;
-  getLoopIVs(*depSourceOp, &srcLoopIVs);
+  getAffineForIVs(*depSourceOp, &srcLoopIVs);
   unsigned numSrcLoopIVs = srcLoopIVs.size();
 
   // Get loop nest surrounding dst operation.
   SmallVector<AffineForOp, 4> dstLoopIVs;
-  getLoopIVs(*depSinkOp, &dstLoopIVs);
+  getAffineForIVs(*depSinkOp, &dstLoopIVs);
   unsigned numDstLoopIVs = dstLoopIVs.size();
 
   assert((!isBackwardSlice && loopDepth <= numSrcLoopIVs) ||
          (isBackwardSlice && loopDepth <= numDstLoopIVs));
 
   // Project out dimensions other than those up to 'loopDepth'.
   unsigned pos = isBackwardSlice ? numSrcLoopIVs + loopDepth : loopDepth;
   unsigned num =

 // iterations from destination index set and check for emptiness --- this is one
 // solution.
 AffineForOp
 mlir::insertBackwardComputationSlice(Operation *srcOpInst, Operation *dstOpInst,
                                      unsigned dstLoopDepth,
                                      ComputationSliceState *sliceState) {
   // Get loop nest surrounding src operation.
   SmallVector<AffineForOp, 4> srcLoopIVs;
-  getLoopIVs(*srcOpInst, &srcLoopIVs);
+  getAffineForIVs(*srcOpInst, &srcLoopIVs);
   unsigned numSrcLoopIVs = srcLoopIVs.size();
 
   // Get loop nest surrounding dst operation.
   SmallVector<AffineForOp, 4> dstLoopIVs;
-  getLoopIVs(*dstOpInst, &dstLoopIVs);
+  getAffineForIVs(*dstOpInst, &dstLoopIVs);
   unsigned dstLoopIVsSize = dstLoopIVs.size();
   if (dstLoopDepth > dstLoopIVsSize) {
     dstOpInst->emitError("invalid destination loop depth");
     return AffineForOp();
   }
 
   // Find the op block positions of 'srcOpInst' within 'srcLoopIVs'.
   SmallVector<unsigned, 4> positions;
   // TODO: This code is incorrect since srcLoopIVs can be 0-d.
   findInstPosition(srcOpInst, srcLoopIVs[0]->getBlock(), &positions);
 
   // Clone src loop nest and insert it a the beginning of the operation block
   // of the loop at 'dstLoopDepth' in 'dstLoopIVs'.
   auto dstAffineForOp = dstLoopIVs[dstLoopDepth - 1];
   OpBuilder b(dstAffineForOp.getBody(), dstAffineForOp.getBody()->begin());
   auto sliceLoopNest =
       cast<AffineForOp>(b.clone(*srcLoopIVs[0].getOperation()));
 
   Operation *sliceInst =
       getInstAtPosition(positions, /*level=*/0, sliceLoopNest.getBody());
   // Get loop nest surrounding 'sliceInst'.
   SmallVector<AffineForOp, 4> sliceSurroundingLoops;
-  getLoopIVs(*sliceInst, &sliceSurroundingLoops);
+  getAffineForIVs(*sliceInst, &sliceSurroundingLoops);
 
   // Sanity check.
   unsigned sliceSurroundingLoopsSize = sliceSurroundingLoops.size();
   (void)sliceSurroundingLoopsSize;
   assert(dstLoopDepth + numSrcLoopIVs >= sliceSurroundingLoopsSize);
   unsigned sliceLoopLimit = dstLoopDepth + numSrcLoopIVs;
   (void)sliceLoopLimit;
   assert(sliceLoopLimit >= sliceSurroundingLoopsSize);
bool MemRefAccess::operator==(const MemRefAccess &rhs) const {
   AffineValueMap diff, thisMap, rhsMap;
   getAccessMap(&thisMap);
   rhs.getAccessMap(&rhsMap);
   AffineValueMap::difference(thisMap, rhsMap, &diff);
   return llvm::all_of(diff.getAffineMap().getResults(),
                       [](AffineExpr e) { return e == 0; });
 }
 
+/// Populates 'loops' with IVs of the surrounding affine.for and affine.parallel
+/// ops ordered from the outermost one to the innermost.
+static void getAffineIVs(Operation &op, SmallVectorImpl<Value> &loops) {
+  auto *currOp = op.getParentOp();
+  AffineForOp currAffineForOp;
+  // Traverse up the hierarchy collecting all 'affine.for' operation while
+  // skipping over 'affine.if' operations.
+  while (currOp) {
+    if (AffineForOp currAffineForOp = dyn_cast<AffineForOp>(currOp))
+      loops.push_back(currAffineForOp.getInductionVar());
+    else if (auto parOp = dyn_cast<AffineParallelOp>(currOp))
+      llvm::append_range(loops, parOp.getIVs());
+    currOp = currOp->getParentOp();
+  }
+  std::reverse(loops.begin(), loops.end());
+}
+
 /// Returns the number of surrounding loops common to 'loopsA' and 'loopsB',
 /// where each lists loops from outer-most to inner-most in loop nest.
 unsigned mlir::getNumCommonSurroundingLoops(Operation &a, Operation &b) {
-  SmallVector<AffineForOp, 4> loopsA, loopsB;
-  getLoopIVs(a, &loopsA);
-  getLoopIVs(b, &loopsB);
+  SmallVector<Value, 4> loopsA, loopsB;
+  getAffineIVs(a, loopsA);
+  getAffineIVs(b, loopsB);
 
   unsigned minNumLoops = std::min(loopsA.size(), loopsB.size());
   unsigned numCommonLoops = 0;
   for (unsigned i = 0; i < minNumLoops; ++i) {
-    if (loopsA[i].getOperation() != loopsB[i].getOperation())
+    if (loopsA[i] != loopsB[i])
       break;
     ++numCommonLoops;
   }
   return numCommonLoops;
 }
 
 static Optional<int64_t> getMemoryFootprintBytes(Block &block,
                                                  Block::iterator start,

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

Speculation::Speculatability AffineForOp::getSpeculatability() {
   // For Step != 1, the loop may not terminate.  We can add more smarts here if
   // needed.
   return getStep() == 1 ? Speculation::RecursivelySpeculatable
                         : Speculation::NotSpeculatable;
 }
 
 /// Returns true if the provided value is the induction variable of a
 /// AffineForOp.
-bool mlir::isForInductionVar(Value val) {
+bool mlir::isAffineForInductionVar(Value val) {
   return getForInductionVarOwner(val) != AffineForOp();
 }
 
 /// Returns the loop parent of an induction variable. If the provided value is
 /// not an induction variable, then return nullptr.
 AffineForOp mlir::getForInductionVarOwner(Value val) {
   auto ivArg = val.dyn_cast<BlockArgument>();
   if (!ivArg || !ivArg.getOwner())

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

if (isa<AffineMapAccessInterface>(op)) {
         // If the memref used by the load/store is used in a store elsewhere in
         // the loop nest, we do not hoist. Similarly, if the memref used in a
         // load is also being stored too, we do not hoist the load.
         if (isa<AffineWriteOpInterface>(user) ||
             (isa<AffineReadOpInterface>(user) &&
              isa<AffineWriteOpInterface>(op))) {
           if (&op != user) {
             SmallVector<AffineForOp, 8> userIVs;
-            getLoopIVs(*user, &userIVs);
+            getAffineForIVs(*user, &userIVs);
             // Check that userIVs don't contain the for loop around the op.
             if (llvm::is_contained(userIVs, getForInductionVarOwner(indVar)))
               return false;
           }
         }
       }
     }
 

mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp

for (auto &idAndNode : nodes) {
     Operation *opInst = node.op;
     for (Value value : opInst->getResults()) {
       for (Operation *user : value.getUsers()) {
         // Ignore users outside of the block.
         if (block->getParent()->findAncestorOpInRegion(*user)->getBlock() !=
             block)
           continue;
         SmallVector<AffineForOp, 4> loops;
-        getLoopIVs(*user, &loops);
+        getAffineForIVs(*user, &loops);
         if (loops.empty())
           continue;
         assert(forToNodeMap.count(loops[0]) > 0 && "missing mapping");
         unsigned userLoopNestId = forToNodeMap[loops[0]];
         addEdge(node.id, userLoopNestId, value);
       }
     }
   }
static bool isFusionProfitable(Operation *srcOpInst, Operation *srcStoreOpInst,
 
   if (maxLegalFusionDepth == 0) {
     LLVM_DEBUG(llvm::dbgs() << "Can't fuse: maxLegalFusionDepth == 0 .\n");
     return false;
   }
 
   // Compute cost of sliced and unsliced src loop nest.
   SmallVector<AffineForOp, 4> srcLoopIVs;
-  getLoopIVs(*srcOpInst, &srcLoopIVs);
+  getAffineForIVs(*srcOpInst, &srcLoopIVs);
 
   // Walk src loop nest and collect stats.
   LoopNestStats srcLoopNestStats;
   if (!getLoopNestStats(srcLoopIVs[0], &srcLoopNestStats))
     return false;
 
   // Compute cost of dst loop nest.
   LoopNestStats dstLoopNestStats;
while (findSiblingNodeToFuse(dstNode, &visitedSibNodeIds, &idAndMemref)) {
       // TODO: Choose the store which postdominates all other stores.
       auto *sibStoreOpInst = sibNode->stores.back();
 
       // Gather 'dstNode' load ops to 'memref'.
       SmallVector<Operation *, 2> dstLoadOpInsts;
       dstNode->getLoadOpsForMemref(memref, &dstLoadOpInsts);
 
       SmallVector<AffineForOp, 4> dstLoopIVs;
-      getLoopIVs(*dstLoadOpInsts[0], &dstLoopIVs);
+      getAffineForIVs(*dstLoadOpInsts[0], &dstLoopIVs);
       unsigned dstLoopDepthTest = dstLoopIVs.size();
       auto sibAffineForOp = cast<AffineForOp>(sibNode->op);
 
       // Compute loop depth and slice union for fusion.
       SmallVector<ComputationSliceState, 8> depthSliceUnions;
       depthSliceUnions.resize(dstLoopDepthTest);
       unsigned maxLegalFusionDepth = 0;
       FusionStrategy strategy(memref);
bool findSiblingNodeToFuse(Node *dstNode,
     Block *block = dstNode->op->getBlock();
     for (unsigned i = 0, e = block->getNumArguments(); i != e; ++i) {
       for (Operation *user : block->getArgument(i).getUsers()) {
         auto loadOp = dyn_cast<AffineReadOpInterface>(user);
         if (!loadOp)
           continue;
         // Gather loops surrounding 'use'.
         SmallVector<AffineForOp, 4> loops;
-        getLoopIVs(*user, &loops);
+        getAffineForIVs(*user, &loops);
         // Skip 'use' if it is not within a loop nest.
         if (loops.empty())
           continue;
         Node *sibNode = mdg->getForOpNode(loops[0]);
         assert(sibNode != nullptr);
         // Skip 'use' if it not a sibling to 'dstNode'.
         if (sibNode->id == dstNode->id)
           continue;

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

opX->walk([&](Operation *op) {
           return WalkResult::interrupt();
         }
         return WalkResult::advance();
       }
       for (Value value : op->getResults()) {
         for (Operation *user : value.getUsers()) {
           SmallVector<AffineForOp, 4> loops;
           // Check if any loop in loop nest surrounding 'user' is 'opB'.
-          getLoopIVs(*user, &loops);
+          getAffineForIVs(*user, &loops);
           if (llvm::is_contained(loops, cast<AffineForOp>(opB))) {
             lastDepOp = opX;
             return WalkResult::interrupt();
           }
         }
       }
       return WalkResult::advance();
     });
if (storeLoadFwdGuaranteed) {
     // Subtract out any load users of 'storeMemrefs' nested below
     // 'insertPointParent'.
     for (Value memref : storeMemrefs) {
       for (auto *user : memref.getUsers()) {
         if (auto loadOp = dyn_cast<AffineReadOpInterface>(user)) {
           SmallVector<AffineForOp, 4> loops;
           // Check if any loop in loop nest surrounding 'user' is
           // 'insertPointParent'.
-          getLoopIVs(*user, &loops);
+          getAffineForIVs(*user, &loops);
           if (llvm::is_contained(loops, cast<AffineForOp>(insertPointParent))) {
             if (auto forOp =
                     dyn_cast_or_null<AffineForOp>(user->getParentOp())) {
               if (computeCostMap.count(forOp) == 0)
                 computeCostMap[forOp] = 0;
               computeCostMap[forOp] -= 1;
             }
           }

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

findHighestBlockForPlacement(const MemRefRegion &region, Block &block,
                              Block **copyPlacementBlock,
                              Block::iterator *copyInPlacementStart,
                              Block::iterator *copyOutPlacementStart) {
   const auto *cst = region.getConstraints();
   SmallVector<Value, 4> symbols;
   cst->getValues(cst->getNumDimVars(), cst->getNumDimAndSymbolVars(), &symbols);
 
   SmallVector<AffineForOp, 4> enclosingFors;
-  getLoopIVs(*block.begin(), &enclosingFors);
+  getAffineForIVs(*block.begin(), &enclosingFors);
   // Walk up loop parents till we find an IV on which this region is
   // symbolic/variant.
   auto it = enclosingFors.rbegin();
   for (auto e = enclosingFors.rend(); it != e; ++it) {
     // TODO: also need to be checking this for regions symbols that
     // aren't loop IVs, whether we are within their resp. defs' dominance scope.
     if (llvm::is_contained(symbols, it->getInductionVar()))
       break;
static bool getFullMemRefAsRegion(Operation *op, unsigned numParamLoopIVs,
   if (!memRefType.hasStaticShape())
     return false;
 
   auto *regionCst = region->getConstraints();
 
   // Just get the first numSymbols IVs, which the memref region is parametric
   // on.
   SmallVector<AffineForOp, 4> ivs;
-  getLoopIVs(*op, &ivs);
+  getAffineForIVs(*op, &ivs);
   ivs.resize(numParamLoopIVs);
   SmallVector<Value, 4> symbols;
   extractForInductionVars(ivs, &symbols);
   regionCst->reset(rank, numParamLoopIVs, 0);
   regionCst->setValues(rank, rank + numParamLoopIVs, symbols);
 
   // Memref dim sizes provide the bounds.
   for (unsigned d = 0; d < rank; d++) {

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

LogicalResult mlir::hoistAffineIfOp(AffineIfOp ifOp, bool *folded) {
   }
   if (folded)
     *folded = false;
 
   // The folding above should have ensured this, but the affine.if's
   // canonicalization is missing composition of affine.applys into it.
   assert(llvm::all_of(ifOp.getOperands(),
                       [](Value v) {
-                        return isTopLevelValue(v) || isForInductionVar(v);
+                        return isTopLevelValue(v) || isAffineForInductionVar(v);
                       }) &&
          "operands not composed");
 
   // We are going hoist as high as possible.
   // TODO: this could be customized in the future.
   auto *hoistOverOp = getOutermostInvariantForOp(ifOp);
 
   AffineIfOp hoistedIfOp = ::hoistAffineIfOp(ifOp, hoistOverOp);

mlir/test/Transforms/memref-dependence-check.mlir

affine.if #set2(%i0) {
       // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
     }
   }
 
   return
 }
 
 // -----
-// CHECK-LABEL: func @parallel_dependence_check_failure() {
-func.func @parallel_dependence_check_failure() {
+// CHECK-LABEL: func @dependent_parallel() {
+func.func @dependent_parallel() {
   %0 = memref.alloc() : memref<10xf32>
   %cst = arith.constant 7.000000e+00 : f32
   affine.parallel (%i0) = (0) to (10) {
-    // expected-error @+1 {{dependence check failed}}
     affine.store %cst, %0[%i0] : memref<10xf32>
+    // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
+    // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
   }
   affine.parallel (%i1) = (0) to (10) {
-    // expected-error @+1 {{dependence check failed}}
     %1 = affine.load %0[%i1] : memref<10xf32>
+    // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 
 func.func @affine_if_no_dependence() {
   %c1 = arith.constant 1 : index