finn-plus 1.0.0__py3-none-any.whl

finn/analysis/fpgadataflow/dataflow_performance.py

@@ -0,0 +1,78 @@
+# Copyright (c) 2020, Xilinx, Inc.
+# Copyright (C) 2024, Advanced Micro Devices, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of FINN nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from qonnx.custom_op.registry import getCustomOp
+
+from finn.util.fpgadataflow import is_hls_node, is_rtl_node
+
+
+def dataflow_performance(model):
+    """Extract key performance indicators from given model with dataflow nodes.
+    Note that the latency (critical path) analysis is very pessimistic, it
+    assumes no overlap between executions and simply sums the expected cycles
+    for each node along the critical path.
+
+    Preconditions:
+    - model consists of HLS/RTL nodes
+    - model has cycle estimates annotated (see AnnotateCycles transformation)
+    - nodes have unique names (see GiveUniqueNodeNames)
+
+    Returns:
+    - max_cycles : number of cycles for slowest node
+    - max_cycles_node_name : name of slowest node
+    - critical_path_cycles : pessimistic expected latency from input to output
+    """
+    latency_at_node_output = {}
+    max_cycles = 0
+    max_node_name = ""
+
+    for node in model.graph.node:
+        if is_hls_node(node) or is_rtl_node(node):
+            inst = getCustomOp(node)
+            node_cycles = int(inst.get_nodeattr("cycles_estimate"))
+            if node_cycles > max_cycles:
+                max_cycles = node_cycles
+                max_node_name = node.name
+            if node.name not in latency_at_node_output:
+                # calculate based on input(s)
+                predecessors = model.find_direct_predecessors(node)
+                if predecessors is None:
+                    # no predecessors, node is first node
+                    max_pred_latency = 0
+                else:
+                    # find max of any of predecessors
+                    pred_latencies = map(lambda x: latency_at_node_output[x.name], predecessors)
+                    max_pred_latency = max(pred_latencies)
+                latency_at_node_output[node.name] = node_cycles + max_pred_latency
+    critical_path_cycles = max(latency_at_node_output.values())
+    return {
+        "critical_path_cycles": int(critical_path_cycles),
+        "max_cycles": int(max_cycles),
+        "max_cycles_node_name": max_node_name,
+    }

finn/analysis/fpgadataflow/exp_cycles_per_layer.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2020, Xilinx, Inc.
+# Copyright (C) 2024, Advanced Micro Devices, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of FINN nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import qonnx.custom_op.registry as registry
+
+from finn.util.fpgadataflow import is_hls_node, is_rtl_node
+
+
+def exp_cycles_per_layer(model):
+    """Estimates the number of cycles per sample for dataflow layers in the given model.
+    Ensure that all nodes have unique names (by calling the GiveUniqueNodeNames
+    transformation) prior to calling this analysis pass to ensure all nodes are
+    visible in the results.
+
+    Returns {node name : cycle estimation}."""
+
+    cycle_dict = {}
+    for node in model.graph.node:
+        if is_hls_node(node) or is_rtl_node(node):
+            inst = registry.getCustomOp(node)
+            cycle_dict[node.name] = int(inst.get_exp_cycles())
+
+    return cycle_dict

finn/analysis/fpgadataflow/floorplan_params.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2020, Xilinx
+# Copyright (C) 2024, Advanced Micro Devices, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of FINN nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from qonnx.custom_op.registry import getCustomOp
+
+from finn.util.fpgadataflow import is_fpgadataflow_node
+
+
+def floorplan_params(model):
+    """Gathers SLR and partition IDs from nodes.
+
+    Returns {node name : {slr, device id, partition id, memory port}}."""
+
+    ret_dict = {
+        "Defaults": {
+            "slr": [-1, ["all"]],
+            "partition_id": [0, ["all"]],
+            "device_id": [0, ["all"]],
+            "mem_port": ["", ["all"]],
+        }
+    }
+    for node in model.graph.node:
+        if is_fpgadataflow_node(node):
+            node_inst = getCustomOp(node)
+            node_slr = node_inst.get_nodeattr("slr")
+            node_pid = node_inst.get_nodeattr("partition_id")
+            node_mport = node_inst.get_nodeattr("mem_port")
+            ret_dict[node.name] = {
+                "slr": node_slr,
+                "partition_id": node_pid,
+                "device_id": 0,
+                "mem_port": node_mport,
+            }
+
+    return ret_dict

finn/analysis/fpgadataflow/hls_synth_res_estimation.py

@@ -0,0 +1,81 @@
+# Copyright (c) 2020, Xilinx
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of FINN nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import os
+import qonnx.custom_op.registry as registry
+import xml.etree.ElementTree as ET
+
+from finn.util.fpgadataflow import is_hls_node
+from finn.util.logging import log
+
+
+def hls_synth_res_estimation(model):
+    """Extracts the FPGA resource results from the Vitis HLS synthesis estimates.
+    Note that this analysis pass only works on nodes that have an HLS backend.
+    Ensure that all nodes have unique names (by calling the GiveUniqueNodeNames
+    transformation) prior to calling this analysis pass to ensure all nodes are
+    visible in the results.
+
+    Returns {node name : resources_dict}."""
+
+    res_dict = {}
+    for node in model.graph.node:
+        if is_hls_node(node):
+            # init values to zero
+            res_dict[node.name] = dict()
+            res_dict[node.name]["BRAM_18K"] = 0
+            res_dict[node.name]["FF"] = 0
+            res_dict[node.name]["LUT"] = 0
+            res_dict[node.name]["DSP48E"] = 0
+            res_dict[node.name]["URAM"] = 0
+            inst = registry.getCustomOp(node)
+            code_gen_dir = inst.get_nodeattr("code_gen_dir_ipgen")
+            if code_gen_dir == "":
+                log.warning(
+                    """Could not find report files, values will be set to zero
+                    for this node. Please run "PrepareIP" transformation and
+                    "HLSSynthIP" first to generate the report files"""
+                )
+            else:
+                xmlfile = "{}/project_{}/sol1/syn/report/{}_csynth.xml".format(
+                    code_gen_dir, node.name, node.name
+                )
+
+                if os.path.isfile(xmlfile):
+                    tree = ET.parse(xmlfile)
+                    root = tree.getroot()
+                    for item in root.findall("AreaEstimates/Resources"):
+                        for child in item:
+                            if child.text is not None:
+                                res_dict[node.name][child.tag] = int(child.text)
+                else:
+                    log.warning(
+                        """Could not find report files, values will be set to zero
+                        for this node. Please run "PrepareIP" transformation and
+                        "HLSSynthIP" first to generate the report files"""
+                    )
+    return res_dict

finn/analysis/fpgadataflow/op_and_param_counts.py

@@ -0,0 +1,60 @@
+# Copyright (c) 2020, Xilinx
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of FINN nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import qonnx.custom_op.registry as registry
+from qonnx.util.basic import is_finn_op
+
+
+def aggregate_dict_keys(res_dict):
+    total_dict = {}
+    for layer in res_dict:
+        layer_res_dict = res_dict[layer]
+        for r_type in layer_res_dict.keys():
+            if "efficiency" in r_type:
+                continue
+            r_amount = layer_res_dict[r_type]
+            r_amount = float(r_amount)
+            if r_type in total_dict.keys():
+                total_dict[r_type] += r_amount
+            else:
+                total_dict[r_type] = r_amount
+    return total_dict
+
+
+def op_and_param_counts(model):
+    """Return per-node and aggregate op counts per inference."""
+
+    ret_dict = {}
+    for node in model.graph.node:
+        if is_finn_op(node.domain):
+            inst = registry.getCustomOp(node)
+            if hasattr(inst, "get_op_and_param_counts"):
+                node_op_and_param_counts = inst.get_op_and_param_counts()
+                ret_dict[node.name] = node_op_and_param_counts
+    ret_dict["total"] = aggregate_dict_keys(ret_dict)
+    return ret_dict

finn/analysis/fpgadataflow/post_synth_res.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2020, Xilinx, Inc.
+# Copyright (C) 2024, Advanced Micro Devices, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of FINN nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import os
+import xml.etree.ElementTree as ET
+from qonnx.core.modelwrapper import ModelWrapper
+from qonnx.custom_op.registry import getCustomOp
+
+from finn.util.fpgadataflow import is_hls_node, is_rtl_node
+
+
+def post_synth_res(model, override_synth_report_filename=None):
+    """Extracts the FPGA resource results from the Vivado synthesis.
+    Ensure that all nodes have unique names (by calling the GiveUniqueNodeNames
+    transformation) prior to calling this analysis pass to ensure all nodes are
+    visible in the results.
+
+    Returns {node name : resources_dict}."""
+
+    res_dict = {}
+    if override_synth_report_filename is not None:
+        synth_report_filename = override_synth_report_filename
+    else:
+        synth_report_filename = model.get_metadata_prop("vivado_synth_rpt")
+    if os.path.isfile(synth_report_filename):
+        tree = ET.parse(synth_report_filename)
+        root = tree.getroot()
+        all_cells = root.findall(".//tablecell")
+        # strip all whitespace from table cell contents
+        for cell in all_cells:
+            cell.attrib["contents"] = cell.attrib["contents"].strip()
+    else:
+        raise Exception("Please run synthesis first")
+
+    restype_to_ind_default = {
+        "LUT": 2,
+        "SRL": 5,
+        "FF": 6,
+        "BRAM_36K": 7,
+        "BRAM_18K": 8,
+        "DSP": 10,
+    }
+    restype_to_ind_vitis = {
+        "LUT": 4,
+        "SRL": 7,
+        "FF": 8,
+        "BRAM_36K": 9,
+        "BRAM_18K": 10,
+        "URAM": 11,
+        "DSP": 12,
+    }
+
+    # format: (human_readable_name_in_report, canonical_name)
+    res_types_to_search = [
+        ("Total LUTs", "LUT"),
+        ("SRLs", "SRL"),
+        ("FFs", "FF"),
+        ("RAMB36", "BRAM_36K"),
+        ("RAMB18", "BRAM_18K"),
+        ("URAM", "URAM"),
+        ("DSP Blocks", "DSP"),
+    ]
+
+    # try to infer resource type to table index by
+    # looking at the names in headings
+    header_row = root.findall(".//*[@contents='Instance']/..")
+    if header_row != []:
+        headers = [x.attrib["contents"] for x in list(header_row[0])]
+        restype_to_ind = {}
+        for res_type_name, res_type in res_types_to_search:
+            if res_type_name in headers:
+                restype_to_ind[res_type] = headers.index(res_type_name)
+    else:
+        # could not infer resource types from header
+        # fall back to default indices
+        if model.get_metadata_prop("platform") == "alveo":
+            restype_to_ind = restype_to_ind_vitis
+        else:
+            restype_to_ind = restype_to_ind_default
+
+    def get_instance_stats(inst_name):
+        row = root.findall(".//*[@contents='%s']/.." % inst_name)
+        if row != []:
+            node_dict = {}
+            row = list(row[0])
+            for restype, ind in restype_to_ind.items():
+                node_dict[restype] = int(row[ind].attrib["contents"])
+            return node_dict
+        else:
+            return None
+
+    # global (top-level) stats, including shell etc.
+    top_dict = get_instance_stats("(top)")
+    if top_dict is not None:
+        res_dict["(top)"] = top_dict
+
+    for node in model.graph.node:
+        if node.op_type == "StreamingDataflowPartition":
+            sdp_model = ModelWrapper(getCustomOp(node).get_nodeattr("model"))
+            sdp_res_dict = post_synth_res(sdp_model, synth_report_filename)
+            res_dict.update(sdp_res_dict)
+        elif is_hls_node(node) or is_rtl_node(node):
+            node_dict = get_instance_stats(node.name)
+            if node_dict is not None:
+                res_dict[node.name] = node_dict
+
+    return res_dict

finn/analysis/fpgadataflow/res_estimation.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2020, Xilinx
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of FINN nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import qonnx.custom_op.registry as registry
+
+from finn.util.fpgadataflow import is_hls_node, is_rtl_node
+
+
+def res_estimation(model, fpgapart):
+    """Estimates the resources needed for the given model.
+    Ensure that all nodes have unique names (by calling the GiveUniqueNodeNames
+    transformation) prior to calling this analysis pass to ensure all nodes are
+    visible in the results.
+
+    Returns {node name : resource estimation}."""
+
+    res_dict = {}
+    for node in model.graph.node:
+        if is_hls_node(node) or is_rtl_node(node):
+            inst = registry.getCustomOp(node)
+            res_dict[node.name] = inst.node_res_estimation(fpgapart)
+
+    return res_dict
+
+
+def res_estimation_complete(model, fpgapart):
+    """Estimates the resources needed for the given model and all values for
+    resource-related switches.
+    Ensure that all nodes have unique names (by calling the GiveUniqueNodeNames
+    transformation) prior to calling this analysis pass to ensure all nodes are
+    visible in the results.
+
+    Returns {node name : [resource estimation(s)]}."""
+
+    res_dict = {}
+    for node in model.graph.node:
+        if is_hls_node(node) or is_rtl_node(node):
+            inst = registry.getCustomOp(node)
+            op_type = node.op_type
+            if op_type.startswith("MVAU") or op_type.startswith("VVAU"):
+                orig_restype = inst.get_nodeattr("resType")
+                res_dict[node.name] = []
+                inst.set_nodeattr("resType", "dsp")
+                res_dict[node.name].append(inst.node_res_estimation(fpgapart))
+                inst.set_nodeattr("resType", "lut")
+                res_dict[node.name].append(inst.node_res_estimation(fpgapart))
+                inst.set_nodeattr("resType", orig_restype)
+            elif op_type.startswith("ConvolutionInputGenerator"):
+                orig_ramstyle = inst.get_nodeattr("ram_style")
+                res_dict[node.name] = []
+                inst.set_nodeattr("ram_style", "block")
+                res_dict[node.name].append(inst.node_res_estimation(fpgapart))
+                inst.set_nodeattr("ram_style", "distributed")
+                res_dict[node.name].append(inst.node_res_estimation(fpgapart))
+                inst.set_nodeattr("ram_style", "ultra")
+                res_dict[node.name].append(inst.node_res_estimation(fpgapart))
+                inst.set_nodeattr("ram_style", orig_ramstyle)
+            else:
+                res_dict[node.name] = [inst.node_res_estimation(fpgapart)]
+
+    return res_dict

finn/analysis/verify_custom_nodes.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2020, Xilinx
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of FINN nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import qonnx.custom_op.registry as registry
+from qonnx.util.basic import is_finn_op
+
+
+def verify_nodes(model):
+    """Checks if custom ops in graph are correctly built, with all attributes
+    and inputs. Please note that many FINN CustomOps don't yet implement the
+    verify_node function required for this analysis pass to work correctly.
+
+    Returns {node op_type : info_messages}
+
+    * info_messages: is list of strings about the result of the verification."""
+
+    verification_dict = {}
+    for node in model.graph.node:
+        if is_finn_op(node.domain):
+            op_type = node.op_type
+            inst = registry.getCustomOp(node)
+            verification_dict[op_type] = inst.verify_node()
+
+    return verification_dict