najaeda 0.1.12__cp310-cp310-macosx_11_0_arm64.whl → 0.1.14__cp310-cp310-macosx_11_0_arm64.whl

najaeda/native/stats.py

@@ -0,0 +1,341 @@
+# SPDX-FileCopyrightText: 2024 The Naja authors <https://github.com/najaeda/naja/blob/main/AUTHORS>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import os
+from naja import snl
+
+
+class DesignsStats:
+    def __init__(self):
+        self.blackboxes = dict()
+        self.hier_designs = dict()
+
+
+class DesignStats:
+    def __init__(self):
+        self.name = ""
+        self.assigns = 0
+        self.flat_assigns = 0
+        self.basic_primitives = dict()
+        self.primitives = dict()
+        self.flat_basic_primitives = dict()
+        self.flat_primitives = dict()
+        self.blackboxes = dict()
+        self.flat_blackboxes = dict()
+        self.ins = dict()
+        self.flat_ins = dict()
+        self.terms = dict()
+        self.bit_terms = dict()
+        self.net_stats = dict()
+
+    def add_ins_stats(self, ins_stats):
+        self.flat_assigns += ins_stats.flat_assigns
+        for ins, nb in ins_stats.flat_ins.items():
+            self.flat_ins[ins] = self.flat_ins.get(ins, 0) + nb
+        for ins, nb in ins_stats.flat_blackboxes.items():
+            self.flat_blackboxes[ins] = self.flat_blackboxes.get(ins, 0) + nb
+        for primitive, nb in ins_stats.flat_primitives.items():
+            self.flat_primitives[primitive] = (
+                self.flat_primitives.get(primitive, 0) + nb
+            )
+        for primitive, nb in ins_stats.flat_basic_primitives.items():
+            self.flat_basic_primitives[primitive] = (
+                self.flat_basic_primitives.get(primitive, 0) + nb
+            )
+
+
+def isBasicPrimitive(design):
+    return design.isConst0() or design.isConst1() or design.isBuf() or design.isInv()
+
+
+def compute_design_stats(design, designs_stats):
+    if design in designs_stats.hier_designs:
+        return designs_stats.hier_designs.get(design)
+    design_stats = DesignStats()
+    design_stats.name = design.getName()
+    for ins in design.getInstances():
+        model = ins.getModel()
+        if model.isAssign():
+            design_stats.assigns += 1
+            design_stats.flat_assigns += 1
+        elif model.isPrimitive():
+            if isBasicPrimitive(model):
+                design_stats.basic_primitives[model] = (
+                    design_stats.basic_primitives.get(model, 0) + 1
+                )
+                design_stats.flat_basic_primitives[model] = (
+                    design_stats.flat_basic_primitives.get(model, 0) + 1
+                )
+            else:
+                design_stats.primitives[model] = (
+                    design_stats.primitives.get(model, 0) + 1
+                )
+                design_stats.flat_primitives[model] = (
+                    design_stats.flat_primitives.get(model, 0) + 1
+                )
+        elif model.isBlackBox():
+            design_stats.blackboxes[model] = design_stats.blackboxes.get(model, 0) + 1
+            design_stats.flat_blackboxes[model] = (
+                design_stats.flat_blackboxes.get(model, 0) + 1
+            )
+            if model not in designs_stats.blackboxes:
+                designs_stats.blackboxes[model] = dict()
+                compute_design_terms(model, designs_stats.blackboxes[model])
+        else:
+            if model in designs_stats.hier_designs:
+                model_stats = designs_stats.hier_designs[model]
+            else:
+                model_stats = compute_design_stats(model, designs_stats)
+            design_stats.ins[model] = design_stats.ins.get(model, 0) + 1
+            design_stats.flat_ins[model] = design_stats.flat_ins.get(model, 0) + 1
+            design_stats.add_ins_stats(model_stats)
+    compute_design_terms(design, design_stats)
+    compute_design_net_stats(design, design_stats)
+    designs_stats.hier_designs[design] = design_stats
+    return design_stats
+
+
+def compute_design_terms(design, design_stats):
+    for term in design.getTerms():
+        if term.getDirection() == snl.SNLTerm.Direction.Input:
+            design_stats.terms["inputs"] = design_stats.terms.get("inputs", 0) + 1
+            bit_terms = sum(1 for _ in term.getBits())
+            design_stats.bit_terms["inputs"] = (
+                design_stats.bit_terms.get("inputs", 0) + bit_terms
+            )
+        elif term.getDirection() == snl.SNLTerm.Direction.Output:
+            design_stats.terms["outputs"] = design_stats.terms.get("outputs", 0) + 1
+            bit_terms = sum(1 for _ in term.getBits())
+            design_stats.bit_terms["outputs"] = (
+                design_stats.bit_terms.get("outputs", 0) + bit_terms
+            )
+        elif term.getDirection() == snl.SNLTerm.Direction.InOut:
+            design_stats.terms["inouts"] = design_stats.terms.get("inouts", 0) + 1
+            bit_terms = sum(1 for _ in term.getBits())
+            design_stats.bit_terms["inouts"] = (
+                design_stats.bit_terms.get("inouts", 0) + bit_terms
+            )
+        else:
+            design_stats.terms["unknowns"] = design_stats.terms.get("unknowns", 0) + 1
+            bit_terms = sum(1 for _ in term.getBits())
+            design_stats.bit_terms["unknowns"] = (
+                design_stats.bit_terms.get("unknowns", 0) + bit_terms
+            )
+
+
+def compute_design_net_stats(design, design_stats):
+    for net in design.getBitNets():
+        if net.isConstant():
+            pass
+        nb_components = sum(1 for c in net.getComponents())
+        design_stats.net_stats[nb_components] = (
+            design_stats.net_stats.get(nb_components, 0) + 1
+        )
+        design_stats.net_stats = dict(sorted(design_stats.net_stats.items()))
+
+
+def dump_instances(stats_file, title, instances):
+    if len(instances) == 0:
+        return
+    sorted_instances = sorted(instances.items(), key=lambda item: item[0].getName())
+    stats_file.write(title + " " + str(sum(j for i, j in sorted_instances)) + "\n")
+    line_char = 0
+    for instance in sorted_instances:
+        if line_char != 0:
+            stats_file.write(",")
+            line_char += 1
+        if line_char > 80:
+            stats_file.write("\n")
+            line_char = 0
+        elif line_char != 0:
+            stats_file.write(" ")
+            line_char += 1
+        instance_char = instance[0].getName() + ":" + str(instance[1])
+        line_char += len(instance_char)
+        stats_file.write(instance_char)
+    stats_file.write("\n\n")
+
+
+def dump_blackboxes_stats(stats_file, design_stats):
+    if len(design_stats.blackboxes) > 0:
+        stats_file.write("*** BlackBoxes ***\n")
+        for bbox in design_stats.blackboxes.items():
+            design = bbox[0]
+            design_terms = bbox[1]
+            stats_file.write("*** " + design.getName() + " ***\n")
+            if len(design_terms) > 0:
+                stats_file.write("Terms: ")
+                first = True
+                for terms in design_terms.items():
+                    if not first:
+                        stats_file.write(", ")
+                    else:
+                        first = False
+                    stats_file.write(terms[0] + ":" + str(terms[1]))
+                stats_file.write("\n")
+            stats_file.write("\n")
+
+
+def dump_stats(design, stats_file, designs_stats, dumped_models):
+    if design.isPrimitive() or design.isBlackBox():
+        return
+    if design in dumped_models:
+        return
+    dumped_models.add(design)
+    stats_file.write("*** " + design.getName() + " ***\n")
+    design_stats = designs_stats.hier_designs.get(design)
+    if design_stats is None:
+        print("Cannot find " + str(design) + " in design_stats")
+        raise
+    if len(design_stats.terms) > 0:
+        stats_file.write("Terms: ")
+        first = True
+        for terms in design_stats.terms.items():
+            if not first:
+                stats_file.write(", ")
+            else:
+                first = False
+            stats_file.write(terms[0] + ":" + str(terms[1]))
+        stats_file.write("\n")
+
+    dump_instances(stats_file, "Instances:", design_stats.ins)
+    nb_primitives = sum(design_stats.basic_primitives.values()) + sum(
+        design_stats.primitives.values()
+    )
+    if nb_primitives > 1:
+        stats_file.write("Primitives: " + str(nb_primitives) + "\n")
+    dump_instances(stats_file, "Simple Primitives:", design_stats.basic_primitives)
+    dump_instances(stats_file, "Other Primitives:", design_stats.primitives)
+    dump_instances(stats_file, "Blackboxes:", design_stats.blackboxes)
+    if design_stats.assigns > 0:
+        stats_file.write("Assigns: " + str(design_stats.assigns) + "\n")
+    dump_instances(stats_file, "Flat Instances:", design_stats.flat_ins)
+    dump_instances(stats_file, "Flat Blackboxes:", design_stats.flat_blackboxes)
+    nb_primitives = sum(design_stats.flat_basic_primitives.values()) + sum(
+        design_stats.flat_primitives.values()
+    )
+    if nb_primitives > 1:
+        stats_file.write("Flat Primitives: " + str(nb_primitives) + "\n")
+    dump_instances(
+        stats_file, "Flat Simple Primitives:", design_stats.flat_basic_primitives
+    )
+    dump_instances(stats_file, "Flat Other Primitives:", design_stats.flat_primitives)
+    if design_stats.flat_assigns > 0:
+        stats_file.write("Flat Assigns: " + str(design_stats.flat_assigns) + "\n")
+    stats_file.write("\n")
+    for ins in design.getInstances():
+        model = ins.getModel()
+        dump_stats(model, stats_file, designs_stats, dumped_models)
+
+
+def dump_pandas(designs_stats):
+    import pandas
+    import matplotlib.pyplot as plt
+
+    # create a figures directory erase the previous one
+    if os.path.exists("figures"):
+        import shutil
+
+        shutil.rmtree("figures")
+    os.makedirs("figures")
+
+    data = []
+    for design, design_stats in designs_stats.hier_designs.items():
+        data.append(
+            [
+                design.getName(),
+                sum(design_stats.terms.values()),
+                sum(design_stats.bit_terms.values()),
+                sum(design_stats.basic_primitives.values()),
+                sum(design_stats.primitives.values()),
+                sum(design_stats.blackboxes.values()),
+                sum(design_stats.ins.values()),
+                sum(design_stats.flat_ins.values()),
+                sum(design_stats.flat_blackboxes.values()),
+                sum(design_stats.flat_basic_primitives.values()),
+                sum(design_stats.flat_primitives.values()),
+            ]
+        )
+    df = pandas.DataFrame(
+        data,
+        columns=[
+            "Design",
+            "Terms",
+            "Bit Terms",
+            "Basic Primitives",
+            "Primitives",
+            "Blackboxes",
+            "Instances",
+            "Flat Instances",
+            "Flat Blackboxes",
+            "Flat Basic Primitives",
+            "Flat Primitives",
+        ],
+    )
+    df.to_csv("figures/designs_stats.csv", index=False)
+
+    net_series = pandas.Series(design_stats.net_stats)
+    nets_plot = net_series.plot(
+        kind="bar",
+        title="Number of nets with a given number of components for\n"
+        + design.getName(),
+        xlabel="number of components",
+        ylabel="number of nets",
+    )
+    nets_plot.set_yscale("log")
+    nets_plot.xaxis.set_major_locator(plt.MaxNLocator(100))
+    nets_figure = nets_plot.get_figure()
+    nets_figure.tight_layout()
+    nets_figure.savefig("figures/nets_" + design.getName() + ".png")
+
+    flat_primitives_series = pandas.Series(design_stats.flat_primitives)
+    primitives_plot = flat_primitives_series.plot(
+        kind="bar",
+        title="Number of  primitives for\n" + design.getName(),
+        xlabel="primitive",
+        ylabel="number of flat instances",
+    )
+    primitives_plot.set_yscale("log")
+    primitives_figure = primitives_plot.get_figure()
+    primitives_figure.tight_layout()
+    primitives_figure.savefig("figures/flat_primitives_" + design.getName() + ".png")
+
+
+def compute_and_dump_design_stats(design, stats_file, with_pandas=False):
+    designs_stats = DesignsStats()
+    compute_design_stats(design, designs_stats)
+    dumped_models = set()
+    dump_stats(design, stats_file, designs_stats, dumped_models)
+    dump_blackboxes_stats(stats_file, designs_stats)
+    if with_pandas:
+        dump_pandas(designs_stats)
+
+
+def dump_constants(design, analyzed_models):
+    if design.isPrimitive():
+        return
+    if design in analyzed_models:
+        return
+    analyzed_models.add(design)
+    for bitnet in design.getBitNets():
+        if bitnet.isConstant():
+            logging.info(
+                "In design "
+                + design.getName()
+                + ", constant net "
+                + bitnet.getName()
+                + " of type "
+                + bitnet.getTypeAsString()
+            )
+            if all(False for _ in bitnet.getComponents()):
+                logging.info(" with zero connections\n")
+            else:
+                logging.info(" connected to:\n")
+                for component in bitnet.getComponents():
+                    logging.info(str(component) + "\n")
+
+    for ins in design.getInstances():
+        model = ins.getModel()
+        dump_constants(model, analyzed_models)

najaeda/net_visitor.py

@@ -0,0 +1,53 @@
+# SPDX-FileCopyrightText: 2024 The Naja authors
+# <https://github.com/najaeda/naja/blob/main/AUTHORS>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# from typing import Callable
+# from najaeda import netlist
+#
+#
+# class VisitorConfig:
+#     def __init__(
+#         self,
+#         enter_condition: Callable[[netlist.Instance], bool] = lambda node: True,
+#         callback: Callable[..., None] = lambda node, *args, **kwargs: None,
+#         args: tuple = (),
+#         kwargs: dict = None,
+#     ):
+#         """
+#         :param enter_condition: A callable that takes a node (dict)
+#             and returns True if the visitor should enter.
+#         :param callback: A callable that takes a node (dict) and performs an operation on it.
+#         :param args: Positional arguments to pass to the callback.
+#         :param kwargs: Keyword arguments to pass to the callback.
+#         """
+#         self.enter_condition = enter_condition
+#         self.callback = callback
+#         self.args = args
+#         self.kwargs = kwargs or {}
+#
+#
+# def visit(equipotential: netlist.Equipotential, config: VisitorConfig):
+#     """Recursively visits nodes in the netlist hierarchy.
+#
+#     :param instance: The current node in the netlist instance hierarchy.
+#     :param config: VisitorConfig object defining conditions and callbacks.
+#     """
+#     # Execute the callback
+#     config.callback(equipotential, *config.args, **config.kwargs)
+#
+#     # Check if we should proceed to children
+#     if config.enter_condition(equipotential):
+#         for component in equipotential.get .get_child_instances():
+#             visit(child, config)
+#
+# def visit(term: netlist.Term, config: VisitorConfig):
+#     config.callback(term, *config.args, **config.kwargs)
+#
+#     #get the corresponding iterms
+#     instance = term.get_instance()
+#     if instance is not None:
+#         for iterm in instance.get_iterms():
+#             visit(iterm, config)
+#

najaeda/netlist.py

@@ -8,11 +8,16 @@ import time
 import logging
 import hashlib
 import struct
+import sys
 from enum import Enum
 
 from najaeda import snl
 
 
+def get_none_existent():
+    return sys.maxsize
+
+
 def consistent_hash(obj):
     def default_serializer(o):
         if isinstance(o, (str, int, float, bool, type(None))):
@@ -40,14 +45,14 @@ def consistent_hash(obj):
 
 
 def get_snl_instance_from_id_list(id_list: list) -> snl.SNLInstance:
-    top = snl.SNLUniverse.get().getTopDesign()
-    design = top
-    instance = None
-    for id in id_list:
-        instance = design.getInstanceByID(id)
-        assert instance is not None
-        design = instance.getModel()
-    return instance
+    design = snl.SNLUniverse.get().getTopDesign()
+    # instance = None
+    # for id in id_list:
+    #     instance = design.getInstanceByID(id)
+    #     assert instance is not None
+    #     design = instance.getModel()
+    # return instance
+    return design.getInstanceByIDList(id_list)
 
 
 def get_snl_path_from_id_list(id_list: list) -> snl.SNLPath:
@@ -71,7 +76,8 @@ class Equipotential:
     """
 
     def __init__(self, term):
-        snl_term = get_snl_term_for_ids(term.pathIDs, term.termIDs)
+        path = get_snl_path_from_id_list(term.pathIDs)
+        snl_term = get_snl_term_for_ids_with_path(path, term.termIDs)
         inst_term = None
         if isinstance(snl_term, snl.SNLBusTerm):
             raise ValueError("Equipotential cannot be constructed on bus term")
@@ -85,10 +91,10 @@ class Equipotential:
                 self.equi = None
                 return
             else:
+                path = snl.SNLPath(path, get_snl_instance_from_id_list(inst_term.pathIDs))
                 snl_term = get_snl_term_for_ids(inst_term.pathIDs, inst_term.termIDs)
         else:
             inst_term = term
-        path = get_snl_path_from_id_list(inst_term.pathIDs)
         ito = snl.SNLNetComponentOccurrence(
             path.getHeadPath(), path.getTailInstance().getInstTerm(snl_term)
         )
@@ -109,10 +115,10 @@ class Equipotential:
         """
         if self.equi is not None:
             for term in self.equi.getInstTermOccurrences():
-                yield Term(
-                    snl.SNLPath(term.getPath(), term.getInstTerm().getInstance()),
-                    term.getInstTerm().getBitTerm(),
-                )
+                path = term.getPath().getPathIDs()
+                path.append(term.getInstTerm().getInstance().getID())
+                yield Term(path,
+                    term.getInstTerm().getBitTerm())
 
     def get_top_terms(self):
         """Iterate over the top terminals of this equipotential.
@@ -130,12 +136,10 @@ class Equipotential:
                 direction = term.getInstTerm().getDirection()
                 if direction != snl.SNLTerm.Direction.Output:
                     if term.getInstTerm().getInstance().getModel().isLeaf():
-                        yield Term(
-                            snl.SNLPath(
-                                term.getPath(), term.getInstTerm().getInstance()
-                            ),
-                            term.getInstTerm().getBitTerm(),
-                        )
+                        path = term.getPath().getPathIDs()
+                        path.append(term.getInstTerm().getInstance().getID())
+                        yield Term(path,
+                            term.getInstTerm().getBitTerm())
 
     def get_leaf_drivers(self):
         if self.equi is not None:
@@ -143,26 +147,24 @@ class Equipotential:
                 direction = term.getInstTerm().getDirection()
                 if direction != snl.SNLTerm.Direction.Input:
                     if term.getInstTerm().getInstance().getModel().isLeaf():
-                        yield Term(
-                            snl.SNLPath(
-                                term.getPath(), term.getInstTerm().getInstance()
-                            ),
-                            term.getInstTerm().getBitTerm(),
-                        )
+                        path = term.getPath().getPathIDs()
+                        path.append(term.getInstTerm().getInstance().getID())
+                        yield Term(path,
+                            term.getInstTerm().getBitTerm())
 
     def get_top_readers(self):
         if self.equi is not None:
             for term in self.equi.getTerms():
                 direction = term.getDirection()
                 if direction != snl.SNLTerm.Direction.Input:
-                    yield Term(snl.SNLPath(), term)
+                    yield Term([], term)
 
     def get_top_drivers(self):
         if self.equi is not None:
             for term in self.equi.getTerms():
                 direction = term.getDirection()
                 if direction != snl.SNLTerm.Direction.Output:
-                    yield Term(snl.SNLPath(), term)
+                    yield Term([], term)
 
 
 class Net:
@@ -343,10 +345,11 @@ class Net:
         """
         if hasattr(self, "net_concat"):
             raise ValueError("Cannot get inst terms from a net_concat")
+        path = self.pathIDs.copy()
         for term in self.net.getInstTerms():
-            path = self.pathIDs.copy()
             path.append(term.getInstance().getID())
             yield Term(path, term.getBitTerm())
+            path.pop()
 
     def get_design_terms(self):
         """
@@ -374,12 +377,28 @@ def get_snl_term_for_ids(pathIDs, termIDs):
         model = snl.SNLUniverse.get().getTopDesign()
     else:
         model = path.getTailInstance().getModel()
-    if termIDs[1] == -1:
+    if termIDs[1] == get_none_existent():
+        return model.getTermByID(termIDs[0])
+    else:
+        snlterm = model.getTermByID(termIDs[0])
+        if isinstance(snlterm, snl.SNLBusTerm):
+            return snlterm.getBusTermBit(termIDs[1])
+        else:
+            return snlterm
+
+
+def get_snl_term_for_ids_with_path(path, termIDs):
+    model = None
+    if path.size() == 0:
+        model = snl.SNLUniverse.get().getTopDesign()
+    else:
+        model = path.getTailInstance().getModel()
+    if termIDs[1] == get_none_existent():
         return model.getTermByID(termIDs[0])
     else:
         snlterm = model.getTermByID(termIDs[0])
         if isinstance(snlterm, snl.SNLBusTerm):
-            return snlterm.getBit(termIDs[1])
+            return snlterm.getBusTermBit(termIDs[1])
         else:
             return snlterm
 
@@ -390,19 +409,12 @@ class Term:
     INOUT = snl.SNLTerm.Direction.InOut
 
     def __init__(self, path, term):
-        self.termIDs = []
-        if isinstance(term, snl.SNLBusTerm):
-            self.termIDs = [term.getID(), -1]
-        else:
-            self.termIDs = [term.getID(), term.getBit()]
-
-        if isinstance(path, snl.SNLPath):
-            if path.size() > 0:
-                self.pathIDs = path.getPathIDs()
-            else:
-                self.pathIDs = []
-        elif isinstance(path, list):
-            self.pathIDs = path.copy()
+        # self.termIDs = []
+        # if isinstance(term, snl.SNLBusTerm):
+        #     self.termIDs = [term.getID(), -1]
+        # else:
+        self.termIDs = [term.getID(), term.getBit()]
+        self.pathIDs = path.copy()
 
     def __eq__(self, other) -> bool:
         return self.pathIDs == other.pathIDs and self.termIDs == other.termIDs
@@ -434,13 +446,19 @@ class Term:
         return consistent_hash((self.pathIDs, termIDs))
 
     def __str__(self):
+        term_str = ""
         path = get_snl_path_from_id_list(self.pathIDs)
         if path.size() == 0:
-            return get_snl_term_for_ids(self.pathIDs, self.termIDs).getName()
+            term_str = get_snl_term_for_ids(self.pathIDs, self.termIDs).getName()
         else:
-            return (
+            term_str = (
                 f"{path}/{get_snl_term_for_ids(self.pathIDs, self.termIDs).getName()}"
             )
+        if self.is_bus:
+            term_str += f"[{self.get_msb()}:{self.get_lsb()}]"
+        elif self.is_bus_bit:
+            term_str += f"[{self.get_lsb()}]"
+        return term_str
 
     def __repr__(self) -> str:
         path = get_snl_path_from_id_list(self.pathIDs)
@@ -486,6 +504,17 @@ class Term:
         """
         return self.is_scalar() or self.is_bus_bit()
 
+    def get_bit_number(self):
+        """
+        :return: the bit index of the term if it is a bit.
+        :rtype: int or None
+        """
+        if isinstance(
+            get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTermBit
+        ):
+            return get_snl_term_for_ids(self.pathIDs, self.termIDs).getBit()
+        return None
+
     def get_msb(self) -> int:
         """
         :return: the most significant bit of the term if it is a bus.
@@ -651,7 +680,7 @@ class Term:
         if isinstance(get_snl_term_for_ids(self.pathIDs, self.termIDs), snl.SNLBusTerm):
             return Term(
                 self.pathIDs,
-                get_snl_term_for_ids(self.pathIDs, self.termIDs).getBit(index),
+                get_snl_term_for_ids(self.pathIDs, self.termIDs).getBusTermBit(index),
             )
         return None
 
@@ -754,13 +783,23 @@ class Instance:
     """
 
     def __init__(self, path=snl.SNLPath()):
+        self.inst = None
+        self.revisionCount = 0
+        self.SNLID = [0, 0, 0, 0, 0, 0]
         if isinstance(path, snl.SNLPath):
             if path.size() > 0:
                 self.pathIDs = path.getPathIDs()
+                self.revisionCount = path.getTailInstance().getModel().getRevisionCount()
+                self.inst = path.getTailInstance()
             else:
                 self.pathIDs = []
         elif isinstance(path, list):
             self.pathIDs = path.copy()
+            if len(path) > 0:
+                self.inst = get_snl_instance_from_id_list(path)
+                self.revisionCount = self.inst.getModel().getRevisionCount()
+        if self.inst is not None:
+            self.SNLID = self.inst.getModel().getSNLID()
 
     def __eq__(self, other) -> bool:
         return self.pathIDs == other.pathIDs
@@ -872,11 +911,24 @@ class Instance:
         """
         return self.__get_snl_model().isInv()
 
+    def is_basic_primitive(instance):
+        design = instance.__get_snl_model()
+        return (
+            design.isConst0() or design.isConst1() or design.isBuf() or design.isInv()
+        )
+
     def __get_snl_model(self):
         if self.is_top():
             return snl.SNLUniverse.get().getTopDesign()
-        instance = get_snl_instance_from_id_list(self.pathIDs)
-        return instance.getModel()
+        if (
+            self.inst.getModel().getRevisionCount() != self.revisionCount or
+            self.inst.getModel().getSNLID() != self.SNLID
+        ):
+            self.inst = get_snl_instance_from_id_list(self.pathIDs)
+            self.revisionCount = self.inst.getModel().getRevisionCount()
+            self.SNLID = self.inst.getModel().getSNLID()
+
+        return self.inst.getModel()
 
     def __get_leaf_snl_object(self):
         if self.is_top():
@@ -919,10 +971,11 @@ class Instance:
         :return: an iterator over the child instances of this instance.
         :rtype: Iterator[Instance]
         """
+        path = get_snl_path_from_id_list(self.pathIDs)
         for inst in self.__get_snl_model().getInstances():
-            path = self.pathIDs.copy()
-            path.append(inst.getID())
-            yield Instance(path)
+            path_child = snl.SNLPath(path, inst)
+            yield Instance(path_child)
+            # path.pop()
 
     def get_number_of_child_instances(self) -> int:
         """
@@ -1181,7 +1234,7 @@ class Instance:
             path = get_snl_path_from_id_list(self.pathIDs)
         design = self.__get_snl_model()
         newSNLTerm = snl.SNLScalarTerm.create(design, direction, name)
-        return Term(path, newSNLTerm)
+        return Term(path.getPathIDs(), newSNLTerm)
 
     def create_output_term(self, name: str) -> Term:
         """Create an output Term in this Instance with the given name.
@@ -1222,10 +1275,9 @@ class Instance:
         path = get_snl_path_from_id_list(self.pathIDs)
         if path.size() > 0:
             snl.SNLUniquifier(path)
-            path = get_snl_path_from_id_list(self.pathIDs)
         design = self.__get_snl_model()
         newSNLTerm = snl.SNLBusTerm.create(design, direction, msb, lsb, name)
-        return Term(path, newSNLTerm)
+        return Term(self.pathIDs, newSNLTerm)
 
     def create_inout_bus_term(self, name: str, msb: int, lsb: int) -> Term:
         """Create an inout bus Term in this Instance with the given name, msb and lsb.
@@ -1300,6 +1352,13 @@ class Instance:
         """
         self.__get_snl_model().dumpVerilog(path, name)
 
+    def get_truth_table(self):
+        """
+        :return: the truth table of the instance.
+        :rtype: list[str]
+        """
+        return self.__get_snl_model().getTruthTable()
+
 
 def get_top_db() -> snl.SNLDB:
     if snl.SNLUniverse.get() is None:
@@ -1334,10 +1393,17 @@ def create_top(name: str) -> Instance:
     return Instance()
 
 
-def load_verilog(files: list):
+class VerilogConfig:
+    def __init__(self, keep_assigns=True):
+        self.keep_assigns = keep_assigns
+
+
+def load_verilog(files: list, config: VerilogConfig = None) -> Instance:
+    if config is None:
+        config = VerilogConfig()  # Use default settings
     start_time = time.time()
     logging.info(f"Loading verilog: {', '.join(files)}")
-    get_top_db().loadVerilog(files)
+    get_top_db().loadVerilog(files, keep_assigns=config.keep_assigns)
     execution_time = time.time() - start_time
     logging.info(f"Loading done in {execution_time:.2f} seconds")
     return get_top()

najaeda/primitives/xilinx.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import logging
 from najaeda import snl
 
 
@@ -426,6 +427,7 @@ def constructRAMB36E1(lib):
 
 
 def load(db):
+    logging.info("Loading Xilinx primitives")
     lib = snl.SNLLibrary.createPrimitives(db, "xilinx")
     constructIBUF(lib)
     constructOBUF(lib)

najaeda/stats.py

@@ -150,10 +150,8 @@ class InstanceStats:
             )
 
 
-def is_basic_primitive(design):
-    return (
-        design.is_const0() or design.is_const1() or design.is_buf() or design.is_inv()
-    )
+def is_basic_primitive(instance):
+    return instance.is_basic_primitive()
 
 
 def compute_instance_stats(instance, instances_stats):

{najaeda-0.1.12.dist-info → najaeda-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: najaeda
-Version: 0.1.12
+Version: 0.1.14
 Summary: Naja EDA Python package
 Author-Email: Naja Authors <contact@keplertech.io>
 License: Apache License 2.0

{najaeda-0.1.12.dist-info → najaeda-0.1.14.dist-info}/RECORD

@@ -1,11 +1,14 @@
-najaeda/netlist.py,sha256=8p0iHWDNbsMo-DndUBKLc43j7agtgb_jhlQdgkoYpvU,46750
-najaeda/libnaja_snl_python.dylib,sha256=cipIwCgVc5N4CO9KfFA0v8hbHfwIpB5A4wNfoQfq--Q,825616
+najaeda/netlist.py,sha256=FadEyKqZMS5cGzDt-WOZRmDcDc3dFFvQSw2iJusW7Y0,49236
+najaeda/libnaja_snl_python.dylib,sha256=xF5MVZMKtWkwiyvigZdTYCOsTH8M9abFn07YWx6C9Fw,887680
 najaeda/pandas_stats.py,sha256=yOb4ka965U7rN4D6AwvSGmRyeT_O7Ed-5cmT8BFbfeo,1070
 najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-najaeda/libnaja_snl.dylib,sha256=T76kBcwP4dGXUXS5aD1mcNr5hBAL8ou-nJGQNg7tXIA,574160
-najaeda/snl.so,sha256=DjnPH0vqcGKKdGaZDmeDq9r6_8m9w2AwxODv0LTcDqE,98272
-najaeda/stats.py,sha256=xWiIHa-S9yCHgAjyi6fVtx9C96o9v4MkYU7x5GdRKwA,16250
+najaeda/net_visitor.py,sha256=P_esjibYb-wBDuF-AyF7es9sJYw1Ha8RhTPu-qKe7G4,1940
+najaeda/libnaja_snl.dylib,sha256=_W6nRABcp6q9xoBF0hTOBDWwHBUB6-n8anUoTyNkn-s,574288
+najaeda/snl.so,sha256=lRUMHy2TG1HRdV65DPiLny314jNElZWEWcHgkg6k0co,98272
+najaeda/stats.py,sha256=wackXsf0x24ic9v-UifECHj4t5yveUWssMDZp2B057A,16187
 najaeda/instance_visitor.py,sha256=JMsPSQaWNiDjxS05rxg83a0PIsrOIuTi9G35hkwdibs,1530
+najaeda/native/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/native/stats.py,sha256=3iIPr-jitdMhbHthA4BauaTXwx1ijYIQuXwtoDyCf-A,13056
 najaeda/docs/requirements.txt,sha256=1XIBGTIplm2arC9HhDCfLuAjozGdVSXkqmOj8ybuT6U,121
 najaeda/docs/.readthedocs.yaml,sha256=nN_Psro-YdfPcIiueZkJcZepts68g23rqVThhKnmVRw,790
 najaeda/docs/source/index.rst,sha256=80VMfeEGHObnOUXRBxIzISQsG_HNkgT-pUpsDZsCfOY,387
@@ -21,10 +24,12 @@ najaeda/docs/source/equipotential.rst,sha256=0MDi-4fPEsX7K_ezWj5DB3mCalnhqN-sicY
 najaeda/docs/source/netlist_classes.rst,sha256=Zrha9MQVEdEwxmP2zhgC0K3iioZXXerzeFoOz5SrOXM,132
 najaeda/docs/source/introduction.rst,sha256=kE4qxEJCgcAswiT3rIJS21oBYIMg1cyT_rKmOzQgvsI,2095
 najaeda/docs/source/api.rst,sha256=47VCPyF4Py_1cklZ3q9fmOMhqqI17rxwU_VUJETfCwY,151
+najaeda/.dylibs/libcapnp-1.1.0.dylib,sha256=l9SvRdxPrCI2mB_UitO7QjsaC7I5mq2R3rZjoIQKEYI,709328
+najaeda/.dylibs/libkj-1.1.0.dylib,sha256=pB7dMks8b8ybJ6xKWqFR_hHjKsmpf7wzbcunZaS7gO4,578320
 najaeda/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-najaeda/primitives/xilinx.py,sha256=fuu4KxEIuC0ueCK4C_gds6hzgtJsLE3tjDtOHtY9McM,25947
-najaeda-0.1.12.dist-info/RECORD,,
-najaeda-0.1.12.dist-info/WHEEL,sha256=rOJaAfyDeYqpyZcvF2uMKwvjCoDaR0tVOjIX1nCiRq8,114
-najaeda-0.1.12.dist-info/METADATA,sha256=SlRgiK7xMLvNflXb_hKnXr7WamPV2wijr-qtmyqUH20,2475
-najaeda-0.1.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-najaeda-0.1.12.dist-info/licenses/AUTHORS,sha256=7NYEGDAX_1QZvCCHfq8YVXC5ZbwH_pbNI8DcSmm70GU,377
+najaeda/primitives/xilinx.py,sha256=_VPQfWAp3oc4EgOzW-gy96BXdFZK6E4C7aOSdCn4JRU,26008
+najaeda-0.1.14.dist-info/RECORD,,
+najaeda-0.1.14.dist-info/WHEEL,sha256=rOJaAfyDeYqpyZcvF2uMKwvjCoDaR0tVOjIX1nCiRq8,114
+najaeda-0.1.14.dist-info/METADATA,sha256=80hWLRV3mUTPKIbrne0o4kPXICFNFUO9oPtLN6zpA7o,2475
+najaeda-0.1.14.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+najaeda-0.1.14.dist-info/licenses/AUTHORS,sha256=7NYEGDAX_1QZvCCHfq8YVXC5ZbwH_pbNI8DcSmm70GU,377