fixed DWC in regular cases and improved buffer correction

Author: Lukas Stasytis

src/finn/custom_op/fpgadataflow/hwcustomop.py

@@ -426,42 +426,65 @@ def derive_characteristic_fxns_analytically(self, period, override_rtlsim_dict):
 
         counter, cycles, txn_in = top_level_phase.traverse_phase_tree(0, counter, cycles, txn_in)
 
-        def apply_micro_buffer_correction(start, txn_in):
+        def apply_micro_buffer_correction(start, txn_in, period):
             """There are cases where a node can buffer up the very first 1-2 inputs
             immediately, even if it has not started properly consuming inputs yet
             This behavior is extremely difficult to model in a characterization tree
             and so we perform a manual correction by incrementing the number of
             inputs read by 1 and detracting 1 read from the tail of the period
 
             Which node types & configurations this applies for is yet to be
-            fully determined, but the corrections should happen here"""
+            fully determined, but the corrections should happen here.
+            It is possible that this correction is entire unncessary and
+            simply an rtlsim artefact, but we maintain it for testability for now"""
+
+            buffer = 0
 
             if "FMPadding" in self.onnx_node.name:
                 if "_rtl" in (self.__class__.__name__):
                     buffer = 1
-                    idx = start + 1
                 else:
                     buffer = 2
-                    txn_in[start + 1] += 1
+
+            if "StreamingDataWidthConverter" in self.onnx_node.name:
+                if "_rtl" in (self.__class__.__name__):
+                    buffer = 1
+                else:
+                    buffer = 2
+
+            if buffer > 0:
+                # buffering does not happen in nodes with short wind-ups
+                if period < 14:
+                    return txn_in
+
+                # main routine
+                if buffer == 2:
+                    if txn_in[start + 1] - txn_in[start] >= 1:
+                        buffer = 1
+                    else:
+                        txn_in[start + 1] += 1
 
                 idx = start + buffer
                 while idx < len(txn_in):
-                    txn_in[idx] += buffer
+                    if txn_in[idx] - txn_in[idx - 1] < buffer:
+                        txn_in[idx] += buffer
                     idx += 1
 
                 idx = len(txn_in) - 1
                 last = txn_in[idx]
+
                 # deduct 1 read from the tail
                 while last == txn_in[idx]:
                     txn_in[idx] -= buffer
                     idx -= 1
 
+                # one extra element to deduct in case of 2 buffers
                 if buffer == 2:
                     txn_in[idx] -= 1
 
             return txn_in
 
-        txn_in = apply_micro_buffer_correction(0, txn_in)
+        txn_in = apply_micro_buffer_correction(0, txn_in, period)
 
         txn_in += [counter] * (period - cycles)
         padding += period - cycles
@@ -471,7 +494,7 @@ def apply_micro_buffer_correction(start, txn_in):
 
         counter, cycles, txn_in = top_level_phase.traverse_phase_tree(0, counter, cycles, txn_in)
 
-        txn_in = apply_micro_buffer_correction(period, txn_in)
+        txn_in = apply_micro_buffer_correction(period, txn_in, period)
 
         txn_in += [counter] * (period * 2 - cycles)
         padding += period * 2 - cycles

src/finn/custom_op/fpgadataflow/streamingdatawidthconverter.py

@@ -220,43 +220,85 @@ def lut_estimation(self):
         return int(cnt_luts + cset_luts)
 
     def prepare_kwargs_for_characteristic_fx(self):
-        # function for the old DWC version
-        # newer version will need a separate, much more
-        # complicated function
+        """Characteristic function of the non-general DWC
+        variant."""
 
-        numInWords = int(np.prod(self.get_folded_input_shape()[-2:-1]))
-        numOutWords = int(np.prod(self.get_folded_output_shape()[-2:-1]))
-        numReps = int(np.prod(self.get_folded_input_shape()[:1]))
+        numReps = int(np.prod(self.get_folded_input_shape()[:-1]))
 
-        # inWidth = self.get_nodeattr("inWidth")
-        # outWidth = self.get_nodeattr("outWidth")
+        inWidth = self.get_nodeattr("inWidth")
+        outWidth = self.get_nodeattr("outWidth")
 
-        read_inputs = Characteristic_Node("read all words", [(numInWords, [1, 0])], True)
+        print("\nin,out widths:", inWidth, outWidth)
+        print("inshape:", self.get_folded_input_shape())
+        print("outshape:", self.get_folded_output_shape())
 
-        write_outputs = Characteristic_Node("write all words", [(numOutWords, [0, 1])], True)
+        wind_up = 1
 
-        up_convert_word = Characteristic_Node(
-            "up convert all words in a single transaction",
-            [(1, read_inputs), (1, write_outputs)],
-            False,
-        )
+        idle = Characteristic_Node("idle", [(1, [0, 0])], True)
 
-        down_convert_word = Characteristic_Node(
-            "down convert all words in a single transaction",
-            [(1, read_inputs), (1, write_outputs)],
-            False,
-        )
+        if inWidth > outWidth:
+            # down-conversion
+            if inWidth % outWidth != 0:
+                return None  # no support for gcd partial conversion yet
 
-        if numInWords > numOutWords:
-            reps = Characteristic_Node(
-                "compute a set of DWCs with up conversion", [(numReps, up_convert_word)], False
+            writes_per_read = inWidth // outWidth
+            # read 1, write many, repeats for in-word count
+
+            read_input = Characteristic_Node("read 1 word", [(1, [1, 0])], True)
+
+            write_output = Characteristic_Node("write words", [(writes_per_read, [0, 1])], True)
+
+            down_convert_word = Characteristic_Node(
+                "down convert all words in a single transaction",
+                [(1, read_input), (1, write_output)],
+                False,
             )
-        else:
-            reps = Characteristic_Node(
-                "compute a set of DWCs with down conversion", [(numReps, down_convert_word)], False
+
+            numReps = int(np.prod(self.get_folded_input_shape()[:-1]))
+
+            dwc_top = Characteristic_Node(
+                "compute a set of DWCs with down conversion",
+                [(wind_up, idle), (numReps, down_convert_word)],
+                False,
+            )
+
+        elif inWidth < outWidth:
+            # up-conversion
+
+            if outWidth % inWidth != 0:
+                return None  # no support for gcd partial conversion yet
+
+            reads_per_write = outWidth // inWidth
+            # read 1, write many, repeats for in-word count
+
+            read_input = Characteristic_Node("read words", [(reads_per_write, [1, 0])], True)
+
+            write_output = Characteristic_Node("write 1 word", [(1, [0, 1])], True)
+
+            up_convert_word = Characteristic_Node(
+                "down convert all words in a single transaction",
+                [(1, read_input), (1, write_output)],
+                False,
+            )
+
+            numReps = int(np.prod(self.get_folded_output_shape()[:-1]))
+            dwc_top = Characteristic_Node(
+                "compute a set of DWCs with up conversion",
+                [(wind_up, idle), (numReps, up_convert_word)],
+                False,
             )
 
-        return reps
+        else:
+            # pass-through
+
+            numReps = int(np.prod(self.get_folded_input_shape()[:-1]))
+
+            pass_through = Characteristic_Node("pass-through", [(1, [1, 1])], True)
+
+            dwc_top = Characteristic_Node(
+                "DWC pass-through, no conversion", [(wind_up, idle), (numReps, pass_through)], False
+            )
+        return dwc_top
 
     # def prepare_kwargs_for_characteristic_fx_old(self):
     #     numInWords = int(np.prod(self.get_folded_input_shape()[-2:-1]))

tests/fpgadataflow/test_fpgadataflow_dwc.py

@@ -186,12 +186,13 @@ def test_fpgadataflow_dwc_stitched_rtlsim(config, impl_style):
 @pytest.mark.parametrize(
     "config",
     [
-        ([1, 24], 6, 4, DataType["INT2"]),
-        ([1, 24], 4, 6, DataType["INT2"]),
+        ([1, 24], 8, 4, DataType["INT2"]),
+        # ([1, 24], 4, 6, DataType["INT2"]),
         ([1, 4], 2, 4, DataType["BIPOLAR"]),
         ([1, 4], 4, 2, DataType["INT2"]),
         ([1, 2, 8], 4, 4, DataType["INT2"]),
         ([1, 2, 8], 8, 16, DataType["INT2"]),
+        ([1, 320], 2, 160, DataType["INT2"]),
     ],
 )
 @pytest.mark.parametrize("exec_mode", ["rtlsim"])
@@ -207,7 +208,7 @@ def test_fpgadataflow_analytical_characterization_dwc(direction, config, exec_mo
     # model = model.transform(InferShapes())
     # model = model.transform(SetExecMode(mode))
 
-    node_details = ("DWC", shape, inWidth, outWidth, finn_dtype, impl_style)
+    node_details = ("DWC", config, impl_style)
     part = "xc7z020clg400-1"
     target_clk_ns = 4
     allowed_chr_offset_positions = 5