def test_remove_sinkless_signals(): """Signals with no sink should be removed.""" # Create a netlist including some signals with no sinks, these signals # should be removed. o1 = mock.Mock(name="O1") o2 = mock.Mock(name="O2") # Create 4 signals (2 associated with connections, 2 not) cs1 = Signal(ObjectPort(o1, None), ObjectPort(o2, None), None) cs2 = Signal(ObjectPort(o1, None), [], None) ss1 = Signal(ObjectPort(o1, None), ObjectPort(o2, None), None) ss2 = Signal(ObjectPort(o1, None), [], None) # Create two mock connections c1 = mock.Mock(name="Connection 1") c2 = mock.Mock(name="Connection 2") # Create the model model = Model() model.extra_operators = [o1, o2] model.connections_signals = {c1: cs1, c2: cs2} model.extra_signals = [ss1, ss2] # Remove sinkless signals remove_sinkless_signals(model) # Check that signals were removed as necessary assert model.connections_signals == {c1: cs1} assert model.extra_signals == [ss1]
def test_extra_operators_and_signals(self): """Test the operators and signals in the extra_operators and extra_signals lists are included when building netlists. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b = mock.Mock(name="vertex B") load_fn_b = mock.Mock(name="load function B") operator_b = mock.Mock(name="operator B") operator_b.make_vertices.return_value = \ netlistspec(vertex_b, load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab = Signal(ObjectPort(operator_a, None), ObjectPort(operator_b, None), keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.extra_operators = [operator_a, operator_b] model.extra_signals = [signal_ab] netlist = model.make_netlist() # Check that the make_vertices functions were called operator_a.make_vertices.assert_called_once_with(model) operator_b.make_vertices.assert_called_once_with(model) # Check that the netlist is as expected assert len(netlist.nets) == 1 for net in netlist.nets: assert net.source is vertex_a assert net.sinks == [vertex_b] assert net.keyspace is keyspace assert net.weight == signal_ab.weight assert set(netlist.vertices) == set([vertex_a, vertex_b]) assert netlist.keyspaces is model.keyspaces assert netlist.groups == list() assert set(netlist.load_functions) == set([load_fn_a, load_fn_b]) assert netlist.before_simulation_functions == [pre_fn_a] assert netlist.after_simulation_functions == [post_fn_a]
def test_get_signals_and_connections_terminating_at(self): """Test getting the signals and connections which end at a given object. """ # Create some objects and some connections obj_a = mock.Mock(name="object a") obj_b = mock.Mock(name="object b") conn_ab1 = mock.Mock() port_b1 = mock.Mock(name="port B1") sig_ab1 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, port_b1), None) conn_ab2 = mock.Mock() port_b2 = mock.Mock(name="port B2") sig_ab2 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, port_b2), None) sig_ab3 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, port_b2), None) conn_ba1 = mock.Mock() sig_ba1 = Signal(ObjectPort(obj_b, OutputPort.standard), ObjectPort(obj_a, InputPort.standard), None) conn_ba2 = mock.Mock() conn_ba3 = mock.Mock() sig_ba2 = Signal(ObjectPort(obj_b, port_b2), ObjectPort(obj_a, InputPort.standard), None) # Create a model holding all of these items model = Model() model.connections_signals = { conn_ab1: sig_ab1, conn_ab2: sig_ab2, conn_ba1: sig_ba1, conn_ba2: sig_ba2, conn_ba3: sig_ba2, } model.extra_signals = [sig_ab3] # Query it for connections terminating at different objects for port, sigs_conns in iteritems( model.get_signals_connections_to_object(obj_a)): assert port is InputPort.standard for sig, conns in iteritems(sigs_conns): if sig is sig_ba1: assert conns == [conn_ba1] elif sig is sig_ba2: for conn in conns: assert conn in [conn_ba2, conn_ba3] elif sig is sig_ba3: assert len(conns) == 0 else: assert False, "Unexpected signal" assert model.get_signals_connections_to_object(obj_b) == { port_b1: { sig_ab1: [conn_ab1], }, port_b2: { sig_ab2: [conn_ab2], sig_ab3: [], }, }
def test_get_signals_and_connections_starting_from(self): """Test getting the signals and connections which start from a given object. """ # Create some objects and some connections obj_a = mock.Mock(name="object a") obj_b = mock.Mock(name="object b") conn_ab1 = mock.Mock() sig_ab1 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, InputPort.standard), None) conn_ab2 = mock.Mock() sig_ab2 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, InputPort.standard), None) sig_ab3 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, InputPort.standard), None) sig_ab4 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, InputPort.standard), None) conn_ba1 = mock.Mock() port_b1 = mock.Mock(name="port B1") sig_ba1 = Signal(ObjectPort(obj_b, port_b1), ObjectPort(obj_a, InputPort.standard), None) conn_ba2 = mock.Mock() conn_ba3 = mock.Mock() port_b2 = mock.Mock(name="port B2") sig_ba2 = Signal(ObjectPort(obj_b, port_b2), ObjectPort(obj_a, InputPort.standard), None) port_b3 = mock.Mock(name="port B3") sig_ba3 = Signal(ObjectPort(obj_b, port_b3), ObjectPort(obj_a, InputPort.standard), None) # Create a model holding all of these items model = Model() model.connections_signals = { conn_ab1: sig_ab1, conn_ab2: sig_ab2, conn_ba1: sig_ba1, conn_ba2: sig_ba2, conn_ba3: sig_ba2, } model.extra_signals = [sig_ab3, sig_ab4, sig_ba3] # Query it for connections starting from different objects assert model.get_signals_connections_from_object(obj_a) == { OutputPort.standard: { sig_ab1: [conn_ab1], sig_ab2: [conn_ab2], sig_ab3: [], sig_ab4: [], }, } for port, sigs_conns in iteritems( model.get_signals_connections_from_object(obj_b)): if port is port_b1: assert sigs_conns == { sig_ba1: [conn_ba1], } elif port is port_b2: for sig, conns in iteritems(sigs_conns): assert sig is sig_ba2 for conn in conns: assert conn is conn_ba2 or conn is conn_ba3 elif port is port_b3: assert sigs_conns == {sig_ba3: []} else: assert False, "Unexpected signal"
def test_remove_childless_filters(): """Filter operators which don't transmit to anything, and their incoming signals, can be removed. """ # Create a netlist including some filters that do and don't transmit to # other objects, check that all the filters which don't connect to anything # are removed. # # -S1--- F3 # / \ S4 ^ \ S5 # / v / v # F1 O1 +S3-> F2 F5 # ^ / | \ ^ # \ / | S4 v / S6 # \-S2--- v F4 # O2 # # F1 should remain, O1 and O2 should be untouched and F2..5 should be # removed. S1 and S2 should be unchanged, S3 should have F2 removed from # its sinks and S4..6 should be removed entirely. # Create the filter operators f1 = mock.Mock(name="F1", spec=Filter) f2 = mock.Mock(name="F2", spec=Filter) f3 = mock.Mock(name="F3", spec=Filter) f4 = mock.Mock(name="F4", spec=Filter) f5 = mock.Mock(name="F5", spec=Filter) # The other operator o1 = mock.Mock(name="O1") o2 = mock.Mock(name="O2") # Create some objects which map to some of the operators oo1 = mock.Mock() of3 = mock.Mock() # Create the signals s1 = Signal(ObjectPort(f1, None), ObjectPort(o1, None), None) s2 = Signal(ObjectPort(o1, None), ObjectPort(f1, None), None) s3 = Signal(ObjectPort(o1, None), [ObjectPort(f2, None), ObjectPort(o2, None)], None) s4 = Signal(ObjectPort(f2, None), [ObjectPort(f3, None), ObjectPort(f4, None)], None) s5 = Signal(ObjectPort(f3, None), ObjectPort(f5, None), None) s6 = Signal(ObjectPort(f4, None), ObjectPort(f5, None), None) # Create some connections which map to the signals cs4 = mock.Mock() cs5 = mock.Mock() # Create the model model = Model() model.object_operators = { oo1: o1, of3: f3, } model.extra_operators = [f1, f2, f4, f5] model.connections_signals = { cs4: s4, cs5: s5, } model.extra_signals = [s1, s2, s3, s6] # Perform the optimisation remove_childless_filters(model) # Check that objects have been removed assert model.object_operators == {oo1: o1} assert model.extra_operators == [f1] assert model.connections_signals == {} assert model.extra_signals == [s1, s2, s3] assert [s.obj for s in s3.sinks] == [o2]