najaeda 0.1.2__cp310-cp310-macosx_11_0_arm64.whl → 0.1.3__cp310-cp310-macosx_11_0_arm64.whl

najaeda/netlist.py

@@ -4,6 +4,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import itertools
+import logging
+
 from najaeda import snl
 
 
@@ -46,102 +48,121 @@ class Equipotential:
 
 
 class Net:
-    def __init__(self, path, net):
+    def __init__(self, path, net=None, net_concat=None):
+        if net is not None and net_concat is not None:
+            raise ValueError(
+                "Only one of `net` or `net_concat` should be provided, not both."
+            )
         self.path = path
-        self.net = net
-
-    def __eq__(self, value):
-        return self.net == value.net and self.path == value.path
-
-    def __ne__(self, value):
-        return not self == value
-
-    def __lt__(self, value):
-        if self.path != value.path:
-            return self.path < value.path
-        return self.net < value.net
-
-    def __le__(self, value):
-        if self.path != value.path:
-            return self.path < value.path
-        return self.net <= value.net
+        if net is not None:
+            self.net = net
+        elif net_concat is not None:
+            self.net_concat = net_concat
 
-    def __gt__(self, value):
-        if self.path != value.path:
-            return self.path > value.path
-        return self.net > value.net
+    def __eq__(self, other):
+        if not isinstance(other, Net):
+            return NotImplemented
+        return vars(self) == vars(other)
 
-    def __ge__(self, value):
-        if self.path != value.path:
-            return self.path > value.path
-        return self.net >= value.net
+    def __ne__(self, other):
+        eq_result = self.__eq__(other)
+        if eq_result is NotImplemented:
+            return NotImplemented
+        return not eq_result
 
     def __str__(self):
+        if hasattr(self, "net"):
+            net_str = str(self.net)
+        elif hasattr(self, "net_concat"):
+            net_str = "{" + ",".join(map(str, self.net_concat)) + "}"
         if self.path.size() > 0:
-            return f"{self.path}/{self.net}"
-        return f"{self.net}"
-
-    def __repr__(self):
-        return f"Net({self.path}, {self.net})"
+            return f"{self.path}/{net_str}"
+        return net_str
 
     def get_name(self) -> str:
         """Return the name of the net."""
-        return self.net.getName()
+        if hasattr(self, "net"):
+            return self.net.getName()
+        return "{" + ",".join(map(str, self.net_concat)) + "}"
 
     def get_msb(self) -> int:
         """Return the most significant bit of the net if it is a bus."""
-        if isinstance(self.net, snl.SNLBusNet):
+        if hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet):
             return self.net.getMSB()
         return None
 
     def get_lsb(self) -> int:
         """Return the least significant bit of the net if it is a bus."""
-        if isinstance(self.net, snl.SNLBusNet):
+        if hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet):
             return self.net.getLSB()
         return None
 
     def is_bus(self) -> bool:
         """Return True if the net is a bus."""
-        return isinstance(self.net, snl.SNLBusNet)
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet)
 
     def is_bus_bit(self) -> bool:
         """Return True if the net is a bit of a bus."""
-        return isinstance(self.net, snl.SNLBusNetBit)
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLBusNetBit)
 
     def is_scalar(self) -> bool:
         """Return True if the net is a scalar."""
-        return isinstance(self.net, snl.SNLScalarNet)
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLScalarNet)
 
     def is_bit(self) -> bool:
         """Return True if the net is a bit."""
         return self.is_scalar() or self.is_bus_bit()
 
-    def is_constant(self) -> bool:
+    def is_concat(self) -> bool:
+        """Return True if the net is a concatenation."""
+        return hasattr(self, "net_concat")
+
+    def is_const(self) -> bool:
         """Return True if the net is a constant generator."""
-        return self.net.isConstant()
+        if hasattr(self, "net"):
+            return self.net.isConstant()
+        for net in self.net_concat:
+            if not net.isConstant():
+                return False
+        return True
 
     def get_width(self) -> int:
         """Return the width of the net."""
-        return self.net.getWidth()
+        if hasattr(self, "net"):
+            return self.net.getWidth()
+        return sum(1 for _ in self.net_concat)
 
     def get_bits(self):
-        if isinstance(self.net, snl.SNLBusNet):
-            for bit in self.net.getBits():
-                yield Net(self.path, bit)
+        if hasattr(self, "net"):
+            if isinstance(self.net, snl.SNLBusNet):
+                for bit in self.net.getBits():
+                    yield Net(self.path, bit)
+            else:
+                yield self
         else:
-            yield self
+            for net in self.net_concat:
+                yield net
 
     def get_bit(self, index: int):
-        if isinstance(self.net, snl.SNLBusNet):
-            return Net(self.path, self.net.getBit(index))
+        if hasattr(self, "net"):
+            if isinstance(self.net, snl.SNLBusNet):
+                return Net(self.path, self.net.getBit(index))
+            else:
+                return None
+        if 0 <= index < len(self.net_concat):
+            return Net(self.path, self.net_concat[index])
         return None
 
     def get_inst_terms(self):
+        if hasattr(self, "net_concat"):
+            raise ValueError("Cannot get inst terms from a net_concat")
         for term in self.net.getInstTerms():
             path = snl.SNLPath(self.path, term.getInstance())
             yield Term(path, term.getBitTerm())
 
     def get_terms(self):
+        if hasattr(self, "net_concat"):
+            raise ValueError("Cannot get terms from a net_concat")
         for term in self.net.getBitTerms():
             yield Term(self.path, term)
 
@@ -151,9 +172,9 @@ class Net:
 
 
 class Term:
-    Input = snl.SNLTerm.Direction.Input
-    Output = snl.SNLTerm.Direction.Output
-    InOut = snl.SNLTerm.Direction.InOut
+    INPUT = snl.SNLTerm.Direction.Input
+    OUTPUT = snl.SNLTerm.Direction.Output
+    INOUT = snl.SNLTerm.Direction.InOut
 
     def __init__(self, path, term):
         self.path = path
@@ -179,15 +200,19 @@ class Term:
     def __ge__(self, other) -> bool:
         return not self < other
 
-    def __str__(self) -> str:
-        return str(self.path) + "." + self.term.getName()
+    def __str__(self):
+        if self.path.size() == 0:
+            return self.term.getName()
+        else:
+            return f"{self.path}/{self.term}"
 
     def __repr__(self) -> str:
         return f"Term({self.path}, {self.term})"
 
     def __make_unique(self):
-        if self.path.size() > 0:
-            snl.SNLUniquifier(self.path)
+        if self.path.size() > 1:
+            path = self.path.getHeadPath()
+            snl.SNLUniquifier(path)
             if self.is_bus_bit():
                 term = (
                     self.path.getTailInstance().getModel().getTerm(self.term.getName())
@@ -237,24 +262,74 @@ class Term:
     def get_direction(self) -> snl.SNLTerm.Direction:
         """Return the direction of the term."""
         if self.term.getDirection() == snl.SNLTerm.Direction.Input:
-            return Term.Input
+            return Term.INPUT
         elif self.term.getDirection() == snl.SNLTerm.Direction.Output:
-            return Term.Output
+            return Term.OUTPUT
         elif self.term.getDirection() == snl.SNLTerm.Direction.InOut:
-            return Term.InOut
+            return Term.INOUT
 
-    def get_net(self) -> Net:
-        if isinstance(self.term, snl.SNLBusTerm):
-            return None  # FIXME xtof in the future
-        net = None
+    def __get_snl_bitnet(self, bit) -> Net:
+        # single bit
         if self.path.size() > 0:
-            instTerm = self.path.getTailInstance().getInstTerm(self.term)
-            net = instTerm.getNet()
+            instTerm = self.path.getTailInstance().getInstTerm(bit)
+            return instTerm.getNet()
+        else:
+            return bit.getNet()
+
+    def __get_snl_lower_bitnet(self, bit) -> Net:
+        return bit.getNet()
+
+    def __get_snl_busnet(self, snl_nets) -> snl.SNLBusNet:
+        # iterate on all elements of the list and check if
+        # a full SNLBusNet can be reconstructed
+        snl_bus_net = None
+        for i in range(len(snl_nets)):
+            snl_net = snl_nets[i]
+            if not isinstance(snl_net, snl.SNLBusNetBit):
+                return None
+            bit_bus = snl_net.getBus()
+            if bit_bus.getWidth() != len(snl_nets):
+                return None
+            if snl_bus_net is None:
+                snl_bus_net = bit_bus
+            if snl_bus_net != bit_bus:
+                return None
+            if snl_bus_net.getBitAtPosition(i) != snl_net:
+                return None
+        return snl_bus_net
+
+    def __get_net(self, path, snl_term_net_accessor) -> Net:
+        if isinstance(self.term, snl.SNLBusTerm):
+            snl_nets = []
+            for bit in self.term.getBits():
+                snl_net = snl_term_net_accessor(bit)
+                snl_nets.append(snl_net)
+            snl_bus_net = self.__get_snl_busnet(snl_nets)
+            if snl_bus_net is not None:
+                return Net(path, snl_bus_net)
+            else:
+                if all(element is not None for element in snl_nets):
+                    return Net(path, net_concat=snl_nets)
         else:
-            net = get_top().model.getTerm(self.term.getName()).getNet()
-        return Net(self.path, net)
+            snl_net = snl_term_net_accessor(self.term)
+            if snl_net is not None:
+                return Net(path, snl_net)
+        return None
+
+    def get_lower_net(self) -> Net:
+        """Return the lower net of the term."""
+        return self.__get_net(self.path, self.__get_snl_lower_bitnet)
+
+    def get_net(self) -> Net:
+        """Return the net of the term."""
+        if self.path.empty():
+            return None
+        # path is one level up
+        path = self.path.getHeadPath()
+        return self.__get_net(path, self.__get_snl_bitnet)
 
     def get_instance(self):
+        """Return the instance of the term."""
         return Instance(self.path)
 
     def get_flat_fanout(self):
@@ -295,6 +370,7 @@ class Term:
             raise ValueError("Width mismatch")
         if self.get_instance().is_top():
             for bterm, bnet in zip(self.term.getBits(), net.net.getBits()):
+                logging.debug(f"Connecting {bterm} to {bnet}")
                 bterm.setNet(bnet)
         else:
             self.__make_unique()
@@ -348,8 +424,15 @@ class Instance:
     def __eq__(self, other) -> bool:
         return self.path == other.path
 
-    def __str__(self) -> str:
-        return str(self.path)
+    def __str__(self):
+        if self.is_top():
+            top = self.__get_snl_model()
+            if top is not None:
+                return top.getName()
+            else:
+                return ""
+        else:
+            return str(self.path)
 
     def __repr__(self) -> str:
         return f"Instance({self.path})"
@@ -396,8 +479,6 @@ class Instance:
 
     def __find_snl_model(self, name: str) -> snl.SNLDesign:
         u = snl.SNLUniverse.get()
-        if u is None:
-            return None
         for db in u.getUserDBs():
             for lib in db.getLibraries():
                 found_model = lib.getDesign(name)
@@ -419,15 +500,21 @@ class Instance:
     def get_number_of_child_instances(self) -> int:
         return sum(1 for _ in self.__get_snl_model().getInstances())
 
-    def get_terms(self):
-        for term in self.__get_snl_model().getTerms():
-            yield Term(self.path, term)
-
-    def get_term(self, name: str) -> Term:
-        term = self.__get_snl_model().getTerm(name)
-        if term is not None:
-            return Term(self.path, self.__get_snl_model().getTerm(name))
-        return None
+    # def get_flat_primitive_instances(self):
+    #    FIXME: concat first local path with the path of the instance
+    #    model = self.__get_snl_model()
+    #    for inst in model.getInstances():
+    #        path = snl.SNLPath(inst)
+    #        stack = [[inst, path]]
+    #        while stack:
+    #            current = stack.pop()
+    #            current_inst = current[0]
+    #            current_path = current[1]
+    #            for inst_child in current_inst.getModel().getInstances():
+    #                path_child = snl.SNLPath(current_path, inst_child)
+    #                if inst_child.getModel().isPrimitive():
+    #                    yield Instance(path_child)
+    #                stack.append([inst_child, path_child])
 
     def get_nets(self):
         for net in self.__get_snl_model().getNets():
@@ -448,8 +535,23 @@ class Instance:
         return None
 
     def is_primitive(self) -> bool:
+        """Return True if this is a primitive."""
         return self.__get_snl_model().isPrimitive()
 
+    def get_terms(self):
+        for term in self.__get_snl_model().getTerms():
+            yield Term(self.path, term)
+
+    def get_flat_terms(self):
+        for term in self.__get_snl_model().getBitTerms():
+            yield Term(self.path, term)
+
+    def get_term(self, name: str) -> Term:
+        term = self.__get_snl_model().getTerm(name)
+        if term is not None:
+            return Term(self.path, self.__get_snl_model().getTerm(name))
+        return None
+
     def get_input_terms(self):
         for term in self.__get_snl_model().getTerms():
             if term.getDirection() == snl.SNLTerm.Direction.Input:
@@ -531,9 +633,10 @@ class Instance:
     def create_input_term(self, name: str) -> Term:
         return self.create_term(name, snl.SNLTerm.Direction.Input)
 
-    def create_bus_term(
-        self, name: str, msb: int, lsb: int, direction: snl.SNLTerm.Direction
-    ) -> Term:
+    def create_inout_term(self, name: str) -> Term:
+        return self.create_term(name, snl.SNLTerm.Direction.InOut)
+
+    def create_bus_term(self, name: str, msb: int, lsb: int, direction) -> Term:
         if self.path.size() > 0:
             path = self.path
             snl.SNLUniquifier(path)
@@ -542,6 +645,9 @@ class Instance:
         newSNLTerm = snl.SNLBusTerm.create(design, direction, msb, lsb, name)
         return Term(self.path, newSNLTerm)
 
+    def create_inout_bus_term(self, name: str, msb: int, lsb: int) -> Term:
+        return self.create_bus_term(name, msb, lsb, snl.SNLTerm.Direction.InOut)
+
     def create_output_bus_term(self, name: str, msb: int, lsb: int) -> Term:
         return self.create_bus_term(name, msb, lsb, snl.SNLTerm.Direction.Output)
 
@@ -621,20 +727,3 @@ def get_model_name(id: tuple[int, int, int]) -> str:
                 if model:
                     return model.getName()
     return None
-
-
-def get_all_primitive_instances():
-    top = snl.SNLUniverse.get().getTopDesign()
-
-    for inst in top.getInstances():
-        path = snl.SNLPath(inst)
-        stack = [[inst, path]]
-        while stack:
-            current = stack.pop()
-            current_inst = current[0]
-            current_path = current[1]
-            for inst_child in current_inst.getModel().getInstances():
-                path_child = snl.SNLPath(current_path, inst_child)
-                if inst_child.getModel().isPrimitive():
-                    yield Instance(path_child)
-                stack.append([inst_child, path_child])

{najaeda-0.1.2.dist-info → najaeda-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: najaeda
-Version: 0.1.2
+Version: 0.1.3
 Summary: Naja EDA Python package
 Author-Email: Naja Authors <contact@keplertech.io>
 License: Apache License 2.0
@@ -11,15 +11,8 @@ Description-Content-Type: text/x-rst
 Naja EDA Python Package
 =======================
 
-Naja EDA is a Python package that provides data structures and APIs for developing post-synthesis Electronic Design Automation (EDA) algorithms. It serves as the Python counterpart to the `Naja C++ project <https://github.com/najaeda/naja>`_.
-
-Features
---------
-
-- **Netlist Simplification**: Perform constant propagation and dead logic elimination.
-- **Logic Replication**: Facilitate duplication of logic elements for optimization.
-- **Netlist Partitioning**: Divide netlists into manageable sections.
-- **Place and Route Support**: Assist in ASIC and FPGA design flows.
+Naja EDA is a Python package that provides data structures and APIs for developing post-synthesis Electronic Design Automation (EDA) algorithms.
+It serves as the Python counterpart to the `Naja C++ project <https://github.com/najaeda/naja>`_.
 
 Installation
 ------------
@@ -32,24 +25,35 @@ Install Naja EDA using pip:
 
 Examples
 --------
+
+Load a design from a liberty file and a Verilog file
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Following snippet shows how to load primitive cells from a liberty file and
 a netlist from a Verilog file.
+
 .. code-block:: python
 
     from os import path
+    import sys
     from najaeda import netlist
     
     benchmarks = path.join('..','benchmarks')
-    liberty_files = ['NangateOpenCellLibrary_typical.lib', 'fakeram45_1024x32.lib', 'fakeram45_64x32.lib']
+    liberty_files = [
+        'NangateOpenCellLibrary_typical.lib',
+        'fakeram45_1024x32.lib',
+        'fakeram45_64x32.lib'
+    ]
     liberty_files = list(map(lambda p:path.join(benchmarks, 'liberty', p), liberty_files))
         
     netlist.load_liberty(liberty_files)
     top = netlist.load_verilog([path.join(benchmarks, 'verilog', 'tinyrocket.v')])
     
-    #dump verilog
-    top.dump_verilog('tinyrocket_naja.v')
+    top.dump_verilog('.', 'tinyrocket_naja.v')
 
+Print all the instances in the netlist
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Next example shows how to browse all the netlist and print all its content.
+
 .. code-block:: python
 
     def print_netlist(instance):
@@ -60,7 +64,7 @@ Next example shows how to browse all the netlist and print all its content.
 Documentation
 -------------
 
-Comprehensive documentation is available on the `Naja GitHub repository <https://github.com/najaeda/naja>`_.
+Naja documentation is available on the `Naja GitHub repository <https://github.com/najaeda/naja>`_.
 
 License
 -------

najaeda-0.1.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+najaeda-0.1.3.dist-info/RECORD,,
+najaeda-0.1.3.dist-info/WHEEL,sha256=rOJaAfyDeYqpyZcvF2uMKwvjCoDaR0tVOjIX1nCiRq8,114
+najaeda-0.1.3.dist-info/METADATA,sha256=cUsTBMA9mhbFVF1WSI0wQYb3hc9-ThpBYShih2Yru6E,2147
+najaeda-0.1.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+najaeda-0.1.3.dist-info/licenses/AUTHORS,sha256=e4DCPGHo6wKMyQz24V59EP7zMwalK-KBDBHHlMLFxHY,330
+najaeda/netlist.py,sha256=sKIacJE8olG3-NxUru0ntAnzeU-enJNocnvJ3O0Jnp0,25102
+najaeda/libnaja_snl_python.dylib,sha256=GyZAaw5tt9Q-KuNYiErmU5p0qWVS1MvIMxo9fGUpVx8,740160
+najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
+najaeda/snl.so,sha256=bEV8QN-wHqCYSDkEpcgMuw4TIWkoNFQSG0zk_fw_bxk,97888
+najaeda/.dylibs/Python,sha256=gNPmu4BlzZFW7BRGmYn97Rh9oazzWgnlPqRHMuLQpdw,9729168

najaeda-0.1.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-najaeda-0.1.2.dist-info/RECORD,,
-najaeda-0.1.2.dist-info/WHEEL,sha256=rOJaAfyDeYqpyZcvF2uMKwvjCoDaR0tVOjIX1nCiRq8,114
-najaeda-0.1.2.dist-info/METADATA,sha256=agjVbL5DID69VNnjngj23q1t-TEOHBaCUhMnhIGEjZI,2267
-najaeda-0.1.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-najaeda-0.1.2.dist-info/licenses/AUTHORS,sha256=e4DCPGHo6wKMyQz24V59EP7zMwalK-KBDBHHlMLFxHY,330
-najaeda/netlist.py,sha256=usJ__3Vh_A8GFK7xUdhwJSdsTc7DWhaIF3Ptp3dfuZU,21251
-najaeda/libnaja_snl_python.dylib,sha256=aukMc3uXSMpY8HW72IFztL8w8D2SWJst8iBBVak88co,739872
-najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
-najaeda/snl.so,sha256=bEV8QN-wHqCYSDkEpcgMuw4TIWkoNFQSG0zk_fw_bxk,97888
-najaeda/.dylibs/Python,sha256=gNPmu4BlzZFW7BRGmYn97Rh9oazzWgnlPqRHMuLQpdw,9729168