[Buffers] Synchronizing cyle enumeration

include/dynamatic/Dialect/Handshake/HandshakeArithOps.td

@@ -25,6 +25,7 @@ class Handshake_Arith_Op<string mnemonic, list<Trait> traits = []> :
 class Handshake_Arith_BinaryOp<string mnemonic, list<Trait> traits = []> :
   Handshake_Arith_Op<mnemonic, traits # [
     SameOperandsAndResultType,
+    JoinLikeOpInterface,
     DeclareOpInterfaceMethods<NamedIOInterface, ["getOperandName", "getResultName"]>,
   ]> {
   let arguments = (ins ChannelType:$lhs, ChannelType:$rhs);

include/dynamatic/Dialect/Handshake/HandshakeInterfaces.td

@@ -52,6 +52,13 @@ def MergeLikeOpInterface : OpInterface<"MergeLikeOpInterface"> {
   ];
 }
 
+def JoinLikeOpInterface : OpInterface<"JoinLikeOpInterface"> {
+  let cppNamespace = "::dynamatic::handshake";
+  let description = [{
+    A two-input handshake operation that contains a join.
+  }];
+}
+
 def BufferLikeOpInterface : OpInterface<"BufferLikeOpInterface"> {
   let cppNamespace = "::dynamatic::handshake";
   let description = [{

include/dynamatic/Dialect/Handshake/HandshakeOps.td

@@ -516,6 +516,7 @@ def BranchOp : Handshake_Op<"br", [
 }
 
 def ConditionalBranchOp : Handshake_Op<"cond_br", [
+  JoinLikeOpInterface,
   AllTypesMatch<["dataOperand", "trueResult", "falseResult"]>,
   AllExtraSignalsMatch<["conditionOperand", "dataOperand", "trueResult", "falseResult"]>,
   IsIntSizedChannel<1, "conditionOperand">,

include/dynamatic/Transforms/BufferPlacement/LatencyAndOccupancyBalancingSupport.h

@@ -13,9 +13,12 @@
 
 #pragma once
 
+#include "dynamatic/Dialect/Handshake/HandshakeInterfaces.h"
 #include "dynamatic/Dialect/Handshake/HandshakeOps.h"
+#include "dynamatic/Transforms/BufferPlacement/CFDFC.h"
 #include "experimental/Support/StdProfiler.h"
 #include "mlir/IR/Operation.h"
+#include "llvm/ADT/ArrayRef.h"
 #include <set>
 
 using namespace dynamatic::experimental;
@@ -24,6 +27,9 @@ using namespace dynamatic::experimental;
 
 namespace dynamatic {
 
+using NodeIdType = size_t;
+using EdgeIdType = size_t;
+
 /// NOTE: No current implementation differentiates between intra-BB and inter-BB
 /// edges. Right now, it's quite useful for visualizing the graph in GraphViz.
 enum DataflowGraphEdgeType {
@@ -33,20 +39,20 @@ enum DataflowGraphEdgeType {
 
 struct DataflowGraphNode {
   mlir::Operation *op; // <-- The underlying Operation.
-  size_t id; // <-- Unique id in the nodes vector to help with traversal.
+  NodeIdType id; // <-- Unique id in the nodes vector to help with traversal.
 
-  DataflowGraphNode(mlir::Operation *op, size_t id) : op(op), id(id) {}
+  DataflowGraphNode(mlir::Operation *op, NodeIdType id) : op(op), id(id) {}
 };
 
 struct DataflowGraphEdge {
-  size_t srcId;
-  size_t dstId;
+  NodeIdType srcId;
+  NodeIdType dstId;
 
   mlir::Value channel;
   DataflowGraphEdgeType type;
 
   DataflowGraphEdge(
-      size_t srcId, size_t dstId, mlir::Value channel,
+      NodeIdType srcId, NodeIdType dstId, mlir::Value channel,
       DataflowGraphEdgeType type = DataflowGraphEdgeType::INTRA_BB)
       : srcId(srcId), dstId(dstId), channel(channel), type(type) {}
 };
@@ -64,11 +70,11 @@ struct DataflowSubgraphBase {
 
   /// Virtual Methods ///
 
-  virtual bool isForkNode(size_t nodeId) const = 0;
-  virtual bool isJoinNode(size_t nodeId) const = 0;
+  virtual bool isForkNode(NodeIdType nodeId) const = 0;
+  virtual bool isJoinNode(NodeIdType nodeId) const = 0;
 
-  virtual std::string getNodeLabel(size_t nodeId) const = 0;
-  virtual std::string getNodeDotId(size_t nodeId) const = 0;
+  virtual std::string getNodeLabel(NodeIdType nodeId) const = 0;
+  virtual std::string getNodeDotId(NodeIdType nodeId) const = 0;
 
   /// Getters ///
 
@@ -80,18 +86,18 @@ struct DataflowSubgraphBase {
   std::vector<DataflowGraphEdge> edges;
 
   /// NOTE: Uses node ID to index the nodes.
-  std::vector<llvm::SmallVector<size_t, 4>> adjList;
-  std::vector<llvm::SmallVector<size_t, 4>> revAdjList;
+  std::vector<llvm::SmallVector<EdgeIdType, 4>> adjList;
+  std::vector<llvm::SmallVector<EdgeIdType, 4>> revAdjList;
 
-  size_t addNode(mlir::Operation *op) {
-    size_t id = nodes.size();
+  NodeIdType addNode(mlir::Operation *op) {
+    NodeIdType id = nodes.size();
     nodes.emplace_back(op, id);
     adjList.emplace_back();
     revAdjList.emplace_back();
     return nodes.size() - 1;
   }
 
-  void addEdge(size_t srcId, size_t dstId, mlir::Value channel,
+  void addEdge(NodeIdType srcId, NodeIdType dstId, mlir::Value channel,
                DataflowGraphEdgeType type = DataflowGraphEdgeType::INTRA_BB) {
     edges.emplace_back(srcId, dstId, channel, type);
     adjList[srcId].push_back(edges.size() - 1);
@@ -102,11 +108,11 @@ struct DataflowSubgraphBase {
 /// A reconvergent path is a subgraph where multiple paths diverge from a fork
 /// and reconverge at a join. This is important for latency balancing.
 struct ReconvergentPath {
-  size_t forkNodeId;        // The divergence point
-  size_t joinNodeId;        // The convergence point
-  std::set<size_t> nodeIds; // All nodes on paths from fork to join.
+  NodeIdType forkNodeId;        // The divergence point
+  NodeIdType joinNodeId;        // The convergence point
+  std::set<NodeIdType> nodeIds; // All nodes on paths from fork to join.
 
-  ReconvergentPath(size_t fork, size_t join, std::set<size_t> nodes)
+  ReconvergentPath(NodeIdType fork, NodeIdType join, std::set<NodeIdType> nodes)
       : forkNodeId(fork), joinNodeId(join), nodeIds(std::move(nodes)) {}
 };
 
@@ -119,8 +125,8 @@ struct ReconvergentPath {
 /// 1 -> 1 (self-loop)
 /// enumerateTransitionSequences(transitions, 3);
 /// Output: [1, 2, 3], [1, 1, 2], [1, 1, 1]
-std::vector<std::vector<ArchBB>>
-enumerateTransitionSequences(const std::vector<ArchBB> &transitions,
+inline std::vector<std::vector<ArchBB>>
+enumerateTransitionSequences(llvm::ArrayRef<ArchBB> transitions,
                              size_t sequenceLength) {
   // 'sequenceLength' is the number of steps to visit.
   // Number of transitions needed = sequenceLength - 1.
@@ -172,23 +178,35 @@ enumerateTransitionSequences(const std::vector<ArchBB> &transitions,
 /// IMPORTANT: This class assumes the graph an ACYCLIC transition sequence.
 class ReconvergentPathFinderGraph : public DataflowSubgraphBase {
 public:
-  bool isForkNode(size_t nodeId) const override;
-  bool isJoinNode(size_t nodeId) const override;
+  bool isForkNode(NodeIdType nodeId) const override {
+    return isa<handshake::ForkOp, handshake::LazyForkOp,
+               handshake::EagerForkLikeOpInterface>(nodes[nodeId].op);
+  }
+
+  // The only nodes with two inputs that allow for both
+  // inputs to be active at the same time. Unlike: ControlMergeOp and MergeOp.
+  /// NOTE: When it belongs to a CFDFC, MuxOp behaves like a join node.
+  bool isJoinNode(NodeIdType nodeId) const override {
+    return isa<handshake::MuxOp, handshake::JoinLikeOpInterface,
+               handshake::ConditionalBranchOp>(nodes[nodeId].op);
+  }
 
-  std::string getNodeLabel(size_t nodeId) const override;
-  std::string getNodeDotId(size_t nodeId) const override;
+  std::string getNodeLabel(NodeIdType nodeId) const override;
+  std::string getNodeDotId(NodeIdType nodeId) const override;
 
   std::vector<ReconvergentPath> findReconvergentPaths() const;
 
   /// Build the graph from a given transition sequence.
   void buildGraphFromSequence(handshake::FuncOp funcOp,
-                              const std::vector<ArchBB> &sequence);
+                              llvm::ArrayRef<ArchBB> sequence);
 
   /// Within the transition sequence, we may have transitions that look like
   /// Step 0: BB1 -> Step 1: BB1 -> Step 2: BB2. Steps are the way to
   /// distinguish between specific operations of the same BB accross different
   /// transitions.
-  unsigned getNodeStep(size_t nodeId) const { return nodeIdToStep.at(nodeId); };
+  unsigned getNodeStep(NodeIdType nodeId) const {
+    return nodeIdToStep.at(nodeId);
+  };
 
   /// Get the BB id for a given step. Returns -1 if step not found.
   unsigned getStepBB(unsigned step) const {
@@ -198,26 +216,31 @@ class ReconvergentPathFinderGraph : public DataflowSubgraphBase {
 
   // Debugging Methods //
 
-  void dumpReconvergentPaths(const std::vector<ReconvergentPath> &paths,
+  void dumpReconvergentPaths(llvm::ArrayRef<ReconvergentPath> paths,
                              llvm::StringRef filename) const;
 
   void dumpTransitionGraph(llvm::StringRef filename) const;
 
   /// Dump multiple graphs to a single GraphViz file.
   /// Each graph is placed in its own cluster subgraph.
-  static void
-  dumpAllGraphs(const std::vector<ReconvergentPathFinderGraph> &graphs,
-                llvm::StringRef filename);
+  static void dumpAllGraphs(llvm::ArrayRef<ReconvergentPathFinderGraph> graphs,
+                            llvm::StringRef filename);
 
   /// Dump all reconvergent paths from multiple graphs to a single GraphViz
   /// file. Each path is placed in its own cluster subgraph with a graph index
-  /// prefix. The input is a vector of (sequenceIndex, (graph, paths)) pairs.
-  static void dumpAllReconvergentPaths(
-      const std::vector<
-          std::pair<size_t, std::pair<const ReconvergentPathFinderGraph *,
-                                      std::vector<ReconvergentPath>>>>
-          &graphPaths,
-      llvm::StringRef filename);
+  /// prefix. The input is a vector of GraphPathsForDumping objects. Each object
+  /// contains:
+  /// - graph: Pointer to the ReconvergentPathFinderGraph for this sequence.
+  /// - paths: Vector of ReconvergentPath objects for this sequence.
+
+  struct GraphPathsForDumping {
+    const ReconvergentPathFinderGraph *graph;
+    std::vector<ReconvergentPath> paths;
+  };
+
+  static void
+  dumpAllReconvergentPaths(llvm::ArrayRef<GraphPathsForDumping> graphPaths,
+                           llvm::StringRef filename);
 
 private:
   std::map<unsigned, unsigned> stepToBB;
@@ -226,19 +249,120 @@ class ReconvergentPathFinderGraph : public DataflowSubgraphBase {
   std::map<unsigned, unsigned> nodeIdToStep;
 
   /// Maps (Operation*, step) to node ID for O(1) lookup.
-  std::map<std::pair<mlir::Operation *, unsigned>, size_t> nodeMap;
+  std::map<std::pair<mlir::Operation *, unsigned>, NodeIdType> nodeMap;
 
   /// Get the node ID for an operation at a given step, creating it if needed.
-  size_t getOrAddNode(mlir::Operation *op, unsigned step) {
+  NodeIdType getOrAddNode(mlir::Operation *op, unsigned step) {
     auto key = std::make_pair(op, step);
     if (auto it = nodeMap.find(key); it != nodeMap.end())
       return it->second;
 
-    size_t id = addNode(op);
+    NodeIdType id = addNode(op);
     nodeMap[key] = id;
     nodeIdToStep[id] = step;
     return id;
   }
 };
 
+struct SimpleCycle {
+  llvm::SmallVector<NodeIdType> nodes; // <-- The node IDs of the cycle.
+  SimpleCycle(llvm::ArrayRef<NodeIdType> nodes) : nodes(nodes) {}
+
+  /// Check if this cycle shares any nodes with another cycle.
+  bool isDisjointFrom(const SimpleCycle &other) const;
+};
+
+struct EdgesToJoin {
+  NodeIdType joinId;
+
+  /// Edge indices (into nonCyclicAdjList) on any path from cycle to join.
+  std::vector<EdgeIdType> edgesFromCycleOne;
+  std::vector<EdgeIdType> edgesFromCycleTwo;
+
+  EdgesToJoin(NodeIdType join) : joinId(join) {}
+};
+
+struct SynchronizingCyclePair {
+  SimpleCycle cycleOne;
+  SimpleCycle cycleTwo;
+
+  std::vector<EdgesToJoin> edgesToJoins;
+
+  SynchronizingCyclePair(SimpleCycle one, SimpleCycle two,
+                         std::vector<EdgesToJoin> edges)
+      : cycleOne(std::move(one)), cycleTwo(std::move(two)),
+        edgesToJoins(std::move(edges)) {}
+};
+
+class SynchronizingCyclesFinderGraph : public DataflowSubgraphBase {
+public:
+  /// Build the graph from a CFDFC.
+  void buildFromCFDFC(handshake::FuncOp funcOp, const buffer::CFDFC &cfdfc);
+
+  /// Find all simple cycles in the graph.
+  std::vector<SimpleCycle> findAllCycles() const;
+
+  /// Find all pairs of synchronizing cylces.
+  std::vector<SynchronizingCyclePair> findSynchronizingCyclePairs();
+
+  bool isForkNode(NodeIdType nodeId) const override {
+    return isa<handshake::ForkOp, handshake::LazyForkOp,
+               handshake::EagerForkLikeOpInterface>(nodes[nodeId].op);
+  }
+
+  /// NOTE: When it belongs to a CFDFC, MuxOp behaves like a join node.
+  bool isJoinNode(NodeIdType nodeId) const override {
+    return isa<handshake::MuxOp, handshake::JoinLikeOpInterface,
+               handshake::ConditionalBranchOp>(nodes[nodeId].op);
+  }
+
+  std::string getNodeLabel(NodeIdType nodeId) const override;
+  std::string getNodeDotId(NodeIdType nodeId) const override;
+
+  /// Dump a single synchronizing cycle pair to a GraphViz file.
+  void dumpSynchronizingCyclePair(const SynchronizingCyclePair &pair,
+                                  llvm::StringRef filename) const;
+
+  /// Dump all synchronizing cycle pairs to a single GraphViz file.
+  void
+  dumpAllSynchronizingCyclePairs(llvm::ArrayRef<SynchronizingCyclePair> pairs,
+                                 llvm::StringRef filename) const;
+
+private:
+  std::map<mlir::Operation *, NodeIdType> opToNodeId;
+
+  /// Adjacency list for the non-cyclic subgraph (stores edge indices).
+  std::vector<std::vector<EdgeIdType>> nonCyclicAdjList;
+
+  NodeIdType getOrAddNode(mlir::Operation *op);
+
+  void computeSccsAndBuildNonCyclicSubgraph();
+
+  /// Find all edges (from nonCyclicAdjList) on any path from cycle to join.
+  /// An edge is included if its source is reachable from the cycle and its
+  /// destination can reach the join.
+  /// @returns A vector of indices into the edges vector.
+  std::vector<EdgeIdType> findEdgesToJoin(const SimpleCycle &cycle,
+                                          NodeIdType joinId) const;
+
+  /// Get all join node IDs in the graph.
+  std::vector<NodeIdType> getAllJoins() const;
+};
+
+// Helper struct needed for Boost's tiernan_all_cycles algorithm.
+// As opposed to just returning cycles directly, it calls a method on a
+// user-provided visitor object each time a cycle is found.
+struct CycleCollector {
+  std::vector<SimpleCycle> &cycles;
+
+  template <typename Path, typename Graph>
+  void cycle(const Path &p, const Graph &) {
+    llvm::SmallVector<NodeIdType> nodeIds;
+    for (auto v : p) {
+      nodeIds.push_back(v);
+    }
+    cycles.emplace_back(std::move(nodeIds));
+  }
+};
+
 } // namespace dynamatic