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