Add C++ driver support

.gitignore

@@ -40,6 +40,7 @@ __pycache__/*
 .cache/*
 .*.swp
 *.ipynb_checkpoints*
+*.sif
 
 # Project files
 .vscode

src/finn/builder/build_dataflow_config.py

@@ -62,6 +62,7 @@ class DataflowOutputType(str, Enum):
     RTLSIM_PERFORMANCE = "rtlsim_performance"
     BITFILE = "bitfile"
     PYNQ_DRIVER = "pynq_driver"
+    CPP_DRIVER = "cpp_driver"
     DEPLOYMENT_PACKAGE = "deployment_package"
 
 
@@ -123,7 +124,7 @@ class VerificationStepType(str, Enum):
     "step_measure_rtlsim_performance",
     "step_out_of_context_synthesis",
     "step_synthesize_bitfile",
-    "step_make_pynq_driver",
+    "step_make_driver",
     "step_deployment_package",
 ]
 
@@ -356,6 +357,11 @@ class DataflowBuildConfig:
     #: rtlsim, otherwise they will be replaced by RTL implementations.
     rtlsim_use_vivado_comps: Optional[bool] = True
 
+    #: Determine if the C++ driver should be generated instead of the PYNQ driver
+    #: If set to latest newest version will be used
+    #: If set to commit hash specified version will be used
+    cpp_driver_version: Optional[str] = "latest"
+
     def _resolve_hls_clk_period(self):
         if self.hls_clk_period_ns is None:
             # use same clk for synth and hls if not explicitly specified

src/finn/builder/build_dataflow_steps.py

@@ -87,7 +87,7 @@
 from finn.transformation.fpgadataflow.hlssynth_ip import HLSSynthIP
 from finn.transformation.fpgadataflow.insert_dwc import InsertDWC
 from finn.transformation.fpgadataflow.insert_fifo import InsertFIFO
-from finn.transformation.fpgadataflow.make_pynq_driver import MakePYNQDriver
+from finn.transformation.fpgadataflow.make_driver import MakeCPPDriver, MakePYNQDriver
 from finn.transformation.fpgadataflow.make_zynq_proj import ZynqBuild
 from finn.transformation.fpgadataflow.minimize_accumulator_width import (
     MinimizeAccumulatorWidth,
@@ -732,15 +732,33 @@ def step_measure_rtlsim_performance(model: ModelWrapper, cfg: DataflowBuildConfi
     return model
 
 
-def step_make_pynq_driver(model: ModelWrapper, cfg: DataflowBuildConfig):
-    """Create a PYNQ Python driver that can be used to interface the generated
-    accelerator."""
+def step_make_driver(model: ModelWrapper, cfg: DataflowBuildConfig):
+    """Create a driver that can be used to interface the generated accelerator.
+    Use DataflowBuildConfig to select PYNQ Python or C++ driver."""
 
+    driver_dir = os.path.join(cfg.output_dir, "driver")
     if DataflowOutputType.PYNQ_DRIVER in cfg.generate_outputs:
-        driver_dir = cfg.output_dir + "/driver"
+        # generate PYNQ driver
         model = model.transform(MakePYNQDriver(cfg._resolve_driver_platform()))
         shutil.copytree(model.get_metadata_prop("pynq_driver_dir"), driver_dir, dirs_exist_ok=True)
         print("PYNQ Python driver written into " + driver_dir)
+    elif DataflowOutputType.CPP_DRIVER in cfg.generate_outputs:
+        # generate C++ Driver
+
+        model = model.transform(
+            MakeCPPDriver(
+                cfg._resolve_driver_platform(),
+                build_dir=cfg.output_dir,
+                version=cfg.cpp_driver_version,
+                driver_dir=driver_dir,
+            )
+        )
+        print("C++ driver written into " + driver_dir)
+    else:
+        warnings.warn(
+            "The step step_make_driver is in the build list but will not be executed"
+            + " since no driver is selected in generate_outputs in your build.py file!"
+        )
     return model
 
 
@@ -862,7 +880,7 @@ def step_deployment_package(model: ModelWrapper, cfg: DataflowBuildConfig):
     "step_set_fifo_depths": step_set_fifo_depths,
     "step_create_stitched_ip": step_create_stitched_ip,
     "step_measure_rtlsim_performance": step_measure_rtlsim_performance,
-    "step_make_pynq_driver": step_make_pynq_driver,
+    "step_make_driver": step_make_driver,
     "step_out_of_context_synthesis": step_out_of_context_synthesis,
     "step_synthesize_bitfile": step_synthesize_bitfile,
     "step_deployment_package": step_deployment_package,

src/finn/transformation/fpgadataflow/get_driver_shapes.py

@@ -0,0 +1,120 @@
+import numpy as np
+from qonnx.core.modelwrapper import ModelWrapper
+from qonnx.custom_op.registry import getCustomOp
+from qonnx.util.basic import gen_finn_dt_tensor, roundup_to_integer_multiple
+from typing import Dict
+
+import finn.util.data_packing as dpk
+from finn.util.data_packing import (
+    hexstring2npbytearray,
+    pack_innermost_dim_as_hex_string,
+)
+
+# TODO: License?
+
+
+def to_external_tensor(init, w_dtype):
+    """Return an appropriately formatted and packed numpy byte array for given
+    external parameter tensor."""
+
+    weight_width = init.shape[1] * w_dtype.bitwidth()
+    weight_width_padded = roundup_to_integer_multiple(weight_width, 4)
+    hex_init = pack_innermost_dim_as_hex_string(init, w_dtype, weight_width_padded, prefix="0x")
+    ext_weight = np.array([], dtype=np.uint8)
+    for line in hex_init:
+        array_line = [x for x in reversed(hexstring2npbytearray(line, remove_prefix="0x"))]
+        ext_weight = np.append(ext_weight, array_line)
+
+    return ext_weight
+
+
+def get_driver_shapes(model: ModelWrapper) -> Dict:
+    idt = []
+    idma_names = []
+    ishape_normal = []
+    ishape_folded = []
+    ishape_packed = []
+    for idma_ind, graph_in in enumerate(model.graph.input):
+        i_tensor_name = graph_in.name
+        # get inp tensor properties
+        i_tensor_dt = model.get_tensor_datatype(i_tensor_name)
+        i_tensor_shape_normal = tuple(model.get_tensor_shape(i_tensor_name))
+        # go down into dataflow partition to get folded shape info etc
+        # TODO consider setting these as attributes during dataflow partitioning
+        i_consumer = model.find_consumer(i_tensor_name)
+        assert (
+            i_consumer.op_type == "StreamingDataflowPartition"
+        ), """
+            Ensure CreateDataflowPartition called before driver creation."""
+        first_df_model = ModelWrapper(getCustomOp(i_consumer).get_nodeattr("model"))
+        assert (
+            first_df_model.graph.node[0].op_type == "IODMA_hls"
+        ), "First partition must hold input IODMA"
+        successors = model.find_direct_successors(i_consumer)
+        successor_input_num = list(successors[0].input).index(i_consumer.output[0])
+        successor_sdp = getCustomOp(successors[0])
+        successor_df_model = ModelWrapper(successor_sdp.get_nodeattr("model"))
+        first_node = successor_df_model.find_consumer(
+            successor_df_model.graph.input[successor_input_num].name
+        )
+        i_tensor_shape_folded = tuple(getCustomOp(first_node).get_folded_input_shape())
+        # generate dummy folded i/o tensors and their packed versions
+        i_tensor_dummy_folded = gen_finn_dt_tensor(i_tensor_dt, i_tensor_shape_folded)
+        i_tensor_dummy_packed = dpk.finnpy_to_packed_bytearray(i_tensor_dummy_folded, i_tensor_dt)
+        i_tensor_shape_packed = i_tensor_dummy_packed.shape
+        # append all input tensor info to relevant lists
+        idt.append("DataType['%s']" % i_tensor_dt.name)
+        ishape_normal.append(i_tensor_shape_normal)
+        ishape_folded.append(i_tensor_shape_folded)
+        ishape_packed.append(i_tensor_shape_packed)
+        idma_names.append(getCustomOp(i_consumer).get_nodeattr("instance_name"))
+
+    odt = []
+    odma_names = []
+    oshape_normal = []
+    oshape_folded = []
+    oshape_packed = []
+    for odma_ind, graph_out in enumerate(model.graph.output):
+        o_tensor_name = graph_out.name
+        # get inp tensor properties
+        o_tensor_dt = model.get_tensor_datatype(o_tensor_name)
+        o_tensor_shape_normal = tuple(model.get_tensor_shape(o_tensor_name))
+        # go down into IODMA partition to get folded shape info etc
+        # TODO consider setting these as attributes during dataflow partitioning
+        o_producer = model.find_producer(o_tensor_name)
+        assert (
+            o_producer.op_type == "StreamingDataflowPartition"
+        ), """
+            Ensure CreateDataflowPartition called before driver creation."""
+        df_model = ModelWrapper(getCustomOp(o_producer).get_nodeattr("model"))
+        assert df_model.graph.node[-1].op_type == "IODMA_hls", "Partition must hold output IODMA"
+        predecessors = model.find_direct_predecessors(o_producer)
+        predecessor_output_num = list(predecessors[0].output).index(o_producer.input[0])
+        predecessor_sdp = getCustomOp(predecessors[0])
+        predecessor_df_model = ModelWrapper(predecessor_sdp.get_nodeattr("model"))
+        last_node = predecessor_df_model.find_producer(
+            predecessor_df_model.graph.output[predecessor_output_num].name
+        )
+        o_tensor_shape_folded = tuple(getCustomOp(last_node).get_folded_output_shape())
+        o_tensor_dummy_folded = gen_finn_dt_tensor(o_tensor_dt, o_tensor_shape_folded)
+        o_tensor_dummy_packed = dpk.finnpy_to_packed_bytearray(o_tensor_dummy_folded, o_tensor_dt)
+        o_tensor_shape_packed = o_tensor_dummy_packed.shape
+        # append all output tensor info to relevant lists
+        odt.append("DataType['%s']" % o_tensor_dt.name)
+        oshape_normal.append(o_tensor_shape_normal)
+        oshape_folded.append(o_tensor_shape_folded)
+        oshape_packed.append(o_tensor_shape_packed)
+        odma_names.append(getCustomOp(o_producer).get_nodeattr("instance_name"))
+
+    return {
+        "idt": idt,
+        "idma_names": idma_names,
+        "ishape_normal": ishape_normal,
+        "ishape_folded": ishape_folded,
+        "ishape_packed": ishape_packed,
+        "odt": odt,
+        "odma_names": odma_names,
+        "oshape_normal": oshape_normal,
+        "oshape_folded": oshape_folded,
+        "oshape_packed": oshape_packed,
+    }