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_make_vertices(self): """Check that the SDPReceiver make_vertices method looks at the signals and connections to make one sdp-rx vertex per outgoing connection and stores these as dictionaries. """ # Create the SDPReceiver, check that it currently has no connections # mapped to vertices. sdp_rx = SDPReceiver() assert sdp_rx.connection_vertices == dict() # Create a model containing some signals and connections originating # from sdp_rx, when calling make_vertices check that one vertex is # created per connection and that the dictionary is updated # accordingly. model = Model() conn_a = mock.Mock(name="connection a") conn_a.size_out = 1 conn_a.post_slice = slice(0, 1) conn_a.post_obj.size_in = 3 ks_a = model.keyspaces["nengo"](object=0, connection=0) sig_a = Signal(ObjectPort(sdp_rx, OutputPort.standard), None, ks_a) conn_b = mock.Mock(name="connection b") conn_b.size_out = 2 conn_b.post_slice = slice(None) conn_b.post_obj.size_in = 2 ks_b = model.keyspaces["nengo"](object=0, connection=1) sig_b = Signal(ObjectPort(sdp_rx, OutputPort.standard), None, ks_b) model.connections_signals = { conn_a: sig_a, conn_b: sig_b, } model.params[conn_a] = mock.Mock() model.params[conn_a].transform = np.eye(conn_a.size_out) model.params[conn_b] = mock.Mock() model.params[conn_b].transform = np.eye(conn_b.size_out) # Make the vertices nls = sdp_rx.make_vertices(model, 1) # TODO Remove number of steps assert len(nls.vertices) == 2 assert nls.load_function == sdp_rx.load_to_machine for conn, vx in six.iteritems(sdp_rx.connection_vertices): print(conn, vx) assert conn is conn_a or conn is conn_b assert vx in nls.vertices assert vx.resources[Cores] == 1 assert vx.resources[SDRAM] == 3*4 + 2*4 + 4*conn.size_out assert sdp_rx._sys_regions[vx].size_out == conn.size_out assert vx in sdp_rx._key_regions
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]