najaeda 0.1.3__cp313-cp313-macosx_11_0_arm64.whl → 0.1.4__cp313-cp313-macosx_11_0_arm64.whl

najaeda/netlist.py

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import itertools
+import time
 import logging
 
 from najaeda import snl
@@ -700,14 +701,29 @@ def create_top(name: str) -> Instance:
 
 
 def load_verilog(files: list):
+    start_time = time.time()
+    logging.info(f"Loading verilog: {', '.join(files)}")
     get_top_db().loadVerilog(files)
+    execution_time = time.time() - start_time
+    logging.info(f"Loading done in {execution_time:.2f} seconds")
     return get_top()
 
 
 def load_liberty(files: list):
+    logging.info(f"Loading liberty: {', '.join(files)}")
     get_top_db().loadLibertyPrimitives(files)
 
 
+def load_primitives(name: str):
+    if name == "xilinx":
+        logging.info("Loading xilinx primitives")
+        from najaeda.primitives import xilinx
+
+        xilinx.load(get_top_db())
+    else:
+        raise ValueError(f"Unknown primitives library: {name}")
+
+
 def get_primitives_library() -> snl.SNLLibrary:
     lib = get_top_db().getLibrary("PRIMS")
     if lib is None:

najaeda/primitives/xilinx.py

@@ -0,0 +1,452 @@
+# SPDX-FileCopyrightText: 2024 The Naja authors <https://github.com/najaeda/naja/blob/main/AUTHORS>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from najaeda import snl
+
+
+def constructIBUF(lib):
+    ibuf = snl.SNLDesign.createPrimitive(lib, "IBUF")
+    i = snl.SNLScalarTerm.create(ibuf, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(ibuf, snl.SNLTerm.Direction.Output, "O")
+    ibuf.addCombinatorialArcs(i, o)
+
+
+def constructOBUF(lib):
+    obuf = snl.SNLDesign.createPrimitive(lib, "OBUF")
+    i = snl.SNLScalarTerm.create(obuf, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(obuf, snl.SNLTerm.Direction.Output, "O")
+    obuf.addCombinatorialArcs(i, o)
+
+
+def constructBUFG(lib):
+    bufg = snl.SNLDesign.createPrimitive(lib, "BUFG")
+    i = snl.SNLScalarTerm.create(bufg, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(bufg, snl.SNLTerm.Direction.Output, "O")
+    bufg.addCombinatorialArcs(i, o)
+
+
+def constructDSP48E1(lib):
+    dsp48e1 = snl.SNLDesign.createPrimitive(lib, "DSP48E1")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 29, 0, "ACOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 17, 0, "BCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "CARRYCASCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "MULTSIGNOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "PCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "OVERFLOW")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "PATTERNBDETECT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "PATTERNDETECT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "UNDERFLOW")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 3, 0, "CARRYOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 47, 0, "P")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 29, 0, "ACIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 17, 0, "BCIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CARRYCASCIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "MULTSIGNIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "PCIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 3, 0, "ALUMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 2, 0, "CARRYINSEL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CLK")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 4, 0, "INMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 6, 0, "OPMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 29, 0, "A")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 17, 0, "B")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "C")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CARRYIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 24, 0, "D")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEA1")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEA2")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEAD")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEALUMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEB1")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEB2")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEC")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CECARRYIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CECTRL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CED")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEINMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEM")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEP")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTA")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTALLCARRYIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTALUMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTB")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTC")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTCTRL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTD")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTINMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTM")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTP")
+    snl.SNLParameter.create_decimal(dsp48e1, "ACASCREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "ADREG", 1)
+    snl.SNLParameter.create_string(dsp48e1, "A_INPUT", "DIRECT")
+    snl.SNLParameter.create_decimal(dsp48e1, "ALUMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "AREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "BCASCREG", 1)
+    snl.SNLParameter.create_string(dsp48e1, "B_INPUT", "DIRECT")
+    snl.SNLParameter.create_decimal(dsp48e1, "BREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CARRYINREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CARRYINSELREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "DREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "INMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "MREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "OPMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "PREG", 1)
+    snl.SNLParameter.create_boolean(dsp48e1, "USE_DPORT", False)
+    snl.SNLParameter.create_string(dsp48e1, "USE_MULT", "MULTIPLY")
+    snl.SNLParameter.create_string(dsp48e1, "USE_SIMD", "ONE48")
+
+
+def constructINV(lib):
+    inv = snl.SNLDesign.createPrimitive(lib, "INV")
+    i = snl.SNLScalarTerm.create(inv, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(inv, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs(i, o)
+
+
+def constructCARRY4(lib):
+    carry4 = snl.SNLDesign.createPrimitive(lib, "CARRY4")
+    o = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Output, 3, 0, "O")
+    co = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Output, 3, 0, "CO")
+    di = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Input, 3, 0, "DI")
+    s = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Input, 3, 0, "S")
+    cyinit = snl.SNLScalarTerm.create(carry4, snl.SNLTerm.Direction.Input, "CYINIT")
+    ci = snl.SNLScalarTerm.create(carry4, snl.SNLTerm.Direction.Input, "CI")
+    o_bits = [b for b in o.getBits()]
+    co_bits = [b for b in co.getBits()]
+    di_bits = [b for b in di.getBits()]
+    s_bits = [b for b in s.getBits()]
+    # cyinit and ci are in combinatorial dependency with o and co outputs
+    snl.SNLDesign.addCombinatorialArcs([cyinit, ci], [o, co])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[0], [o, co])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[1], [o_bits[1], o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[1], [co_bits[1], co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[2], [o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[2], [co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[3], o_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[3], co_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[0], [o_bits[1], o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[0], co)
+    snl.SNLDesign.addCombinatorialArcs(di_bits[1], [o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[1], [co_bits[1], co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[2], o_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[2], [co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[3], co_bits[3])
+
+
+def constructLUT1(lib):
+    lut1 = snl.SNLDesign.createPrimitive(lib, "LUT1")
+    i0 = snl.SNLScalarTerm.create(lut1, snl.SNLTerm.Direction.Input, "I0")
+    o = snl.SNLScalarTerm.create(lut1, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs(i0, o)
+    snl.SNLParameter.create_binary(lut1, "INIT", 2, 0b00)
+
+
+def constructLUT2(lib):
+    lut2 = snl.SNLDesign.createPrimitive(lib, "LUT2")
+    i0 = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1], o)
+    snl.SNLParameter.create_binary(lut2, "INIT", 4, 0x0)
+
+
+def constructLUT3(lib):
+    lut3 = snl.SNLDesign.createPrimitive(lib, "LUT3")
+    i0 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I2")
+    o = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2], o)
+    snl.SNLParameter.create_binary(lut3, "INIT", 8, 0x00)
+
+
+def constructLUT4(lib):
+    lut4 = snl.SNLDesign.createPrimitive(lib, "LUT4")
+    i0 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I3")
+    o = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3], o)
+    snl.SNLParameter.create_binary(lut4, "INIT", 16, 0x0000)
+
+
+def constructLUT5(lib):
+    lut5 = snl.SNLDesign.createPrimitive(lib, "LUT5")
+    i0 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I3")
+    i4 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I4")
+    o = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3, i4], o)
+    snl.SNLParameter.create_binary(lut5, "INIT", 32, 0x00000000)
+
+
+def constructLUT6(lib):
+    lut6 = snl.SNLDesign.createPrimitive(lib, "LUT6")
+    i0 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I3")
+    i4 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I4")
+    i5 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I5")
+    o = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3, i4, i5], o)
+    snl.SNLParameter.create_binary(lut6, "INIT", 64, 0x0000000000000000)
+
+
+def constructMUXF7(lib):
+    muxf7 = snl.SNLDesign.createPrimitive(lib, "MUXF7")
+    i0 = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Output, "O")
+    s = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "S")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, s], o)
+
+
+def constructMUXF8(lib):
+    muxf8 = snl.SNLDesign.createPrimitive(lib, "MUXF8")
+    i0 = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Output, "O")
+    s = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "S")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, s], o)
+
+
+def constructSRL16E(lib):
+    srl16e = snl.SNLDesign.createPrimitive(lib, "SRL16E")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "CE")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "CLK")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Output, "Q")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A0")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A1")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A2")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A3")
+    snl.SNLParameter.create_binary(srl16e, "INIT", 16, 0x0000)
+    snl.SNLParameter.create_binary(srl16e, "IS_CLK_INVERTED", 1, 0)
+
+
+def constructFDCE(lib):
+    fdce = snl.SNLDesign.createPrimitive(lib, "FDCE")
+    q = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "CE")
+    clr = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "CLR")
+    d = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdce, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, clr, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDPE(lib):
+    fdpe = snl.SNLDesign.createPrimitive(lib, "FDPE")
+    q = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "CE")
+    pre = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "PRE")
+    d = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdpe, "INIT", 1, 0b1)
+    snl.SNLDesign.addInputsToClockArcs([ce, pre, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDRE(lib):
+    fdre = snl.SNLDesign.createPrimitive(lib, "FDRE")
+    q = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "CE")
+    r = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "R")
+    d = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdre, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, r, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDSE(lib):
+    fdse = snl.SNLDesign.createPrimitive(lib, "FDSE")
+    q = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "CE")
+    s = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "S")
+    d = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdse, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, s, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructRAM32M(lib):
+    ram32m = snl.SNLDesign.createPrimitive(lib, "RAM32M")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOD")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRD")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DID")
+    snl.SNLScalarTerm.create(ram32m, snl.SNLTerm.Direction.Input, "WCLK")
+    snl.SNLScalarTerm.create(ram32m, snl.SNLTerm.Direction.Input, "WE")
+    snl.SNLParameter.create_binary(ram32m, "INIT_A", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_B", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_C", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_D", 64, 0)
+
+
+def constructRAM64M(lib):
+    ram64m = snl.SNLDesign.createPrimitive(lib, "RAM64M")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOA")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOB")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOC")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOD")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRA")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRB")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRC")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRD")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIA")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIB")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIC")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DID")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "WCLK")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "WE")
+    snl.SNLParameter.create_binary(ram64m, "INIT_A", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_B", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_C", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_D", 64, 0)
+
+
+def constructRAMB18E1(lib):
+    ramb18e1 = snl.SNLDesign.createPrimitive(lib, "RAMB18E1")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 13, 0, "ADDRARDADDR")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 13, 0, "ADDRBWRADDR")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "CLKARDCLK")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "CLKBWRCLK")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 15, 0, "DIADI")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 15, 0, "DIBDI")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "DIPADIP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "DIPBDIP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 15, 0, "DOADO")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 15, 0, "DOBDO")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 1, 0, "DOPADOP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 1, 0, "DOPBDOP")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "ENARDEN")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "ENBWREN")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "REGCEAREGCE")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "REGCEB")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTRAMARSTRAM")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTRAMB")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTREGARSTREG")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTREGB")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "WEA")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 3, 0, "WEBWE")
+    snl.SNLParameter.create_decimal(ramb18e1, "DOA_REG", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "DOB_REG", 0)
+    snl.SNLParameter.create_binary(ramb18e1, "INIT_A", 18, 0x00000)
+    snl.SNLParameter.create_binary(ramb18e1, "INIT_B", 18, 0x00000)
+    for i in range(64):
+        paramName = "INIT_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb18e1, paramName, 256, 0)
+    for i in range(8):
+        paramName = "INITP_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb18e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb18e1, "RAM_MODE", "TDP")
+    snl.SNLParameter.create_decimal(ramb18e1, "READ_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "READ_WIDTH_B", 0)
+    snl.SNLParameter.create_binary(ramb18e1, "SRVAL_A", 18, 0)
+    snl.SNLParameter.create_binary(ramb18e1, "SRVAL_B", 18, 0)
+    snl.SNLParameter.create_string(ramb18e1, "WRITE_MODE_A", "WRITE_FIRST")
+    snl.SNLParameter.create_string(ramb18e1, "WRITE_MODE_B", "WRITE_FIRST")
+    snl.SNLParameter.create_decimal(ramb18e1, "WRITE_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "WRITE_WIDTH_B", 0)
+
+
+def constructRAMB36E1(lib):
+    ramb36e1 = snl.SNLDesign.createPrimitive(lib, "RAMB36E1")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 15, 0, "ADDRARDADDR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 15, 0, "ADDRBWRADDR")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CASCADEINA")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CASCADEINB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "CASCADEOUTA")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "CASCADEOUTB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CLKARDCLK")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CLKBWRCLK")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "DBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 31, 0, "DIADI")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 31, 0, "DIBDI")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "DIPADIP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "DIPBDIP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 31, 0, "DOADO")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 31, 0, "DOBDO")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 3, 0, "DOPADOP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 3, 0, "DOPBDOP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 7, 0, "ECCPARITY")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "ENARDEN")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "ENBWREN")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "INJECTDBITERR")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "INJECTSBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 8, 0, "RDADDRECC")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "REGCEAREGCE")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "REGCEB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTRAMARSTRAM")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTRAMB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTREGARSTREG")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTREGB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "SBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "WEA")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 7, 0, "WEBWE")
+
+    snl.SNLParameter.create_decimal(ramb36e1, "DOA_REG", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "DOB_REG", 0)
+    snl.SNLParameter.create_binary(ramb36e1, "INIT_A", 36, 0)
+    snl.SNLParameter.create_binary(ramb36e1, "INIT_B", 36, 0)
+    for i in range(128):
+        paramName = "INIT_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb36e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb36e1, "RAM_EXTENSION_A", "NONE")
+    snl.SNLParameter.create_string(ramb36e1, "RAM_EXTENSION_B", "NONE")
+    for i in range(16):
+        paramName = "INITP_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb36e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb36e1, "RAM_MODE", "TDP")
+    snl.SNLParameter.create_decimal(ramb36e1, "READ_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "READ_WIDTH_B", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "WRITE_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "WRITE_WIDTH_B", 0)
+    snl.SNLParameter.create_binary(ramb36e1, "SRVAL_A", 36, 0)
+    snl.SNLParameter.create_binary(ramb36e1, "SRVAL_B", 36, 0)
+    snl.SNLParameter.create_string(ramb36e1, "WRITE_MODE_A", "WRITE_FIRST")
+    snl.SNLParameter.create_string(ramb36e1, "WRITE_MODE_B", "WRITE_FIRST")
+
+
+def load(db):
+    lib = snl.SNLLibrary.createPrimitives(db, "xilinx")
+    constructIBUF(lib)
+    constructOBUF(lib)
+    constructBUFG(lib)
+    constructDSP48E1(lib)
+    constructINV(lib)
+    constructCARRY4(lib)
+    constructLUT1(lib)
+    constructLUT2(lib)
+    constructLUT3(lib)
+    constructLUT4(lib)
+    constructLUT5(lib)
+    constructLUT6(lib)
+    constructMUXF7(lib)
+    constructMUXF8(lib)
+    constructSRL16E(lib)
+    constructFDCE(lib)
+    constructFDPE(lib)
+    constructFDRE(lib)
+    constructFDSE(lib)
+    constructRAM32M(lib)
+    constructRAM64M(lib)
+    constructRAMB18E1(lib)
+    constructRAMB36E1(lib)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: najaeda
-Version: 0.1.3
+Version: 0.1.4
 Summary: Naja EDA Python package
 Author-Email: Naja Authors <contact@keplertech.io>
 License: Apache License 2.0
@@ -33,10 +33,6 @@ 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',
@@ -50,6 +46,23 @@ a netlist from a Verilog file.
     
     top.dump_verilog('.', 'tinyrocket_naja.v')
 
+Load a design with pre-existing libraries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+In FPGA design environments, Liberty files are often unavailable.
+To address this, the following example demonstrates how to load primitives
+without relying on Liberty files.
+
+najaeda comes with pre-configured libraries to simplify this process.
+Currently, it includes support for partial Xilinx primitives, but this can be
+easily extended in the future. Don't hesitate to reach out if you need help.
+
+.. code-block:: python
+
+    netlist.load_primitives('xilinx')
+    benchmarks = path.join('..','benchmarks')
+    top = netlist.load_verilog([path.join(benchmarks, 'verilog', 'arm_core_netlist.v')])
+    #
+
 Print all the instances in the netlist
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Next example shows how to browse all the netlist and print all its content.
@@ -63,6 +76,7 @@ Next example shows how to browse all the netlist and print all its content.
 
 Documentation
 -------------
+najaeda is a work in progress, and the documentation is still under development.
 
 Naja documentation is available on the `Naja GitHub repository <https://github.com/najaeda/naja>`_.
 

najaeda-0.1.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+najaeda-0.1.4.dist-info/RECORD,,
+najaeda-0.1.4.dist-info/WHEEL,sha256=PJzLOGr1UQbVJ9ClJnwqiFhnlyWYjSsyNgebnLgIQKg,114
+najaeda-0.1.4.dist-info/METADATA,sha256=rpver3Febf2UhLXS-HAceNHU3YnNLGKde1icywDK_-Y,2842
+najaeda-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+najaeda-0.1.4.dist-info/licenses/AUTHORS,sha256=7NYEGDAX_1QZvCCHfq8YVXC5ZbwH_pbNI8DcSmm70GU,377
+najaeda/netlist.py,sha256=ena4A9S1UxQV-pO1XWxO_qbG-4ELnorKInJgX0zN3M0,25633
+najaeda/libnaja_snl_python.dylib,sha256=RQAQ20Q3u5Zi64AmzlsUzu9yFOJZqJ4MlVfJm019_eY,740160
+najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
+najaeda/snl.so,sha256=nwbhD_k8zYEQZh-LsCexOj9j2uSibNAeUnWTxwUy1iM,97888
+najaeda/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/primitives/xilinx.py,sha256=fuu4KxEIuC0ueCK4C_gds6hzgtJsLE3tjDtOHtY9McM,25947

{najaeda-0.1.3.dist-info → najaeda-0.1.4.dist-info}/licenses/AUTHORS

@@ -3,4 +3,5 @@
 # This does not necessarily list everyone who has contributed code, since in
 # some cases, their employer may be the copyright holder.  To see the full list
 # of contributors, see the revision history in source control.
-Christophe Alexandre <christophe.alex@gmail.com>
+Christophe Alexandre <christophe.alexandre@keplertech.io>
+Noam Cohen <noam.cohen@keplertech.io>

najaeda-0.1.3.dist-info/RECORD

@@ -1,11 +0,0 @@
-najaeda-0.1.3.dist-info/RECORD,,
-najaeda-0.1.3.dist-info/WHEEL,sha256=PJzLOGr1UQbVJ9ClJnwqiFhnlyWYjSsyNgebnLgIQKg,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=Sf6NksKm6A7l3vbE-MA_RGh2qABYZ0Q1fjo560r-E24,740160
-najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
-najaeda/snl.so,sha256=4DtbiiUnQFfh4Z1RJe7bTb5G5pbuHyIp0zqYrMXGQss,97888
-najaeda/.dylibs/Python,sha256=MV_0lc8R2aLm9tKXgFqMtJJSUdCKlimwSG68Bzb1HsI,13420608