(feature) Extend the header and the typedef's to incorperate the collective operations

* Extend the header / typedef

* Rename the existing "CollectB" to "ParallelReduction"

* Extend floogen to support reduction operations

* Extend the route configuration to support collectiv operations

Author: Raphael

floogen/model/routing.py

@@ -557,6 +557,9 @@ class Routing(BaseModel):
     port_id_bits: int = 1
     num_vc_id_bits: int = 0
     en_multicast: bool = False
+    en_parallel_reduction: bool = False
+    en_narrow_offload_reduction: bool = False
+    en_wide_offload_reduction: bool = False
 
     @field_validator("route_algo", mode="before")
     @classmethod
@@ -566,6 +569,28 @@ def validate_route_algo(cls, v):
             v = RouteAlgo[v]
         return v
 
+    @model_validator(mode="after")
+    def validate_collective(self):
+        """Reduction can be supported with multicast only."""
+        if not self.en_multicast and (
+            self.en_parallel_reduction or
+            self.en_narrow_offload_reduction or
+            self.en_wide_offload_reduction
+        ):
+            raise ValueError(
+                "Multicast must be enabled to use any reduction feature "
+            )
+        return self
+
+    @model_validator(mode="after")
+    def validate_multicast_route_algo(self):
+        """Multicast is supported with XY routing only"""
+        if self.en_multicast and self.route_algo != RouteAlgo.XY:
+            raise ValueError(
+                "Multicast is only supported with XY routing algorithm, "
+                f"but got {self.route_algo}"
+            )
+        return self
     def render_param_decl(self) -> str:
         """Render the SystemVerilog parameter declaration."""
         string = ""
@@ -627,6 +652,14 @@ def render_hdr_typedef(self, network_type) -> str:
 
         if self.num_vc_id_bits == 0:
             if self.en_multicast:
+                if ( self.en_parallel_reduction
+                    or self.en_narrow_offload_reduction
+                    or self.en_wide_offload_reduction
+                ):
+                    return (
+                        f"`FLOO_TYPEDEF_HDR_T(hdr_t, {dst_type}, id_t, {ch_type}, rob_idx_t,"
+                        f"id_t, collect_comm_e, reduction_op_t)")
+
                 return (
                     f"`FLOO_TYPEDEF_HDR_T(hdr_t, {dst_type}, id_t, {ch_type}, rob_idx_t,"
                     f"id_t, collect_comm_e)")
@@ -645,6 +678,9 @@ def render_route_cfg(self, name) -> str:
                                 self.route_algo == RouteAlgo.ID and not self.use_id_table else 0,
             "NumSamRules": len(self.sam),
             "NumRoutes": self.num_endpoints if self.route_algo == RouteAlgo.SRC else 0,
-            "EnMultiCast": bool_to_sv(self.en_multicast)
+            "EnMultiCast": bool_to_sv(self.en_multicast),
+            "EnParallelReduction": bool_to_sv(self.en_parallel_reduction),
+            "EnNarrowOffloadReduction": bool_to_sv(self.en_narrow_offload_reduction),
+            "EnWideOffloadReduction": bool_to_sv(self.en_wide_offload_reduction)
         }
         return sv_param_decl(name, sv_struct_render(fields), dtype="route_cfg_t")

hw/floo_axi_chimney.sv

@@ -613,7 +613,8 @@ module floo_axi_chimney #(
     floo_axi_b.hdr.atop     = aw_out_hdr_out.hdr.atop;
     floo_axi_b.payload      = meta_buf_rsp_out.b;
     floo_axi_b.payload.id   = aw_out_hdr_out.id;
-    floo_axi_b.hdr.commtype = (aw_out_hdr_out.hdr.commtype == Multicast)? CollectB : Unicast;
+    floo_axi_b.hdr.commtype = (aw_out_hdr_out.hdr.commtype == Multicast)?
+                              ParallelReduction : Unicast;
   end
 
   always_comb begin

hw/floo_nw_chimney.sv

@@ -947,7 +947,7 @@ module floo_nw_chimney #(
     floo_narrow_b.payload      = axi_narrow_meta_buf_rsp_out.b;
     floo_narrow_b.payload.id   = narrow_aw_buf_hdr_out.id;
     floo_narrow_b.hdr.commtype = (narrow_aw_buf_hdr_out.hdr.commtype == Multicast)?
-                                 CollectB : Unicast;
+                                 ParallelReduction : Unicast;
   end
 
   always_comb begin
@@ -1015,7 +1015,8 @@ module floo_nw_chimney #(
     floo_wide_b.hdr.axi_ch  = WideB;
     floo_wide_b.payload     = axi_wide_meta_buf_rsp_out.b;
     floo_wide_b.payload.id  = wide_aw_buf_hdr_out.id;
-    floo_wide_b.hdr.commtype = (wide_aw_buf_hdr_out.hdr.commtype == Multicast)? CollectB : Unicast;
+    floo_wide_b.hdr.commtype = (wide_aw_buf_hdr_out.hdr.commtype == Multicast)?
+                               ParallelReduction : Unicast;
   end
 
   always_comb begin

hw/floo_output_arbiter.sv

@@ -39,7 +39,7 @@ module floo_output_arbiter import floo_pkg::*;
 
   // Determine which input ports are to be reduced
   for (genvar i = 0; i < NumRoutes; i++) begin : gen_reduce_mask
-    assign reduce_mask[i] = (data_i[i].hdr.commtype == CollectB);
+    assign reduce_mask[i] = (data_i[i].hdr.commtype == ParallelReduction);
   end
 
   // Arbitrate unicasts

hw/floo_pkg.sv

@@ -89,10 +89,42 @@ package floo_pkg;
     Unicast = 2'd0,
     /// Multicast communication
     Multicast = 2'd1,
-    /// Reduction of AXI B-responses
-    CollectB = 2'd2
+    /// Parallel reduction operations
+    ParallelReduction = 2'd2,
+    /// Offload Reduction
+    OffloadReduction = 2'd3
   } collect_comm_e;
 
+  /// Different offloadable reduction
+  typedef enum logic [3:0] {
+    R_Select  = 4'b0000, // Select the first incoming flit
+    F_Add     = 4'b0100, // FP Addition
+    F_Mul     = 4'b0101, // FP Multiplication
+    F_Min     = 4'b0110, // FP Min
+    F_Max     = 4'b0111, // FP Max
+    A_Add     = 4'b1000, // Atomic Add (signed)
+    A_Mul     = 4'b1001, // (Non-) Atomic (signed)
+    A_Min_S   = 4'b1010, // Atomic Min (signed)
+    A_Min_U   = 4'b1110, // Atomic Min (unsigned)
+    A_Max_S   = 4'b1011, // Atomic Max (signed)
+    A_Max_U   = 4'b1111  // Atomic Max (unsigned)
+  } reduction_offload_op_e;
+
+  /// Different instantanous reduction
+  typedef enum logic [3:0] {
+    SelectAW  = 4'b0000,  // Select the first incoming flit
+    CollectB  = 4'b0001,  // Collect the B responses from an AXI transmission
+    LSBAnd    = 4'b0010   // AND Connect the LSB of the payload (useful for barrier ops)
+  } reduction_parallel_op_e;
+
+  /// Union for both Datatype(s) - because they need to have the same size for the chimney
+  /// The chimney needs this information as it does not know if we support an offload reduction
+  /// or an parallel reduction.
+  typedef union packed {
+    reduction_offload_op_e op_offload;
+    reduction_parallel_op_e op_parallel;
+  } reduction_op_t;
+
   /// The types of AXI channels in narrow-wide AXI network interfaces
   typedef enum logic [3:0] {
     NarrowAw = 4'd0,
@@ -157,6 +189,12 @@ package floo_pkg;
     int unsigned NumRoutes;
     /// Whether to enable the multicast feature in the NoC
     bit EnMultiCast;
+    /// Whether to use the parallel reduction on the narrow req link
+    bit EnParallelReduction;
+    /// Whether to use the offload reduction on the narrow req link
+    bit EnNarrowOffloadReduction;
+    /// Whether to use the offload reduction on the wide link
+    bit EnWideOffloadReduction;
   } route_cfg_t;
 
   /// Configuration for the network interface (chimney)
@@ -220,7 +258,10 @@ package floo_pkg;
     IdAddrOffset: 0,
     NumSamRules: 0,
     NumRoutes: 0,
-    EnMultiCast: 1'b0
+    EnMultiCast: 1'b0,
+    EnParallelReduction: 1'b0,
+    EnNarrowOffloadReduction: 1'b0,
+    EnWideOffloadReduction: 1'b0
   };
 
   /// The AXI channel to link mapping in a single-AXI network interface

hw/floo_route_xymask.sv

@@ -36,8 +36,9 @@ module floo_route_xymask
   // `dst_id` in from the forward path.
   assign dst_id = (FwdMode)? channel_i.hdr.dst_id : channel_i.hdr.src_id;
   assign src_id = (FwdMode)? channel_i.hdr.src_id : channel_i.hdr.dst_id;
-  // TODO(fischeti): Clarify with Chen why `CollectB` are excluded
-  assign mask_in = (FwdMode && channel_i.hdr.commtype==CollectB)? '0 : channel_i.hdr.mask;
+  // TODO(fischeti): Clarify with Chen why `ParallelReduction` are excluded
+  assign mask_in = (FwdMode && channel_i.hdr.commtype==ParallelReduction)?
+                    '0 : channel_i.hdr.mask;
 
   // We compute minimum and maximum destination IDs, to decide whether
   // we need to send left and/or right resp. up and/or down.

hw/include/floo_noc/typedef.svh

@@ -47,7 +47,7 @@
 //
 // For `SourceRouting`:
 // `FLOO_TYPEDEF_HDR_T(hdr_t, route_t, id_t, floo_pkg::axi_ch_e, logic)
-`define FLOO_TYPEDEF_HDR_T(hdr_t, dst_t, src_t, ch_t, rob_idx_t, mask_t = logic, collect_comm_t = logic)  \
+`define FLOO_TYPEDEF_HDR_T(hdr_t, dst_t, src_t, ch_t, rob_idx_t, mask_t = logic, collect_comm_t = logic, reduction_t = logic)  \
   typedef struct packed {                                         \
     logic rob_req;                                                \
     rob_idx_t rob_idx;                                            \
@@ -58,6 +58,7 @@
     logic atop;                                                   \
     ch_t axi_ch;                                                  \
     collect_comm_t commtype;                                      \
+    reduction_t reduction_op;                                     \
   } hdr_t;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

hw/test/floo_test_pkg.sv

@@ -33,7 +33,10 @@ package floo_test_pkg;
     IdAddrOffset: 0,
     NumSamRules: 1,
     NumRoutes: 1,
-    EnMultiCast: 1'b0
+    EnMultiCast: 1'b0,
+    EnParallelReduction: 1'b0,
+    EnNarrowOffloadReduction: 1'b0,
+    EnWideOffloadReduction: 1'b0
   };
 
   // Common chimney parameters