def __init__(
self,
n_neurons,
machine_time_step,
timescale_factor,
spike_times=None,
port=None,
tag=None,
ip_address=None,
board_address=None,
max_on_chip_memory_usage_for_spikes_in_bytes=(constants.SPIKE_BUFFER_SIZE_BUFFERING_IN),
space_before_notification=640,
constraints=None,
label="SpikeSourceArray",
spike_recorder_buffer_size=(constants.EIEIO_SPIKE_BUFFER_SIZE_BUFFERING_OUT),
buffer_size_before_receive=(constants.EIEIO_BUFFER_SIZE_BEFORE_RECEIVE),
):
self._ip_address = ip_address
if ip_address is None:
self._ip_address = config.get("Buffers", "receive_buffer_host")
self._port = port
if port is None:
self._port = config.getint("Buffers", "receive_buffer_port")
if spike_times is None:
spike_times = []
ReverseIpTagMultiCastSource.__init__(
self,
n_keys=n_neurons,
machine_time_step=machine_time_step,
timescale_factor=timescale_factor,
label=label,
constraints=constraints,
max_atoms_per_core=(SpikeSourceArray._model_based_max_atoms_per_core),
board_address=board_address,
receive_port=None,
receive_sdp_port=None,
receive_tag=None,
virtual_key=None,
prefix=None,
prefix_type=None,
check_keys=False,
send_buffer_times=spike_times,
send_buffer_max_space=max_on_chip_memory_usage_for_spikes_in_bytes,
send_buffer_space_before_notify=space_before_notification,
send_buffer_notification_ip_address=self._ip_address,
send_buffer_notification_port=self._port,
send_buffer_notification_tag=tag,
)
AbstractSpikeRecordable.__init__(self)
AbstractProvidesOutgoingEdgeConstraints.__init__(self)
SimplePopulationSettable.__init__(self)
AbstractMappable.__init__(self)
AbstractHasFirstMachineTimeStep.__init__(self)
# handle recording
self._spike_recorder = EIEIOSpikeRecorder(machine_time_step)
self._spike_recorder_buffer_size = spike_recorder_buffer_size
self._buffer_size_before_receive = buffer_size_before_receive
# Keep track of any previously generated buffers
self._send_buffers = dict()
self._spike_recording_region_size = None
self._partitioned_vertices = list()
self._partitioned_vertices_current_max_buffer_size = dict()
# used for reset and rerun
self._requires_mapping = True
self._last_runtime_position = 0
self._max_on_chip_memory_usage_for_spikes = max_on_chip_memory_usage_for_spikes_in_bytes
self._space_before_notification = space_before_notification
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 exceptions.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
def __init__(self):
AbstractMappable.__init__(self)
SimplePopulationSettable.__init__(self)
self._change_requires_mapping = True
def __init__(
self, n_neurons, binary, label, max_atoms_per_core,
machine_time_step, timescale_factor, spikes_per_second,
ring_buffer_sigma, model_name, neuron_model, input_type,
synapse_type, threshold_type, additional_input=None,
constraints=None):
ReceiveBuffersToHostBasicImpl.__init__(self)
AbstractPartitionableVertex.__init__(
self, n_neurons, label, max_atoms_per_core, constraints)
AbstractDataSpecableVertex.__init__(
self, machine_time_step, timescale_factor)
AbstractSpikeRecordable.__init__(self)
AbstractVRecordable.__init__(self)
AbstractGSynRecordable.__init__(self)
AbstractProvidesOutgoingEdgeConstraints.__init__(self)
AbstractProvidesIncomingEdgeConstraints.__init__(self)
AbstractPopulationInitializable.__init__(self)
AbstractPopulationSettable.__init__(self)
AbstractMappable.__init__(self)
self._binary = binary
self._label = label
self._machine_time_step = machine_time_step
self._timescale_factor = timescale_factor
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._spike_recorder = SpikeRecorder(machine_time_step)
self._v_recorder = VRecorder(machine_time_step)
self._gsyn_recorder = GsynRecorder(machine_time_step)
self._spike_buffer_max_size = config.getint(
"Buffers", "spike_buffer_size")
self._v_buffer_max_size = config.getint(
"Buffers", "v_buffer_size")
self._gsyn_buffer_max_size = config.getint(
"Buffers", "gsyn_buffer_size")
self._buffer_size_before_receive = config.getint(
"Buffers", "buffer_size_before_receive")
self._time_between_requests = config.getint(
"Buffers", "time_between_requests")
# Set up synapse handling
self._synapse_manager = SynapticManager(
synapse_type, machine_time_step, ring_buffer_sigma,
spikes_per_second)
# Get buffering information for later use
self._receive_buffer_host = config.get(
"Buffers", "receive_buffer_host")
self._receive_buffer_port = config.getint(
"Buffers", "receive_buffer_port")
self._enable_buffered_recording = config.getboolean(
"Buffers", "enable_buffered_recording")
# bool for if state has changed.
self._change_requires_mapping = True
