def EthernetControlPopulation(n_neurons,
model,
label=None,
local_host=None,
local_port=None,
database_notify_port_num=None,
database_ack_port_num=None):
""" Create a PyNN population that can be included in a network to\
control an external device which is connected to the host
:param n_neurons: The number of neurons in the control population
:param model:\
Class of a model that creates a vertex of type\
AbstractEthernetController
:param label: An optional label for the population
:param local_host:\
The optional local host IP address to listen on for commands
:param local_port: The optional local port to listen on for commands
:param database_ack_port_num:\
The optional port to which responses to the database notification\
protocol are to be sent
:param database_notify_port_num:\
The optional port to which notifications from the database\
notification protocol are to be sent
:return:\
A pyNN Population which can be used as the target of a Projection.\
Note that the Population can also be used as the source of a\
Projection, but it might not send spikes.
"""
# pylint: disable=protected-access, too-many-arguments, too-many-locals
population = Population(n_neurons, model, label=label)
vertex = population._get_vertex
if not isinstance(vertex, AbstractEthernetController):
raise Exception(
"Vertex must be an instance of AbstractEthernetController")
translator = vertex.get_message_translator()
ethernet_control_connection = EthernetControlConnection(
translator, local_host, local_port)
devices_with_commands = [
device for device in vertex.get_external_devices()
if isinstance(device, AbstractSendMeMulticastCommandsVertex)
]
if devices_with_commands:
ethernet_command_connection = EthernetCommandConnection(
translator, devices_with_commands, local_host,
database_notify_port_num)
add_database_socket_address(
ethernet_command_connection.local_ip_address,
ethernet_command_connection.local_port, database_ack_port_num)
live_packet_gather = LivePacketGather(
ethernet_control_connection.local_ip_address,
ethernet_control_connection.local_port,
message_type=EIEIOType.KEY_PAYLOAD_32_BIT,
payload_as_time_stamps=False,
use_payload_prefix=False)
spynnaker_external_devices.add_application_vertex(live_packet_gather)
for partition_id in vertex.get_outgoing_partition_ids():
spynnaker_external_devices.add_edge(vertex, live_packet_gather,
partition_id)
return population
def _add_app_lpg_vertex(self, chip, params):
""" Adds a LPG vertex to a machine graph that has an associated\
application graph.
:param ~.Chip chip:
:param LivePacketGatherParameters params:
:rtype: LivePacketGatherMachineVertex
"""
app_vtx = LivePacketGather(params)
self._application_graph.add_vertex(app_vtx)
# No need to handle resources when allocating; LPG has core to itself
vtx = app_vtx.create_machine_vertex(
vertex_slice=None,
resources_required=None,
label="LivePacketGatherer",
constraints=[ChipAndCoreConstraint(x=chip.x, y=chip.y)])
self._machine_graph.add_vertex(vtx)
return vtx
def test_local_verts_go_to_local_lpgs_app_graph(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
graph = MachineGraph("Test")
app_graph = ApplicationGraph("Test")
app_graph_mapper = GraphMapper()
default_params = {
'use_prefix': False,
'key_prefix': None,
'prefix_type': None,
'message_type': EIEIOType.KEY_32_BIT,
'right_shift': 0,
'payload_as_time_stamps': True,
'use_payload_prefix': True,
'payload_prefix': None,
'payload_right_shift': 0,
'number_of_packets_sent_per_time_step': 0,
'hostname': None,
'port': None,
'strip_sdp': None,
'board_address': None,
'tag': None}
# data stores needed by algorithm
live_packet_gatherers = dict()
extended = dict(default_params)
extended.update({'partition_id': "EVENTS"})
default_params_holder = LivePacketGatherParameters(**extended)
live_packet_gatherers[default_params_holder] = list()
live_packet_gatherers_to_vertex_mapping = defaultdict(dict)
placements = Placements()
# add LPG's (1 for each Ethernet connected chip
for chip in machine.ethernet_connected_chips:
vertex = LivePacketGather(**default_params)
app_graph.add_vertex(vertex)
vertex_slice = Slice(0, 0)
resources_required = vertex.get_resources_used_by_atoms(
vertex_slice)
mac_vertex = vertex.create_machine_vertex(
vertex_slice, resources_required)
graph.add_vertex(mac_vertex)
app_graph_mapper.add_vertex_mapping(
mac_vertex, Slice(0, 0), vertex)
placements.add_placement(
Placement(x=chip.x, y=chip.y, p=2, vertex=mac_vertex))
live_packet_gatherers_to_vertex_mapping[
default_params_holder][chip.x, chip.y] = mac_vertex
# tracker of wirings
verts_expected = defaultdict(list)
positions = list()
positions.append([0, 0, 0, 0])
positions.append([4, 4, 0, 0])
positions.append([1, 1, 0, 0])
positions.append([2, 2, 0, 0])
positions.append([8, 4, 8, 4])
positions.append([11, 4, 8, 4])
positions.append([4, 11, 4, 8])
positions.append([4, 8, 4, 8])
positions.append([0, 11, 8, 4])
positions.append([11, 11, 4, 8])
positions.append([8, 8, 4, 8])
positions.append([4, 0, 0, 0])
positions.append([7, 7, 0, 0])
# add graph vertices which reside on areas of the machine to ensure
# spread over boards.
for x, y, eth_x, eth_y in positions:
vertex = SimpleTestVertex(1)
app_graph.add_vertex(vertex)
vertex_slice = Slice(0, 0)
resources_required = vertex.get_resources_used_by_atoms(
vertex_slice)
mac_vertex = vertex.create_machine_vertex(
vertex_slice, resources_required)
graph.add_vertex(mac_vertex)
app_graph_mapper.add_vertex_mapping(
mac_vertex, vertex_slice, vertex)
live_packet_gatherers[default_params_holder].append(vertex)
verts_expected[eth_x, eth_y].append(mac_vertex)
placements.add_placement(
Placement(x=x, y=y, p=5, vertex=mac_vertex))
# run edge inserter that should go boom
edge_inserter = InsertEdgesToLivePacketGatherers()
edge_inserter(
live_packet_gatherer_parameters=live_packet_gatherers,
placements=placements,
live_packet_gatherers_to_vertex_mapping=(
live_packet_gatherers_to_vertex_mapping),
machine=machine, machine_graph=graph, application_graph=app_graph,
graph_mapper=app_graph_mapper)
# verify edges are in the right place
for chip in machine.ethernet_connected_chips:
edges = graph.get_edges_ending_at_vertex(
live_packet_gatherers_to_vertex_mapping[
default_params_holder][chip.x, chip.y])
for edge in edges:
self.assertIn(edge.pre_vertex, verts_expected[chip.x, chip.y])
# check app graph
for chip in machine.ethernet_connected_chips:
app_verts_expected = [
app_graph_mapper.get_application_vertex(vert)
for vert in verts_expected[chip.x, chip.y]]
lpg_machine = live_packet_gatherers_to_vertex_mapping[
default_params_holder][chip.x, chip.y]
lpg_app = app_graph_mapper.get_application_vertex(lpg_machine)
edges = app_graph.get_edges_ending_at_vertex(lpg_app)
for edge in edges:
self.assertIn(edge.pre_vertex, app_verts_expected)
def test_local_verts_go_to_local_lpgs_app_graph(self):
machine = VirtualMachine(width=12, height=12, with_wrap_arounds=True)
graph = MachineGraph("Test")
app_graph = ApplicationGraph("Test")
app_graph_mapper = GraphMapper()
default_params = {
'use_prefix': False,
'key_prefix': None,
'prefix_type': None,
'message_type': EIEIOType.KEY_32_BIT,
'right_shift': 0,
'payload_as_time_stamps': True,
'use_payload_prefix': True,
'payload_prefix': None,
'payload_right_shift': 0,
'number_of_packets_sent_per_time_step': 0,
'hostname': None,
'port': None,
'strip_sdp': None,
'board_address': None,
'tag': None,
'label': "test"
}
# data stores needed by algorithm
live_packet_gatherers = dict()
extended = dict(default_params)
extended.update({'partition_id': "EVENTS"})
default_params_holder = LivePacketGatherParameters(**extended)
live_packet_gatherers[default_params_holder] = list()
live_packet_gatherers_to_vertex_mapping = defaultdict(dict)
placements = Placements()
# add LPG's (1 for each Ethernet connected chip
for chip in machine.ethernet_connected_chips:
vertex = LivePacketGather(**default_params)
app_graph.add_vertex(vertex)
vertex_slice = Slice(0, 0)
resources_required = vertex.get_resources_used_by_atoms(
vertex_slice)
mac_vertex = vertex.create_machine_vertex(vertex_slice,
resources_required)
graph.add_vertex(mac_vertex)
app_graph_mapper.add_vertex_mapping(mac_vertex, Slice(0, 0),
vertex)
placements.add_placement(
Placement(x=chip.x, y=chip.y, p=2, vertex=mac_vertex))
live_packet_gatherers_to_vertex_mapping[default_params_holder][
chip.x, chip.y] = mac_vertex
# tracker of wirings
verts_expected = defaultdict(list)
positions = list()
positions.append([0, 0, 0, 0])
positions.append([4, 4, 0, 0])
positions.append([1, 1, 0, 0])
positions.append([2, 2, 0, 0])
positions.append([8, 4, 8, 4])
positions.append([11, 4, 8, 4])
positions.append([4, 11, 4, 8])
positions.append([4, 8, 4, 8])
positions.append([0, 11, 8, 4])
positions.append([11, 11, 4, 8])
positions.append([8, 8, 4, 8])
positions.append([4, 0, 0, 0])
positions.append([7, 7, 0, 0])
# add graph vertices which reside on areas of the machine to ensure
# spread over boards.
for x, y, eth_x, eth_y in positions:
vertex = TestVertex(1)
app_graph.add_vertex(vertex)
vertex_slice = Slice(0, 0)
resources_required = vertex.get_resources_used_by_atoms(
vertex_slice)
mac_vertex = vertex.create_machine_vertex(vertex_slice,
resources_required)
graph.add_vertex(mac_vertex)
app_graph_mapper.add_vertex_mapping(mac_vertex, vertex_slice,
vertex)
live_packet_gatherers[default_params_holder].append(vertex)
verts_expected[eth_x, eth_y].append(mac_vertex)
placements.add_placement(
Placement(x=x, y=y, p=5, vertex=mac_vertex))
# run edge inserter that should go boom
edge_inserter = InsertEdgesToLivePacketGatherers()
edge_inserter(live_packet_gatherer_parameters=live_packet_gatherers,
placements=placements,
live_packet_gatherers_to_vertex_mapping=(
live_packet_gatherers_to_vertex_mapping),
machine=machine,
machine_graph=graph,
application_graph=app_graph,
graph_mapper=app_graph_mapper)
# verify edges are in the right place
for chip in machine.ethernet_connected_chips:
edges = graph.get_edges_ending_at_vertex(
live_packet_gatherers_to_vertex_mapping[default_params_holder][
chip.x, chip.y])
for edge in edges:
self.assertIn(edge.pre_vertex, verts_expected[chip.x, chip.y])
# check app graph
for chip in machine.ethernet_connected_chips:
app_verts_expected = [
app_graph_mapper.get_application_vertex(vert)
for vert in verts_expected[chip.x, chip.y]
]
lpg_machine = live_packet_gatherers_to_vertex_mapping[
default_params_holder][chip.x, chip.y]
lpg_app = app_graph_mapper.get_application_vertex(lpg_machine)
edges = app_graph.get_edges_ending_at_vertex(lpg_app)
for edge in edges:
self.assertIn(edge.pre_vertex, app_verts_expected)
def test_new_live_spike_recorder(self):
LivePacketGather(1000, 1, 1, 1, "")