def setUpClass(cls) -> None:
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = definition.create_child()
instance.name = "MY_INST"
top_instance = sdn.Instance()
top_instance.name = "TOP_INST"
top_instance.reference = definition
netlist.top_instance = top_instance
cls.netlist = netlist
cls.library = library
cls.definition = definition
cls.instance = instance
cls.top_instance = top_instance
leaf_definition = library.create_definition()
leaf_cable = leaf_definition.create_cable()
leaf_wire = leaf_cable.create_wire()
instance.reference = leaf_definition
cls.leaf_definition = leaf_definition
cls.leaf_cable = leaf_cable
cls.leaf_wire = leaf_wire
cable = definition.create_cable()
wire = cable.create_wire()
port = definition.create_port()
pin = port.create_pin()
outer_pin = top_instance.pins[pin]
cls.cable = cable
cls.wire = wire
cls.port = port
cls.pin = pin
cls.outer_pin = outer_pin
def test_through_hierarchy(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
middle_inst = definition.create_child()
middle_def = library.create_definition()
middle_cable = middle_def.create_cable()
middle_wire = middle_cable.create_wire()
middle_inst.reference = middle_def
leaf_inst = middle_def.create_child()
leaf_def = library.create_definition()
leaf_inst.reference = leaf_def
top_inst_href = next(sdn.get_hinstances(netlist.top_instance))
hrefs = list(sdn.get_hcables(top_inst_href, recursive=True))
self.assertTrue(
len(hrefs) == 1
and all(isinstance(x.item, sdn.Cable) for x in hrefs))
hrefs = list(sdn.get_hcables(middle_inst))
self.assertTrue(
len(hrefs) == 1
and all(isinstance(x.item, sdn.Cable) for x in hrefs))
def test_constructor(self):
self.assertIsInstance(self.netlist, FirstClassElement,
"Netlist is not an element.")
self.assertTrue(self.netlist,
"Constructor return None type or empty collection")
netlist2 = sdn.Netlist()
self.assertNotEqual(self.netlist, netlist2,
"Unique objects are considered equal.")
def test_write_header(self):
composer = self.initialize_tests()
netlist = sdn.Netlist()
netlist.name = "Netlist_name"
composer._write_header(netlist)
assert composer.file.compare(
"//Generated from netlist by SpyDrNet\n//netlist name: Netlist_name\n"
)
def test_single_object(self):
netlist = sdn.Netlist()
library1 = netlist.create_library()
library1.name = "work"
library2 = netlist.create_library()
library2.name = "hdi_primitives"
library = next(get_libraries(netlist, "work"))
self.assertEqual(library1, library)
def test_pin_and_wire_chain(self):
netlist = sdn.Netlist()
netlist.name = "MY_NETLIST"
library = netlist.create_library()
definition = library.create_definition()
port = definition.create_port()
pin = port.create_pin()
cable = definition.create_cable()
wire = cable.create_wire()
instance = sdn.Instance()
instance.name = "MY_INST"
instance.reference = definition
netlist.top_instance = instance
netlist_lookup = next(wire.get_netlists(), None)
self.assertIs(netlist, netlist_lookup)
cable.remove_wire(wire)
netlist_lookup = next(sdn.get_netlists(wire), None)
self.assertIsNone(netlist_lookup)
definition.remove_cable(cable)
netlist_lookup = next(sdn.get_netlists(cable), None)
self.assertIsNone(netlist_lookup)
outer_pin = instance.pins[pin]
netlist_lookup = next(sdn.get_netlists(outer_pin), None)
self.assertIs(netlist, netlist_lookup)
port.remove_pin(pin)
netlist_lookup = next(sdn.get_netlists(pin), None)
self.assertIsNone(netlist_lookup)
self.assertIsNone(outer_pin.inner_pin)
self.assertIsNone(outer_pin.instance)
top_instance_href = next(sdn.get_hinstances(netlist.top_instance))
netlist_lookup = next(sdn.get_netlists(top_instance_href))
self.assertIs(netlist, netlist_lookup)
definition.remove_port(port)
netlist_lookup = next(sdn.get_netlists(port), None)
self.assertIsNone(netlist_lookup)
instance.reference = None
netlist_lookup = next(sdn.get_netlists(instance), None)
self.assertIsNone(netlist_lookup)
library.remove_definition(definition)
netlist_lookup = next(sdn.get_netlists(definition), None)
self.assertIsNone(netlist_lookup)
netlist.remove_library(library)
netlist_lookup = next(sdn.get_netlists(library), None)
self.assertIsNone(netlist_lookup)
netlist_lookup = next(sdn.get_netlists(netlist, "MY_NETLIST"))
self.assertTrue(netlist is netlist_lookup)
def test_get_cables_in_netlist(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
cables = definition.create_cable()
cables.name = "MY_PORT"
instance = sdn.Instance()
instance.reference = definition
port1 = next(netlist.get_cables("MY_PORT"))
self.assertEqual(cables, port1)
def test_of_href_to_cable(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
port = definition.create_port()
pin = port.create_pin()
cable = definition.create_cable()
wire = cable.create_wire()
wire.connect_pin(pin)
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
href = next(sdn.get_hcables(cable))
search = next(sdn.get_pins(href))
self.assertEqual(search, pin)
def test_of_netlist_and_library_and_port(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
port = definition.create_port()
pin = port.create_pin()
instance = sdn.Instance()
instance.reference = definition
search = next(netlist.get_pins())
self.assertEqual(search, pin)
search = next(sdn.get_pins(library))
self.assertEqual(search, pin)
search = next(sdn.get_pins(port))
self.assertEqual(search, pin)
def test_get_all_hrefs_of_item(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
href = next(HRef.get_all_hrefs_of_item(instance))
self.assertTrue(href.item is instance)
href = next(HRef.get_all_hrefs_of_item(definition))
self.assertTrue(href.item is instance)
port = definition.create_port()
href = next(HRef.get_all_hrefs_of_item(port))
self.assertTrue(href.is_valid and href.item is port)
def test_parameter_checking(self):
netlist = sdn.Netlist()
library = netlist.create_library()
library.name = "MY_LIB"
self.assertRaises(TypeError,
sdn.get_netlists,
netlist,
"MY_LIB",
patterns="MY_LIB")
self.assertRaises(TypeError,
sdn.get_netlists,
netlist,
"MY_LIB",
unsupported_keyword=None)
self.assertRaises(TypeError, sdn.get_netlists, None, "MY_LIB")
self.assertRaises(TypeError, sdn.get_netlists, [None, netlist],
"MY_LIB")
def test_unique(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
port = definition.create_port()
pin = port.create_pin()
cable = definition.create_cable()
wire = cable.create_wire()
wire.connect_pin(pin)
instance = sdn.Instance()
instance.reference = definition
search = list(sdn.get_ports([netlist, cable]))
self.assertIs(port, search[0])
search = list(sdn.get_ports(cable))
self.assertIs(port, search[0])
def test_href_str_and_repr(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
cable = definition.create_cable()
cable.name = "MY_CABLE"
cable.create_wires(8)
href = HRef.from_sequence([instance, cable])
href_str = str(href)
self.assertTrue(href_str == "MY_CABLE")
href_repr = repr(href)
self.assertTrue(HRef.__name__ in href_repr)
self.assertTrue(cable.__class__.__name__ in href_repr)
def test_through_hierarchy(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
middle_inst = definition.create_child()
middle_def = library.create_definition()
middle_inst.reference = middle_def
leaf_inst = middle_def.create_child()
leaf_def = library.create_definition()
leaf_inst.reference = leaf_def
hrefs = list(sdn.get_hinstances(leaf_inst))
self.assertTrue(len(hrefs) == 1)
def test_is_unique(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition1 = library.create_definition()
instance1 = definition1.create_child()
definition2 = library.create_definition()
instance2a = definition2.create_child()
instance2a.reference = definition1
instance2b = definition2.create_child()
instance2b.reference = definition1
instance3 = sdn.Instance()
instance3.reference = definition2
netlist.top_instance = instance3
href1 = HRef.from_sequence([instance3, instance2a, instance1])
href2 = HRef.from_sequence([instance3, instance2b, instance1])
# Another test for test_flyweight stuffed in here :)
self.assertTrue(href1.parent.parent is href2.parent.parent)
self.assertTrue(href1.is_valid)
self.assertTrue(href2.is_valid)
self.assertFalse(href2.is_unique)
self.assertFalse(href1.is_unique)
definition2.remove_child(instance2b)
self.assertFalse(href2.is_valid)
self.assertFalse(href2.is_unique)
self.assertTrue(href1.is_unique)
definition4 = library.create_definition()
definition4.add_child(instance2b)
instance4 = sdn.Instance()
instance4.reference = definition4
definition2.add_child(instance4)
self.assertFalse(href1.is_unique)
class TestPrint(unittest.TestCase):
netlist = sdn.Netlist(name='netlist')
cable = sdn.Cable(name='cable', is_downto=False)
instance = sdn.Instance()
print(netlist)
netlist.top_instance = instance
print(netlist)
print(cable)
print(instance)
library = netlist.create_library(name='lib')
print(library)
definition = sdn.Definition()
print(definition)
pin = sdn.Pin()
cable = sdn.Cable()
print(cable)
wire = cable.create_wire()
wire.connect_pin(pin)
print(pin)
print(wire)
port = sdn.Port()
port.direction = sdn.IN
print(port)
import spydrnet as sdn netlist = sdn.Netlist(name='netlist') cable = sdn.Cable(name='cable') instance = sdn.Instance() print(netlist) netlist.top_instance = instance print(netlist) print(cable) print(instance) library = netlist.create_library(name='lib') print(library) definition = sdn.Definition() print(definition) pin = sdn.Pin() cable = sdn.Cable() print(cable) wire = cable.create_wire() wire.connect_pin(pin) print(pin) print(wire) port = sdn.Port() port.direction = sdn.IN print(port)
def gen_netlist(self):
netlist = sdn.Netlist()
return netlist
def test_set_top_instance_using_definition(self):
netlist = sdn.Netlist()
definition = sdn.Definition()
netlist.set_top_instance(definition)
self.assertTrue(netlist.top_instance.reference is definition)
def test_set_top_instance_using_instance(self):
netlist = sdn.Netlist()
instance = sdn.Instance()
netlist.set_top_instance(instance)
self.assertTrue(netlist.top_instance is instance)
def setUp(self):
self.netlist = sdn.Netlist()
def test_no_parent_netlist_name(self):
netlist = sdn.Netlist()
library = sdn.Library()
netlist.add_library(library)
self.assertTrue('parent netlist.name undefined' in library.__str__())
def test_href_valid(self):
instance = sdn.Instance()
href = HRef.from_parent_and_item(None, instance)
self.assertFalse(href.is_valid)
definition = sdn.Definition()
instance.reference = definition
self.assertFalse(href.is_valid)
library = sdn.Library()
library.add_definition(definition)
self.assertFalse(href.is_valid)
netlist = sdn.Netlist()
netlist.add_library(library)
self.assertFalse(href.is_valid)
netlist.top_instance = instance
self.assertTrue(href.is_valid)
cable = sdn.Cable()
wire = sdn.Wire()
href = HRef.from_sequence([instance, cable, wire])
self.assertFalse(href.is_valid)
cable.add_wire(wire)
self.assertFalse(href.is_valid)
definition.add_cable(cable)
self.assertTrue(href.is_valid)
instance.reference = None
self.assertFalse(href.is_valid)
port = sdn.Port()
pin = sdn.InnerPin()
href = HRef.from_sequence([instance, port, pin])
self.assertFalse(href.is_valid)
port.add_pin(pin)
self.assertFalse(href.is_valid)
definition.add_port(port)
self.assertFalse(href.is_valid)
instance.reference = definition
self.assertTrue(href.is_valid)
higher_definition = library.create_definition()
higher_definition.add_child(instance)
self.assertTrue(href.is_valid)
higher_instance = sdn.Instance()
higher_instance.reference = higher_definition
netlist.top_instance = higher_instance
self.assertFalse(href.is_valid)
href = HRef.from_sequence([higher_instance, instance, cable, wire])
self.assertTrue(href.is_valid)
higher_instance.reference = None
self.assertFalse(href.is_valid)
higher_definition.remove_child(instance)
self.assertFalse(href.is_valid)
definition.remove_cable(cable)
self.assertFalse(href.is_valid)
cable.remove_wire(wire)
self.assertFalse(href.is_valid)
cable.add_wire(wire)
href = HRef.from_sequence([cable, wire])
self.assertFalse(href.is_valid)
cable.remove_wire(wire)
new_cable = sdn.Cable()
new_cable.add_wire(wire)
self.assertFalse(href.is_valid)
href = HRef.from_parent_and_item(None, wire)
self.assertFalse(href.is_valid)
port.remove_pin(pin)
new_port = sdn.Port()
new_port.add_pin(pin)
href = HRef.from_sequence([port, pin])
self.assertFalse(href.is_valid)
href = HRef.from_parent_and_item(None, pin)
self.assertFalse(href.is_valid)
href = HRef.from_parent_and_item(None, definition)
self.assertFalse(href.is_valid)
# Specify number of inputs for the lookup-table
# Possible sizes for lookup-table: 2, 3, 4, 5, 6. Bigger sizes may not be
# supported on the device you are working with.
LUT_SIZE = 4
# Configure the LUT with a hex value. Lookup table can be configured easily by
# creating a n-input truth table, then converting the output column from
# binary to hexadecimal.
# 0xF888 refers to the following logic equation: (A * B) + (C * D)
LUT_CONFIG = 0xF888
if len(bin(LUT_CONFIG)[2:]) > 2**LUT_SIZE:
sys.exit("LUT_CONFIG has too many bits for LUT size")
# Create netlist
netlist = sdn.Netlist(name="netlist")
# Create HDI primitives library within netlist.
prim_library = netlist.create_library(name="hdi_primitives")
# Create all definitions for the primitives library
IBUF_def = prim_library.create_definition(name="IBUF")
# Output Buffer definition
OBUF_def = prim_library.create_definition(name="OBUF")
# Lookup table definition
prim_LUT_def = prim_library.create_definition(name="LUT" + str(LUT_SIZE))
# Inverter definition
INV_def = prim_library.create_definition(name="INV")
# Create input/output ports for IBUF and OBUF definition
IBUF_port_output = IBUF_def.create_port(name="O", direction=sdn.OUT)
def setUpClass(cls) -> None:
cls.netlist = sdn.Netlist()
leaf_library = cls.netlist.create_library()
leaf_library.name = 'primitives'
library = cls.netlist.create_library()
library.name = 'work'
leaf_def = leaf_library.create_definition()
leaf_def.name = 'leaf'
leaf_port = leaf_def.create_port()
leaf_port.name = 'I'
leaf_port.create_pins(1)
bottom_def = library.create_definition()
bottom_def.name = 'bottom'
bottom_port = bottom_def.create_port()
bottom_port.name = 'I'
bottom_port.create_pins(1)
leaf_inst = bottom_def.create_child()
leaf_inst.reference = leaf_def
bottom_cable = bottom_def.create_cable()
bottom_cable.name = 'bottom_cable'
bottom_wire = bottom_cable.create_wire()
bottom_wire.connect_pin(bottom_port.pins[0])
bottom_wire.connect_pin(leaf_inst.pins[leaf_port.pins[0]])
cls.leaf_inst = leaf_inst
bottom_floating_wire = bottom_cable.create_wire()
middle_def = library.create_definition()
middle_def.name = 'middle'
middle_port = middle_def.create_port()
middle_port.name = "I"
middle_port.create_pin()
bottom_inst = middle_def.create_child()
bottom_inst.name = 'bottom'
bottom_inst.reference = bottom_def
middle_cable = middle_def.create_cable()
middle_cable.name = "middle_cable"
middle_wire = middle_cable.create_wire()
middle_wire.connect_pin(middle_port.pins[0])
middle_wire.connect_pin(bottom_inst.pins[bottom_port.pins[0]])
middle_floating_wire = middle_cable.create_wire()
top_def = library.create_definition()
top_def.name = 'top'
top_port = top_def.create_port()
top_port.name = "I"
top_port.create_pin()
middle_inst = top_def.create_child()
middle_inst.name = 'middle'
middle_inst.reference = middle_def
top_cable = top_def.create_cable()
top_cable.name = "top_cable"
top_wire = top_cable.create_wire()
top_wire.connect_pin(top_port.pins[0])
top_wire.connect_pin(middle_inst.pins[middle_port.pins[0]])
top_floating_wire = top_cable.create_wire()
top_instance = sdn.Instance()
top_instance.name = 'top'
top_instance.reference = top_def
cls.netlist.top_instance = top_instance
def test_top_sort(self):
ce = ComposeEdif()
def library_dependence(library):
depend_set = set()
for definition in library.definitions:
# print("library: " + library.name)
for child in definition.children:
# print("contains: " + child.name)
if child.reference.library != library:
# print("which instances definition " + child.reference.name)
# print("which depends on " + child.reference.library.name)
depend_set.add(child.reference.library)
# print("DEPENDENCY LIST RETURNED")
# for lib_dep in depend_set:
# print(lib_dep.name)
return depend_set
netlist = sdn.Netlist()
lib_a = netlist.create_library()
lib_a.name = "lib_a"
definition_a = lib_a.create_definition()
definition_a.name = "def_a"
lib_b = netlist.create_library()
lib_b.name = "lib_b"
definition_b = lib_b.create_definition()
definition_b.name = "def_b"
instance_b = definition_b.create_child()
instance_b.name = "relies_on_lib_a"
instance_b.reference = definition_a
lib_c = netlist.create_library()
lib_c.name = "lib_c"
definition_c = lib_c.create_definition()
definition_c.name = "def_c"
instance_c1 = definition_c.create_child()
instance_c1.name = "relies_on_a"
instance_c1.reference = definition_a
instance_c2 = definition_c.create_child()
instance_c2.name = "relies_on_b"
instance_c2.reference = definition_b
libraries = ce._topological_sort(netlist.libraries, library_dependence)
print("should be a, b, c")
for lib in libraries:
print(lib.name)
print("dependencies")
for lib in libraries:
print(lib.name, end="")
print(" relies on")
for l in library_dependence(lib):
print("\t" + l.name)
for l in libraries:
assert l in netlist.libraries
for l in netlist.libraries:
assert l in libraries
found_libraries = set()
for l in libraries:
found_libraries.add(l)
for l_dep in library_dependence(l):
assert l_dep in found_libraries
def test_collection(self):
netlist = sdn.Netlist()
library = netlist.create_library()
library.name = "MY_LIB"
netlists = list(sdn.get_netlists([netlist, netlist]))
self.assertEqual(len(netlists), 1)
def test_compose(self):
netlist = sdn.Netlist()
self.assertRaises(RuntimeError, sdn.compose, netlist,
"fakefile.fakeext")
def test_through_hierarchy_again(self):
netlist = sdn.Netlist()
library = netlist.create_library()
library.name = 'work'
leaf_def = library.create_definition()
leaf_def.name = 'leaf'
leaf_port = leaf_def.create_port()
leaf_port.name = 'I'
leaf_port.create_pins(1)
bottom_def = library.create_definition()
bottom_def.name = 'bottom'
bottom_port = bottom_def.create_port()
bottom_port.name = 'I'
bottom_port.create_pins(1)
leaf_inst = bottom_def.create_child()
leaf_inst.reference = leaf_def
bottom_cable = bottom_def.create_cable()
bottom_cable.name = 'bottom_cable'
bottom_wire = bottom_cable.create_wire()
bottom_wire.connect_pin(bottom_port.pins[0])
bottom_wire.connect_pin(leaf_inst.pins[leaf_port.pins[0]])
bottom_floating_wire = bottom_cable.create_wire()
middle_def = library.create_definition()
middle_def.name = 'middle'
middle_port = middle_def.create_port()
middle_port.name = "I"
middle_port.create_pin()
bottom_inst = middle_def.create_child()
bottom_inst.name = 'bottom'
bottom_inst.reference = bottom_def
middle_cable = middle_def.create_cable()
middle_cable.name = "middle_cable"
middle_wire = middle_cable.create_wire()
middle_wire.connect_pin(middle_port.pins[0])
middle_wire.connect_pin(bottom_inst.pins[bottom_port.pins[0]])
middle_floating_wire = middle_cable.create_wire()
top_def = library.create_definition()
top_def.name = 'top'
top_port = top_def.create_port()
top_port.name = "I"
top_port.create_pin()
middle_inst = top_def.create_child()
middle_inst.name = 'middle'
middle_inst.reference = middle_def
top_cable = top_def.create_cable()
top_cable.name = "top_cable"
top_wire = top_cable.create_wire()
top_wire.connect_pin(top_port.pins[0])
top_wire.connect_pin(middle_inst.pins[middle_port.pins[0]])
top_floating_wire = top_cable.create_wire()
top_instance = sdn.Instance()
top_instance.name = 'top'
top_instance.reference = top_def
netlist.top_instance = top_instance
href = next(sdn.get_hwires(top_floating_wire))
hrefs = set(sdn.get_hwires(netlist.top_instance))
self.assertTrue(href in hrefs)
#look at wire_name
href = next(sdn.get_hwires(middle_floating_wire))
self.assertTrue('middle/middle_cable[1]', href.name)
hrefs = set(sdn.get_hwires(netlist.top_instance, recursive=True))
self.assertTrue(href in hrefs)
hrefs = set(sdn.get_hwires(middle_cable, selection="OUTSIDE"))
href_top_wire = next(sdn.get_hwires(top_cable.wires[0]))
href_middle_wire = next(sdn.get_hwires(middle_cable.wires[0]))
href_bottom_wire = next(sdn.get_hwires(bottom_cable.wires[0]))
self.assertTrue(href_top_wire in hrefs and href_middle_wire not in hrefs and href_bottom_wire in hrefs)
hrefs = set(sdn.get_hwires(middle_cable, selection="ALL"))
href_middle_floating_wire = next(sdn.get_hwires(middle_floating_wire))
self.assertTrue(href_top_wire in hrefs and href_middle_wire in hrefs and href_bottom_wire in hrefs and
href_middle_floating_wire in hrefs)
all_wires = set(netlist.get_hwires())
self.assertTrue(len(all_wires) == 2)
all_wires = set(netlist.get_hwires(recursive=True))
self.assertTrue(len(all_wires) == 6)
def initialize_netlist(self):
netlist = sdn.Netlist()
netlist.name = "test_netlist"
return netlist
