[mlir][Linalg] NFC: Refactor LinalgDependenceGraphElem to allow representing dependence from producer result to consumer.

[mravishankar]

Summary

With Linalg on tensors the dependence between operations can be from
the result of the producer to the consumer. This change just does a
NFC refactoring of the LinalgDependenceGraphElem to allow representing
both OpResult and OpOperand*.

mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h

 /// Data structure for holding a dependence graph that operates on LinalgOp and
 /// views as SSA values.
 class LinalgDependenceGraph {
 public:
   enum DependenceType { RAR = 0, RAW, WAR, WAW, NumTypes };
   // TODO: OpOperand tracks dependencies on buffer operands. Tensor result will
   // need an extension to use OpResult.
   struct LinalgDependenceGraphElem {
+    using OpView = PointerUnion<OpOperand *, Value>;
     // dependentOpView may be either:
     //   1. src in the case of dependencesIntoGraphs.
     //   2. dst in the case of dependencesFromDstGraphs.
-    OpOperand *dependentOpView;
+    OpView dependentOpView;
     // View in the op that is used to index in the graph:
     //   1. src in the case of dependencesFromDstGraphs.
     //   2. dst in the case of dependencesIntoGraphs.
-    OpOperand *indexingOpView;
+    OpView indexingOpView;
     // Type of the dependence.
     DependenceType dependenceType;
+
+    // Return the Operation that owns the operand or result represented in
+    // `opView`.
+    static Operation *getOwner(OpView opView) {
+      if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
+        return operand->getOwner();
+      return opView.get<Value>().cast<OpResult>().getOwner();
+    }
+    // Return the operand or the result Value represented by the `opView`.
+    static Value getValue(OpView opView) {
+      if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
+        return operand->get();
+      return opView.get<Value>();
+    }
+    // Return the indexing map of the operand/result in `opView` specified in
+    // the owning LinalgOp. If the owner is not a LinalgOp returns llvm::None.
+    static Optional<AffineMap> getIndexingMap(OpView opView) {
+      auto owner = dyn_cast<LinalgOp>(getOwner(opView));
+      if (!owner)
+        return llvm::None;
+      if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
+        return owner.getIndexingMap(operand->getOperandNumber());
+      return owner.getOutputIndexingMap(
+          opView.get<Value>().cast<OpResult>().getResultNumber());
+    }
+    // Return the operand number if the `opView` is an OpOperand *. Otherwise
+    // return llvm::None.
+    static Optional<unsigned> getOperandNumber(OpView opView) {
+      if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
+        return operand->getOperandNumber();
+      return llvm::None;
+    }
+    // Return the result number if the `opView` is an OpResult. Otherwise return
+    // llvm::None.
+    static Optional<unsigned> getResultNumber(OpView opView) {
+      if (OpResult result = opView.dyn_cast<Value>().cast<OpResult>())
+        return result.getResultNumber();
+      return llvm::None;
+    }
+
+    // Return the owner of the dependent OpView.
+    Operation *getDependentOp() const { return getOwner(dependentOpView); }
+
+    // Return the owner of the indexing OpView.
+    Operation *getIndexingOp() const { return getOwner(indexingOpView); }
+
+    // Return the operand or result stored in the dependentOpView.
+    Value getDependentValue() const { return getValue(dependentOpView); }
+
+    // Return the operand or result stored in the indexingOpView.
+    Value getIndexingValue() const { return getValue(indexingOpView); }
+
+    // If the dependent OpView is an operand, return operand number. Return
+    // llvm::None otherwise.
+    Optional<unsigned> getDependentOpViewOperandNum() const {
+      return getOperandNumber(dependentOpView);
+    }
+
+    // If the indexing OpView is an operand, return operand number. Return
+    // llvm::None otherwise.
+    Optional<unsigned> getIndexingOpViewOperandNum() const {
+      return getOperandNumber(indexingOpView);
+    }
+
+    // If the dependent OpView is a result value, return the result
+    // number. Return llvm::None otherwise.
+    Optional<unsigned> getDependentOpViewResultNum() const {
+      return getResultNumber(dependentOpView);
+    }
+
+    // If the dependent OpView is a result value, return the result
+    // number. Return llvm::None otherwise.
+    Optional<unsigned> getIndexingOpViewResultNum() const {
+      return getResultNumber(indexingOpView);
+    }
+
+    // Return the indexing map of the operand/result in the dependent OpView as
+    // specified in the owner of the OpView.
+    Optional<AffineMap> getDependentOpViewIndexingMap() const {
+      return getIndexingMap(dependentOpView);
+    }
+
+    // Return the indexing map of the operand/result in the indexing OpView as
+    // specified in the owner of the OpView.
+    Optional<AffineMap> getIndexingOpViewIndexingMap() const {
+      return getIndexingMap(indexingOpView);
+    }
   };
   using LinalgDependences = SmallVector<LinalgDependenceGraphElem, 8>;
   using DependenceGraph = DenseMap<Operation *, LinalgDependences>;
   using dependence_iterator = LinalgDependences::const_iterator;
   using dependence_range = iterator_range<dependence_iterator>;
 
   static StringRef getDependenceTypeStr(DependenceType depType);
 

mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp

LinalgDependenceGraph::findOperationsWithCoveringDependences(
   assert(srcPos < dstPos && "expected dst after src in IR traversal order");
 
   SmallVector<Operation *, 8> res;
   // Consider an intermediate interleaved `interim` op, look for any dependence
   // to an aliasing view on a src -> op -> dst path.
   // TODO: we are not considering paths yet, just interleaved positions.
   for (auto dt : types) {
     for (auto dependence : getDependencesFrom(src, dt)) {
-      auto interimPos =
-          linalgOpPositions.lookup(dependence.dependentOpView->getOwner());
+      auto interimPos = linalgOpPositions.lookup(dependence.getDependentOp());
       // Skip if not interleaved.
       if (interimPos >= dstPos || interimPos <= srcPos)
         continue;
-      Value consumerView = dependence.indexingOpView->get();
+      Value consumerView = dependence.getIndexingValue();
       if (view && !aliases.alias(view, consumerView))
         continue;
-      auto *op = dependence.dependentOpView->getOwner();
+      auto *op = dependence.getDependentOp();
       LLVM_DEBUG(dbgs() << "\n***Found covering dependence of type "
                         << getDependenceTypeStr(dt) << ": " << *src << " -> "
                         << *op << " on " << consumerView);
       res.push_back(op);
     }
   }
   return res;
 }
 
 bool LinalgDependenceGraph::hasDependenceFrom(
     LinalgOp srcLinalgOp, LinalgOp dstLinalgOp,
     ArrayRef<LinalgDependenceGraph::DependenceType> depTypes) const {
   for (auto dep : depTypes)
     for (auto dependence : getDependencesInto(dstLinalgOp, dep))
-      if (dependence.dependentOpView->getOwner() == srcLinalgOp)
+      if (dependence.getDependentOp() == srcLinalgOp)
         return true;
   return false;
 }
 
 bool LinalgDependenceGraph::hasDependentOperationsFrom(
     LinalgOp linalgOp,
     ArrayRef<LinalgDependenceGraph::DependenceType> depTypes) const {
   for (auto dep : depTypes) {

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

 /// is needed just before the `consumer.
 ///
 /// Depending on the type of `consumer.getShapedOperand(consumerIdx)`, there are
 /// 2 cases:
 ///   1. Buffer case: `producerIdx` is the index of the buffer in
 ///      `producer.getOutputBuffers()`.
 ///   2. Tensor case: `producerIdx` is the index of the tensor in
 ///      `producer.getResults()`.
-static LinalgOp fuse(OpBuilder &b, LinalgOp producerOp,
-                     unsigned producerOutNumber, OpOperand &consumerOpOperand) {
-  AffineMap producerMap = producerOp.getOutputIndexingMap(producerOutNumber);
-  LLVM_DEBUG(llvm::dbgs() << "Producer Idx: " << producerOutNumber
-                          << ", producer map: " << producerMap << "\n");
+static LinalgOp fuse(OpBuilder &b, LinalgOp producerOp, AffineMap producerMap,
+                     OpOperand &consumerOpOperand) {
+  LLVM_DEBUG(llvm::dbgs() << "Producer map: " << producerMap << "\n");
   DenseMap<unsigned, Range> fusedLoopsAndRanges;
   Value shapedOperand = consumerOpOperand.get();
   for (auto en : llvm::enumerate(producerMap.getResults())) {
     unsigned posInProducerLoop = en.value().cast<AffineDimExpr>().getPosition();
     fusedLoopsAndRanges[posInProducerLoop] = getRangeFromOperandShape(
         b, consumerOpOperand.getOwner()->getLoc(), shapedOperand, en.index());
   }
   return fuse(b, producerOp, fusedLoopsAndRanges);
bool mlir::linalg::isFusableInto(const LinalgDependenceGraph &graph,
   }
   return true;
 }
 
 static Optional<LinalgDependenceGraph::LinalgDependenceGraphElem>
 findFusableProducer(OpOperand &consumerOpOperand,
                     const LinalgDependenceGraph &dependenceGraph) {
   LinalgOp consumerOp = cast<LinalgOp>(consumerOpOperand.getOwner());
+  // Note that buffer semantics implies that the dependence will only be from
+  // OpOperand -> OpOperand.
   assert(consumerOp.hasBufferSemantics() && "revisit usage of shaped operand");
 
   // Only consider RAW and WAW atm.
   for (auto depType : {
            LinalgDependenceGraph::DependenceType::RAW,
            LinalgDependenceGraph::DependenceType::WAW,
        }) {
     for (auto dependence : llvm::make_filter_range(
              dependenceGraph.getDependencesInto(consumerOp, depType),
              [&](LinalgDependenceGraph::LinalgDependenceGraphElem elem) {
-               return elem.indexingOpView->get() == consumerOpOperand.get() &&
-                      elem.indexingOpView->getOperandNumber() ==
+               Value v = elem.getIndexingValue();
+               Optional<unsigned> operandNum =
+                   elem.getIndexingOpViewOperandNum();
+               return isa<LinalgOp>(elem.getDependentOp()) &&
+                      v == consumerOpOperand.get() && operandNum &&
+                      operandNum.getValue() ==
                           consumerOpOperand.getOperandNumber();
              })) {
-
       // Consumer consumes this view, `isStructurallyFusableProducer` also
       // checks whether it is a strict subview of the producer view.
-      auto producer = cast<LinalgOp>(dependence.dependentOpView->getOwner());
+      auto producer = cast<LinalgOp>(dependence.getDependentOp());
       LLVM_DEBUG(llvm::dbgs()
                  << "\n"
                  << LinalgDependenceGraph::getDependenceTypeStr(depType)
-                 << "producer: " << *dependence.dependentOpView->getOwner()
-                 << " view: " << dependence.dependentOpView->get()
-                 << " output index: "
-                 << dependence.dependentOpView->getOperandNumber() -
-                        producer.getNumInputs()
+                 << "producer: " << *dependence.getDependentOp() << " view: "
+                 << dependence.getDependentValue() << " output index: "
+                 << (dependence.getDependentOpViewOperandNum().getValue() -
+                     producer.getNumInputs())
                  << "\n");
 
       // Simple fusability checks.
       if (!isFusableInto(dependenceGraph, consumerOp, consumerOpOperand.get(),
                          producer))
         continue;
 
       return dependence;
     }
   }
   return {};
 }
 
 Optional<FusionInfo>
 mlir::linalg::fuseProducerOfBuffer(OpBuilder &b, OpOperand &consumerOpOperand,
                                    const LinalgDependenceGraph &graph) {
   Optional<LinalgDependenceGraph::LinalgDependenceGraphElem> fusableDependence =
       findFusableProducer(consumerOpOperand, graph);
   if (!fusableDependence)
-    return {};
+    return llvm::None;
+
+  LinalgOp producerOp = dyn_cast<LinalgOp>(fusableDependence->getDependentOp());
+  if (!producerOp)
+    return llvm::None;
 
-  LinalgOp producerOp =
-      cast<LinalgOp>(fusableDependence->dependentOpView->getOwner());
   // If producer is already in the same block as consumer, we are done.
   if (consumerOpOperand.get().getParentBlock() ==
-      fusableDependence->dependentOpView->get().getParentBlock())
-    return {};
+      fusableDependence->getDependentValue().getParentBlock())
+    return llvm::None;
 
-  unsigned producerIdx =
-      fusableDependence->dependentOpView->getOperandNumber() -
-      producerOp.getNumInputs();
+  Optional<AffineMap> producerMap =
+      fusableDependence->getDependentOpViewIndexingMap();
+  if (!producerMap)
+    return llvm::None;
 
   // Must be a subview or a slice to guarantee there are loops we can fuse
   // into.
   auto subView = consumerOpOperand.get().getDefiningOp<SubViewOp>();
   auto slice = consumerOpOperand.get().getDefiningOp<SliceOp>();
   if (!subView && !slice) {
     LLVM_DEBUG(llvm::dbgs() << "\nNot fusable (not a subview or slice)");
-    return {};
+    return llvm::None;
   }
 
   // Fuse `producer` just before `consumer`.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(consumerOpOperand.getOwner());
   ScopedContext scope(b, consumerOpOperand.getOwner()->getLoc());
   LLVM_DEBUG(llvm::dbgs() << "Fuse into consumer: "
                           << *consumerOpOperand.getOwner() << "\n");
 
-  auto fusedProducer = fuse(b, producerOp, producerIdx, consumerOpOperand);
+  auto fusedProducer = fuse(b, producerOp, *producerMap, consumerOpOperand);
   return FusionInfo{producerOp, fusedProducer};
 }
 
 /// Walk back use-def chain through scf::For yields.
 /// Sets `producer` and `outputIndex` if it finds a producer LinalgOp
 static void getProducerOfTensor(Value tensor, OpResult &opResult) {
   if (!tensor.getType().isa<RankedTensorType>())
     return;
mlir::linalg::fuseProducerOfTensor(OpBuilder &b, OpOperand &consumerOpOperand) {
   }
   return fuseProducerOfTensor(b, producerOpResult, consumerOpOperand);
 }
 
 Optional<FusionInfo>
 mlir::linalg::fuseProducerOfTensor(OpBuilder &b, OpResult producerOpResult,
                                    OpOperand &consumerOpOperand) {
   auto producerOp = dyn_cast<LinalgOp>(producerOpResult.getOwner());
-  assert(producerOp && "expected Linalg producer");
-  LinalgOp consumerOp = cast<LinalgOp>(consumerOpOperand.getOwner());
+  if (!producerOp)
+    return llvm::None;
+
+  LinalgOp consumerOp = dyn_cast<LinalgOp>(consumerOpOperand.getOwner());
+  if (!consumerOp)
+    return llvm::None;
+
   Value inputTensor = consumerOpOperand.get();
 
   // Must be a subtensor to guarantee there are loops we can fuse into.
   auto subTensor = inputTensor.getDefiningOp<SubTensorOp>();
   if (!subTensor) {
     LLVM_DEBUG(llvm::dbgs()
                << "\nNot fusable, not a subtensor: " << inputTensor);
     return {};
   }
 
   // If producer is already in the same block as consumer, we are done.
   if (consumerOpOperand.get().getParentBlock() ==
       producerOpResult.getParentBlock())
     return {};
 
   // Insert fused `producer` just before `consumer`.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(consumerOp);
   ScopedContext scope(b, consumerOp->getLoc());
   LLVM_DEBUG(llvm::dbgs() << "Fuse into consumer: " << *consumerOp << "\n");
-  LinalgOp fusedProducer = fuse(
-      b, producerOp, producerOpResult.getResultNumber(), consumerOpOperand);
+  LinalgOp fusedProducer =
+      fuse(b, producerOp,
+           producerOp.getOutputIndexingMap(producerOpResult.getResultNumber()),
+           consumerOpOperand);
 
   // Replace use.
   // Canonicalizations are not guaranteed to have happened before constructing
   // `fusedProducer`. In the tensor case this can result in temporary type
   // mismatches. Insert a `tensor.cast` op to propagate the transformation
   // invariant that types are compatible.
   Value def = fusedProducer->getResult(producerOpResult.getResultNumber());
   Type consumerType = consumerOpOperand.get().getType();

 /// Returns the mapping from iterations in the consumer that write to the same
 /// location as the iterations in the producer. To do so use
 /// - indexing map of the fused view in the consumer : consumerIndexMap
 /// - indexing map of the fused view in the producer : producerIndexMap
 ///     consumerLoopToProducerLoop =
 ///       inverse(producerIndexMap).compose(consumerIndexMap)
 static Optional<AffineMap> getConsumerLoopToProducerLoopMap(
     LinalgDependenceGraph::LinalgDependenceGraphElem dependence) {
-  auto producer = cast<LinalgOp>(dependence.dependentOpView->getOwner());
-  AffineMap producerIndexingMap =
-      producer.getIndexingMap(dependence.dependentOpView->getOperandNumber());
-  auto consumer = cast<LinalgOp>(dependence.indexingOpView->getOwner());
-  AffineMap consumerIndexingMap =
-      consumer.getIndexingMap(dependence.indexingOpView->getOperandNumber());
+  auto producer = dyn_cast<LinalgOp>(dependence.getDependentOp());
+  if (!producer)
+    return None;
+
+  Optional<AffineMap> producerIndexingMap =
+      dependence.getDependentOpViewIndexingMap();
+  Optional<AffineMap> consumerIndexingMap =
+      dependence.getIndexingOpViewIndexingMap();
+  if (!producerIndexingMap || !consumerIndexingMap)
+    return None;
 
   AffineMap prunedProducerIndexingMap = pruneReductionDimsFromMap(
-      producer.iterator_types().getValue(), producerIndexingMap);
+      producer.iterator_types().getValue(), *producerIndexingMap);
   if (!prunedProducerIndexingMap.isPermutation())
     return None;
 
-  if (consumerIndexingMap.getNumResults() !=
+  if (consumerIndexingMap->getNumResults() !=
       prunedProducerIndexingMap.getNumResults())
     return None;
 
   LLVM_DEBUG({
     llvm::dbgs() << "\t producerMap : ";
-    producerIndexingMap.print(llvm::dbgs());
+    producerIndexingMap->print(llvm::dbgs());
     llvm::dbgs() << "  pruned : ";
     prunedProducerIndexingMap.print(llvm::dbgs());
     llvm::dbgs() << "\n";
     llvm::dbgs() << "\t consumerMap : ";
-    consumerIndexingMap.print(llvm::dbgs());
+    consumerIndexingMap->print(llvm::dbgs());
     llvm::dbgs() << "\n";
   });
 
   AffineMap invProducerIndexMap = inversePermutation(prunedProducerIndexingMap);
   if (!invProducerIndexMap)
     return None;
 
-  return invProducerIndexMap.compose(consumerIndexingMap);
+  return invProducerIndexMap.compose(*consumerIndexingMap);
 }
 
 /// Given a projected permutation `map`, returns true if the map changes the
 /// order in which the fused loop dimension appear.
 static bool doesTransposeAccess(AffineMap map,
                                 const std::set<unsigned> &fusableLoops) {
   Optional<unsigned> lastFusableLoop;
   for (unsigned pos : llvm::map_range(map.getResults(), [](AffineExpr expr) {
collectFusableLoops(ArrayRef<LinalgOp> ops,
 
   return fusableLoops;
 }
 
 /// Find all dependences that are fusable.
 FusableOpDependencesTy mlir::linalg::findAllFusableDependences(
     ArrayRef<LinalgOp> ops, const LinalgDependenceGraph &dependenceGraph) {
   FusableOpDependencesTy fusableDependences;
-  // TODO: Currently fusion would not be legal if the fusable dependence is to
-  // the same producer but different indexing map in the consumer. Fix this, but
-  // in the meanwhile disallow such a fusion.
-  DenseMap<Operation *, AffineMap> fusedProducerIndexingMap;
+  DenseMap<Operation *, SmallVector<AffineMap, 1>> fusedProducerIndexingMap;
   for (LinalgOp op : reverse(ops)) {
     for (OpOperand &opOperand : op.getShapedOpOperands()) {
       Optional<LinalgDependenceGraph::LinalgDependenceGraphElem>
           fusableDependence = findFusableProducer(opOperand, dependenceGraph);
       if (!fusableDependence)
         continue;
       LinalgOp producerOp =
-          cast<LinalgOp>(fusableDependence->dependentOpView->getOwner());
+          dyn_cast<LinalgOp>(fusableDependence->getDependentOp());
+      if (!producerOp)
+        continue;
       // Do not fuse dependences that are to operations not in the same basic
       // block. This avoid moving fused operations across loops that might
       // themselves carry dependency making the fusion illegal.
-      if (producerOp->getBlock() != op->getBlock()) {
-        op.emitRemark("unhandled fusion of ops in different basic blocks");
-        return FusableOpDependencesTy{};
-      }
+      if (producerOp->getBlock() != op->getBlock())
+        continue;
+
       // Make sure that the indexing map of the view used for fusion in the
       // producer is a projected permutation.
-      unsigned producerIdx =
-          fusableDependence->dependentOpView->getOperandNumber();
-      AffineMap producerMap = producerOp.getIndexingMap(producerIdx);
-      if (!producerMap.isProjectedPermutation()) {
-        op.emitRemark(
-            "unhandled non permutation indexing map for fused view in "
-            "producer for operand at index ")
-            << opOperand.getOperandNumber();
-        return FusableOpDependencesTy{};
-      }
-
-      unsigned consumerIdx =
-          fusableDependence->indexingOpView->getOperandNumber();
-      AffineMap consumerMap = op.getIndexingMap(consumerIdx);
-      if (!consumerMap.isProjectedPermutation()) {
-        op.emitRemark(
-            "unhandled case where indexing map for fused view in the consumer "
-            "is not a projected permutation while fusing at index ")
-            << opOperand.getOperandNumber();
-        return FusableOpDependencesTy{};
-      }
-
-      // Check if the producer is already a fusion candidate. Cannot fuse this
-      // dependence if it has a different indexing map when used in the
-      // consumer.
-      if (fusedProducerIndexingMap.count(producerOp.getOperation()) &&
-          fusedProducerIndexingMap[producerOp.getOperation()] != consumerMap) {
-        op.emitRemark(
-            "unhandled fusion to the same producer but with different "
-            "indexing maps");
-        return FusableOpDependencesTy{};
-      }
-      fusedProducerIndexingMap[producerOp.getOperation()] = consumerMap;
+      Optional<AffineMap> producerMap =
+          fusableDependence->getDependentOpViewIndexingMap();
+      Optional<AffineMap> consumerMap =
+          fusableDependence->getIndexingOpViewIndexingMap();
+      assert(
+          consumerMap &&
+          "unable to find indexing map of operand/result of indexing OpView");
+      fusedProducerIndexingMap[producerOp.getOperation()].push_back(
+          *consumerMap);
+      if (!producerMap || !producerMap->isProjectedPermutation() ||
+          !consumerMap->isProjectedPermutation())
+        continue;
 
       fusableDependences[producerOp.getOperation()].push_back(
           *fusableDependence);
     }
   }
+  // TODO: Currently fusion would not be legal if the fusable dependence is to
+  // the same producer but different indexing map in the consumer. Fix this, but
+  // in the meanwhile disallow such a fusion.
+  for (auto useIndexingMapsList : fusedProducerIndexingMap) {
+    AffineMap map1 = useIndexingMapsList.second.front();
+    for (AffineMap map2 :
+         ArrayRef<AffineMap>(useIndexingMapsList.second).drop_front()) {
+      if (map1 != map2) {
+        fusableDependences.erase(useIndexingMapsList.first);
+        break;
+      }
+    }
+  }
   return fusableDependences;
 }
 
 /// Tile the fused loops in the root operation, by setting the tile sizes for
 /// all other loops to zero (those will be tiled later).
 static Optional<TiledLinalgOp> tileRootOperation(
     OpBuilder &builder, LinalgOp op, ArrayRef<Value> tileSizeVector,
     const LinalgTilingOptions &options, const std::set<unsigned> &fusedLoops) {
fuseOperations(OpBuilder &builder, LinalgOp tiledOp,
   return fusedOps;
 }
 
 template <typename LoopType>
 static Optional<TiledAndFusedLinalgOps>
 tileAndFuseLinalgOpsImpl(OpBuilder &builder, ArrayRef<LinalgOp> ops,
                          const LinalgDependenceGraph &dependenceGraph,
                          const LinalgTilingOptions &tilingOptions) {
-  if (ops.empty())
+  if (ops.size() < 2)
     return llvm::None;
   LinalgOp rootOp = ops.back();
   for (auto op : enumerate(ops)) {
     // TODO: Nothing in the fusion of sequence of ops is specific to
     // buffers. This check can be removed after it is tested on tensors.
     LinalgOp linalgOp = op.value();
     if (!linalgOp.hasBufferSemantics()) {
-      linalgOp.emitError("tile and fuse only tested for buffer operation");
+      linalgOp.emitRemark("tile and fuse only tested for buffer operation");
       return llvm::None;
     }
   }
   // TODO: Support interchange with tile + fuse. This might actually help do
   // better fusion.
   if (!tilingOptions.interchangeVector.empty()) {
-    rootOp.emitError("unable to handle tile and fuse with interchange");
+    rootOp.emitRemark("unable to handle tile and fuse with interchange");
     return llvm::None;
   }
 
   OpBuilder::InsertionGuard guard(builder);
   builder.setInsertionPoint(rootOp);
   ScopedContext scope(builder, rootOp.getLoc());
 
   // Find all the producers.
tileAndFuseLinalgOpsImpl(OpBuilder &builder, ArrayRef<LinalgOp> ops,
   }
 
   // Tile the fused loops in the last operation in the list.
   SmallVector<Value, 4> tileSizeVector =
       tilingOptions.tileSizeComputationFunction(builder, rootOp);
   Optional<TiledLinalgOp> tiledRootOp = tileRootOperation(
       builder, rootOp, tileSizeVector, tilingOptions, ret.fusedLoopDims);
   if (!tiledRootOp) {
-    rootOp.emitError("failed to tile the fused loops");
+    rootOp.emitRemark("failed to tile the fused loops");
     return llvm::None;
   }
   ret.op = tiledRootOp->op;
   ret.fusedLoops.assign(tiledRootOp->loops.begin(), tiledRootOp->loops.end());
 
   // Fuse the other operations into the fused inter-tile loops produced above.
   ret.fusedProducers = fuseOperations(builder, ret.op, ops.drop_back(),
                                       fusableDependences, ret.fusedLoopDims);

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

if (!linalgOp)
     return failure();
   if (failed(marker.checkAndNotify(rewriter, linalgOp)))
     return failure();
   if (!linalgOp.hasBufferSemantics())
     return failure();
 
   DenseSet<Operation *> producers;
   producers.insert(linalgOp);
-  for (auto dependence : dependenceGraph.getDependentOperations(linalgOp)) {
-    if (!fusionOptions.indicesToFuse.count(
-            dependence.indexingOpView->getOperandNumber()))
+  for (auto dependence : dependenceGraph.getDependentOperationsInto(linalgOp)) {
+    Optional<unsigned> operandNumber = dependence.getIndexingOpViewOperandNum();
+    // When looking at dependences into, indexingOp is always OpOperand. We
+    // could assert, but continue if this is not the case.
+    if (!operandNumber)
       continue;
-    if (isa<LinalgOp>(dependence.dependentOpView->getOwner()))
-      producers.insert(dependence.dependentOpView->getOwner());
+    if (!fusionOptions.indicesToFuse.count(operandNumber.getValue()))
+      continue;
+    if (isa<LinalgOp>(dependence.getDependentOp()))
+      producers.insert(dependence.getDependentOp());
   }
 
   SmallVector<LinalgOp, 1> fusionOps;
   for (auto it = op->getBlock()->begin(), ie = Block::iterator(op); it != ie;
        ++it) {
     auto producerLinalgOp = dyn_cast<LinalgOp>(&(*it));
     if (producerLinalgOp && producers.count(producerLinalgOp))
       fusionOps.push_back(producerLinalgOp);

mlir/test/Dialect/Linalg/fusion-pattern.mlir

-// RUN: mlir-opt %s -test-linalg-fusion-transform-patterns -canonicalize -cse -split-input-file -verify-diagnostics | FileCheck %s
+// RUN: mlir-opt %s -test-linalg-fusion-transform-patterns -canonicalize -cse -split-input-file | FileCheck %s
 
 module {
   func @basic_fusion(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>,
                      %arg2: memref<?x?xf32>) {
     %cst = constant 0.000000e+00 : f32
     linalg.fill(%arg2, %cst) : memref<?x?xf32>, f32
     linalg.matmul {__internal_linalg_transform__ = "basic_fusion"}
       ins(%arg0, %arg1 : memref<?x?xf32>, memref<?x?xf32>)
func @matmul_plus_transpose_matmul(%arg0: memref<?x?xf32>,
                                      %arg2: memref<?x?xf32>) {
     %c0 = constant 0 : index
     %c1 = constant 1 : index
     %0 = dim %arg2, %c0 : memref<?x?xf32>
     %1 = dim %arg2, %c1 : memref<?x?xf32>
     %2 = alloc(%0, %1) : memref<?x?xf32>
     linalg.matmul ins(%arg0, %arg1 : memref<?x?xf32>, memref<?x?xf32>)
       outs(%2 : memref<?x?xf32>)
-    // expected-remark @+1 {{unhandled fusion to the same producer but with different indexing maps}}
     linalg.generic
       {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>,
                         affine_map<(d0, d1) -> (d1, d0)>,
                         affine_map<(d0, d1) -> (d0, d1)>],
        iterator_types = ["parallel", "parallel"],
        __internal_linalg_transform__ = "transpose_fusion"}
       ins(%2, %2 : memref<?x?xf32>, memref<?x?xf32>)
       outs(%arg2 : memref<?x?xf32>) {
       ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32) :
         %3 = addf %arg3, %arg4 : f32
         linalg.yield %3 : f32
       }
     return
   }
 }
+// CHECK-LABEL: func @matmul_plus_transpose_matmul
+//   CHECK-NOT:   scf.parallel
+//   CHECK-NOT:   scf.for
+//       CHECK:   linalg.matmul
+//   CHECK-NOT:   scf.parallel
+//   CHECK-NOT:   scf.for
+//       CHECK:   linalg.generic
+//   CHECK-NOT:   scf.parallel
+//   CHECK-NOT:   scf.for
 
 // -----
 
 #map0 = affine_map<(d0)[s0] -> (32, -d0 + s0)>
 #map1 = affine_map<(d0)[s0] -> (64, -d0 + s0)>
 #map2 = affine_map<(d0)[s0] -> (16, -d0 + s0)>
 #map3 = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 module {
func @basic_no_fusion(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>,
     scf.parallel (%arg3, %arg4) = (%c0, %c0) to (%0, %1) step (%c32, %c64) {
       scf.for %arg5 = %c0 to %2 step %c16 {
         %3 = affine.min #map0(%arg3)[%0]
         %4 = affine.min #map1(%arg4)[%1]
         %5 = affine.min #map2(%arg5)[%2]
         %6 = subview %arg0[%arg3, %arg5] [%3, %5] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #map3>
         %7 = subview %arg1[%arg5, %arg4] [%5, %4] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #map3>
         %8 = subview %arg2[%arg3, %arg4] [%3, %4] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #map3>
-  // expected-remark @+1 {{unhandled fusion of ops in different basic blocks}}
         linalg.matmul {__internal_linalg_transform__ = "basic_fusion"}
           ins(%6, %7 : memref<?x?xf32, #map3>, memref<?x?xf32, #map3>)
           outs(%8 : memref<?x?xf32, #map3>)
       }
       scf.yield
     }
     return
   }
 }
+// CHECK-LABEL: func @basic_no_fusion
+//   CHECK-NOT:   scf.parallel
+//       CHECK:   linalg.fill
+//       CHECK:   scf.parallel
+//       CHECK:     scf.for
+//   CHECK-NOT:     linalg.fill
+//       CHECK:     linalg.matmul
 
 // -----
 
 module {
   func @basic_conv_fusion(%arg0: memref<?x?x?x?xf32>, %arg1: memref<?x?x?x?xf32>,
                           %arg2: memref<?x?x?x?xf32>) {
     %cst = constant 0.000000e+00 : f32
     linalg.fill(%arg2, %cst) : memref<?x?x?x?xf32>, f32