[mlir][Linalg] Add some depedence query methods to LinalgDependenceGraph.

[mravishankar]

Summary

The methods allow to check

• if an operation has dependencies,
• if there is a dependence from one operation to another.

[nicolasvasilache]

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

250

auto + 1 liner + drop spurious braces?

[mravishankar]

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

250

Will add auto, but the for has an if within it. I think the convention is to keep braces for the for.

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

public:
 
   /// Returns the operations that are interleaved between `srcLinalgOp` and
   /// `dstLinalgOp` and that are involved in a WAR or WAW with `srcLinalgOp`.
   /// Dependences are restricted to views aliasing `view`.
   SmallVector<Operation *, 8> findCoveringWrites(LinalgOp srcLinalgOp,
                                                  LinalgOp dstLinalgOp,
                                                  Value view) const;
 
+  /// Returns true if the two operations have the specified dependence from
+  /// `srcLinalgOp` to `dstLinalgOp`.
+  bool hasDependenceFrom(LinalgOp srcLinalgOp, LinalgOp dstLinalgOp,
+                         ArrayRef<DependenceType> depTypes = {
+                             DependenceType::RAW, DependenceType::WAW}) const;
+
+  /// Returns true if the `linalgOp` has dependences into or from it.
+  bool hasDependentOperations(LinalgOp linalgOp,
+                              ArrayRef<DependenceType> depTypes = {
+                                  DependenceType::RAW,
+                                  DependenceType::WAW}) const;
+
 private:
   // Keep dependences in both directions, this is not just a performance gain
   // but it also reduces usage errors.
   // Dependence information is stored as a map of:
   //   (source operation -> LinalgDependenceGraphElem)
   DependenceGraph dependencesFromGraphs[DependenceType::NumTypes];
   // Reverse dependence information is stored as a map of:
   //   (destination operation -> LinalgDependenceGraphElem)

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

for (auto dstView : dst.getInputs()) {   // R
       if (aliases.alias(srcView, dstView)) { // if alias, fill RAW
         addDependenceElem(DependenceType::RAW,
                           LinalgOpView{src.getOperation(), srcView},
                           LinalgOpView{dst.getOperation(), dstView});
       }
     }
     // WAW graph
     for (auto dstView : dst.getOutputBuffers()) { // W
-      if (aliases.alias(srcView, dstView)) { // if alias, fill WAW
+      if (aliases.alias(srcView, dstView)) {      // if alias, fill WAW
         addDependenceElem(DependenceType::WAW,
                           LinalgOpView{src.getOperation(), srcView},
                           LinalgOpView{dst.getOperation(), dstView});
       }
     }
   }
   for (auto srcView : src.getInputs()) { // R
     // RAR graph
     for (auto dstView : dst.getInputs()) {   // R
       if (aliases.alias(srcView, dstView)) { // if alias, fill RAR
         addDependenceElem(DependenceType::RAR,
                           LinalgOpView{src.getOperation(), srcView},
                           LinalgOpView{dst.getOperation(), dstView});
       }
     }
     // WAR graph
     for (auto dstView : dst.getOutputBuffers()) { // W
-      if (aliases.alias(srcView, dstView)) { // if alias, fill WAR
+      if (aliases.alias(srcView, dstView)) {      // if alias, fill WAR
         addDependenceElem(DependenceType::WAR,
                           LinalgOpView{src.getOperation(), srcView},
                           LinalgOpView{dst.getOperation(), dstView});
       }
     }
   }
 }
 
for (auto dependence : getDependencesFrom(src, dt)) {
       LLVM_DEBUG(dbgs() << "\n***Found covering dependence of type "
                         << getDependenceTypeStr(dt) << ": " << *src << " -> "
                         << *op << " on " << dependence.indexingView);
       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.op == srcLinalgOp)
+        return true;
+    }
+  }
+  return false;
+}
+
+bool LinalgDependenceGraph::hasDependentOperations(
+    LinalgOp linalgOp,
+    ArrayRef<LinalgDependenceGraph::DependenceType> depTypes) const {
+  for (auto dep : depTypes) {
+    if (!getDependencesFrom(linalgOp, dep).empty() ||
+        !getDependencesInto(linalgOp, dep).empty())
+      return true;
+  }
+  return false;
+}