def __call__(self, machine_graph, placements, n_keys_map):
"""
:param MachineGraph machine_graph:
The machine graph to allocate the routing info for
:param Placements placements: The placements of the vertices
:param AbstractMachinePartitionNKeysMap n_keys_map:
A map between the edges and the number of keys required by the
edges
:return: The routing information
:rtype: PartitionRoutingInfo
:raise PacmanRouteInfoAllocationException:
If something goes wrong with the allocation
"""
# check that this algorithm supports the constraints put onto the
# partitions
check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.outgoing_edge_partitions,
supported_constraints=[ContiguousKeyRangeContraint],
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# take each edge and create keys from its placement
progress = ProgressBar(machine_graph.n_vertices,
"Allocating routing keys")
routing_infos = RoutingInfo()
for vertex in progress.over(machine_graph.vertices):
for partition in machine_graph.\
get_multicast_edge_partitions_starting_at_vertex(vertex):
routing_infos.add_partition_info(
self._allocate_key_for_partition(partition, vertex,
placements, n_keys_map))
return routing_infos
def __call__(self, machine_graph, placements, n_keys_map):
"""
:param MachineGraph machine_graph:
The graph to allocate the routing info for
:param Placements placements: The placements of the vertices
:param AbstractMachinePartitionNKeysMap n_keys_map:
A map between the edges and the number of keys required by the
edges
:return: The routing information
:rtype: tuple(RoutingInfo, AbstractMulticastRoutingTable)
:raise PacmanRouteInfoAllocationException:
If something goes wrong with the allocation
"""
# check that this algorithm supports the constraints put onto the
# partitions
check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.partitions,
supported_constraints=[],
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# take each edge and create keys from its placement
progress = ProgressBar(machine_graph.n_outgoing_edge_partitions,
"Allocating routing keys")
routing_infos = RoutingInfo()
routing_tables = MulticastRoutingTables()
for partition in progress.over(machine_graph.outgoing_edge_partitions):
for edge in partition.edges:
routing_infos.add_partition_info(
self._allocate_partition_route(edge, placements,
machine_graph, n_keys_map))
return routing_infos, routing_tables
def __allocate(self):
multicast_partitions = self.__machine_graph.multicast_partitions
progress = ProgressBar(len(multicast_partitions),
"Allocating routing keys")
routing_infos = RoutingInfo()
app_part_index = 0
for app_id in progress.over(multicast_partitions):
while app_part_index in self.__fixed_used:
app_part_index += 1
for partition_name, paritition_vertices in \
multicast_partitions[app_id].items():
# convert set to a list and sort by slice
machine_vertices = list(paritition_vertices)
machine_vertices.sort(key=lambda x: x.vertex_slice.lo_atom)
n_bits_atoms = self.__atom_bits_per_app_part[(app_id,
partition_name)]
if self.__flexible:
n_bits_machine = self.__n_bits_atoms_and_mac - n_bits_atoms
else:
if n_bits_atoms <= self.__n_bits_atoms:
# Ok it fits use global sizes
n_bits_atoms = self.__n_bits_atoms
n_bits_machine = self.__n_bits_machine
else:
# Nope need more bits! Use the flexible approach here
n_bits_machine = \
self.__n_bits_atoms_and_mac - n_bits_atoms
for machine_index, vertex in enumerate(machine_vertices):
partition = self.__machine_graph.\
get_outgoing_edge_partition_starting_at_vertex(
vertex, partition_name)
if partition in self.__fixed_partitions:
# Ignore zone calculations and just use fixed
keys_and_masks = self.__fixed_partitions[partition]
else:
mask = self.__mask(n_bits_atoms)
key = app_part_index
key = (key << n_bits_machine) | machine_index
key = key << n_bits_atoms
keys_and_masks = [
BaseKeyAndMask(base_key=key, mask=mask)
]
routing_infos.add_partition_info(
PartitionRoutingInfo(keys_and_masks, partition))
app_part_index += 1
return routing_infos
def _construct_routing_info(machine_graph, outgoing_partition_key_spaces):
""" wrap a nengo bit field key space in a NengoBaseKeysAndMasks object.
so that it can get the keys when requested
:param machine_graph: the machine graph
:param outgoing_partition_key_spaces:
:return:
"""
routing_infos = RoutingInfo()
for outgoing_partition in machine_graph.outgoing_edge_partitions:
if outgoing_partition.traffic_type == EdgeTrafficType.MULTICAST:
keys_and_masks = list([NengoBaseKeysAndMasks(
outgoing_partition_key_spaces[outgoing_partition])])
routing_infos.add_partition_info(
PartitionRoutingInfo(keys_and_masks, outgoing_partition))
return routing_infos
def test_router_with_one_hop_route_all_default_link_5(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=2, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
def __call__(self, machine_graph, placements, n_keys_map):
"""
:param machine_graph: The graph to allocate the routing info for
:type machine_graph:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:param placements: The placements of the vertices
:type placements:\
:py:class:`pacman.model.placements.Placements`
:param n_keys_map: A map between the edges and the number of keys\
required by the edges
:type n_keys_map:\
:py:class:`pacman.model.routing_info.AbstractMachinePartitionNKeysMap`
:return: The routing information
:rtype: \
:py:class:`pacman.model.routing_info.RoutingInfo`, \
:py:class:`pacman.model.routing_tables.MulticastRoutingTable
:raise pacman.exceptions.PacmanRouteInfoAllocationException: \
If something goes wrong with the allocation
"""
# check that this algorithm supports the constraints put onto the
# partitions
supported_constraints = []
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.partitions,
supported_constraints=supported_constraints,
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# take each edge and create keys from its placement
progress = ProgressBar(machine_graph.n_outgoing_edge_partitions,
"Allocating routing keys")
routing_infos = RoutingInfo()
routing_tables = MulticastRoutingTables()
for partition in progress.over(machine_graph.outgoing_edge_partitions):
for edge in partition.edges:
routing_infos.add_partition_info(
self._allocate_partition_route(edge, placements,
machine_graph, n_keys_map))
return routing_infos, routing_tables
def __call__(self, machine_graph, n_keys_map):
"""
:param MachineGraph machine_graph:
:param AbstractMachinePartitionNKeysMap n_keys_map:
:rtype: RoutingInfo
:raises PacmanRouteInfoAllocationException:
"""
self._n_keys_map = n_keys_map
# check that this algorithm supports the constraints
check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.outgoing_edge_partitions,
supported_constraints=[
FixedMaskConstraint, FixedKeyAndMaskConstraint,
ContiguousKeyRangeContraint, ShareKeyConstraint
],
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# verify that no edge has more than 1 of a constraint ,and that
# constraints are compatible
check_types_of_edge_constraint(machine_graph)
# final keys allocations
routing_infos = RoutingInfo()
# Get the edges grouped by those that require the same key
(fixed_keys, shared_keys, fixed_masks, fixed_fields, continuous,
noncontinuous) = get_mulitcast_edge_groups(machine_graph)
# Go through the groups and allocate keys
progress = ProgressBar(machine_graph.n_outgoing_edge_partitions,
"Allocating routing keys")
# allocate the groups that have fixed keys
for group in progress.over(fixed_keys, False):
self._allocate_fixed_keys(group, routing_infos)
for group in progress.over(fixed_masks, False):
self._allocate_fixed_masks(group, routing_infos)
for group in progress.over(fixed_fields, False):
self._allocate_fixed_fields(group, routing_infos)
for group in progress.over(shared_keys, False):
self._allocate_share_key(group, routing_infos)
for group in continuous:
self._allocate_other_groups(group, routing_infos, True)
for group in noncontinuous:
self._allocate_other_groups(group, routing_infos, False)
progress.end()
return routing_infos
def __call__(self, machine_graph, n_keys_map, graph_mapper=None):
# check that this algorithm supports the constraints
check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.outgoing_edge_partitions,
supported_constraints=[
FixedMaskConstraint, FixedKeyAndMaskConstraint,
ContiguousKeyRangeContraint, ShareKeyConstraint
],
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# verify that no edge has more than 1 of a constraint ,and that
# constraints are compatible
utilities.check_types_of_edge_constraint(machine_graph)
# final keys allocations
routing_infos = RoutingInfo()
# Get the edges grouped by those that require the same key
(fixed_keys, shared_keys, fixed_masks, fixed_fields, flexi_fields,
continuous,
noncontinuous) = utilities.get_edge_groups(machine_graph,
EdgeTrafficType.MULTICAST)
# Even non-continuous keys will be continuous
for group in noncontinuous:
continuous.append(group)
# Go through the groups and allocate keys
progress = ProgressBar(machine_graph.n_outgoing_edge_partitions,
"Allocating routing keys")
# allocate the groups that have fixed keys
for group in progress.over(fixed_keys, False):
self._allocate_fixed_keys(group, routing_infos)
for group in progress.over(fixed_masks, False):
self._allocate_fixed_masks(group, n_keys_map, routing_infos)
for group in progress.over(fixed_fields, False):
self._allocate_fixed_fields(group, n_keys_map, routing_infos)
if flexi_fields:
raise PacmanConfigurationException(
"MallocBasedRoutingInfoAllocator does not support FlexiField")
for group in progress.over(shared_keys, False):
self._allocate_share_key(group, routing_infos, n_keys_map)
for group in continuous:
self._allocate_continuous_groups(group, routing_infos, n_keys_map)
progress.end()
return routing_infos
def __call__(self, machine_graph, placements, n_keys_map):
"""
:param machine_graph:\
The machine graph to allocate the routing info for
:type machine_graph:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:param placements: The placements of the vertices
:type placements:\
:py:class:`pacman.model.placements.placements.Placements`
:param n_keys_map:\
A map between the edges and the number of keys required by the\
edges
:type n_keys_map:\
:py:class:`pacman.model.routing_info.AbstractMachinePartitionNKeysMap`
:return: The routing information
:rtype:\
:py:class:`pacman.model.routing_info.PartitionRoutingInfo`
:raise pacman.exceptions.PacmanRouteInfoAllocationException: \
If something goes wrong with the allocation
"""
# check that this algorithm supports the constraints put onto the
# partitions
supported_constraints = [ContiguousKeyRangeContraint]
utility_calls.check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.outgoing_edge_partitions,
supported_constraints=supported_constraints,
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# take each edge and create keys from its placement
progress = ProgressBar(machine_graph.n_vertices,
"Allocating routing keys")
routing_infos = RoutingInfo()
for vertex in progress.over(machine_graph.vertices):
for partition in machine_graph.\
get_outgoing_edge_partitions_starting_at_vertex(vertex):
routing_infos.add_partition_info(
self._allocate_key_for_partition(partition, vertex,
placements, n_keys_map))
return routing_infos
def __call__(self, machine_graph, placements, n_keys_map):
"""
:param machine_graph: The graph to allocate the routing info for
:type machine_graph:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:param placements: The placements of the vertices
:type placements:\
:py:class:`pacman.model.placements.Placements`
:param n_keys_map: A map between the edges and the number of keys\
required by the edges
:type n_keys_map:\
:py:class:`pacman.model.routing_info.AbstractMachinePartitionNKeysMap`
:return: The routing information
:rtype: \
:py:class:`pacman.model.routing_info.RoutingInfo`, \
:py:class:`pacman.model.routing_tables.MulticastRoutingTable
:raise pacman.exceptions.PacmanRouteInfoAllocationException: \
If something goes wrong with the allocation
"""
# check that this algorithm supports the constraints put onto the
# partitions
check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.partitions,
supported_constraints=[],
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# take each edge and create keys from its placement
progress = ProgressBar(machine_graph.n_outgoing_edge_partitions,
"Allocating routing keys")
routing_infos = RoutingInfo()
routing_tables = MulticastRoutingTables()
for partition in progress.over(machine_graph.outgoing_edge_partitions):
for edge in partition.edges:
routing_infos.add_partition_info(
self._allocate_partition_route(
edge, placements, machine_graph, n_keys_map))
return routing_infos, routing_tables
def __call__(self, machine_graph, placements, n_keys_map):
"""
:param machine_graph:\
The machine graph to allocate the routing info for
:type machine_graph:\
:py:class:`pacman.model.graphs.machine.MachineGraph`
:param placements: The placements of the vertices
:type placements:\
:py:class:`pacman.model.placements.placements.Placements`
:param n_keys_map:\
A map between the edges and the number of keys required by the\
edges
:type n_keys_map:\
:py:class:`pacman.model.routing_info.AbstractMachinePartitionNKeysMap`
:return: The routing information
:rtype:\
:py:class:`pacman.model.routing_info.PartitionRoutingInfo`
:raise pacman.exceptions.PacmanRouteInfoAllocationException: \
If something goes wrong with the allocation
"""
# check that this algorithm supports the constraints put onto the
# partitions
check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.outgoing_edge_partitions,
supported_constraints=[ContiguousKeyRangeContraint],
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# take each edge and create keys from its placement
progress = ProgressBar(
machine_graph.n_vertices, "Allocating routing keys")
routing_infos = RoutingInfo()
for vertex in progress.over(machine_graph.vertices):
for partition in machine_graph.\
get_outgoing_edge_partitions_starting_at_vertex(vertex):
routing_infos.add_partition_info(
self._allocate_key_for_partition(
partition, vertex, placements, n_keys_map))
return routing_infos
def test_routing_info(self):
partition = MachineOutgoingEdgePartition("Test")
pre_vertex = SimpleMachineVertex(resources=ResourceContainer())
post_vertex = SimpleMachineVertex(resources=ResourceContainer())
edge = MachineEdge(pre_vertex, post_vertex)
key = 12345
partition_info = PartitionRoutingInfo(
[BaseKeyAndMask(key, _32_BITS)], partition)
partition.add_edge(edge)
routing_info = RoutingInfo([partition_info])
with self.assertRaises(PacmanAlreadyExistsException):
routing_info.add_partition_info(partition_info)
assert routing_info.get_first_key_from_partition(partition) == key
assert routing_info.get_first_key_from_partition(None) is None
assert routing_info.get_routing_info_from_partition(partition) == \
partition_info
assert routing_info.get_routing_info_from_partition(None) is None
assert routing_info.get_routing_info_from_pre_vertex(
pre_vertex, "Test") == partition_info
assert routing_info.get_routing_info_from_pre_vertex(
post_vertex, "Test") is None
assert routing_info.get_routing_info_from_pre_vertex(
pre_vertex, "None") is None
assert routing_info.get_first_key_from_pre_vertex(
pre_vertex, "Test") == key
assert routing_info.get_first_key_from_pre_vertex(
post_vertex, "Test") is None
assert routing_info.get_first_key_from_pre_vertex(
pre_vertex, "None") is None
assert routing_info.get_routing_info_for_edge(edge) == partition_info
assert routing_info.get_routing_info_for_edge(None) is None
assert routing_info.get_first_key_for_edge(edge) == key
assert routing_info.get_first_key_for_edge(None) is None
assert next(iter(routing_info)) == partition_info
partition2 = MachineOutgoingEdgePartition("Test")
partition2.add_edge(MachineEdge(pre_vertex, post_vertex))
with self.assertRaises(PacmanAlreadyExistsException):
routing_info.add_partition_info(PartitionRoutingInfo(
[BaseKeyAndMask(key, _32_BITS)], partition2))
assert partition != partition2
partition3 = MachineOutgoingEdgePartition("Test2")
partition3.add_edge(MachineEdge(pre_vertex, post_vertex))
routing_info.add_partition_info(PartitionRoutingInfo(
[BaseKeyAndMask(key, _32_BITS)], partition3))
assert routing_info.get_routing_info_from_partition(partition) != \
routing_info.get_routing_info_from_partition(partition3)
assert partition != partition3
assert routing_info.get_routing_info_from_partition(
partition3).get_keys().tolist() == [key]
partition3 = MachineOutgoingEdgePartition("Test3")
partition3.add_edge(MachineEdge(pre_vertex, post_vertex))
routing_info.add_partition_info(PartitionRoutingInfo(
[BaseKeyAndMask(key, _32_BITS),
BaseKeyAndMask(key*2, _32_BITS)], partition3))
assert routing_info.get_routing_info_from_partition(
partition3).get_keys().tolist() == [key, key*2]
def test_write_synaptic_matrix_and_master_population_table(self):
MockSimulator.setup()
# Add an sdram so max SDRAM is high enough
SDRAM(10000)
# UGLY but the mock transceiver NEED generate_on_machine to be False
AbstractGenerateConnectorOnMachine.generate_on_machine = self.say_false
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40)
machine_time_step = 1000.0
pre_app_vertex = SimpleApplicationVertex(10)
pre_vertex_slice = Slice(0, 9)
pre_vertex = pre_app_vertex.create_machine_vertex(
pre_vertex_slice, None)
post_app_vertex = SimpleApplicationVertex(10)
post_vertex_slice = Slice(0, 9)
post_vertex = post_app_vertex.create_machine_vertex(
post_vertex_slice, None)
post_slice_index = 0
one_to_one_connector_1 = OneToOneConnector(None)
direct_synapse_information_1 = SynapseInformation(
one_to_one_connector_1, pre_app_vertex, post_app_vertex, False,
False, None, SynapseDynamicsStatic(), 0, 1.5, 1.0)
one_to_one_connector_1.set_projection_information(
machine_time_step, direct_synapse_information_1)
one_to_one_connector_2 = OneToOneConnector(None)
direct_synapse_information_2 = SynapseInformation(
one_to_one_connector_2, pre_app_vertex, post_app_vertex, False,
False, None, SynapseDynamicsStatic(), 1, 2.5, 2.0)
one_to_one_connector_2.set_projection_information(
machine_time_step, direct_synapse_information_2)
all_to_all_connector = AllToAllConnector(None)
all_to_all_synapse_information = SynapseInformation(
all_to_all_connector, pre_app_vertex, post_app_vertex, False,
False, None, SynapseDynamicsStatic(), 0, 4.5, 4.0)
all_to_all_connector.set_projection_information(
machine_time_step, all_to_all_synapse_information)
app_edge = ProjectionApplicationEdge(pre_app_vertex, post_app_vertex,
direct_synapse_information_1)
app_edge.add_synapse_information(direct_synapse_information_2)
app_edge.add_synapse_information(all_to_all_synapse_information)
machine_edge = app_edge.create_machine_edge(pre_vertex,
post_vertex,
label=None)
partition_name = "TestPartition"
graph = MachineGraph("Test")
graph.add_vertex(pre_vertex)
graph.add_vertex(post_vertex)
graph.add_edge(machine_edge, partition_name)
weight_scales = [4096.0, 4096.0]
key = 0
routing_info = RoutingInfo()
routing_info.add_partition_info(
PartitionRoutingInfo(
[BaseKeyAndMask(key, 0xFFFFFFF0)],
graph.get_outgoing_edge_partition_starting_at_vertex(
pre_vertex, partition_name)))
temp_spec = tempfile.mktemp()
spec_writer = FileDataWriter(temp_spec)
spec = DataSpecificationGenerator(spec_writer, None)
master_pop_sz = 1000
all_syn_block_sz = 2000
master_pop_region = 0
synapse_region = 1
direct_region = 2
spec.reserve_memory_region(master_pop_region, master_pop_sz)
spec.reserve_memory_region(synapse_region, all_syn_block_sz)
synaptic_manager = SynapticManager(n_synapse_types=2,
ring_buffer_sigma=5.0,
spikes_per_second=100.0,
config=config)
# Poke in our testing region IDs
synaptic_manager._pop_table_region = master_pop_region
synaptic_manager._synaptic_matrix_region = synapse_region
synaptic_manager._direct_matrix_region = direct_region
synaptic_manager._write_synaptic_matrix_and_master_population_table(
spec, [post_vertex_slice], post_slice_index, post_vertex,
post_vertex_slice, all_syn_block_sz, weight_scales, routing_info,
graph, machine_time_step)
spec.end_specification()
spec_writer.close()
spec_reader = FileDataReader(temp_spec)
executor = DataSpecificationExecutor(spec_reader,
master_pop_sz + all_syn_block_sz)
executor.execute()
master_pop_table = executor.get_region(0)
synaptic_matrix = executor.get_region(1)
direct_matrix = executor.get_region(2)
all_data = bytearray()
all_data.extend(
master_pop_table.region_data[:master_pop_table.max_write_pointer])
all_data.extend(
synaptic_matrix.region_data[:synaptic_matrix.max_write_pointer])
all_data.extend(
direct_matrix.region_data[:direct_matrix.max_write_pointer])
master_pop_table_address = 0
synaptic_matrix_address = master_pop_table.max_write_pointer
direct_synapses_address = (synaptic_matrix_address +
synaptic_matrix.max_write_pointer)
direct_synapses_address += 4
indirect_synapses_address = synaptic_matrix_address
placement = Placement(None, 0, 0, 1)
transceiver = MockTransceiverRawData(all_data)
# Get the master population table details
items = synaptic_manager._extract_synaptic_matrix_data_location(
key, master_pop_table_address, transceiver, placement)
# The first entry should be direct, but the rest should be indirect;
# the second is potentially direct, but has been restricted by the
# restriction on the size of the direct matrix
assert len(items) == 3
assert items[0][2]
assert not items[1][2]
assert not items[2][2]
data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block(
txrx=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=0,
using_monitors=False)
connections_1 = synaptic_manager._read_synapses(
direct_synapse_information_1, pre_vertex_slice, post_vertex_slice,
row_len_1, 0, weight_scales, data_1, None, machine_time_step)
# The first matrix is a 1-1 matrix, so row length is 1
assert row_len_1 == 1
# Check that all the connections have the right weight and delay
assert len(connections_1) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 1.5 for conn in connections_1])
assert all([conn["delay"] == 1.0 for conn in connections_1])
data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block(
txrx=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=1,
using_monitors=False)
connections_2 = synaptic_manager._read_synapses(
direct_synapse_information_2, pre_vertex_slice, post_vertex_slice,
row_len_2, 0, weight_scales, data_2, None, machine_time_step)
# The second matrix is a 1-1 matrix, so row length is 1
assert row_len_2 == 1
# Check that all the connections have the right weight and delay
assert len(connections_2) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 2.5 for conn in connections_2])
assert all([conn["delay"] == 2.0 for conn in connections_2])
data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block(
txrx=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=2,
using_monitors=False)
connections_3 = synaptic_manager._read_synapses(
all_to_all_synapse_information, pre_vertex_slice,
post_vertex_slice, row_len_3, 0, weight_scales, data_3, None,
machine_time_step)
# The third matrix is an all-to-all matrix, so length is n_atoms
assert row_len_3 == post_vertex_slice.n_atoms
# Check that all the connections have the right weight and delay
assert len(connections_3) == \
post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms
assert all([conn["weight"] == 4.5 for conn in connections_3])
assert all([conn["delay"] == 4.0 for conn in connections_3])
def test_routing_info(self):
# mock to avoid having to create a graph for this test
graph_code = 123
pre_vertex = SimpleMachineVertex(resources=ResourceContainer())
partition = MulticastEdgePartition(pre_vertex, "Test")
partition.register_graph_code(graph_code) # This is a hack
post_vertex = SimpleMachineVertex(resources=ResourceContainer())
edge = MachineEdge(pre_vertex, post_vertex)
key = 12345
partition_info = PartitionRoutingInfo([BaseKeyAndMask(key, FULL_MASK)],
partition)
partition.add_edge(edge, graph_code)
routing_info = RoutingInfo([partition_info])
with self.assertRaises(PacmanAlreadyExistsException):
routing_info.add_partition_info(partition_info)
assert routing_info.get_first_key_from_partition(partition) == key
assert routing_info.get_first_key_from_partition(None) is None
assert routing_info.get_routing_info_from_partition(partition) == \
partition_info
assert routing_info.get_routing_info_from_partition(None) is None
assert routing_info.get_routing_info_from_pre_vertex(
pre_vertex, "Test") == partition_info
assert routing_info.get_routing_info_from_pre_vertex(
post_vertex, "Test") is None
assert routing_info.get_routing_info_from_pre_vertex(
pre_vertex, "None") is None
assert routing_info.get_first_key_from_pre_vertex(pre_vertex,
"Test") == key
assert routing_info.get_first_key_from_pre_vertex(post_vertex,
"Test") is None
assert routing_info.get_first_key_from_pre_vertex(pre_vertex,
"None") is None
assert routing_info.get_routing_info_for_edge(edge) == partition_info
assert routing_info.get_routing_info_for_edge(None) is None
assert routing_info.get_first_key_for_edge(edge) == key
assert routing_info.get_first_key_for_edge(None) is None
assert next(iter(routing_info)) == partition_info
partition2 = MulticastEdgePartition(pre_vertex, "Test")
partition2.register_graph_code(graph_code) # This is a hack
partition2.add_edge(MachineEdge(pre_vertex, post_vertex), graph_code)
with self.assertRaises(PacmanAlreadyExistsException):
routing_info.add_partition_info(
PartitionRoutingInfo([BaseKeyAndMask(key, FULL_MASK)],
partition2))
assert partition != partition2
partition3 = MulticastEdgePartition(pre_vertex, "Test2")
partition3.register_graph_code(graph_code) # This is a hack
partition3.add_edge(MachineEdge(pre_vertex, post_vertex), graph_code)
routing_info.add_partition_info(
PartitionRoutingInfo([BaseKeyAndMask(key, FULL_MASK)], partition3))
assert routing_info.get_routing_info_from_partition(partition) != \
routing_info.get_routing_info_from_partition(partition3)
assert partition != partition3
assert routing_info.get_routing_info_from_partition(
partition3).get_keys().tolist() == [key]
partition4 = MulticastEdgePartition(pre_vertex, "Test4")
partition4.register_graph_code(graph_code) # This is a hack
partition4.add_edge(MachineEdge(pre_vertex, post_vertex), graph_code)
routing_info.add_partition_info(
PartitionRoutingInfo([
BaseKeyAndMask(key, FULL_MASK),
BaseKeyAndMask(key * 2, FULL_MASK)
], partition4))
assert routing_info.get_routing_info_from_partition(
partition4).get_keys().tolist() == [key, key * 2]
def test_write_synaptic_matrix_and_master_population_table(self):
MockSimulator.setup()
# Add an sdram so maxsdram is high enough
SDRAM(10000)
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40)
machine_time_step = 1000.0
pre_app_vertex = SimpleApplicationVertex(10)
pre_vertex = SimpleMachineVertex(resources=None)
pre_vertex_slice = Slice(0, 9)
post_app_vertex = SimpleApplicationVertex(10)
post_vertex = SimpleMachineVertex(resources=None)
post_vertex_slice = Slice(0, 9)
post_slice_index = 0
one_to_one_connector_1 = OneToOneConnector(None)
one_to_one_connector_1.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
one_to_one_connector_2 = OneToOneConnector(None)
one_to_one_connector_2.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
all_to_all_connector = AllToAllConnector(None)
all_to_all_connector.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
direct_synapse_information_1 = SynapseInformation(
one_to_one_connector_1, SynapseDynamicsStatic(), 0, 1.5, 1.0)
direct_synapse_information_2 = SynapseInformation(
one_to_one_connector_2, SynapseDynamicsStatic(), 1, 2.5, 2.0)
all_to_all_synapse_information = SynapseInformation(
all_to_all_connector, SynapseDynamicsStatic(), 0, 4.5, 4.0)
app_edge = ProjectionApplicationEdge(
pre_app_vertex, post_app_vertex, direct_synapse_information_1)
app_edge.add_synapse_information(direct_synapse_information_2)
app_edge.add_synapse_information(all_to_all_synapse_information)
machine_edge = ProjectionMachineEdge(
app_edge.synapse_information, pre_vertex, post_vertex)
partition_name = "TestPartition"
graph = MachineGraph("Test")
graph.add_vertex(pre_vertex)
graph.add_vertex(post_vertex)
graph.add_edge(machine_edge, partition_name)
graph_mapper = GraphMapper()
graph_mapper.add_vertex_mapping(
pre_vertex, pre_vertex_slice, pre_app_vertex)
graph_mapper.add_vertex_mapping(
post_vertex, post_vertex_slice, post_app_vertex)
graph_mapper.add_edge_mapping(machine_edge, app_edge)
weight_scales = [4096.0, 4096.0]
key = 0
routing_info = RoutingInfo()
routing_info.add_partition_info(PartitionRoutingInfo(
[BaseKeyAndMask(key, 0xFFFFFFF0)],
graph.get_outgoing_edge_partition_starting_at_vertex(
pre_vertex, partition_name)))
temp_spec = tempfile.mktemp()
spec_writer = FileDataWriter(temp_spec)
spec = DataSpecificationGenerator(spec_writer, None)
master_pop_sz = 1000
master_pop_region = 0
all_syn_block_sz = 2000
synapse_region = 1
direct_region = 2
spec.reserve_memory_region(master_pop_region, master_pop_sz)
spec.reserve_memory_region(synapse_region, all_syn_block_sz)
synaptic_manager = SynapticManager(
n_synapse_types=2, ring_buffer_sigma=5.0,
spikes_per_second=100.0, config=config)
# UGLY but the mock transceiver NEED generate_on_machine be False
abstract_generate_connector_on_machine.IS_PYNN_8 = False
synaptic_manager._write_synaptic_matrix_and_master_population_table(
spec, [post_vertex_slice], post_slice_index, post_vertex,
post_vertex_slice, all_syn_block_sz, weight_scales,
master_pop_region, synapse_region, direct_region, routing_info,
graph_mapper, graph, machine_time_step)
spec.end_specification()
spec_writer.close()
spec_reader = FileDataReader(temp_spec)
executor = DataSpecificationExecutor(
spec_reader, master_pop_sz + all_syn_block_sz)
executor.execute()
master_pop_table = executor.get_region(0)
synaptic_matrix = executor.get_region(1)
direct_matrix = executor.get_region(2)
all_data = bytearray()
all_data.extend(master_pop_table.region_data[
:master_pop_table.max_write_pointer])
all_data.extend(synaptic_matrix.region_data[
:synaptic_matrix.max_write_pointer])
all_data.extend(direct_matrix.region_data[
:direct_matrix.max_write_pointer])
master_pop_table_address = 0
synaptic_matrix_address = master_pop_table.max_write_pointer
direct_synapses_address = (
synaptic_matrix_address + synaptic_matrix.max_write_pointer)
direct_synapses_address += 4
indirect_synapses_address = synaptic_matrix_address
placement = Placement(None, 0, 0, 1)
transceiver = MockTransceiverRawData(all_data)
# Get the master population table details
items = synaptic_manager._poptable_type\
.extract_synaptic_matrix_data_location(
key, master_pop_table_address, transceiver,
placement.x, placement.y)
# The first entry should be direct, but the rest should be indirect;
# the second is potentially direct, but has been restricted by the
# restriction on the size of the direct matrix
assert len(items) == 3
assert items[0][2]
assert not items[1][2]
assert not items[2][2]
data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=0,
using_extra_monitor_cores=False)
connections_1 = synaptic_manager._synapse_io.read_synapses(
direct_synapse_information_1, pre_vertex_slice, post_vertex_slice,
row_len_1, 0, 2, weight_scales, data_1, None,
app_edge.n_delay_stages, machine_time_step)
# The first matrix is a 1-1 matrix, so row length is 1
assert row_len_1 == 1
# Check that all the connections have the right weight and delay
assert len(connections_1) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 1.5 for conn in connections_1])
assert all([conn["delay"] == 1.0 for conn in connections_1])
data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=1,
using_extra_monitor_cores=False)
connections_2 = synaptic_manager._synapse_io.read_synapses(
direct_synapse_information_2, pre_vertex_slice, post_vertex_slice,
row_len_2, 0, 2, weight_scales, data_2, None,
app_edge.n_delay_stages, machine_time_step)
# The second matrix is a 1-1 matrix, so row length is 1
assert row_len_2 == 1
# Check that all the connections have the right weight and delay
assert len(connections_2) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 2.5 for conn in connections_2])
assert all([conn["delay"] == 2.0 for conn in connections_2])
data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver, placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address, key=key,
n_rows=pre_vertex_slice.n_atoms, index=2,
using_extra_monitor_cores=False)
connections_3 = synaptic_manager._synapse_io.read_synapses(
all_to_all_synapse_information, pre_vertex_slice,
post_vertex_slice, row_len_3, 0, 2, weight_scales, data_3, None,
app_edge.n_delay_stages, machine_time_step)
# The third matrix is an all-to-all matrix, so length is n_atoms
assert row_len_3 == post_vertex_slice.n_atoms
# Check that all the connections have the right weight and delay
assert len(connections_3) == \
post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms
assert all([conn["weight"] == 4.5 for conn in connections_3])
assert all([conn["delay"] == 4.0 for conn in connections_3])
def test_write_synaptic_matrix_and_master_population_table(self):
MockSimulator.setup()
default_config_paths = os.path.join(
os.path.dirname(abstract_spinnaker_common.__file__),
AbstractSpiNNakerCommon.CONFIG_FILE_NAME)
config = conf_loader.load_config(
AbstractSpiNNakerCommon.CONFIG_FILE_NAME, default_config_paths)
config.set("Simulation", "one_to_one_connection_dtcm_max_bytes", 40)
machine_time_step = 1000.0
pre_app_vertex = SimpleApplicationVertex(10)
pre_vertex = SimpleMachineVertex(resources=None)
pre_vertex_slice = Slice(0, 9)
post_app_vertex = SimpleApplicationVertex(10)
post_vertex = SimpleMachineVertex(resources=None)
post_vertex_slice = Slice(0, 9)
post_slice_index = 0
one_to_one_connector_1 = OneToOneConnector(None)
one_to_one_connector_1.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
one_to_one_connector_1.set_weights_and_delays(1.5, 1.0)
one_to_one_connector_2 = OneToOneConnector(None)
one_to_one_connector_2.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
one_to_one_connector_2.set_weights_and_delays(2.5, 2.0)
all_to_all_connector = AllToAllConnector(None)
all_to_all_connector.set_projection_information(
pre_app_vertex, post_app_vertex, None, machine_time_step)
all_to_all_connector.set_weights_and_delays(4.5, 4.0)
direct_synapse_information_1 = SynapseInformation(
one_to_one_connector_1, SynapseDynamicsStatic(), 0)
direct_synapse_information_2 = SynapseInformation(
one_to_one_connector_2, SynapseDynamicsStatic(), 1)
all_to_all_synapse_information = SynapseInformation(
all_to_all_connector, SynapseDynamicsStatic(), 0)
app_edge = ProjectionApplicationEdge(pre_app_vertex, post_app_vertex,
direct_synapse_information_1)
app_edge.add_synapse_information(direct_synapse_information_2)
app_edge.add_synapse_information(all_to_all_synapse_information)
machine_edge = ProjectionMachineEdge(app_edge.synapse_information,
pre_vertex, post_vertex)
partition_name = "TestPartition"
graph = MachineGraph("Test")
graph.add_vertex(pre_vertex)
graph.add_vertex(post_vertex)
graph.add_edge(machine_edge, partition_name)
graph_mapper = GraphMapper()
graph_mapper.add_vertex_mapping(pre_vertex, pre_vertex_slice,
pre_app_vertex)
graph_mapper.add_vertex_mapping(post_vertex, post_vertex_slice,
post_app_vertex)
graph_mapper.add_edge_mapping(machine_edge, app_edge)
weight_scales = [4096.0, 4096.0]
key = 0
routing_info = RoutingInfo()
routing_info.add_partition_info(
PartitionRoutingInfo(
[BaseKeyAndMask(key, 0xFFFFFFF0)],
graph.get_outgoing_edge_partition_starting_at_vertex(
pre_vertex, partition_name)))
temp_spec = tempfile.mktemp()
spec_writer = FileDataWriter(temp_spec)
spec = DataSpecificationGenerator(spec_writer, None)
master_pop_sz = 1000
master_pop_region = 0
all_syn_block_sz = 2000
synapse_region = 1
spec.reserve_memory_region(master_pop_region, master_pop_sz)
spec.reserve_memory_region(synapse_region, all_syn_block_sz)
synapse_type = MockSynapseType()
synaptic_manager = SynapticManager(synapse_type=synapse_type,
ring_buffer_sigma=5.0,
spikes_per_second=100.0,
config=config)
synaptic_manager._write_synaptic_matrix_and_master_population_table(
spec, [post_vertex_slice], post_slice_index, post_vertex,
post_vertex_slice, all_syn_block_sz, weight_scales,
master_pop_region, synapse_region, routing_info, graph_mapper,
graph, machine_time_step)
spec.end_specification()
spec_writer.close()
spec_reader = FileDataReader(temp_spec)
executor = DataSpecificationExecutor(spec_reader,
master_pop_sz + all_syn_block_sz)
executor.execute()
master_pop_table = executor.get_region(0)
synaptic_matrix = executor.get_region(1)
all_data = bytearray()
all_data.extend(
master_pop_table.region_data[:master_pop_table.max_write_pointer])
all_data.extend(
synaptic_matrix.region_data[:synaptic_matrix.max_write_pointer])
master_pop_table_address = 0
synaptic_matrix_address = master_pop_table.max_write_pointer
direct_synapses_address = struct.unpack_from(
"<I", synaptic_matrix.region_data)[0]
direct_synapses_address += synaptic_matrix_address + 8
indirect_synapses_address = synaptic_matrix_address + 4
placement = Placement(None, 0, 0, 1)
transceiver = MockTransceiverRawData(all_data)
# Get the master population table details
items = synaptic_manager._poptable_type\
.extract_synaptic_matrix_data_location(
key, master_pop_table_address, transceiver,
placement.x, placement.y)
# The first entry should be direct, but the rest should be indirect;
# the second is potentially direct, but has been restricted by the
# restriction on the size of the direct matrix
assert len(items) == 3
# TODO: This has been changed because direct matrices are disabled!
assert not items[0][2]
assert not items[1][2]
assert not items[2][2]
data_1, row_len_1 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=0,
using_extra_monitor_cores=False)
connections_1 = synaptic_manager._synapse_io.read_synapses(
direct_synapse_information_1, pre_vertex_slice, post_vertex_slice,
row_len_1, 0, 2, weight_scales, data_1, None,
app_edge.n_delay_stages, machine_time_step)
# The first matrix is a 1-1 matrix, so row length is 1
assert row_len_1 == 1
# Check that all the connections have the right weight and delay
assert len(connections_1) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 1.5 for conn in connections_1])
assert all([conn["delay"] == 1.0 for conn in connections_1])
data_2, row_len_2 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=1,
using_extra_monitor_cores=False)
connections_2 = synaptic_manager._synapse_io.read_synapses(
direct_synapse_information_2, pre_vertex_slice, post_vertex_slice,
row_len_2, 0, 2, weight_scales, data_2, None,
app_edge.n_delay_stages, machine_time_step)
# The second matrix is a 1-1 matrix, so row length is 1
assert row_len_2 == 1
# Check that all the connections have the right weight and delay
assert len(connections_2) == post_vertex_slice.n_atoms
assert all([conn["weight"] == 2.5 for conn in connections_2])
assert all([conn["delay"] == 2.0 for conn in connections_2])
data_3, row_len_3 = synaptic_manager._retrieve_synaptic_block(
transceiver=transceiver,
placement=placement,
master_pop_table_address=master_pop_table_address,
indirect_synapses_address=indirect_synapses_address,
direct_synapses_address=direct_synapses_address,
key=key,
n_rows=pre_vertex_slice.n_atoms,
index=2,
using_extra_monitor_cores=False)
connections_3 = synaptic_manager._synapse_io.read_synapses(
all_to_all_synapse_information, pre_vertex_slice,
post_vertex_slice, row_len_3, 0, 2, weight_scales, data_3, None,
app_edge.n_delay_stages, machine_time_step)
# The third matrix is an all-to-all matrix, so length is n_atoms
assert row_len_3 == post_vertex_slice.n_atoms
# Check that all the connections have the right weight and delay
assert len(connections_3) == \
post_vertex_slice.n_atoms * pre_vertex_slice.n_atoms
assert all([conn["weight"] == 4.5 for conn in connections_3])
assert all([conn["delay"] == 4.0 for conn in connections_3])
def __call__(self, machine_graph, n_keys_map, routing_tables):
"""
:param MachineGraph machine_graph:
:param AbstractMachinePartitionNKeysMap n_keys_map:
:param MulticastRoutingTableByPartition routing_tables:
:rtype: RoutingInfo
"""
# check that this algorithm supports the constraints
check_algorithm_can_support_constraints(
constrained_vertices=machine_graph.outgoing_edge_partitions,
supported_constraints=[
FixedMaskConstraint, FixedKeyAndMaskConstraint,
ContiguousKeyRangeContraint
],
abstract_constraint_type=AbstractKeyAllocatorConstraint)
# verify that no edge has more than 1 of a constraint ,and that
# constraints are compatible
check_types_of_edge_constraint(machine_graph)
routing_infos = RoutingInfo()
# Get the edges grouped by those that require the same key
(fixed_keys, _shared_keys, fixed_masks, fixed_fields, continuous,
noncontinuous) = get_mulitcast_edge_groups(machine_graph)
# Even non-continuous keys will be continuous
continuous.extend(noncontinuous)
# Go through the groups and allocate keys
progress = ProgressBar(machine_graph.n_outgoing_edge_partitions,
"Allocating routing keys")
# allocate the groups that have fixed keys
for group in progress.over(fixed_keys, False):
# Get any fixed keys and masks from the group and attempt to
# allocate them
fixed_mask = None
fixed_key_and_mask_constraint = locate_constraints_of_type(
group.constraints, FixedKeyAndMaskConstraint)[0]
# attempt to allocate them
self._allocate_fixed_keys_and_masks(
fixed_key_and_mask_constraint.keys_and_masks, fixed_mask)
# update the pacman data objects
self._update_routing_objects(
fixed_key_and_mask_constraint.keys_and_masks, routing_infos,
group)
continuous.remove(group)
for group in progress.over(fixed_masks, False):
# get mask and fields if need be
fixed_mask = locate_constraints_of_type(
group.constraints, FixedMaskConstraint)[0].mask
fields = None
if group in fixed_fields:
fields = locate_constraints_of_type(
group.constraints, FixedKeyFieldConstraint)[0].fields
fixed_fields.remove(group)
# try to allocate
keys_and_masks = self._allocate_keys_and_masks(
fixed_mask, fields, n_keys_map.n_keys_for_partition(group))
# update the pacman data objects
self._update_routing_objects(keys_and_masks, routing_infos, group)
continuous.remove(group)
for group in progress.over(fixed_fields, False):
fields = locate_constraints_of_type(
group.constraints, FixedKeyFieldConstraint)[0].fields
# try to allocate
keys_and_masks = self._allocate_keys_and_masks(
None, fields, n_keys_map.n_keys_for_partition(group))
# update the pacman data objects
self._update_routing_objects(keys_and_masks, routing_infos, group)
continuous.remove(group)
# Sort the rest of the groups, using the routing tables for guidance
# Group partitions by those which share routes in any table
partition_groups = OrderedDict()
routers = reversed(
sorted(
routing_tables.get_routers(),
key=lambda item: len(
routing_tables.get_entries_for_router(item[0], item[1]))))
for x, y in routers:
# Find all partitions that share a route in this table
partitions_by_route = defaultdict(OrderedSet)
routing_table = routing_tables.get_entries_for_router(x, y)
for partition, entry in iteritems(routing_table):
if partition in continuous:
entry_hash = sum(1 << i for i in entry.link_ids)
entry_hash += sum(1 << (i + 6)
for i in entry.processor_ids)
partitions_by_route[entry_hash].add(partition)
for entry_hash, partitions in iteritems(partitions_by_route):
found_groups = list()
for partition in partitions:
if partition in partition_groups:
found_groups.append(partition_groups[partition])
if not found_groups:
# If no group was found, create a new one
for partition in partitions:
partition_groups[partition] = partitions
elif len(found_groups) == 1:
# If a single other group was found, merge it
for partition in partitions:
found_groups[0].add(partition)
partition_groups[partition] = found_groups[0]
else:
# Merge the groups
new_group = partitions
for group in found_groups:
for partition in group:
new_group.add(partition)
for partition in new_group:
partition_groups[partition] = new_group
# Sort partitions by largest group
continuous = list(
OrderedSet(tuple(group) for group in itervalues(partition_groups)))
for group in reversed(sorted(continuous, key=len)):
for partition in progress.over(group, False):
keys_and_masks = self._allocate_keys_and_masks(
None, None, n_keys_map.n_keys_for_partition(partition))
# update the pacman data objects
self._update_routing_objects(keys_and_masks, routing_infos,
partition)
progress.end()
return routing_infos
def __call__(self, application_graph, graph_mapper, machine_graph,
n_keys_map):
"""
:param application_graph: The application graph
:param graph_mapper: the mapping between graphs
:param machine_graph: the machine graph
:param n_keys_map: the mapping between edges and n keys
:return: routing information objects
"""
progress_bar = ProgressBar(
machine_graph.n_outgoing_edge_partitions * 3,
"Allocating routing keys")
# ensure groups are stable and correct
self._determine_groups(
machine_graph, graph_mapper, application_graph, n_keys_map,
progress_bar)
# define the key space
bit_field_space = BitField(32)
field_positions = set()
# locate however many types of constraints there are
seen_fields = deduce_types(machine_graph)
progress_bar.update(machine_graph.n_outgoing_edge_partitions)
if len(seen_fields) > 1:
self._adds_application_field_to_the_fields(seen_fields)
# handle the application space
self._create_application_space_in_the_bit_field_space(
bit_field_space, seen_fields, field_positions)
# assign fields to positions in the space
bit_field_space.assign_fields()
# get positions of the flexible fields:
self._assign_flexi_field_positions(
bit_field_space, seen_fields, field_positions)
# create routing_info_allocator
routing_info = RoutingInfo()
seen_mask_instances = 0
# extract keys and masks for each edge from the bitfield
for partition in machine_graph.outgoing_edge_partitions:
# get keys and masks
keys_and_masks, seen_mask_instances = \
self._extract_keys_and_masks_from_bit_field(
partition, bit_field_space, n_keys_map,
seen_mask_instances)
# update routing info for each edge in the partition
partition_info = PartitionRoutingInfo(keys_and_masks, partition)
routing_info.add_partition_info(partition_info)
# update the progress bar again
progress_bar.update()
progress_bar.end()
return routing_info, field_positions
def test_routing_info(self):
partition = MachineOutgoingEdgePartition("Test")
pre_vertex = SimpleMachineVertex(resources=ResourceContainer())
post_vertex = SimpleMachineVertex(resources=ResourceContainer())
edge = MachineEdge(pre_vertex, post_vertex)
key = 12345
partition_info = PartitionRoutingInfo([BaseKeyAndMask(key, _32_BITS)],
partition)
partition.add_edge(edge)
routing_info = RoutingInfo([partition_info])
with self.assertRaises(PacmanAlreadyExistsException):
routing_info.add_partition_info(partition_info)
assert routing_info.get_first_key_from_partition(partition) == key
assert routing_info.get_first_key_from_partition(None) is None
assert routing_info.get_routing_info_from_partition(partition) == \
partition_info
assert routing_info.get_routing_info_from_partition(None) is None
assert routing_info.get_routing_info_from_pre_vertex(
pre_vertex, "Test") == partition_info
assert routing_info.get_routing_info_from_pre_vertex(
post_vertex, "Test") is None
assert routing_info.get_routing_info_from_pre_vertex(
pre_vertex, "None") is None
assert routing_info.get_first_key_from_pre_vertex(pre_vertex,
"Test") == key
assert routing_info.get_first_key_from_pre_vertex(post_vertex,
"Test") is None
assert routing_info.get_first_key_from_pre_vertex(pre_vertex,
"None") is None
assert routing_info.get_routing_info_for_edge(edge) == partition_info
assert routing_info.get_routing_info_for_edge(None) is None
assert routing_info.get_first_key_for_edge(edge) == key
assert routing_info.get_first_key_for_edge(None) is None
assert next(iter(routing_info)) == partition_info
partition2 = MachineOutgoingEdgePartition("Test")
partition2.add_edge(MachineEdge(pre_vertex, post_vertex))
with self.assertRaises(PacmanAlreadyExistsException):
routing_info.add_partition_info(
PartitionRoutingInfo([BaseKeyAndMask(key, _32_BITS)],
partition2))
assert partition != partition2
partition3 = MachineOutgoingEdgePartition("Test2")
partition3.add_edge(MachineEdge(pre_vertex, post_vertex))
routing_info.add_partition_info(
PartitionRoutingInfo([BaseKeyAndMask(key, _32_BITS)], partition3))
assert routing_info.get_routing_info_from_partition(partition) != \
routing_info.get_routing_info_from_partition(partition3)
assert partition != partition3
assert routing_info.get_routing_info_from_partition(
partition3).get_keys().tolist() == [key]
partition3 = MachineOutgoingEdgePartition("Test3")
partition3.add_edge(MachineEdge(pre_vertex, post_vertex))
routing_info.add_partition_info(
PartitionRoutingInfo([
BaseKeyAndMask(key, _32_BITS),
BaseKeyAndMask(key * 2, _32_BITS)
], partition3))
assert routing_info.get_routing_info_from_partition(
partition3).get_keys().tolist() == [key, key * 2]
class TestRouter(unittest.TestCase):
def setUp(self):
# sort out graph
self.vert1 = Vertex(10, "New AbstractConstrainedVertex 1")
self.vert2 = Vertex(5, "New AbstractConstrainedVertex 2")
self.edge1 = ApplicationEdge(self.vert1, self.vert2, "First edge")
self.verts = [self.vert1, self.vert2]
self.edges = [self.edge1]
self.graph = ApplicationGraph("Graph", self.verts, self.edges)
# sort out graph
self.graph = MachineGraph()
self.vertex1 = SimpleMachineVertex(
0, 10, self.vert1.get_resources_used_by_atoms(0, 10, []))
self.vertex2 = SimpleMachineVertex(
0, 5, self.vert2.get_resources_used_by_atoms(0, 10, []))
self.edge = MachineEdge(self.vertex1, self.vertex2)
self.graph.add_vertex(self.vertex1)
self.graph.add_vertex(self.vertex2)
self.graph.add_edge(self.edge, "TEST")
@unittest.skip("demonstrating skipping")
def test_router_with_same_chip_route(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=3, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_neighbour_chip(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=1, y=1, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_0(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=2, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_1(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=2, y=2, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_2(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=2, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_3(self):
self.placements = Placements()
self.placement1 = Placement(x=2, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_4(self):
self.placements = Placements()
self.placement1 = Placement(x=2, y=2, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_all_default_link_5(self):
self.placements = Placements()
self.placement1 = Placement(x=0, y=2, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_one_hop_route_not_default(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=2, y=1, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=0, y=0, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_router_with_multi_hop_route_across_board(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=8, y=7, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
@unittest.skip("demonstrating skipping")
def test_new_router(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertIsInstance(self.routing._router_algorithm,
BasicDijkstraRouting)
self.assertEqual(self.routing._graph_mappings, None)
@unittest.skip("demonstrating skipping")
def test_new_router_set_non_default_routing_algorithm(self):
report_folder = "..\reports"
self.routing = BasicDijkstraRouting()
self.assertEqual(self.routing._report_folder, report_folder)
self.assertEqual(self.routing._graph, None)
self.assertEqual(self.routing.report_states, None)
self.assertEqual(self.routing._hostname, None)
self.assertEqual(self.routing._graph_mappings, None)
@unittest.skip("demonstrating skipping")
def test_run_router(self):
# sort out placements
self.placements = Placements()
self.placement1 = Placement(x=0, y=0, p=2, vertex=self.vertex1)
self.placement2 = Placement(x=1, y=1, p=2, vertex=self.vertex2)
self.placements.add_placement(self.placement1)
self.placements.add_placement(self.placement2)
# sort out routing infos
self.routing_info = RoutingInfo()
self.edge_routing_info1 = PartitionRoutingInfo(key=2 << 11,
mask=DEFAULT_MASK,
edge=self.edge)
self.routing_info.add_partition_info(self.edge_routing_info1)
# create machine
self.machine = VirtualMachine(10, 10, False)
self.routing = BasicDijkstraRouting()
self.routing.route(machine=self.machine,
placements=self.placements,
machine_graph=self.graph,
routing_info_allocation=self.routing_info)
