def test_simple_record():
simulator = MockSimulator()
globals_variables.set_failed_state(SpynnakerFailedState())
globals_variables.set_simulator(simulator)
recordables = ["v", "gsyn_exc", "gsyn_inh"]
data_types = {
"v": DataType.S1615,
"gsyn_exc": DataType.S1615,
"gsyn_inh": DataType.S1615
}
nr = NeuronRecorder(recordables, data_types, [], 100)
assert(frozenset(["v", "gsyn_exc", "gsyn_inh"]) ==
frozenset(nr.get_recordable_variables()))
assert([] == nr.recording_variables)
nr.set_recording("v", True)
assert(["v"] == nr.recording_variables)
_slice = Slice(0, 50)
gps = nr.get_global_parameters(_slice)
# 3 rates (index "0" is v)
assert (gps[0].get_value() == 1)
# 3 n_neurons (index "3" is v)
assert (gps[3].get_value() == _slice.n_atoms)
def __init__(self, n_neurons, label, constraints, max_atoms_per_core,
spikes_per_second, ring_buffer_sigma,
incoming_spike_buffer_size, neuron_impl, pynn_model):
# pylint: disable=too-many-arguments, too-many-locals
super(AbstractPopulationVertex, self).__init__(label, constraints,
max_atoms_per_core)
self.__n_atoms = n_neurons
self.__n_subvertices = 0
self.__n_data_specs = 0
# buffer data
self.__incoming_spike_buffer_size = incoming_spike_buffer_size
# get config from simulator
config = globals_variables.get_simulator().config
if incoming_spike_buffer_size is None:
self.__incoming_spike_buffer_size = config.getint(
"Simulation", "incoming_spike_buffer_size")
self.__neuron_impl = neuron_impl
self.__pynn_model = pynn_model
self._parameters = SpynnakerRangeDictionary(n_neurons)
self._state_variables = SpynnakerRangeDictionary(n_neurons)
self.__neuron_impl.add_parameters(self._parameters)
self.__neuron_impl.add_state_variables(self._state_variables)
self.__initial_state_variables = None
self.__updated_state_variables = set()
# Set up for recording
recordable_variables = list(
self.__neuron_impl.get_recordable_variables())
record_data_types = dict(
self.__neuron_impl.get_recordable_data_types())
self.__neuron_recorder = NeuronRecorder(recordable_variables,
record_data_types,
[NeuronRecorder.SPIKES],
n_neurons)
# Set up synapse handling
self.__synapse_manager = SynapticManager(
self.__neuron_impl.get_n_synapse_types(), ring_buffer_sigma,
spikes_per_second, config)
# bool for if state has changed.
self.__change_requires_mapping = True
self.__change_requires_neuron_parameters_reload = False
self.__change_requires_data_generation = False
self.__has_reset_last = True
# Set up for profiling
self.__n_profile_samples = helpful_functions.read_config_int(
config, "Reports", "n_profile_samples")
def test_recording_variables():
simulator = MockSimulator()
globals_variables.set_failed_state(SpynnakerFailedState())
globals_variables.set_simulator(simulator)
nr = NeuronRecorder(["spikes", "v", "gsyn_exc", "gsyn_inh"], 100)
assert ([] == nr.recording_variables)
nr.set_recording("v", True)
nr.set_recording("gsyn_inh", True)
assert (["v", "gsyn_inh"] == nr.recording_variables)
assert ([1, 3] == nr.recorded_region_ids)
def test_turn_off_some_indexes(self):
data_types = {
"v": DataType.S1615,
"gsyn_exc": DataType.S1615,
"gsyn_inh": DataType.S1615
}
recorder = NeuronRecorder(["v", "gsyn_exc", "gsyn_inh"], data_types,
["spikes"], 5, [], [], [], [])
recorder.set_recording("spikes", True)
self.assertCountEqual(["spikes"], recorder.recording_variables)
recorder.set_recording("spikes", False, indexes=[2, 4])
self.assertCountEqual([0, 1, 3], recorder._indexes["spikes"])
def test_recording_variables():
unittest_setup()
recordables = ["v", "gsyn_exc", "gsyn_inh"]
data_types = {
"v": DataType.S1615,
"gsyn_exc": DataType.S1615,
"gsyn_inh": DataType.S1615
}
nr = NeuronRecorder(recordables, data_types, [], 100, [], [], [], [])
assert([] == nr.recording_variables)
nr.set_recording("v", True)
nr.set_recording("gsyn_inh", True)
assert(["v", "gsyn_inh"] == nr.recording_variables)
assert([0, 2] == nr.recorded_region_ids)
def test_simple_record():
unittest_setup()
recordables = ["v", "gsyn_exc", "gsyn_inh"]
data_types = {
"v": DataType.S1615,
"gsyn_exc": DataType.S1615,
"gsyn_inh": DataType.S1615
}
nr = NeuronRecorder(recordables, data_types, [], 100, [], [], [], [])
assert(frozenset(["v", "gsyn_exc", "gsyn_inh"]) ==
frozenset(nr.get_recordable_variables()))
assert([] == nr.recording_variables)
nr.set_recording("v", True)
assert(["v"] == nr.recording_variables)
def test_simple_record():
simulator = _MockBasicSimulator()
globals_variables.set_failed_state(SpynnakerFailedState())
globals_variables.set_simulator(simulator)
nr = NeuronRecorder(["spikes", "v", "gsyn_exc", "gsyn_inh"], 100)
assert (frozenset(["spikes", "v", "gsyn_exc", "gsyn_inh"
]) == frozenset(nr.get_recordable_variables()))
assert ([] == nr.recording_variables)
nr.set_recording("v", True)
assert (["v"] == nr.recording_variables)
_slice = Slice(0, 50)
gps = nr.get_global_parameters(_slice)
# 4 rates second (index "1") is v
assert (gps[1].get_value() == 1)
# 4 n_neurons second (index "5") is v
assert (gps[5].get_value() == _slice.n_atoms)
def test_recording_variables():
simulator = MockSimulator()
globals_variables.set_failed_state(SpynnakerFailedState())
globals_variables.set_simulator(simulator)
recordables = ["v", "gsyn_exc", "gsyn_inh"]
data_types = {
"v": DataType.S1615,
"gsyn_exc": DataType.S1615,
"gsyn_inh": DataType.S1615
}
nr = NeuronRecorder(recordables, data_types, [], 100)
assert([] == nr.recording_variables)
nr.set_recording("v", True)
nr.set_recording("gsyn_inh", True)
assert(["v", "gsyn_inh"] == nr.recording_variables)
assert([0, 2] == nr.recorded_region_ids)
def test_simple_record():
simulator = MockSimulator()
globals_variables.set_failed_state(SpynnakerFailedState())
globals_variables.set_simulator(simulator)
recordables = ["v", "gsyn_exc", "gsyn_inh"]
data_types = {
"v": DataType.S1615,
"gsyn_exc": DataType.S1615,
"gsyn_inh": DataType.S1615
}
nr = NeuronRecorder(recordables, data_types, [], 100, [], [])
assert(frozenset(["v", "gsyn_exc", "gsyn_inh"]) ==
frozenset(nr.get_recordable_variables()))
assert([] == nr.recording_variables)
nr.set_recording("v", True)
assert(["v"] == nr.recording_variables)
def __init__(self,
n_neurons,
binary,
label,
max_atoms_per_core,
spikes_per_second,
ring_buffer_sigma,
incoming_spike_buffer_size,
model_name,
neuron_model,
input_type,
synapse_type,
threshold_type,
additional_input=None,
constraints=None):
# pylint: disable=too-many-arguments, too-many-locals
super(AbstractPopulationVertex, self).__init__(label, constraints,
max_atoms_per_core)
self._units = {
'spikes': 'spikes',
'v': 'mV',
'gsyn_exc': "uS",
'gsyn_inh': "uS"
}
self._binary = binary
self._n_atoms = n_neurons
# buffer data
self._incoming_spike_buffer_size = incoming_spike_buffer_size
# get config from simulator
config = globals_variables.get_simulator().config
if incoming_spike_buffer_size is None:
self._incoming_spike_buffer_size = config.getint(
"Simulation", "incoming_spike_buffer_size")
self._model_name = model_name
self._neuron_model = neuron_model
self._input_type = input_type
self._threshold_type = threshold_type
self._additional_input = additional_input
# Set up for recording
self._neuron_recorder = NeuronRecorder(
["spikes", "v", "gsyn_exc", "gsyn_inh"], n_neurons)
self._time_between_requests = config.getint("Buffers",
"time_between_requests")
self._minimum_buffer_sdram = config.getint("Buffers",
"minimum_buffer_sdram")
self._using_auto_pause_and_resume = config.getboolean(
"Buffers", "use_auto_pause_and_resume")
self._receive_buffer_host = config.get("Buffers",
"receive_buffer_host")
self._receive_buffer_port = helpful_functions.read_config_int(
config, "Buffers", "receive_buffer_port")
# If live buffering is enabled, set a maximum on the buffer sizes
spike_buffer_max_size = 0
v_buffer_max_size = 0
gsyn_buffer_max_size = 0
self._buffer_size_before_receive = None
if config.getboolean("Buffers", "enable_buffered_recording"):
spike_buffer_max_size = config.getint("Buffers",
"spike_buffer_size")
v_buffer_max_size = config.getint("Buffers", "v_buffer_size")
gsyn_buffer_max_size = config.getint("Buffers", "gsyn_buffer_size")
self._buffer_size_before_receive = config.getint(
"Buffers", "buffer_size_before_receive")
self._maximum_sdram_for_buffering = [
spike_buffer_max_size, v_buffer_max_size, gsyn_buffer_max_size,
gsyn_buffer_max_size
]
# Set up synapse handling
self._synapse_manager = SynapticManager(synapse_type,
ring_buffer_sigma,
spikes_per_second, config)
# bool for if state has changed.
self._change_requires_mapping = True
self._change_requires_neuron_parameters_reload = False
# Set up for profiling
self._n_profile_samples = helpful_functions.read_config_int(
config, "Reports", "n_profile_samples")
def test_turn_off_some_indexes(self):
recorder = NeuronRecorder(["spikes", "v", "gsyn_exc", "gsyn_inh"], 5)
recorder.set_recording("spikes", True)
self.assertListEq(["spikes"], recorder.recording_variables)
recorder.set_recording("spikes", False, indexes=[2, 4])
self.assertListEq([0, 1, 3], recorder._indexes["spikes"])
def __init__(self, n_neurons, label, constraints, max_atoms_per_core,
spikes_per_second, ring_buffer_sigma,
incoming_spike_buffer_size, neuron_impl, pynn_model):
"""
:param int n_neurons: The number of neurons in the population
:param str label: The label on the population
:param list(~pacman.model.constraints.AbstractConstraint) constraints:
Constraints on where a population's vertices may be placed.
:param int max_atoms_per_core:
The maximum number of atoms (neurons) per SpiNNaker core.
:param spikes_per_second: Expected spike rate
:type spikes_per_second: float or None
:param ring_buffer_sigma:
How many SD above the mean to go for upper bound of ring buffer \
size; a good starting choice is 5.0. Given length of simulation \
we can set this for approximate number of saturation events.
:type ring_buffer_sigma: float or None
:param incoming_spike_buffer_size:
:type incoming_spike_buffer_size: int or None
:param AbstractNeuronImpl neuron_impl:
The (Python side of the) implementation of the neurons themselves.
:param AbstractPyNNNeuronModel pynn_model:
The PyNN neuron model that this vertex is working on behalf of.
"""
# pylint: disable=too-many-arguments, too-many-locals
ApplicationVertex.__init__(self, label, constraints,
max_atoms_per_core)
self.__n_atoms = n_neurons
self.__n_subvertices = 0
self.__n_data_specs = 0
# buffer data
self.__incoming_spike_buffer_size = incoming_spike_buffer_size
# get config from simulator
config = globals_variables.get_simulator().config
if incoming_spike_buffer_size is None:
self.__incoming_spike_buffer_size = config.getint(
"Simulation", "incoming_spike_buffer_size")
self.__neuron_impl = neuron_impl
self.__pynn_model = pynn_model
self._parameters = SpynnakerRangeDictionary(n_neurons)
self._state_variables = SpynnakerRangeDictionary(n_neurons)
self.__neuron_impl.add_parameters(self._parameters)
self.__neuron_impl.add_state_variables(self._state_variables)
self.__initial_state_variables = None
self.__updated_state_variables = set()
# Set up for recording
recordable_variables = list(
self.__neuron_impl.get_recordable_variables())
record_data_types = dict(
self.__neuron_impl.get_recordable_data_types())
self.__neuron_recorder = NeuronRecorder(recordable_variables,
record_data_types,
[NeuronRecorder.SPIKES],
n_neurons)
# Set up synapse handling
self.__synapse_manager = SynapticManager(
self.__neuron_impl.get_n_synapse_types(), ring_buffer_sigma,
spikes_per_second, config)
# bool for if state has changed.
self.__change_requires_mapping = True
self.__change_requires_neuron_parameters_reload = False
self.__change_requires_data_generation = False
self.__has_reset_last = True
# Set up for profiling
self.__n_profile_samples = helpful_functions.read_config_int(
config, "Reports", "n_profile_samples")
def __init__(self, n_neurons, constraints, label, model, profile,
time_scale_factor):
# Superclasses
ApplicationVertex.__init__(self, label, constraints)
AbstractAcceptsIncomingSynapses.__init__(self)
SimplePopulationSettable.__init__(self)
HandOverToVertex.__init__(self)
AbstractChangableAfterRun.__init__(self)
AbstractSpikeRecordable.__init__(self)
AbstractNeuronRecordable.__init__(self)
AbstractProvidesNKeysForPartition.__init__(self)
self._model = model
self._profile = profile
self._remapping_required = True
self._synapse_dynamics = None
self._n_fibres_per_ihc = None
self._n_group_tree_rows = None
self._ihcan_vertices = list()
self._drnl_vertices = list()
self._final_agg_vertices = list()
self.__synapse_manager = SynapticManager(
self.N_SYNAPSE_TYPES, None, None,
globals_variables.get_simulator().config)
# calculate n fibres per ihcan core
sample_time = time_scale_factor / self._model.fs
# how many channels
self._n_channels = int(self.get_out_going_size() /
self._model.n_fibres_per_ihc)
# process pole freqs
self._pole_freqs = self._process_pole_freqs()
# how many fibres / atoms ran on each ihcan core
self._n_fibres_per_ihcan_core = self.fibres_per_ihcan_core(
sample_time, self._model.n_fibres_per_ihc)
# process all the other internal numbers
atoms_per_row = self.process_internal_numbers()
# read in param file if needed
self._process_param_file(atoms_per_row)
# recording stuff
self._drnl_neuron_recorder = NeuronRecorder(
DRNLMachineVertex.RECORDABLES,
DRNLMachineVertex.get_matrix_scalar_data_types(),
DRNLMachineVertex.get_matrix_output_data_types(), self._n_dnrls)
self._ihcan_neuron_recorder = NeuronRecorder(
IHCANMachineVertex.RECORDABLES,
IHCANMachineVertex.get_matrix_scalar_data_types(),
IHCANMachineVertex.get_matrix_output_data_types(),
self._n_dnrls * self._n_fibres_per_ihc)
# bool for if state has changed.
self._change_requires_mapping = True
self._change_requires_neuron_parameters_reload = False
self._change_requires_data_generation = False
self._has_reset_last = True
# safety check
if self._n_atoms != n_neurons:
raise ConfigurationException(
self.N_NEURON_ERROR.format(n_neurons, self._n_atoms))
# safety stuff
if (self._model.fs / time_scale_factor >
self.MAX_TIME_SCALE_FACTOR_RATIO):
raise Exception(self.FREQUENCY_ERROR)
# write timer period
self._timer_period = (MICRO_TO_SECOND_CONVERSION *
(self._model.seq_size / self._model.fs))
def __init__(self, n_neurons, label, constraints, max_atoms_per_core,
spikes_per_second, ring_buffer_sigma,
incoming_spike_buffer_size, neuron_impl, pynn_model):
# pylint: disable=too-many-arguments, too-many-locals
super(AbstractPopulationVertex, self).__init__(label, constraints,
max_atoms_per_core)
self._n_atoms = n_neurons
# buffer data
self._incoming_spike_buffer_size = incoming_spike_buffer_size
# get config from simulator
config = globals_variables.get_simulator().config
if incoming_spike_buffer_size is None:
self._incoming_spike_buffer_size = config.getint(
"Simulation", "incoming_spike_buffer_size")
self._neuron_impl = neuron_impl
self._pynn_model = pynn_model
self._parameters = SpynnakerRangeDictionary(n_neurons)
self._state_variables = SpynnakerRangeDictionary(n_neurons)
self._neuron_impl.add_parameters(self._parameters)
self._neuron_impl.add_state_variables(self._state_variables)
# Set up for recording
recordables = ["spikes"]
recordables.extend(self._neuron_impl.get_recordable_variables())
self._neuron_recorder = NeuronRecorder(recordables, n_neurons)
self._time_between_requests = config.getint("Buffers",
"time_between_requests")
self._minimum_buffer_sdram = config.getint("Buffers",
"minimum_buffer_sdram")
self._using_auto_pause_and_resume = config.getboolean(
"Buffers", "use_auto_pause_and_resume")
self._receive_buffer_host = config.get("Buffers",
"receive_buffer_host")
self._receive_buffer_port = helpful_functions.read_config_int(
config, "Buffers", "receive_buffer_port")
# If live buffering is enabled, set a maximum on the buffer sizes
spike_buffer_max_size = 0
variable_buffer_max_size = 0
self._buffer_size_before_receive = None
if config.getboolean("Buffers", "enable_buffered_recording"):
spike_buffer_max_size = config.getint("Buffers",
"spike_buffer_size")
variable_buffer_max_size = config.getint("Buffers",
"variable_buffer_size")
self._maximum_sdram_for_buffering = [spike_buffer_max_size]
for _ in self._neuron_impl.get_recordable_variables():
self._maximum_sdram_for_buffering.append(variable_buffer_max_size)
# Set up synapse handling
self._synapse_manager = SynapticManager(
self._neuron_impl.get_n_synapse_types(), ring_buffer_sigma,
spikes_per_second, config)
# bool for if state has changed.
self._change_requires_mapping = True
self._change_requires_neuron_parameters_reload = False
# Set up for profiling
self._n_profile_samples = helpful_functions.read_config_int(
config, "Reports", "n_profile_samples")