[Buffers][NOT COMPLETE] Add latency and occupancy balancing constraints.

CMakeLists.txt

@@ -25,7 +25,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED YES)
 if (MSVC)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHs-c- /GR-")
 else ()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions -frtti")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -frtti")
 endif ()
 
 include(FindPackageHandleStandardArgs)

build.sh

@@ -237,6 +237,7 @@ if [[ $SKIP_POLYGEIST -eq 0 ]]; then
         -DLLVM_ENABLE_PROJECTS="mlir;clang;polly" \
         -DLLVM_TARGETS_TO_BUILD="host" \
         -DLLVM_ENABLE_RTTI=ON \
+        -DLLVM_ENABLE_EH=ON \
         -DBUILD_SHARED_LIBS=ON \
         -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
         -DLLVM_PARALLEL_LINK_JOBS=$LLVM_PARALLEL_LINK_JOBS \

experimental/include/experimental/Support/SubjectGraph.h

@@ -98,7 +98,7 @@ class BaseSubjectGraph {
   DenseMap<BaseSubjectGraph *, unsigned int> inputSubjectGraphToResultNumber;
 
   // static map that holds all Operation/Subject Graph Pairs
-  static inline DenseMap<Operation *, BaseSubjectGraph *> moduleMap;
+  static inline DenseMap<Operation *, BaseSubjectGraph *> moduleMap{};
 
   // A vector of all BaseSubjectGraphs. This is not a subset of the Values of
   // moduleMap, since not all of the SubjectGraphs are created from Operations

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/BufferPlacementMILP.h

@@ -30,9 +30,11 @@
 #include "experimental/Support/SubjectGraph.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/Value.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace dynamatic {
 namespace buffer {
@@ -54,6 +56,8 @@ struct UnitVars {
   /// Fluid retiming of tokens at unit's output. Identical to retiming at unit's
   /// input if the latter is combinational (real).
   CPVar retOut;
+  /// Occupancy contribution of this unit (real).
+  CPVar occupancy;
 };
 
 /// Holds MILP variables related to a specific signal (e.g., data, valid, ready)
@@ -78,6 +82,18 @@ struct ChannelVars {
   CPVar dataLatency;
   /// Usage of a shift register on the channel (binary).
   CPVar shiftReg;
+
+  /// Extra latency to insert on this channel for balancing (integer).
+  CPVar extraLatency;
+  /// Whether the channel is stalled due to pattern imbalance (binary).
+  CPVar stalled;
+  /// Maximum token occupancy for this channel (real).
+  CPVar maxOccupancy;
+};
+
+struct SynchronizationPatternVars {
+  /// Whether the synchronization pattern is imbalanced (binary).
+  CPVar imbalanced;
 };
 
 /// Holds all variables associated to a CFDFC. These are a set of variables for
@@ -100,6 +116,12 @@ struct MILPVars {
   llvm::MapVector<CFDFC *, CFDFCVars> cfdfcVars;
   /// Mapping between channels and their related variables.
   llvm::MapVector<Value, ChannelVars> channelVars;
+  /// Balancing variables for reconvergent paths.
+  SmallVector<SynchronizationPatternVars> reconvergentPathVars;
+  /// Balancing variables for synchronizing cycles.
+  SmallVector<SynchronizationPatternVars> syncCycleVars;
+  /// List of units in the function.
+  llvm::MapVector<Operation *, UnitVars> unitVars;
 };
 
 /// Abstract class holding the basic logic for the smart buffer placement pass,

include/dynamatic/Transforms/BufferPlacement/FPGA24Buffers.h

@@ -0,0 +1,144 @@
+//===- FPGA24Buffers.h ------------------------------------------------===//
+//
+// Dynamatic is under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===------------------------------------------------------------------===//
+//
+// TODO
+//
+//===------------------------------------------------------------------===//
+
+#ifndef DYNAMATIC_TRANSFORMS_BUFFERPLACEMENT_FPGA24BUFFERS_H
+#define DYNAMATIC_TRANSFORMS_BUFFERPLACEMENT_FPGA24BUFFERS_H
+
+#include "dynamatic/Support/ConstraintProgramming/ConstraintProgramming.h"
+#include "dynamatic/Support/TimingModels.h"
+#include "dynamatic/Transforms/BufferPlacement/BufferPlacementMILP.h"
+#include "dynamatic/Transforms/BufferPlacement/BufferingSupport.h"
+#include "dynamatic/Transforms/BufferPlacement/CFDFC.h"
+#include "dynamatic/Transforms/BufferPlacement/LatencyAndOccupancyBalancingSupport.h"
+
+namespace dynamatic {
+namespace buffer {
+namespace fpga24 {
+
+/// Latency Balancing MILP ///
+
+/// Holds the result of the first LP for usage in the LP.
+struct LatencyBalancingResult {
+  /// Map from channel to its computed extra latency.
+  DenseMap<Value, unsigned> channelExtraLatency;
+  /// Target intiation interval.
+  double targetII;
+};
+
+/// Helper struct that pairs a reconvergent path with its corresponding
+/// transition graph. Since we're enumerating transition sequences, build graphs
+/// from those and then in turn build reconvergent paths from those graphs, it's
+/// better to pair them like this instead of playing around with indices.
+struct ReconvergentPathWithGraph {
+  ReconvergentPath path;
+  const ReconvergentPathFinderGraph *graph;
+
+  ReconvergentPathWithGraph(ReconvergentPath p,
+                            const ReconvergentPathFinderGraph *g)
+      : path(std::move(p)), graph(g) {}
+};
+
+class LatencyBalancingMILP : public BufferPlacementMILP {
+public:
+  LatencyBalancingMILP(CPSolver::SolverKind solverKind, int timeout,
+                       FuncInfo &funcInfo, const TimingDatabase &timingDB,
+                       double targetPeriod,
+                       ArrayRef<ReconvergentPathWithGraph> reconvergentPaths,
+                       ArrayRef<SynchronizingCyclePair> syncCyclePairs,
+                       const SynchronizingCyclesFinderGraph &syncGraph,
+                       ArrayRef<CFDFC *> cfdfcs);
+
+  /// Extract latency results after solving.
+  LatencyBalancingResult extractLatencyResults();
+
+protected:
+  /// Interpret solution - not used for buffer placement directly.
+  void extractResult(BufferPlacement &placement) override;
+
+private:
+  ArrayRef<ReconvergentPathWithGraph> reconvergentPaths;
+  ArrayRef<SynchronizingCyclePair> syncCyclePairs;
+
+  /// Reference to synchronizing cycles graph.
+  const SynchronizingCyclesFinderGraph &syncGraph;
+
+  /// CFDFCs needed for cylce constraints.
+  ArrayRef<CFDFC *> cfdfcs;
+
+  void addLatencyVariables();
+
+  /// Add pattern imbalance constraints for reconvergent paths.
+  void addReconvergentPathConstraints();
+
+  /// Add pattern imbalance constraints for synchronizing cycles.
+  void addSyncCycleConstraints();
+
+  void addStallPropagationConstraints();
+
+  /// Add cycle time (II) constraints for each CFDFC cycle.
+  void addCycleTimeConstraints();
+
+  /// Minimize stalls first, then latency cost.
+  void setLatencyBalancingObjective();
+
+  /// Setups the entire MILP, creating all variables, constraints, and setting
+  /// the system's objective. Called by the constructor in the absence of prior
+  /// failures, after which the MILP is ready to be optimized.
+  void setup();
+};
+
+class OccupancyBalancingLP : public BufferPlacementMILP {
+public:
+  OccupancyBalancingLP(CPSolver::SolverKind solverKind, int timeout,
+                       FuncInfo &funcInfo, const TimingDatabase &timingDB,
+                       double targetPeriod,
+                       const LatencyBalancingResult &latencyResult,
+                       ArrayRef<ReconvergentPathWithGraph> reconvergentPaths,
+                       ArrayRef<CFDFC *> cfdfcs);
+
+  bool isUnsatisfiable() const { return unsatisfiable; }
+
+  void extractResult(BufferPlacement &placement) override;
+
+private:
+  const LatencyBalancingResult &latencyResult;
+
+  ArrayRef<ReconvergentPathWithGraph> reconvergentPaths;
+  ArrayRef<CFDFC *> cfdfcs;
+
+  DenseMap<Value, CPVar> channelOccupancy;
+
+  void setup();
+};
+
+class FPGA24Buffers {
+public:
+  FPGA24Buffers(CPSolver::SolverKind solverKind, int timeout,
+                FuncInfo &funcInfo, const TimingDatabase &timingDB,
+                double targetPeriod);
+
+  /// Run the complete algorithm and return placement.
+  LogicalResult solve(BufferPlacement &placement);
+
+private:
+  CPSolver::SolverKind solverKind;
+  int timeout;
+  FuncInfo &funcInfo;
+  double targetPeriod;
+  const TimingDatabase &timingDB;
+};
+
+} // namespace fpga24
+} // namespace buffer
+} // namespace dynamatic
+
+#endif /// DYNAMATIC_TRANSFORMS_BUFFERPLACEMENT_FPGA24BUFFERS_H