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]
