def __init__(self, n_neurons, machine_time_step, timescale_factor,
constraints=None, label="SpikeSourcePoisson",
rate=1.0, start=0.0, duration=None, seed=None):
"""
Creates a new SpikeSourcePoisson Object.
"""
AbstractPartitionableVertex.__init__(
self, n_atoms=n_neurons, label=label, constraints=constraints,
max_atoms_per_core=self._model_based_max_atoms_per_core)
AbstractDataSpecableVertex.__init__(
self, machine_time_step=machine_time_step,
timescale_factor=timescale_factor)
AbstractSpikeRecordable.__init__(self)
# Store the parameters
self._rate = rate
self._start = start
self._duration = duration
self._rng = numpy.random.RandomState(seed)
# Prepare for recording, and to get spikes
self._spike_recorder = SpikeRecorder(machine_time_step)
self._outgoing_edge_key_restrictor = \
OutgoingEdgeSameContiguousKeysRestrictor()
def __init__(
self, n_neurons, spike_times, machine_time_step, timescale_factor,
port=None, tag=None, ip_address=None, board_address=None,
max_on_chip_memory_usage_for_spikes_in_bytes=None,
space_before_notification=640,
constraints=None, label="SpikeSourceArray"):
if ip_address is None:
ip_address = config.get("Buffers", "receive_buffer_host")
if port is None:
port = config.getint("Buffers", "receive_buffer_port")
AbstractDataSpecableVertex.__init__(
self, machine_time_step=machine_time_step,
timescale_factor=timescale_factor)
AbstractPartitionableVertex.__init__(
self, n_atoms=n_neurons, label=label,
max_atoms_per_core=self._model_based_max_atoms_per_core,
constraints=constraints)
AbstractSpikeRecordable.__init__(self)
self._spike_times = spike_times
self._max_on_chip_memory_usage_for_spikes = \
max_on_chip_memory_usage_for_spikes_in_bytes
self._space_before_notification = space_before_notification
self.add_constraint(TagAllocatorRequireIptagConstraint(
ip_address, port, strip_sdp=True, board_address=board_address,
tag_id=tag))
if self._max_on_chip_memory_usage_for_spikes is None:
self._max_on_chip_memory_usage_for_spikes = \
front_end_common_constants.MAX_SIZE_OF_BUFFERED_REGION_ON_CHIP
# check the values do not conflict with chip memory limit
if self._max_on_chip_memory_usage_for_spikes < 0:
raise ConfigurationException(
"The memory usage on chip is either beyond what is supportable"
" on the spinnaker board being supported or you have requested"
" a negative value for a memory usage. Please correct and"
" try again")
if (self._max_on_chip_memory_usage_for_spikes <
self._space_before_notification):
self._space_before_notification =\
self._max_on_chip_memory_usage_for_spikes
# Keep track of any previously generated buffers
self._send_buffers = dict()
self._spike_recording_region_size = None
# handle recording
self._spike_recorder = EIEIOSpikeRecorder(machine_time_step)
#handle outgoing constraints
self._outgoing_edge_key_restrictor = \
OutgoingEdgeSameContiguousKeysRestrictor()
def __init__(self, n_neurons, max_delay_per_neuron, source_vertex,
machine_time_step, timescale_factor, constraints=None,
label="DelayExtension"):
"""
Creates a new DelayExtension Object.
"""
AbstractPartitionableVertex.__init__(self, n_atoms=n_neurons,
constraints=constraints,
label=label,
max_atoms_per_core=256)
AbstractDataSpecableVertex.__init__(
self, machine_time_step=machine_time_step,
timescale_factor=timescale_factor)
AbstractProvidesIncomingEdgeConstraints.__init__(self)
AbstractProvidesNKeysForEdge.__init__(self)
self._max_delay_per_neuron = max_delay_per_neuron
self._max_stages = 0
self._source_vertex = source_vertex
joint_constrant = PartitionerSameSizeAsVertexConstraint(source_vertex)
self.add_constraint(joint_constrant)
self._outgoing_edge_key_restrictor = \
OutgoingEdgeSameContiguousKeysRestrictor()
class DelayExtensionVertex(AbstractPartitionableVertex,
AbstractDataSpecableVertex,
AbstractProvidesIncomingEdgeConstraints,
AbstractProvidesOutgoingEdgeConstraints,
AbstractProvidesNKeysForEdge):
"""
Instance of this class provide delays to incoming spikes in multiples
of the maximum delays of a neuron (typically 16 or 32)
"""
_DELAY_EXTENSION_REGIONS = Enum(
value="DELAY_EXTENSION_REGIONS",
names=[('SYSTEM', 0),
('DELAY_PARAMS', 1),
('SPIKE_HISTORY', 2)])
def __init__(self, n_neurons, max_delay_per_neuron, source_vertex,
machine_time_step, timescale_factor, constraints=None,
label="DelayExtension"):
"""
Creates a new DelayExtension Object.
"""
AbstractPartitionableVertex.__init__(self, n_atoms=n_neurons,
constraints=constraints,
label=label,
max_atoms_per_core=256)
AbstractDataSpecableVertex.__init__(
self, machine_time_step=machine_time_step,
timescale_factor=timescale_factor)
AbstractProvidesIncomingEdgeConstraints.__init__(self)
AbstractProvidesNKeysForEdge.__init__(self)
self._max_delay_per_neuron = max_delay_per_neuron
self._max_stages = 0
self._source_vertex = source_vertex
joint_constrant = PartitionerSameSizeAsVertexConstraint(source_vertex)
self.add_constraint(joint_constrant)
self._outgoing_edge_key_restrictor = \
OutgoingEdgeSameContiguousKeysRestrictor()
def get_incoming_edge_constraints(self, partitioned_edge, graph_mapper):
return list([KeyAllocatorFixedMaskConstraint(0xFFFFF800)])
@property
def model_name(self):
"""
Return a string representing a label for this class.
"""
return "DelayExtension"
@property
def max_stages(self):
""" The maximum number of delay stages required by any connection
out of this delay extension vertex
"""
return self._max_stages
@max_stages.setter
def max_stages(self, max_stages):
self._max_stages = max_stages
@property
def max_delay_per_neuron(self):
return self._max_delay_per_neuron
# noinspection PyUnusedLocal
@staticmethod
def get_spikes_per_timestep(lo_atom, hi_atom, machine_time_step):
# TODO: More accurate calculation of bounds
return 200
@staticmethod
def get_spike_block_row_length(n_atoms):
return int(math.ceil(n_atoms / common_constants.BITS_PER_WORD))
@staticmethod
def get_spike_region_bytes(spike_block_row_length, no_active_timesteps):
return spike_block_row_length * no_active_timesteps * 4
def get_spike_buffer_size(self, lo_atom, hi_atom):
"""
Gets the size of the spike buffer for a range of neurons and time steps
"""
if not self._record:
return 0
out_spikes_bytes = int(math.ceil((hi_atom - lo_atom + 1) / 32.0)) * 4
return self.get_recording_region_size(out_spikes_bytes)
@staticmethod
def get_block_index_bytes(no_active_timesteps):
return (constants.BLOCK_INDEX_HEADER_WORDS + (no_active_timesteps *
constants.BLOCK_INDEX_ROW_WORDS)) * 4
def generate_data_spec(
self, subvertex, placement, sub_graph, graph, routing_info,
hostname, graph_mapper, report_folder, ip_tags, reverse_ip_tags,
write_text_specs, application_run_time_folder):
"""
Model-specific construction of the data blocks necessary to build a
single Delay Extension Block on one core.
"""
data_writer, report_writer = \
self.get_data_spec_file_writers(
placement.x, placement.y, placement.p, hostname, report_folder,
write_text_specs, application_run_time_folder)
spec = DataSpecificationGenerator(data_writer, report_writer)
# Reserve memory:
spec.comment("\nReserving memory space for data regions:\n\n")
# ###################################################################
# Reserve SDRAM space for memory areas:
delay_params_header_words = 3
vertex_slice = graph_mapper.get_subvertex_slice(subvertex)
n_atoms = vertex_slice.hi_atom - vertex_slice.lo_atom + 1
block_len_words = int(math.ceil(n_atoms / 32.0))
num_delay_blocks, delay_blocks = self.get_delay_blocks(
subvertex, sub_graph, graph_mapper)
delay_params_sz = 4 * (delay_params_header_words +
(num_delay_blocks * block_len_words))
spec.reserve_memory_region(
region=self._DELAY_EXTENSION_REGIONS.SYSTEM.value,
size=constants.DATA_SPECABLE_BASIC_SETUP_INFO_N_WORDS * 4,
label='setup')
spec.reserve_memory_region(
region=self._DELAY_EXTENSION_REGIONS.DELAY_PARAMS.value,
size=delay_params_sz, label='delay_params')
self.write_setup_info(spec, 0)
spec.comment("\n*** Spec for Delay Extension Instance ***\n\n")
key = None
if len(sub_graph.outgoing_subedges_from_subvertex(subvertex)) > 0:
keys_and_masks = routing_info.get_keys_and_masks_from_subedge(
sub_graph.outgoing_subedges_from_subvertex(subvertex)[0])
# NOTE: using the first key assigned as the key. Should in future
# get the list of keys and use one per neuron, to allow arbitrary
# key and mask assignments
key = keys_and_masks[0].key
self.write_delay_parameters(spec, placement.x, placement.y,
placement.p, subvertex, num_delay_blocks,
delay_blocks, vertex_slice, key)
# End-of-Spec:
spec.end_specification()
data_writer.close()
def write_setup_info(self, spec, spike_history_region_sz):
"""
"""
# Write this to the system region (to be picked up by the simulation):
self._write_basic_setup_info(
spec, self._DELAY_EXTENSION_REGIONS.SYSTEM.value)
def get_delay_blocks(self, subvertex, sub_graph, graph_mapper):
# Create empty list of words to fill in with delay data:
vertex_slice = graph_mapper.get_subvertex_slice(subvertex)
n_atoms = (vertex_slice.hi_atom - vertex_slice.lo_atom) + 1
num_words_per_row = int(math.ceil(n_atoms / 32.0))
one_block = [0] * num_words_per_row
delay_block = list()
num_delay_blocks = 0
for subedge in sub_graph.outgoing_subedges_from_subvertex(subvertex):
subedge_assocated_edge = \
graph_mapper.get_partitionable_edge_from_partitioned_edge(
subedge)
if not isinstance(subedge_assocated_edge, DelayPartitionableEdge):
raise exceptions.DelayExtensionException(
"One of the incoming subedges is not a subedge of a"
" DelayPartitionableEdge")
# Loop through each possible delay block
dest = subedge.post_subvertex
source_vertex_slice = graph_mapper.get_subvertex_slice(subvertex)
dest_vertex_slice = graph_mapper.get_subvertex_slice(dest)
partitionable_edge = graph_mapper.\
get_partitionable_edge_from_partitioned_edge(subedge)
synapse_list = partitionable_edge.synapse_list.create_atom_sublist(
source_vertex_slice, dest_vertex_slice)
rows = synapse_list.get_rows()
for (source_id, row) in zip(range(len(rows)), rows):
for delay in row.delays:
stage = int(math.floor((delay - 1) /
self.max_delay_per_neuron)) - 1
num_delay_blocks = max(stage + 1, num_delay_blocks)
if num_delay_blocks > self._max_stages:
raise Exception(
"Too many stages ({} of {}) have been"
" created for delay extension {}".format(
num_delay_blocks, self._max_stages,
self._label))
while num_delay_blocks > len(delay_block):
delay_block.append(copy.copy(one_block))
# This source neurons has synapses in the current delay
# range. So set the bit in the delay_block:
word_id = int(source_id / 32)
bit_id = source_id - (word_id * 32)
delay_block[stage][word_id] |= (1 << bit_id)
return num_delay_blocks, delay_block
def write_delay_parameters(self, spec, processor_chip_x, processor_chip_y,
processor_id, subvertex, num_delay_blocks,
delay_block, vertex_slice, key):
"""
Generate Delay Parameter data (region 2):
"""
n_atoms = (vertex_slice.hi_atom - vertex_slice.lo_atom) + 1
# Write spec with commands to construct required delay region:
spec.comment("\nWriting Delay Parameters for {} Neurons:\n"
.format(n_atoms))
# Set the focus to the memory region 2 (delay parameters):
spec.switch_write_focus(
region=self._DELAY_EXTENSION_REGIONS.DELAY_PARAMS.value)
# Write header info to the memory region:
# Write Key info for this core:
# Every outgoing edge from this vertex should have the same key
spec.write_value(data=key)
# Write the number of neurons in the block:
spec.write_value(data=n_atoms)
# Write the number of blocks of delays:
spec.write_value(data=num_delay_blocks)
# Write the actual delay blocks
for i in range(0, num_delay_blocks):
spec.write_array(array_values=delay_block[i])
# inherited from partitionable vertex
def get_cpu_usage_for_atoms(self, vertex_slice, graph):
n_atoms = (vertex_slice.hi_atom - vertex_slice.lo_atom) + 1
return 128 * n_atoms
def get_sdram_usage_for_atoms(self, vertex_slice, graph):
# TODO: Fill this in
return 0
def get_dtcm_usage_for_atoms(self, vertex_slice, graph):
n_atoms = (vertex_slice.hi_atom - vertex_slice.lo_atom) + 1
return (44 + (16 * 4)) * n_atoms
def get_binary_file_name(self):
return "delay_extension.aplx"
def is_data_specable(self):
"""
helper method for isinstance
:return:
"""
return True
def get_n_keys_for_partitioned_edge(self, partitioned_edge, graph_mapper):
vertex_slice = graph_mapper.get_subvertex_slice(
partitioned_edge.pre_subvertex)
return vertex_slice.n_atoms * self._max_stages
def get_outgoing_edge_constraints(self, partitioned_edge, graph_mapper):
"""
gets the constraints for edges going out of this vertex
:param partitioned_edge: the parittioned edge that leaves this vertex
:param graph_mapper: the graph mapper object
:return: list of constraints
"""
return self._outgoing_edge_key_restrictor.get_outgoing_edge_constraints(
partitioned_edge, graph_mapper)
class SpikeSourceArray(
AbstractDataSpecableVertex, AbstractPartitionableVertex,
AbstractSpikeRecordable, AbstractProvidesOutgoingEdgeConstraints):
"""
model for play back of spikes
"""
_CONFIGURATION_REGION_SIZE = 36
# limited to the n of the x,y,p,n key format
_model_based_max_atoms_per_core = sys.maxint
_SPIKE_SOURCE_REGIONS = Enum(
value="_SPIKE_SOURCE_REGIONS",
names=[('SYSTEM_REGION', 0),
('CONFIGURATION_REGION', 1),
('SPIKE_DATA_REGION', 2),
('SPIKE_DATA_RECORDED_REGION', 3)])
def __init__(
self, n_neurons, spike_times, machine_time_step, timescale_factor,
port=None, tag=None, ip_address=None, board_address=None,
max_on_chip_memory_usage_for_spikes_in_bytes=None,
space_before_notification=640,
constraints=None, label="SpikeSourceArray"):
if ip_address is None:
ip_address = config.get("Buffers", "receive_buffer_host")
if port is None:
port = config.getint("Buffers", "receive_buffer_port")
AbstractDataSpecableVertex.__init__(
self, machine_time_step=machine_time_step,
timescale_factor=timescale_factor)
AbstractPartitionableVertex.__init__(
self, n_atoms=n_neurons, label=label,
max_atoms_per_core=self._model_based_max_atoms_per_core,
constraints=constraints)
AbstractSpikeRecordable.__init__(self)
self._spike_times = spike_times
self._max_on_chip_memory_usage_for_spikes = \
max_on_chip_memory_usage_for_spikes_in_bytes
self._space_before_notification = space_before_notification
self.add_constraint(TagAllocatorRequireIptagConstraint(
ip_address, port, strip_sdp=True, board_address=board_address,
tag_id=tag))
if self._max_on_chip_memory_usage_for_spikes is None:
self._max_on_chip_memory_usage_for_spikes = \
front_end_common_constants.MAX_SIZE_OF_BUFFERED_REGION_ON_CHIP
# check the values do not conflict with chip memory limit
if self._max_on_chip_memory_usage_for_spikes < 0:
raise ConfigurationException(
"The memory usage on chip is either beyond what is supportable"
" on the spinnaker board being supported or you have requested"
" a negative value for a memory usage. Please correct and"
" try again")
if (self._max_on_chip_memory_usage_for_spikes <
self._space_before_notification):
self._space_before_notification =\
self._max_on_chip_memory_usage_for_spikes
# Keep track of any previously generated buffers
self._send_buffers = dict()
self._spike_recording_region_size = None
# handle recording
self._spike_recorder = EIEIOSpikeRecorder(machine_time_step)
#handle outgoing constraints
self._outgoing_edge_key_restrictor = \
OutgoingEdgeSameContiguousKeysRestrictor()
@property
def spike_times(self):
return self._spike_times
@spike_times.setter
def spike_times(self, spike_times):
self._spike_times = spike_times
def is_recording_spikes(self):
return self._spike_recorder.record
def set_recording_spikes(self):
self._spike_recorder.record = True
def get_spikes(self, transceiver, n_machine_time_steps, placements,
graph_mapper):
return self._spike_recorder.get_spikes(
self.label, transceiver,
self._SPIKE_SOURCE_REGIONS.SPIKE_DATA_RECORDED_REGION.value,
placements, graph_mapper, self)
@property
def model_name(self):
"""
Return a string representing a label for this class.
"""
return "SpikeSourceArray"
@staticmethod
def set_model_max_atoms_per_core(new_value):
"""
:param new_value:
:return:
"""
SpikeSourceArray._model_based_max_atoms_per_core = new_value
def create_subvertex(self, vertex_slice, resources_required, label=None,
constraints=list()):
"""
creates a partitioned vertex from a partitionable vertex
:param vertex_slice: the slice of partitionable atoms that the
new partitioned vertex will contain
:param resources_required: the reosurces used by the partitioned vertex
:param label: the label of the partitioned vertex
:param constraints: extra constraints added to the partitioned vertex
:return: a partitioned vertex
:rtype: SpikeSourceArrayPartitionedVertex
"""
# map region id to the sned buffer for this partitioned vertex
send_buffer = dict()
send_buffer[self._SPIKE_SOURCE_REGIONS.SPIKE_DATA_REGION.value] =\
self._get_spike_send_buffer(vertex_slice)
# create and return the partitioned vertex
return SpikeSourceArrayPartitionedVertex(
send_buffer, resources_required, label, constraints)
def _get_spike_send_buffer(self, vertex_slice):
"""
spikeArray is a list with one entry per 'neuron'. The entry for
one neuron is a list of times (in ms) when the neuron fires.
We need to transpose this 'matrix' and get a list of firing neuron
indices for each time tick:
List can come in two formats (both now supported):
1) Official PyNN format - single list that is used for all neurons
2) SpiNNaker format - list of lists, one per neuron
"""
send_buffer = None
key = (vertex_slice.lo_atom, vertex_slice.hi_atom)
if key not in self._send_buffers:
send_buffer = BufferedSendingRegion(
self._max_on_chip_memory_usage_for_spikes)
if hasattr(self._spike_times[0], "__len__"):
# This is in SpiNNaker 'list of lists' format:
for neuron in range(vertex_slice.lo_atom,
vertex_slice.hi_atom + 1):
for timeStamp in sorted(self._spike_times[neuron]):
time_stamp_in_ticks = int(
math.ceil((timeStamp * 1000.0) /
self._machine_time_step))
send_buffer.add_key(time_stamp_in_ticks,
neuron - vertex_slice.lo_atom)
else:
# This is in official PyNN format, all neurons use the
# same list:
neuron_list = range(vertex_slice.n_atoms)
for timeStamp in sorted(self._spike_times):
time_stamp_in_ticks = int(
math.ceil((timeStamp * 1000.0) /
self._machine_time_step))
# add to send_buffer collection
send_buffer.add_keys(time_stamp_in_ticks, neuron_list)
self._send_buffers[key] = send_buffer
else:
send_buffer = self._send_buffers[key]
return send_buffer
def _reserve_memory_regions(
self, spec, spike_region_size, recorded_region_size):
""" Reserve memory for the system, indices and spike data regions.
The indices region will be copied to DTCM by the executable.
"""
spec.reserve_memory_region(
region=self._SPIKE_SOURCE_REGIONS.SYSTEM_REGION.value,
size=(constants.DATA_SPECABLE_BASIC_SETUP_INFO_N_WORDS * 4) + 8,
label='systemInfo')
spec.reserve_memory_region(
region=self._SPIKE_SOURCE_REGIONS.CONFIGURATION_REGION.value,
size=self._CONFIGURATION_REGION_SIZE, label='configurationRegion')
spec.reserve_memory_region(
region=self._SPIKE_SOURCE_REGIONS.SPIKE_DATA_REGION.value,
size=spike_region_size, label='SpikeDataRegion', empty=True)
if self._spike_recorder.record:
spec.reserve_memory_region(
region=(self._SPIKE_SOURCE_REGIONS
.SPIKE_DATA_RECORDED_REGION.value),
size=recorded_region_size + 4, label="RecordedSpikeDataRegion",
empty=True)
def _write_setup_info(self, spec, spike_buffer_region_size, ip_tags,
total_recording_region_size):
"""
Write information used to control the simulation and gathering of
results. Currently, this means the flag word used to signal whether
information on neuron firing and neuron potential is either stored
locally in a buffer or passed out of the simulation for storage/display
as the simulation proceeds.
The format of the information is as follows:
Word 0: Flags selecting data to be gathered during simulation.
Bit 0: Record spike history
Bit 1: Record neuron potential
Bit 2: Record gsyn values
Bit 3: Reserved
Bit 4: Output spike history on-the-fly
Bit 5: Output neuron potential
Bit 6: Output spike rate
"""
self._write_basic_setup_info(
spec, self._SPIKE_SOURCE_REGIONS.SYSTEM_REGION.value)
# write flag for recording
if self._spike_recorder.record:
value = 1 | 0xBEEF0000
spec.write_value(data=value)
spec.write_value(data=(total_recording_region_size + 4))
else:
spec.write_value(data=0)
spec.write_value(data=0)
spec.switch_write_focus(
region=self._SPIKE_SOURCE_REGIONS.CONFIGURATION_REGION.value)
# write configs for reverse ip tag
# NOTE
# as the packets are formed in the buffers, and that its a spike source
# array, and shouldn't have injected packets, no config should be
# required for it to work. the packet format will override these anyhow
# END NOTE
spec.write_value(data=0) # prefix value
spec.write_value(data=0) # prefix
spec.write_value(data=0) # key left shift
spec.write_value(data=0) # add key check
spec.write_value(data=0) # key for transmitting
spec.write_value(data=0) # mask for transmitting
# write configs for buffers
spec.write_value(data=spike_buffer_region_size)
spec.write_value(data=self._space_before_notification)
ip_tag = iter(ip_tags).next()
spec.write_value(data=ip_tag.tag)
# inherited from dataspecable vertex
def generate_data_spec(
self, subvertex, placement, subgraph, graph, routing_info,
hostname, graph_mapper, report_folder, ip_tags, reverse_ip_tags,
write_text_specs, application_run_time_folder):
"""
Model-specific construction of the data blocks necessary to build a
single SpikeSource Array on one core.
:param subvertex:
:param placement:
:param subgraph:
:param graph:
:param routing_info:
:param hostname:
:param graph_mapper:
:param report_folder:
:param ip_tags:
:param reverse_ip_tags:
:param write_text_specs:
:param application_run_time_folder:
:return:
"""
data_writer, report_writer = \
self.get_data_spec_file_writers(
placement.x, placement.y, placement.p, hostname, report_folder,
write_text_specs, application_run_time_folder)
spec = DataSpecificationGenerator(data_writer, report_writer)
spec.comment("\n*** Spec for SpikeSourceArray Instance ***\n\n")
# ###################################################################
# Reserve SDRAM space for memory areas:
spec.comment("\nReserving memory space for spike data region:\n\n")
vertex_slice = graph_mapper.get_subvertex_slice(subvertex)
spike_buffer = self._get_spike_send_buffer(vertex_slice)
recording_size = (spike_buffer.total_region_size + 4 +
_RECORD_OVERALLOCATION)
self._reserve_memory_regions(spec, spike_buffer.buffer_size,
recording_size)
self._write_setup_info(
spec, spike_buffer.buffer_size, ip_tags, recording_size)
# End-of-Spec:
spec.end_specification()
data_writer.close()
# tell the subvertex its region size
subvertex.region_size = recording_size
def get_binary_file_name(self):
"""
:return:
"""
return "reverse_iptag_multicast_source.aplx"
# inherited from partitionable vertex
def get_cpu_usage_for_atoms(self, vertex_slice, graph):
"""
:param vertex_slice:
:param graph:
:return:
"""
return 0
def get_sdram_usage_for_atoms(self, vertex_slice, graph):
""" calculates the total sdram usage of the spike source array. If the
memory requirement is beyond what is deemed to be the usage of the
processor, then it executes a buffered format.
:param vertex_slice: the slice of atoms this partitioned vertex will
represent from the partiionable vertex
:param graph: the partitionable graph which contains the high level
objects
:return:
"""
send_buffer = self._get_spike_send_buffer(vertex_slice)
send_size = send_buffer.buffer_size
record_size = 0
if self._spike_recorder.record:
record_size = (send_buffer.total_region_size + 4 +
_RECORD_OVERALLOCATION)
return (
(constants.DATA_SPECABLE_BASIC_SETUP_INFO_N_WORDS * 4) +
SpikeSourceArray._CONFIGURATION_REGION_SIZE + send_size +
record_size)
def get_dtcm_usage_for_atoms(self, vertex_slice, graph):
"""
:param vertex_slice:
:param graph:
:return:
"""
return 0
def get_outgoing_edge_constraints(self, partitioned_edge, graph_mapper):
"""
gets the constraints for edges going out of this vertex
:param partitioned_edge: the parittioned edge that leaves this vertex
:param graph_mapper: the graph mapper object
:return: list of constraints
"""
return self._outgoing_edge_key_restrictor.get_outgoing_edge_constraints(
partitioned_edge, graph_mapper)
def is_data_specable(self):
"""
helper method for isinstance
:return:
"""
return True
def get_value(self, key):
""" Get a property of the overall model
"""
if hasattr(self, key):
return getattr(self, key)
raise Exception("Population {} does not have parameter {}".format(
self, key))
def set_value(self, key, value):
""" Set a property of the overall model
:param key: the name of the param to change
:param value: the value of the parameter to change
"""
if hasattr(self, key):
setattr(self, key, value)
return
raise Exception("Type {} does not have parameter {}".format(
self._model_name, key))
class SpikeSourcePoisson(
AbstractPartitionableVertex, AbstractDataSpecableVertex,
AbstractSpikeRecordable, AbstractProvidesOutgoingEdgeConstraints):
"""
This class represents a Poisson Spike source object, which can represent
a pynn_population.py of virtual neurons each with its own parameters.
"""
_POISSON_SPIKE_SOURCE_REGIONS = Enum(
value="_POISSON_SPIKE_SOURCE_REGIONS",
names=[('SYSTEM_REGION', 0),
('POISSON_PARAMS_REGION', 1),
('SPIKE_HISTORY_REGION', 2)])
# Technically, this is ~2900 in terms of DTCM, but is timescale dependent
# in terms of CPU (2900 at 10 times slowdown is fine, but not at realtime)
_model_based_max_atoms_per_core = 500
def __init__(self, n_neurons, machine_time_step, timescale_factor,
constraints=None, label="SpikeSourcePoisson",
rate=1.0, start=0.0, duration=None, seed=None):
"""
Creates a new SpikeSourcePoisson Object.
"""
AbstractPartitionableVertex.__init__(
self, n_atoms=n_neurons, label=label, constraints=constraints,
max_atoms_per_core=self._model_based_max_atoms_per_core)
AbstractDataSpecableVertex.__init__(
self, machine_time_step=machine_time_step,
timescale_factor=timescale_factor)
AbstractSpikeRecordable.__init__(self)
# Store the parameters
self._rate = rate
self._start = start
self._duration = duration
self._rng = numpy.random.RandomState(seed)
# Prepare for recording, and to get spikes
self._spike_recorder = SpikeRecorder(machine_time_step)
self._outgoing_edge_key_restrictor = \
OutgoingEdgeSameContiguousKeysRestrictor()
@property
def rate(self):
return self._rate
@rate.setter
def rate(self, rate):
self._rate = rate
@property
def start(self):
return self._start
@start.setter
def start(self, start):
self._start = start
@property
def duration(self):
return self._duration
@duration.setter
def duration(self, duration):
self._duration = duration
@property
def seed(self):
return self._seed
@seed.setter
def seed(self, seed):
self._seed = seed
@property
def model_name(self):
"""
Return a string representing a label for this class.
"""
return "SpikeSourcePoisson"
@staticmethod
def set_model_max_atoms_per_core(new_value):
"""
:param new_value:
:return:
"""
SpikeSourcePoisson._model_based_max_atoms_per_core = new_value
@staticmethod
def get_params_bytes(vertex_slice):
"""
Gets the size of the possion parameters in bytes
:param vertex_slice:
"""
return (RANDOM_SEED_WORDS + PARAMS_BASE_WORDS +
(((vertex_slice.hi_atom - vertex_slice.lo_atom) + 1) *
PARAMS_WORDS_PER_NEURON)) * 4
def reserve_memory_regions(self, spec, setup_sz, poisson_params_sz,
spike_hist_buff_sz):
"""
Reserve memory regions for poisson source parameters
and output buffer.
:param spec:
:param setup_sz:
:param poisson_params_sz:
:param spike_hist_buff_sz:
:return:
"""
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=self._POISSON_SPIKE_SOURCE_REGIONS.SYSTEM_REGION.value,
size=setup_sz, label='setup')
spec.reserve_memory_region(
region=self._POISSON_SPIKE_SOURCE_REGIONS
.POISSON_PARAMS_REGION.value,
size=poisson_params_sz, label='PoissonParams')
if spike_hist_buff_sz > 0:
spec.reserve_memory_region(
region=self._POISSON_SPIKE_SOURCE_REGIONS
.SPIKE_HISTORY_REGION.value,
size=spike_hist_buff_sz, label='spikeHistBuffer',
empty=True)
def write_setup_info(self, spec, spike_history_region_sz):
"""
Write information used to control the simulationand gathering of
results.
Currently, this means the flag word used to signal whether information
on neuron firing and neuron potential is either stored locally in a
buffer or
passed out of the simulation for storage/display as the simulation
proceeds.
The format of the information is as follows:
Word 0: Flags selecting data to be gathered during simulation.
Bit 0: Record spike history
:param spec:
:param spike_history_region_sz:
:return:
"""
self._write_basic_setup_info(
spec, self._POISSON_SPIKE_SOURCE_REGIONS.SYSTEM_REGION.value)
recording_info = 0
if self._spike_recorder.record:
recording_info |= constants.RECORD_SPIKE_BIT
recording_info |= 0xBEEF0000
# Write this to the system region (to be picked up by the simulation):
spec.write_value(data=recording_info)
spec.write_value(data=spike_history_region_sz)
def write_poisson_parameters(self, spec, key, num_neurons):
"""
Generate Neuron Parameter data for Poisson spike sources (region 2):
:param spec:
:param key:
:param num_neurons:
:return:
"""
spec.comment("\nWriting Neuron Parameters for {} poisson sources:\n"
.format(num_neurons))
# Set the focus to the memory region 2 (neuron parameters):
spec.switch_write_focus(
region=self._POISSON_SPIKE_SOURCE_REGIONS
.POISSON_PARAMS_REGION.value)
# Write header info to the memory region:
# Write Key info for this core:
if key is None:
# if theres no key, then two falses will cover it.
spec.write_value(data=0)
spec.write_value(data=0)
else:
# has a key, thus set has key to 1 and then add key
spec.write_value(data=1)
spec.write_value(data=key)
# Write the random seed (4 words), generated randomly!
spec.write_value(data=self._rng.randint(0x7FFFFFFF))
spec.write_value(data=self._rng.randint(0x7FFFFFFF))
spec.write_value(data=self._rng.randint(0x7FFFFFFF))
spec.write_value(data=self._rng.randint(0x7FFFFFFF))
# For each neuron, get the rate to work out if it is a slow
# or fast source
slow_sources = list()
fast_sources = list()
for i in range(0, num_neurons):
# Get the parameter values for source i:
rate_val = generate_parameter(self._rate, i)
start_val = generate_parameter(self._start, i)
end_val = None
if self._duration is not None:
end_val = generate_parameter(self._duration, i) + start_val
# Decide if it is a fast or slow source and
spikes_per_tick = \
(float(rate_val) * (self._machine_time_step / 1000000.0))
if spikes_per_tick <= SLOW_RATE_PER_TICK_CUTOFF:
slow_sources.append([i, rate_val, start_val, end_val])
else:
fast_sources.append([i, spikes_per_tick, start_val, end_val])
# Write the numbers of each type of source
spec.write_value(data=len(slow_sources))
spec.write_value(data=len(fast_sources))
# Now write one struct for each slow source as follows
#
# typedef struct slow_spike_source_t
# {
# uint32_t neuron_id;
# uint32_t start_ticks;
# uint32_t end_ticks;
#
# accum mean_isi_ticks;
# accum time_to_spike_ticks;
# } slow_spike_source_t;
for (neuron_id, rate_val, start_val, end_val) in slow_sources:
if rate_val == 0:
isi_val = 0
else:
isi_val = float(1000000.0 /
(rate_val * self._machine_time_step))
start_scaled = int(start_val * 1000.0 / self._machine_time_step)
end_scaled = 0xFFFFFFFF
if end_val is not None:
end_scaled = int(end_val * 1000.0 / self._machine_time_step)
spec.write_value(data=neuron_id, data_type=DataType.UINT32)
spec.write_value(data=start_scaled, data_type=DataType.UINT32)
spec.write_value(data=end_scaled, data_type=DataType.UINT32)
spec.write_value(data=isi_val, data_type=DataType.S1615)
spec.write_value(data=0x0, data_type=DataType.UINT32)
# Now write
# typedef struct fast_spike_source_t
# {
# uint32_t neuron_id;
# uint32_t start_ticks;
# uint32_t end_ticks;
#
# unsigned long fract exp_minus_lambda;
# } fast_spike_source_t;
for (neuron_id, spikes_per_tick, start_val, end_val) in fast_sources:
if spikes_per_tick == 0:
exp_minus_lamda = 0
else:
exp_minus_lamda = math.exp(-1.0 * spikes_per_tick)
start_scaled = int(start_val * 1000.0 / self._machine_time_step)
end_scaled = 0xFFFFFFFF
if end_val is not None:
end_scaled = int(end_val * 1000.0 / self._machine_time_step)
spec.write_value(data=neuron_id, data_type=DataType.UINT32)
spec.write_value(data=start_scaled, data_type=DataType.UINT32)
spec.write_value(data=end_scaled, data_type=DataType.UINT32)
spec.write_value(data=exp_minus_lamda, data_type=DataType.U032)
def is_recording_spikes(self):
return self._spike_recorder.record
def set_recording_spikes(self):
self._spike_recorder.record = True
# inherited from partionable vertex
def get_sdram_usage_for_atoms(self, vertex_slice, graph):
"""
method for calculating sdram usage
:param vertex_slice:
:param graph:
:return:
"""
poisson_params_sz = self.get_params_bytes(vertex_slice)
spike_hist_buff_sz = \
self._spike_recorder.get_sdram_usage_in_bytes(
vertex_slice.n_atoms, self._no_machine_time_steps)
return ((constants.DATA_SPECABLE_BASIC_SETUP_INFO_N_WORDS * 4) + 8 +
poisson_params_sz + spike_hist_buff_sz)
def get_dtcm_usage_for_atoms(self, vertex_slice, graph):
"""
method for calculating dtcm usage for a collection of atoms
:param vertex_slice:
:param graph:
:return:
"""
return 0
def get_cpu_usage_for_atoms(self, vertex_slice, graph):
"""
Gets the CPU requirements for a range of atoms
:param vertex_slice:
:param graph:
:return:
"""
return 0
# inherited from dataspecable vertex
def generate_data_spec(self, subvertex, placement, subgraph, graph,
routing_info, hostname, graph_mapper, report_folder,
ip_tags, reverse_ip_tags, write_text_specs,
application_run_time_folder):
"""
Model-specific construction of the data blocks necessary to build a
single SpikeSourcePoisson on one core.
:param subvertex:
:param placement:
:param subgraph:
:param graph:
:param routing_info:
:param hostname:
:param graph_mapper:
:param report_folder:
:param ip_tags:
:param reverse_ip_tags:
:param write_text_specs:
:param application_run_time_folder:
:return:
"""
data_writer, report_writer = \
self.get_data_spec_file_writers(
placement.x, placement.y, placement.p, hostname, report_folder,
write_text_specs, application_run_time_folder)
spec = DataSpecificationGenerator(data_writer, report_writer)
vertex_slice = graph_mapper.get_subvertex_slice(subvertex)
spike_hist_buff_sz = self._spike_recorder.get_sdram_usage_in_bytes(
vertex_slice.n_atoms, self._no_machine_time_steps)
spec.comment("\n*** Spec for SpikeSourcePoisson Instance ***\n\n")
# Basic setup plus 8 bytes for recording flags and recording size
setup_sz = ((constants.DATA_SPECABLE_BASIC_SETUP_INFO_N_WORDS * 4) + 8)
poisson_params_sz = self.get_params_bytes(vertex_slice)
# Reserve SDRAM space for memory areas:
self.reserve_memory_regions(
spec, setup_sz, poisson_params_sz, spike_hist_buff_sz)
self.write_setup_info(spec, spike_hist_buff_sz)
# Every subedge should have the same key
key = None
subedges = subgraph.outgoing_subedges_from_subvertex(subvertex)
if len(subedges) > 0:
keys_and_masks = routing_info.get_keys_and_masks_from_subedge(
subedges[0])
key = keys_and_masks[0].key
self.write_poisson_parameters(spec, key, vertex_slice.n_atoms)
# End-of-Spec:
spec.end_specification()
data_writer.close()
def get_binary_file_name(self):
"""
:return:
"""
return "spike_source_poisson.aplx"
def get_spikes(self, transceiver, n_machine_time_steps, placements,
graph_mapper):
return self._spike_recorder.get_spikes(
self._label, transceiver,
self._POISSON_SPIKE_SOURCE_REGIONS.SPIKE_HISTORY_REGION.value,
n_machine_time_steps, placements, graph_mapper, self)
def get_outgoing_edge_constraints(self, partitioned_edge, graph_mapper):
"""
gets the constraints for edges going out of this vertex
:param partitioned_edge: the parittioned edge that leaves this vertex
:param graph_mapper: the graph mapper object
:return: list of constraints
"""
return self._outgoing_edge_key_restrictor.get_outgoing_edge_constraints(
partitioned_edge, graph_mapper)
def is_data_specable(self):
"""
helper method for isinstance
:return:
"""
return True
def get_value(self, key):
""" Get a property of the overall model
"""
if hasattr(self, key):
return getattr(self, key)
raise Exception("Population {} does not have parameter {}".format(
self, key))
