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 __init__( self, pre_vertex, post_vertex, synapse_information, label=None): MultiCastPartitionableEdge.__init__( self, pre_vertex, post_vertex, label=label) # A list of all synapse information for all the projections that are # represented by this edge self._synapse_information = [synapse_information] # The edge from the delay extension of the pre_vertex to the # post_vertex - this might be None if no long delays are present self._delay_edge = None self._stored_synaptic_data_from_machine = None
def __init__(self, presynaptic_population, postsynaptic_population, machine_time_step, connector=None, synapse_list=None, synapse_dynamics=None, label=None): MultiCastPartitionableEdge.__init__( self, presynaptic_population._get_vertex, postsynaptic_population._get_vertex, label=label) self._connector = connector self._synapse_dynamics = synapse_dynamics self._synapse_list = synapse_list self._synapse_row_io = FixedSynapseRowIO() self._stored_synaptic_data_from_machine = None # If there are synapse dynamics for this connector, create a plastic # synapse list if synapse_dynamics is not None: self._synapse_row_io = synapse_dynamics.get_synapse_row_io()
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 __init__(self, prevertex, delayvertex, label=None): MultiCastPartitionableEdge.__init__(self, prevertex, delayvertex, label=label)
def add_edge(self, vertex, device_vertex): _spinnaker = get_spynnaker() edge = MultiCastPartitionableEdge(vertex, device_vertex) _spinnaker.add_partitionable_edge(edge)