def test_sizeof_regions(vertex_slice, include_app_ptr):
"""Test getting the total memory usage of some regions."""
class MyRegion(Region):
def __init__(self, size):
self.size = size
self.called = False
def sizeof(self, sl):
assert sl == vertex_slice
self.called = True
return self.size
# Create all the regions
regions = [
MyRegion(4), # 1 word
MyRegion(3), # < 1 word
MyRegion(5), # < 2 words
MyRegion(100), # 25 words
None, # No region
MyRegion(32), # 8 words
]
# Now query their size
assert (utils.sizeof_regions(regions, vertex_slice, include_app_ptr) ==
37*4 + (len(regions)*4 + 4 if include_app_ptr else 0))
assert all(r.called for r in regions if r is not None)
def make_vertices(self, model, *args, **kwargs):
"""Create vertices that will simulate the SDPTransmitter."""
# Build the system region
self._sys_region = SystemRegion(model.machine_timestep, self.size_in,
1)
# Build the filter regions
in_sigs = model.get_signals_to_object(self)[InputPort.standard]
self._filter_region, self._routing_region = make_filter_regions(
in_sigs, model.dt, True, model.keyspaces.filter_routing_tag)
# Get the resources
resources = {
Cores:
1,
SDRAM:
region_utils.sizeof_regions(
[self._sys_region, self._filter_region, self._routing_region],
None)
}
# Create the vertex
self._vertex = Vertex(self._label, get_application("tx"), resources)
# Return the netlist specification
return netlistspec(
(self._vertex, ), # Tuple is required
load_function=self.load_to_machine)
def make_vertices(self, model, *args, **kwargs):
"""Create vertices that will simulate the SDPTransmitter."""
# Build the system region
self._sys_region = SystemRegion(model.machine_timestep,
self.size_in, 1)
# Build the filter regions
in_sigs = model.get_signals_connections_to_object(self)
self._filter_region, self._routing_region = make_filter_regions(
in_sigs[InputPort.standard], model.dt, True,
model.keyspaces.filter_routing_tag
)
# Get the resources
resources = {
Cores: 1,
SDRAM: region_utils.sizeof_regions(
[self._sys_region, self._filter_region, self._routing_region],
None
)
}
# Create the vertex
self._vertex = Vertex(get_application("tx"), resources)
# Return the netlist specification
return netlistspec(self._vertex,
load_function=self.load_to_machine)
def make_vertices(self, model, *args, **kwargs):
"""Create vertices that will simulate the SDPReceiver."""
# NOTE This approach will result in more routes being created than are
# actually necessary; the way to avoid this is to modify how the
# builder deals with signals when creating netlists.
# Get all outgoing signals and their associated connections (this
# SHOULD be a 1:1 mapping)
out = model.get_signals_connections_from_object(self)
for signal, connections in six.iteritems(out[OutputPort.standard]):
assert len(connections) == 1, "Expecting a 1:1 mapping"
conn = connections[0]
# Get the transform, and from this the keys
transform = model.params[conn].transform
keys = [signal.keyspace(index=i) for i in
range(transform.shape[0])]
# Create a vertex for this connection (assuming its size out <= 64)
if len(keys) > 64:
raise NotImplementedError(
"Connection {!s} is too wide to transmit to SpiNNaker. "
"Consider breaking the connection up or making the "
"originating node a function of time Node.".format(conn)
)
# Create the regions for the system
sys_region = SystemRegion(model.machine_timestep, len(keys))
keys_region = KeyspacesRegion(keys,
[KeyField({"cluster": "cluster"})])
# Get the resources
resources = {
Cores: 1,
SDRAM: region_utils.sizeof_regions([sys_region, keys_region],
None)
}
# Create the vertex
v = self.connection_vertices[conn] = Vertex(get_application("rx"),
resources)
self._sys_regions[v] = sys_region
self._key_regions[v] = keys_region
# Return the netlist specification
return netlistspec(list(self.connection_vertices.values()),
load_function=self.load_to_machine)
def make_vertices(self, model, *args, **kwargs):
"""Create vertices that will simulate the SDPReceiver."""
# NOTE This approach will result in more routes being created than are
# actually necessary; the way to avoid this is to modify how the
# builder deals with signals when creating netlists.
# Get all outgoing signals and their associated transmission parameters
for signal, transmission_params in \
model.get_signals_from_object(self)[OutputPort.standard]:
# Get the transform, and from this the keys
transform = transmission_params.full_transform(slice_out=False)
keys = [(signal, {"index": i}) for i in
range(transform.shape[0])]
# Create a vertex for this connection (assuming its size out <= 64)
if len(keys) > 64:
raise NotImplementedError(
"Connection is too wide to transmit to SpiNNaker. "
"Consider breaking the connection up or making the "
"originating node a function of time Node."
)
# Create the regions for the system
sys_region = SystemRegion(model.machine_timestep, len(keys))
keys_region = KeyspacesRegion(keys,
[KeyField({"cluster": "cluster"})])
# Get the resources
resources = {
Cores: 1,
SDRAM: region_utils.sizeof_regions([sys_region, keys_region],
None)
}
# Create the vertex
v = self.connection_vertices[transmission_params] = \
Vertex(self._label, get_application("rx"), resources)
self._sys_regions[v] = sys_region
self._key_regions[v] = keys_region
# Return the netlist specification
return netlistspec(list(self.connection_vertices.values()),
load_function=self.load_to_machine)
