def add_partitionable_vertex(self, vertex_to_add):
"""
:param vertex_to_add:
:return:
"""
if isinstance(vertex_to_add, CommandSender):
self._multi_cast_vertex = vertex_to_add
self._partitionable_graph.add_vertex(vertex_to_add)
if isinstance(vertex_to_add, AbstractSendMeMulticastCommandsVertex):
if self._multi_cast_vertex is None:
self._multi_cast_vertex = CommandSender(
self._machine_time_step, self._time_scale_factor)
self.add_partitionable_vertex(self._multi_cast_vertex)
edge = MultiCastPartitionableEdge(self._multi_cast_vertex,
vertex_to_add)
self._multi_cast_vertex.add_commands(vertex_to_add.commands, edge)
self.add_partitionable_edge(edge)
# add any dependent edges and vertices if needed
if isinstance(vertex_to_add,
AbstractVertexWithEdgeToDependentVertices):
for dependant_vertex in vertex_to_add.dependent_vertices:
self.add_partitionable_vertex(dependant_vertex)
dependant_edge = MultiCastPartitionableEdge(
pre_vertex=vertex_to_add, post_vertex=dependant_vertex)
self.add_partitionable_edge(
dependant_edge,
vertex_to_add.edge_partition_identifier_for_dependent_edge)
def add_edge_to_recorder_vertex(self,
vertex_to_record_from,
port,
hostname,
tag=None,
board_address=None,
strip_sdp=True,
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):
_spinnaker = get_spynnaker()
# locate the live spike recorder
if (port, hostname) in self._live_spike_recorders:
live_spike_recorder = self._live_spike_recorders[(port, hostname)]
else:
live_spike_recorder = LivePacketGather(
_spinnaker.machine_time_step,
_spinnaker.timescale_factor,
hostname,
port,
board_address,
tag,
strip_sdp,
use_prefix,
key_prefix,
prefix_type,
message_type,
right_shift,
payload_as_time_stamps,
use_payload_prefix,
payload_prefix,
payload_right_shift,
number_of_packets_sent_per_time_step,
label="LiveSpikeReceiver")
self._live_spike_recorders[(port, hostname)] = live_spike_recorder
_spinnaker.add_partitionable_vertex(live_spike_recorder)
# create the edge and add
edge = MultiCastPartitionableEdge(vertex_to_record_from,
live_spike_recorder,
label="recorder_edge")
_spinnaker.add_partitionable_edge(edge, PARTITION_ID)
def _add_delay_extension(self, presynaptic_population,
postsynaptic_population, max_delay_for_projection,
max_delay_per_neuron, machine_time_step,
timescale_factor):
""" Instantiate delay extension component
"""
# Create a delay extension vertex to do the extra delays
delay_vertex = presynaptic_population._internal_delay_vertex
pre_vertex = presynaptic_population._get_vertex
if delay_vertex is None:
delay_name = "{}_delayed".format(pre_vertex.label)
delay_vertex = DelayExtensionVertex(pre_vertex.n_atoms,
max_delay_per_neuron,
pre_vertex,
machine_time_step,
timescale_factor,
label=delay_name)
presynaptic_population._internal_delay_vertex = delay_vertex
pre_vertex.add_constraint(
PartitionerSameSizeAsVertexConstraint(delay_vertex))
self._spinnaker.add_partitionable_vertex(delay_vertex)
# Add the edge
delay_afferent_edge = DelayAfferentPartitionableEdge(
pre_vertex,
delay_vertex,
label="{}_to_DelayExtension".format(pre_vertex.label))
self._spinnaker.add_partitionable_edge(delay_afferent_edge,
EDGE_PARTITION_ID)
# Ensure that the delay extension knows how many states it will support
n_stages = int(
math.ceil(
float(max_delay_for_projection - max_delay_per_neuron) /
float(max_delay_per_neuron)))
if n_stages > delay_vertex.n_delay_stages:
delay_vertex.n_delay_stages = n_stages
# Create the delay edge if there isn't one already
post_vertex = postsynaptic_population._get_vertex
delay_edge = self._find_existing_edge(delay_vertex, post_vertex)
if delay_edge is None:
delay_edge = MultiCastPartitionableEdge(
delay_vertex,
post_vertex,
label="{}_delayed_to_{}".format(pre_vertex.label,
post_vertex.label))
self._spinnaker.add_partitionable_edge(delay_edge,
EDGE_PARTITION_ID)
return delay_edge
def add_edge(self, vertex, device_vertex):
_spinnaker = get_spynnaker()
edge = MultiCastPartitionableEdge(vertex, device_vertex)
_spinnaker.add_partitionable_edge(edge)
