[Buffer] Added debugCounter attr to BufferOp

data/rtl-config-smv.json

@@ -6,14 +6,18 @@
   },
   {
     "name": "handshake.buffer",
-   "parameters": [
-    {"name": "NUM_SLOTS", "type": "unsigned"},
-    {
-      "name": "BUFFER_TYPE",
-      "type": "string"
-    }
-  ],
-    "generator": "python $DYNAMATIC/experimental/tools/unit-generators/smv/smv-unit-generator.py -n $MODULE_NAME -o $OUTPUT_DIR/$MODULE_NAME.smv -t buffer -p num_slots=$NUM_SLOTS bitwidth=$BITWIDTH  buffer_type='\"$BUFFER_TYPE\"'",
+    "parameters": [
+      {"name": "NUM_SLOTS", "type": "unsigned"},
+      {
+        "name": "BUFFER_TYPE",
+        "type": "string"
+      },
+      {
+        "name": "DEBUG_COUNTER",
+        "type": "boolean"
+      }
+    ],
+    "generator": "python $DYNAMATIC/experimental/tools/unit-generators/smv/smv-unit-generator.py -n $MODULE_NAME -o $OUTPUT_DIR/$MODULE_NAME.smv -t buffer -p num_slots=$NUM_SLOTS bitwidth=$BITWIDTH  buffer_type='\"$BUFFER_TYPE\"' debug_counter=$DEBUG_COUNTER",
     "hdl": "smv"
   },
   {

data/rtl-config-vhdl-beta.json

@@ -92,9 +92,13 @@
       {
         "name": "BUFFER_TYPE",
         "type": "string"
+      },
+      {
+        "name": "DEBUG_COUNTER",
+        "type": "boolean"
       }
     ],
-    "generator": "python $DYNAMATIC/experimental/tools/unit-generators/vhdl/vhdl-unit-generator.py -n $MODULE_NAME -o $OUTPUT_DIR/$MODULE_NAME.vhd -t buffer -p num_slots=$NUM_SLOTS bitwidth=$BITWIDTH buffer_type='\"$BUFFER_TYPE\"' extra_signals=$EXTRA_SIGNALS"
+    "generator": "python $DYNAMATIC/experimental/tools/unit-generators/vhdl/vhdl-unit-generator.py -n $MODULE_NAME -o $OUTPUT_DIR/$MODULE_NAME.vhd -t buffer -p num_slots=$NUM_SLOTS bitwidth=$BITWIDTH buffer_type='\"$BUFFER_TYPE\"' extra_signals=$EXTRA_SIGNALS debug_counter=$DEBUG_COUNTER"
   },
   {
     "name": "handshake.fork",

experimental/tools/unit-generators/smv/generators/handshake/buffer.py

@@ -22,25 +22,26 @@ class BufferType(Enum):
 def generate_buffer(name, params):
     slots = params[ATTR_SLOTS]
     bitwidth = params[ATTR_BITWIDTH]
+    debug_counter = params.get(ATTR_DEBUG_COUNTER, False)
 
     buffer_type = try_enum_cast(params[ATTR_BUFFER_TYPE], BufferType)
 
     match buffer_type:
         case BufferType.ONE_SLOT_BREAK_R:
-            return generate_one_slot_break_r(name, {ATTR_BITWIDTH: bitwidth})
+            return generate_one_slot_break_r(name, {ATTR_BITWIDTH: bitwidth, ATTR_DEBUG_COUNTER: debug_counter})
         case BufferType.FIFO_BREAK_NONE:
-            return generate_fifo_break_none(name, {ATTR_SLOTS: slots, ATTR_BITWIDTH: bitwidth})
+            return generate_fifo_break_none(name, {ATTR_SLOTS: slots, ATTR_BITWIDTH: bitwidth, ATTR_DEBUG_COUNTER: debug_counter})
         case BufferType.ONE_SLOT_BREAK_DV:
-            return generate_one_slot_break_dv(name, {ATTR_BITWIDTH: bitwidth})
+            return generate_one_slot_break_dv(name, {ATTR_BITWIDTH: bitwidth, ATTR_DEBUG_COUNTER: debug_counter})
         case BufferType.FIFO_BREAK_DV:
-            return generate_fifo_break_dv(name, {ATTR_SLOTS: slots, ATTR_BITWIDTH: bitwidth})
+            return generate_fifo_break_dv(name, {ATTR_SLOTS: slots, ATTR_BITWIDTH: bitwidth, ATTR_DEBUG_COUNTER: debug_counter})
         case BufferType.ONE_SLOT_BREAK_DVR:
             # this is wrong
             # but it is what was being generated based on the previous code
-            return generate_one_slot_break_dv(name, {ATTR_SLOTS: slots, ATTR_BITWIDTH: bitwidth})
+            return generate_one_slot_break_dv(name, {ATTR_SLOTS: slots, ATTR_BITWIDTH: bitwidth, ATTR_DEBUG_COUNTER: debug_counter})
         case BufferType.SHIFT_REG_BREAK_DV:
             # this is wrong
             # but it is what was being generated based on the previous code
-            return generate_ofifo(name, {ATTR_SLOTS: slots, ATTR_BITWIDTH: bitwidth})
+            return generate_ofifo(name, {ATTR_SLOTS: slots, ATTR_BITWIDTH: bitwidth, ATTR_DEBUG_COUNTER: debug_counter})
         case _:
             raise ValueError(f"Unhandled buffer type: {buffer_type}")

experimental/tools/unit-generators/smv/generators/handshake/buffers/fifo_break_dv.py

@@ -1,29 +1,32 @@
 from generators.support.utils import *
 from generators.handshake.buffers.fifo_break_none import generate_fifo_break_none
 from generators.handshake.buffers.one_slot_break_dv import generate_one_slot_break_dv
+from generators.support.buffer_counter import generate_buffer_counter
 
 
 def generate_fifo_break_dv(name, params):
     slots = params[ATTR_SLOTS] if ATTR_SLOTS in params else 1
     data_type = SmvScalarType(params[ATTR_BITWIDTH])
+    debug_counter = params.get(ATTR_DEBUG_COUNTER, False)
 
     if slots == 1:
-        return generate_one_slot_break_dv(name, {ATTR_BITWIDTH: params[ATTR_BITWIDTH]})
+        return generate_one_slot_break_dv(name, {ATTR_BITWIDTH: params[ATTR_BITWIDTH], ATTR_DEBUG_COUNTER: debug_counter})
 
     if data_type.bitwidth == 0:
-        return _generate_fifo_break_dv_dataless(name, slots)
+        return _generate_fifo_break_dv_dataless(name, slots, debug_counter)
     else:
-        return _generate_fifo_break_dv(name, slots, data_type)
+        return _generate_fifo_break_dv(name, slots, data_type, debug_counter)
 
 
-def _generate_fifo_break_dv_dataless(name, slots):
+def _generate_fifo_break_dv_dataless(name, slots, debug_counter):
     fifo_name = f"{name}__fifo"
     one_slot_name = f"{name}__break_dv"
     return f"""
 MODULE {name}(ins_valid, outs_ready)
   VAR
     fifo : {fifo_name}(ins_valid, break_dv_ready);
     break_dv   : {one_slot_name}(fifo_valid, outs_ready);
+    {f"debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
   DEFINE
     fifo_valid := fifo.outs_valid;
@@ -34,17 +37,19 @@ def _generate_fifo_break_dv_dataless(name, slots):
 
 {generate_fifo_break_none(fifo_name, {ATTR_SLOTS: slots - 1, ATTR_BITWIDTH: 0})}
 {generate_one_slot_break_dv(one_slot_name, {ATTR_BITWIDTH: 0})}
+{generate_buffer_counter(f"{name}__debug_counter", slots) if debug_counter else ""}
 """
 
 
-def _generate_fifo_break_dv(name, slots, data_type):
+def _generate_fifo_break_dv(name, slots, data_type, debug_counter):
     fifo_name = f"{name}__fifo"
     one_slot_name = f"{name}__break_dv"
     return f"""
 MODULE {name}(ins, ins_valid, outs_ready)
   VAR
     fifo : {fifo_name}(ins, ins_valid, break_dv_ready);
     break_dv : {one_slot_name}(fifo_data, fifo_valid, outs_ready);
+    {f"debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
   DEFINE
     fifo_data := fifo.outs;
@@ -57,4 +62,5 @@ def _generate_fifo_break_dv(name, slots, data_type):
 
 {generate_fifo_break_none(fifo_name, {ATTR_SLOTS: slots - 1, ATTR_BITWIDTH: data_type.bitwidth})}
 {generate_one_slot_break_dv(one_slot_name, {ATTR_BITWIDTH: data_type.bitwidth})}
+{generate_buffer_counter(f"{name}__debug_counter", slots) if debug_counter else ""}
 """

experimental/tools/unit-generators/smv/generators/handshake/buffers/fifo_break_none.py

@@ -1,27 +1,30 @@
 from generators.support.utils import *
+from generators.support.buffer_counter import generate_buffer_counter
 
 
 def generate_fifo_break_none(name, params):
     slots = params[ATTR_SLOTS]
     data_type = SmvScalarType(params[ATTR_BITWIDTH])
+    debug_counter = params.get(ATTR_DEBUG_COUNTER, False)
 
     if data_type.bitwidth == 0:
         if slots == 1:
-            return _generate_one_slot_break_none_dataless(name)
+            return _generate_one_slot_break_none_dataless(name, debug_counter)
         else:
-            return _generate_fifo_break_none_dataless(name, slots)
+            return _generate_fifo_break_none_dataless(name, slots, debug_counter)
     else:
         if slots == 1:
-            return _generate_one_slot_break_none(name, data_type)
+            return _generate_one_slot_break_none(name, data_type, debug_counter)
         else:
-            return _generate_fifo_break_none(name, slots, data_type)
+            return _generate_fifo_break_none(name, slots, data_type, debug_counter)
 
 
-def _generate_one_slot_break_none_dataless(name):
+def _generate_one_slot_break_none_dataless(name, debug_counter):
     return f"""
 MODULE {name}(ins_valid, outs_ready)
     VAR 
     full : boolean;
+    {f"debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
     ASSIGN
     init(full) := FALSE;
@@ -31,15 +34,17 @@ def _generate_one_slot_break_none_dataless(name):
     DEFINE
     outs_valid := full | ins_valid;
     ins_ready := (!full) | outs_ready;
+{generate_buffer_counter(f"{name}__debug_counter", 1) if debug_counter else ""}
 """
 
 
-def _generate_one_slot_break_none(name, data_type):
+def _generate_one_slot_break_none(name, data_type, debug_counter):
     return f"""
 MODULE {name}(ins, ins_valid, outs_ready)
     VAR 
     reg : {data_type};
     full : boolean;
+    {f"debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
     ASSIGN
     init(reg) := {data_type.format_constant(0)};
@@ -52,36 +57,45 @@ def _generate_one_slot_break_none(name, data_type):
     outs := full ? reg : ins;
     outs_valid := full | ins_valid;
     ins_ready := (!full) | outs_ready;
+{generate_buffer_counter(f"{name}__debug_counter", 1) if debug_counter else ""}
 """
 
 
-def _generate_fifo_break_none_dataless(name, slots):
+def _generate_fifo_break_none_dataless(name, slots, debug_counter):
     # fifo generated as chain of fully transparent slots for faster model checking
-    slots_valid = ["ins_valid"] + [f"b{i}.outs_valid" for i in range(slots - 1)]
-    slots_ready = [f"b{i + 1}.ins_ready" for i in range(slots - 1)] + ["outs_ready"]
+    slots_valid = ["ins_valid"] + \
+        [f"b{i}.outs_valid" for i in range(slots - 1)]
+    slots_ready = [
+        f"b{i + 1}.ins_ready" for i in range(slots - 1)] + ["outs_ready"]
     return f"""
 MODULE {name}(ins_valid, outs_ready)
     {"\n    ".join([f"VAR b{n} : {name}_tslot({valid}, {ready});" for n, (valid, ready) in enumerate(zip(slots_valid, slots_ready))])}
+    {f"VAR debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
     -- outputs
 		DEFINE outs_valid := b{slots - 1}.outs_valid;
 		DEFINE ins_ready := b0.ins_ready;
-{_generate_one_slot_break_none_dataless(f"{name}_tslot")}
+{_generate_one_slot_break_none_dataless(f"{name}_tslot", False)}
+{generate_buffer_counter(f"{name}__debug_counter", slots) if debug_counter else ""}
 """
 
 
-def _generate_fifo_break_none(name, slots, data_type):
+def _generate_fifo_break_none(name, slots, data_type, debug_counter):
     # fifo generated as chain of fully transparent slots for faster model checking
     slots_data = ["ins"] + [f"b{i}.outs" for i in range(slots)]
-    slots_valid = ["ins_valid"] + [f"b{i}.outs_valid" for i in range(slots - 1)]
-    slots_ready = [f"b{i + 1}.ins_ready" for i in range(slots - 1)] + ["outs_ready"]
+    slots_valid = ["ins_valid"] + \
+        [f"b{i}.outs_valid" for i in range(slots - 1)]
+    slots_ready = [
+        f"b{i + 1}.ins_ready" for i in range(slots - 1)] + ["outs_ready"]
     return f"""
 MODULE {name}(ins, ins_valid, outs_ready)
     {"\n    ".join([f"VAR b{n} : {name}_tslot({data}, {valid}, {ready});" for n, (data, valid, ready) in enumerate(zip(slots_data, slots_valid, slots_ready))])}
+    {f"VAR debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
     -- output
 		DEFINE outs   := b{slots - 1}.outs;
 		DEFINE outs_valid   := b{slots - 1}.outs_valid;
 		DEFINE ins_ready   := b0.ins_ready;
-{_generate_one_slot_break_none(f"{name}_tslot", data_type)}
+{_generate_one_slot_break_none(f"{name}_tslot", data_type, False)}
+{generate_buffer_counter(f"{name}__debug_counter", slots) if debug_counter else ""}
 """

experimental/tools/unit-generators/smv/generators/handshake/buffers/ofifo.py

@@ -1,24 +1,27 @@
 from generators.support.utils import *
 from generators.handshake.buffers.fifo_break_dv import generate_fifo_break_dv
 from generators.handshake.buffers.one_slot_break_r import generate_one_slot_break_r
+from generators.support.buffer_counter import generate_buffer_counter
 
 
 def generate_ofifo(name, params):
     slots = params[ATTR_SLOTS]
     data_type = SmvScalarType(params[ATTR_BITWIDTH])
+    debug_counter = params.get(ATTR_DEBUG_COUNTER, False)
 
     if data_type.bitwidth == 0:
-        return _generate_ofifo_dataless(name, slots)
+        return _generate_ofifo_dataless(name, slots, debug_counter)
     else:
-        return _generate_ofifo(name, slots, data_type)
+        return _generate_ofifo(name, slots, data_type, debug_counter)
 
 
-def _generate_ofifo_dataless(name, slots):
+def _generate_ofifo_dataless(name, slots, debug_counter):
     return f"""
 MODULE {name} (ins_valid, outs_ready)
   VAR
   inner_tehb : {name}__tehb_dataless(ins_valid, inner_elastic_fifo.ins_ready);
   inner_elastic_fifo : {name}__elastic_fifo_inner_dataless(inner_tehb.outs_valid, outs_ready);
+  {f"debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
   -- output
   DEFINE
@@ -27,15 +30,17 @@ def _generate_ofifo_dataless(name, slots):
 
 {generate_one_slot_break_r(f"{name}__tehb_dataless", {ATTR_BITWIDTH: 0})}
 {generate_fifo_break_dv(f"{name}__elastic_fifo_inner_dataless", {ATTR_SLOTS: slots, ATTR_BITWIDTH: 0})}
+{generate_buffer_counter(f"{name}__debug_counter", slots) if debug_counter else ""}
 """
 
 
-def _generate_ofifo(name, slots, data_type):
+def _generate_ofifo(name, slots, data_type, debug_counter):
     return f"""
 MODULE {name} (ins, ins_valid, outs_ready)
   VAR
   inner_tehb : {name}__tehb(ins, ins_valid, inner_elastic_fifo.ins_ready);
   inner_elastic_fifo : {name}__elastic_fifo_inner(inner_tehb.outs, inner_tehb.outs_valid, outs_ready);
+  {f"debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
   -- output
   DEFINE
@@ -45,4 +50,5 @@ def _generate_ofifo(name, slots, data_type):
 
 {generate_one_slot_break_r(f"{name}__tehb", {ATTR_BITWIDTH: data_type.bitwidth})}
 {generate_fifo_break_dv(f"{name}__elastic_fifo_inner", {ATTR_SLOTS: slots, ATTR_BITWIDTH: data_type.bitwidth})}
+{generate_buffer_counter(f"{name}__debug_counter", slots) if debug_counter else ""}
 """

experimental/tools/unit-generators/smv/generators/handshake/buffers/one_slot_break_dv.py

@@ -1,20 +1,23 @@
 from generators.support.utils import *
+from generators.support.buffer_counter import generate_buffer_counter
 
 
 def generate_one_slot_break_dv(name, params):
     data_type = SmvScalarType(params[ATTR_BITWIDTH])
+    debug_counter = params.get(ATTR_DEBUG_COUNTER, False)
 
     if data_type.bitwidth == 0:
-        return _generate_one_slot_break_dv_dataless(name)
+        return _generate_one_slot_break_dv_dataless(name, debug_counter)
     else:
-        return _generate_one_slot_break_dv(name, data_type)
+        return _generate_one_slot_break_dv(name, data_type, debug_counter)
 
 
-def _generate_one_slot_break_dv_dataless(name):
+def _generate_one_slot_break_dv_dataless(name, debug_counter):
     return f"""
 MODULE {name} (ins_valid, outs_ready)
   VAR
   outs_valid_i : boolean;
+  {f"debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
   ASSIGN
   init(outs_valid_i) := FALSE;
@@ -24,15 +27,17 @@ def _generate_one_slot_break_dv_dataless(name):
   DEFINE
   ins_ready := !outs_valid_i | outs_ready;
   outs_valid := outs_valid_i;
+{generate_buffer_counter(f"{name}__debug_counter", 1) if debug_counter else ""}
 """
 
 
-def _generate_one_slot_break_dv(name, data_type):
+def _generate_one_slot_break_dv(name, data_type, debug_counter):
     return f"""
 MODULE {name} (ins, ins_valid, outs_ready)
   VAR
   inner_one_slot_break_dv : {name}__one_slot_break_dv_dataless(ins_valid, outs_ready);
   data : {data_type};
+  {f"debug_counter : {name}__debug_counter(ins_valid, ins_ready, outs_valid, outs_ready);" if debug_counter else ""}
 
   ASSIGN
   init(data) := {data_type.format_constant(0)};
@@ -47,5 +52,6 @@ def _generate_one_slot_break_dv(name, data_type):
   outs_valid := inner_one_slot_break_dv.outs_valid;
   outs := data;
 
-{_generate_one_slot_break_dv_dataless(f"{name}__one_slot_break_dv_dataless")}
+{_generate_one_slot_break_dv_dataless(f"{name}__one_slot_break_dv_dataless", False)}
+{generate_buffer_counter(f"{name}__debug_counter", 1) if debug_counter else ""}
 """