[Operations] Replace top-level join and blocker with synchronizer

experimental/include/experimental/Support/HandshakeSimulator.h

@@ -582,27 +582,6 @@ class ForkModel : public OpExecutionModel<handshake::ForkOp> {
   std::vector<ProducerData> outsData;
 };
 
-// Never used but let it be
-class JoinModel : public OpExecutionModel<handshake::JoinOp> {
-public:
-  using OpExecutionModel<handshake::JoinOp>::OpExecutionModel;
-  JoinModel(handshake::JoinOp joinOp, mlir::DenseMap<Value, RW *> &subset);
-
-  void reset() override;
-
-  void exec(bool isClkRisingEdge) override;
-
-  void printStates() override;
-
-private:
-  // ports
-  std::vector<ConsumerRW *> ins;
-  ProducerRW *outs;
-
-  // internal components
-  JoinSupport join;
-};
-
 class LazyForkModel : public OpExecutionModel<handshake::LazyForkOp> {
 public:
   using OpExecutionModel<handshake::LazyForkOp>::OpExecutionModel;

experimental/lib/Support/FtdImplementation.cpp

@@ -506,27 +506,27 @@ LogicalResult ftd::createPhiNetworkDeps(
       continue;
     }
 
-    // If the operand has one dependency only, there is no need for a join.
+    // If the operand has one dependency only, there is no need for a synchronizer.
     if (dependencies.size() == 1) {
       if (failed(connect(operand, dependencies[0])))
         return failure();
       continue;
     }
 
     // If the operand has many dependencies, then each of them is singularly
-    // connected with an SSA network, and then everything is joined.
+    // connected with an SSA network, and then everything is synchronized.
     ValueRange operands = dependencies;
     rewriter.setInsertionPointToStart(operand->getOwner()->getBlock());
-    auto joinOp = rewriter.create<handshake::JoinOp>(
+    auto synchronizerOp = rewriter.create<handshake::SynchronizerOp>(
         operand->getOwner()->getLoc(), operands);
-    joinOp->moveBefore(operandOwner);
+    synchronizerOp->moveBefore(operandOwner);
 
     for (unsigned i = 0; i < dependencies.size(); i++) {
-      if (failed(connect(&joinOp->getOpOperand(i), dependencies[i])))
+      if (failed(connect(&synchronizerOp->getOpOperand(i), dependencies[i])))
         return failure();
     }
 
-    operand->set(joinOp.getResult());
+    operand->set(synchronizerOp.getOuts()[0]);
   }
 
   return success();

experimental/lib/Support/HandshakeSimulator.cpp

@@ -680,25 +680,6 @@ void ForkModel::printStates() {
     printValue<ProducerRW, Data>("outs", outs[i], outsData[i].data);
 }
 
-JoinModel::JoinModel(handshake::JoinOp joinOp,
-                     mlir::DenseMap<Value, RW *> &subset)
-    : OpExecutionModel<handshake::JoinOp>(joinOp),
-      outs(getState<ProducerRW>(joinOp.getResult(), subset)),
-      join(joinOp->getNumOperands()) {
-  for (auto oper : joinOp->getOperands())
-    ins.push_back(getState<ConsumerRW>(oper, subset));
-}
-
-void JoinModel::reset() { join.exec(ins, outs); }
-
-void JoinModel::exec(bool isClkRisingEdge) { reset(); }
-
-void JoinModel::printStates() {
-  for (auto *in : ins)
-    llvm::outs() << "Ins: " << in->valid << " " << in->ready << "\n";
-  llvm::outs() << "Outs: " << outs->valid << " " << outs->ready << "\n";
-}
-
 LazyForkModel::LazyForkModel(handshake::LazyForkOp lazyForkOp,
                              mlir::DenseMap<Value, RW *> &subset)
     : OpExecutionModel<handshake::LazyForkOp>(lazyForkOp),
@@ -1384,9 +1365,6 @@ void Simulator::associateModel(Operation *op) {
       .Case<handshake::ForkOp>([&](handshake::ForkOp forkOp) {
         registerModel<ForkModel, handshake::ForkOp>(forkOp);
       })
-      .Case<handshake::JoinOp>([&](handshake::JoinOp joinOp) {
-        registerModel<JoinModel, handshake::JoinOp>(joinOp);
-      })
       .Case<handshake::LazyForkOp>([&](handshake::LazyForkOp lForkOp) {
         registerModel<LazyForkModel, handshake::LazyForkOp>(lForkOp);
       })

experimental/tools/elastic-miter/FabricGeneration.cpp

@@ -489,12 +489,12 @@ createElasticMiter(MLIRContext &context, ModuleOp lhsModule, ModuleOp rhsModule,
     setHandshakeAttributes(builder, rhsEndBufferOp, BB_OUT, rhsBufName);
 
     if (lhsResult.getType().isa<handshake::ControlType>()) {
-      ValueRange joinInputs = {lhsEndBufferOp.getResult(),
+      ValueRange synchronizerInputs = {lhsEndBufferOp.getResult(),
                                rhsEndBufferOp.getResult()};
-      JoinOp joinOp =
-          builder.create<JoinOp>(builder.getUnknownLoc(), joinInputs);
-      setHandshakeAttributes(builder, joinOp, BB_OUT, eqName);
-      miterResultValues.push_back(joinOp.getResult());
+      SynchronizerOp synchronizerOp =
+          builder.create<SynchronizerOp>(builder.getUnknownLoc(), synchronizerInputs);
+      setHandshakeAttributes(builder, synchronizerOp, BB_OUT, eqName);
+      miterResultValues.push_back(synchronizerOp.getOuts()[0]);
     } else {
       CmpIOp compOp = builder.create<CmpIOp>(
           builder.getUnknownLoc(), CmpIPredicate::eq,

experimental/tools/unit-generators/vhdl/generators/handshake/synchronizer.py

@@ -0,0 +1,118 @@
+from generators.handshake.join import generate_join
+from generators.handshake.fork import generate_fork
+from generators.support.utils import data
+
+
+def generate_synchronizer(name, params):
+  size = params["size"]
+
+  bitwidths = []
+  for i in range(size):
+      bitwidths.append(params[f"bitwidth_{i}"])
+
+  input_ports = ""
+  for i, bitwidth in enumerate(bitwidths):
+      input_ports += input_port(i, bitwidth)
+  input_ports = input_ports.lstrip()
+
+  output_ports = ""
+  for i, bitwidth in enumerate(bitwidths):
+      output_ports += output_port(i, bitwidth)
+  output_ports = output_ports.lstrip().rpartition(";")[0].rstrip()
+
+  join_name = f"{name}_join"
+  fork_name = f"{name}_fork"
+
+  dependencies = generate_join(join_name, {"size": size}) + \
+                generate_fork(fork_name, {"size": size, "bitwidth": 0})
+
+
+  entity = f"""
+  library ieee;
+  use ieee.std_logic_1164.all;
+
+  -- Entity of synchronizer
+  entity {name} is
+    port (
+      {input_ports}
+      {output_ports}
+    );
+  end entity;
+  """
+
+  valid_instance_assignments = ""
+  for i in range(size):
+      valid_instance_assignments += f"    ins_valid({i}) => ins{i}_valid,\n"
+
+  for i in range(size):
+      valid_instance_assignments += (f"    ins_ready({i}) => ins{i}_ready,\n")
+
+  valid_instance_assignments = valid_instance_assignments.lstrip()
+
+
+  fork_instance_assignments = ""
+  for i in range(size):
+      fork_instance_assignments += f"    outs_valid({i}) => outs{i}_valid,\n"
+
+  for i in range(size):
+      fork_instance_assignments += (f"    outs_ready({i}) => outs{i}_ready,\n")
+
+  fork_instance_assignments = fork_instance_assignments.lstrip()
+
+  assignments = ""
+  for i, bitwidth in enumerate(bitwidths):
+      potential_assignment = f"  outs{i} <= ins{i};\n"
+      assignments += data(potential_assignment, bitwidth)
+  assignments = assignments.lstrip()
+
+
+  architecture = f"""
+  -- Architecture of synchronizer
+  architecture arch of {name} is
+    signal join_valid : std_logic;
+    signal fork_ready : std_logic;
+  begin
+    join : entity work.{join_name}
+    port map(
+      -- input channels
+      {valid_instance_assignments}
+      -- output channel to eager fork
+      outs_valid => join_valid,
+      outs_ready => fork_ready
+    );
+
+    fork : entity work.{fork_name}
+    port map(
+      -- output channels
+      {fork_instance_assignments}
+      -- input channel from fork
+      ins_valid => join_valid,
+      ins_ready => fork_ready
+    );
+
+    {assignments}
+
+  end architecture;
+  """
+
+
+  return dependencies + entity + architecture
+
+
+def input_port(i, bitwidth):
+    potential_port_declaration = f"ins{i}        : in std_logic_vector({bitwidth} - 1 downto 0);"
+    return f"""    -- input port {i}
+    {data(potential_port_declaration, bitwidth)}
+    ins{i}_valid  : in std_logic;
+    ins{i}_ready  : out std_logic;
+
+"""
+
+def output_port(i, bitwidth):
+    potential_port_declaration = f"outs{i}        : out std_logic_vector({bitwidth} - 1 downto 0);"
+    return f"""    -- output port {i}
+    {data(potential_port_declaration, bitwidth)}
+    outs{i}_valid  : out std_logic;
+    outs{i}_ready  : in std_logic;
+
+"""

experimental/tools/unit-generators/vhdl/generators/support/utils.py

@@ -1,6 +1,6 @@
 from typing import Type, Union
 from enum import Enum
-
+import re
 
 def data(code: str, bitwidth: int) -> str:
     return code if bitwidth else ""

experimental/tools/unit-generators/vhdl/vhdl-unit-generator.py

@@ -39,6 +39,7 @@
 import generators.handshake.fptosi as fptosi
 import generators.handshake.ready_remover as ready_remover
 import generators.handshake.valid_merger as valid_merger
+import generators.handshake.synchronizer as synchronizer
 
 
 def generate_code(name, mod_type, parameters):
@@ -117,6 +118,8 @@ def generate_code(name, mod_type, parameters):
             return ready_remover.generate_ready_remover(name, parameters)
         case "valid_merger":
             return valid_merger.generate_valid_merger(name, parameters)
+        case "synchronizer":
+            return synchronizer.generate_synchronizer(name, parameters)
         case _:
             raise ValueError(f"Module type {mod_type} not found")
 

include/dynamatic/Dialect/Handshake/HandshakeOps.td

@@ -591,47 +591,32 @@ def SourceOp : Handshake_Op<"source", [Pure]> {
   let assemblyFormat = "attr-dict `:` type($result)";
 }
 
-def JoinOp : Handshake_Op<"join", [
-  SameOperandsAndResultType,
-  DeclareOpInterfaceMethods<ControlInterface, ["isControl"]>
-]> {
-  let summary = "join operation";
+def SynchronizerOp : Handshake_Op<"synchronizer"> {
+  let summary = "Synchronization operation";
   let description = [{
-    A control-only synchronizer.  Produces a valid output when all
-    inputs become available.
+    Token synchronizer.
+    Outputs only become valid when all inputs are valid.
 
     Example:
 
     ```mlir
-    %0 = join %a, %b, %c : !handshake.control
+    %0, %1, %2 = synchronizer %a, %b, %c : !handshake.channel<i32>, !handshake.channel<i8>, !handshake.control
     ```
   }];
 
-  let arguments = (ins Variadic<ControlType>:$data);
-  let results = (outs ControlType:$result);
-  let assemblyFormat = "$data attr-dict `:` type($result)";
-}
-
-// TODO: Split the input into two parts and explicitly mark the forwarded input,
-// once the backend supports variadic channels with zero or one item correctly.
-def BlockerOp : Handshake_Op<"blocker", [
-  SameOperandsAndResultType
-]> {
-  let summary = "blocker operation";
-  let description = [{
-    A data synchronizer. Blocks handshakes until all inputs are valid, 
-    then forwards the first input.
-
-    Example:
+  let arguments = (ins Variadic<ChannelType>:$ins);
+  let results = (outs Variadic<ChannelType>:$outs);
 
-    ```mlir
-    %0 = blocker %a, %b, %c : !handshake.channel<i32>
-    ```
-  }];
+  let builders = [
+    OpBuilder<(ins "ValueRange":$ins), [{
+      SmallVector<Type> outTypes;
+      for (Value v : ins)
+        outTypes.push_back(v.getType());
+      build($_builder, $_state, outTypes, ins);
+    }]>
+  ];
 
-  let arguments = (ins Variadic<ChannelType>:$data);
-  let results = (outs ChannelType:$result);
-  let assemblyFormat = "$data attr-dict `:` type($result)";
+  let assemblyFormat = "$ins `:` type($ins) attr-dict `->` type($outs)";
 }
 
 def NotOp : Handshake_Op<"not", [Pure, SameOperandsAndResultType]> {

lib/Conversion/HandshakeToHW/HandshakeToHW.cpp

@@ -537,7 +537,7 @@ ModuleDiscriminator::ModuleDiscriminator(Operation *op) {
         addUnsigned("SIZE", op->getNumOperands());
         addType("DATA_TYPE", op->getResult(0));
       })
-      .Case<handshake::JoinOp, handshake::BlockerOp>([&](auto) {
+      .Case<handshake::SynchronizerOp>([&](auto) {
         // Number of input channels
         addUnsigned("SIZE", op->getNumOperands());
       })
@@ -1821,8 +1821,7 @@ class HandshakeToHWPass
                     ConvertToHWInstance<handshake::MergeOp>,
                     ConvertToHWInstance<handshake::ControlMergeOp>,
                     ConvertToHWInstance<handshake::MuxOp>,
-                    ConvertToHWInstance<handshake::JoinOp>,
-                    ConvertToHWInstance<handshake::BlockerOp>,
+                    ConvertToHWInstance<handshake::SynchronizerOp>,
                     ConvertToHWInstance<handshake::SourceOp>,
                     ConvertToHWInstance<handshake::ConstantOp>,
                     ConvertToHWInstance<handshake::SinkOp>,

lib/Dialect/Handshake/HandshakeOps.cpp

@@ -584,8 +584,6 @@ LogicalResult ConstantOp::verify() {
   return success();
 }
 
-bool JoinOp::isControl() { return true; }
-
 /// Based on mlir::func::CallOp::verifySymbolUses
 LogicalResult InstanceOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   // Check that the module attribute was specified.

lib/Support/TimingModels.cpp

@@ -62,7 +62,7 @@ unsigned dynamatic::getOpDatawidth(Operation *op) {
       .Case<handshake::SourceOp, handshake::ConstantOp>([&](auto) {
         return getHandshakeTypeBitWidth(op->getResult(0).getType());
       })
-      .Case<handshake::EndOp, handshake::JoinOp, handshake::BlockerOp>(
+      .Case<handshake::EndOp, handshake::SynchronizerOp>(
           [&](auto) {
             if (op->getNumOperands() == 0)
               return 0u;

tools/export-dot/export-dot.cpp

@@ -250,9 +250,9 @@ static std::string getPrettyNodeLabel(Operation *op) {
 
 static StringRef getNodeColor(Operation *op) {
   return llvm::TypeSwitch<Operation *, StringRef>(op)
-      .Case<handshake::ForkOp, handshake::LazyForkOp, handshake::JoinOp>(
+      .Case<handshake::ForkOp, handshake::LazyForkOp>(
           [&](auto) { return "lavender"; })
-      .Case<handshake::BlockerOp>([&](auto) { return "cyan"; })
+      .Case<handshake::SynchronizerOp>([&](auto) { return "cyan"; })
       .Case<handshake::BufferOp>([&](auto) { return "palegreen"; })
       .Case<handshake::EndOp>([&](auto) { return "gold"; })
       .Case<handshake::SourceOp, handshake::SinkOp>(