def __init__(
self, n_neurons, machine_time_step, timescale_factor,
spinnaker_link_id, speed=30, sample_time=4096, update_time=512,
delay_time=5, delta_threshold=23, continue_if_not_different=True,
label="RobotMotorControl"):
"""
"""
if n_neurons != 6:
logger.warn("The specified number of neurons for the munich motor"
" device has been ignored; 6 will be used instead")
AbstractDataSpecableVertex.__init__(self, machine_time_step,
timescale_factor)
AbstractPartitionableVertex.__init__(self, 6, label, 6, None)
AbstractVertexWithEdgeToDependentVertices.__init__(
self, [_MunichMotorDevice(spinnaker_link_id)], None)
AbstractProvidesOutgoingEdgeConstraints.__init__(self)
self._speed = speed
self._sample_time = sample_time
self._update_time = update_time
self._delay_time = delay_time
self._delta_threshold = delta_threshold
self._continue_if_not_different = continue_if_not_different
def __init__(
self, n_neurons, machine_time_step, timescale_factor,
constraints=None, label="SpikeSourcePoisson", rate=1.0, start=0.0,
duration=None, seed=None):
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)
ReceiveBuffersToHostBasicImpl.__init__(self)
AbstractProvidesOutgoingEdgeConstraints.__init__(self)
PopulationSettableChangeRequiresMapping.__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._spike_buffer_max_size = config.getint(
"Buffers", "spike_buffer_size")
self._buffer_size_before_receive = config.getint(
"Buffers", "buffer_size_before_receive")
self._time_between_requests = config.getint(
"Buffers", "time_between_requests")
def __init__(self, spinnaker_link_id, msg_key, msg_mask=0xFFFFFFFF):
self.key = msg_key
self.mask = msg_mask
AbstractVirtualVertex.__init__(
self, 1, spinnaker_link_id, "External IO Device",
max_atoms_per_core=1)
AbstractProvidesOutgoingEdgeConstraints.__init__(self)
def __init__(self):
AbstractProvidesOutgoingEdgeConstraints.__init__(self)
# The first partitioned edge of this population for any subvertex,
# indexed by the subvertex lo atom
self._first_partitioned_edge = dict()
# Set of partitioned edges that have already had constraints added,
# to avoid over processing
self._seen_partitioned_edges = set()
def __init__(self, machine_time_step, timescale_factor):
AbstractProvidesOutgoingEdgeConstraints.__init__(self)
AbstractPartitionableVertex.__init__(self, 1, "Command Sender", 1)
AbstractDataSpecableVertex.__init__(
self, machine_time_step, timescale_factor)
self._edge_constraints = dict()
self._command_edge = dict()
self._times_with_commands = set()
self._commands_with_payloads = dict()
self._commands_without_payloads = dict()
def __init__(self, n_neurons, machine_time_step, timescale_factor,
label, images=None,
port=12345, virtual_key=None,
spikes_per_second=0, ring_buffer_sigma=None,
database_socket=None,
behaviour="SACCADE", max_saccade_distance=1,
frames_per_microsaccade = 1, frames_per_saccade = 29, #~30
total_on_time_ms = 1000, inter_off_time_ms = 100,
background_gray = 0,
fps=90, mode="128", scale_img=True, polarity="MERGED",
inhibition = False, inh_area_width = 2,
threshold=12, adaptive_threshold = False,
min_threshold=6, max_threshold=168,
threshold_delta_down = 2, threshold_delta_up = 12,
output_type="TIME", num_bits_per_spike=5,
history_weight=0.99, save_spikes=None,
local_port=19876):
"""
:param device_id: int for webcam modes, or string for video file
:param mode: The retina "mode"
:param retina_key: The value of the top 16-bits of the key
:param polarity: The "polarity" of the retina data
:param machine_time_step: The time step of the simulation
:param timescale_factor: The timescale factor of the simulation
:param label: The label for the population
:param n_neurons: The number of neurons in the population
"""
self._loaded_idx = 0
self._total_images = 0
self._image_list = self.get_images_paths(images)
fixed_n_neurons = n_neurons
if mode == ExternalImageDvsEmulatorDevice.MODE_128 or \
mode == ExternalImageDvsEmulatorDevice.MODE_64 or \
mode == ExternalImageDvsEmulatorDevice.MODE_32 or \
mode == ExternalImageDvsEmulatorDevice.MODE_16:
self._out_res = int(mode)
else:
raise exceptions.SpynnakerException("the model does not "
"recongise this mode")
if (polarity == ExternalImageDvsEmulatorDevice.UP_POLARITY or
polarity == ExternalImageDvsEmulatorDevice.DOWN_POLARITY):
fixed_n_neurons = self._out_res**2
else:
fixed_n_neurons = 2*(self._out_res**2)
if fixed_n_neurons != n_neurons and n_neurons is not None:
logger.warn("The specified number of neurons for the DVS emulator"
" device has been ignored {} will be used instead"
.format(fixed_n_neurons))
self._center_x = 0
self._center_y = 0
self._max_saccade_distance = max_saccade_distance
self._frames_per_microsaccade = frames_per_microsaccade
self._frames_per_saccade = frames_per_saccade
self._traverse_speed = (self._out_res*2.)/((total_on_time_ms/1000.)*fps)
self._behaviour = behaviour
self._total_on_time_ms = total_on_time_ms
self._inter_off_time_ms = inter_off_time_ms
self._background_gray = background_gray
self._polarity = polarity
self._polarity_n = ExternalImageDvsEmulatorDevice.POLARITY_DICT[polarity]
self._global_max = int16(0)
self._output_type = output_type
self._raw_frame = None
self._gray_frame = None
self._tmp_frame = None
self._ref_frame = 128*numpy.ones((self._out_res, self._out_res), dtype=int16)
self._curr_frame = numpy.zeros((self._out_res, self._out_res), dtype=int16)
self._moved_frame = numpy.zeros((self._out_res, self._out_res), dtype=int16)
self._silence_frame = numpy.zeros((self._out_res, self._out_res), dtype=int16)
self._spikes_frame = numpy.zeros((self._out_res, self._out_res, 3), dtype=uint8)
self._diff = numpy.zeros((self._out_res, self._out_res), dtype=int16)
self._abs_diff = numpy.zeros((self._out_res, self._out_res), dtype=int16)
self._spikes = numpy.zeros((self._out_res, self._out_res), dtype=int16)
self._adaptive_threshold = adaptive_threshold
self._thresh_matrix = None
if adaptive_threshold:
self._thresh_matrix = numpy.zeros((self._out_res, self._out_res),
dtype=int16)
self._threshold_delta_down = int16(threshold_delta_down)
self._threshold_delta_up = int16(threshold_delta_up)
self._max_threshold = int16(max_threshold)
self._min_threshold = int16(min_threshold)
self._up_spikes = None
self._down_spikes = None
self._spikes_lists = None
self._threshold = int16(threshold)
self._data_shift = uint8(numpy.log2(self._out_res))
self._up_down_shift = uint8(2*self._data_shift)
self._data_mask = uint8(self._out_res - 1)
if self._output_type == ExternalImageDvsEmulatorDevice.OUTPUT_TIME_BIN:
self._num_bins = 8 #8-bit images don't need more
elif self._output_type == ExternalImageDvsEmulatorDevice.OUTPUT_TIME_BIN_THR:
self._num_bins = 6 #should be enough?
else:
self._num_bins = int(1000./fps)
self._num_bits_per_spike = min(num_bits_per_spike, self._num_bins)
if self._output_type == ExternalImageDvsEmulatorDevice.OUTPUT_TIME_BIN or \
self._output_type == ExternalImageDvsEmulatorDevice.OUTPUT_TIME_BIN_THR:
self._log2_table = generate_log2_table(self._num_bits_per_spike, self._num_bins)
else:
self._log2_table = generate_log2_table(self._num_bits_per_spike, 8) #stupid hack, compatibility issues
self._scale_img = scale_img
self._img_height = 0
self._img_height_crop_u = 0
self._img_height_crop_b = 0
self._img_width = 0
self._img_width_crop_l = 0
self._img_width_crop_r = 0
self._img_ratio = 0.
self._img_scaled_width = 0
self._scaled_width = 0
self._fps = fps
self._half_frame = fps/2
self._max_time_ms = int16((1./fps)*1000)
self._time_per_spike_pack_ms = self.calculate_time_per_pack()
self._get_sizes = True
self._scale_changed = False
self._running = True
self._label = label
self._n_neurons = fixed_n_neurons
self._local_port = local_port
self._inh_area_width = inh_area_width
self._inhibition = inhibition
self._history_weight = history_weight
################################################################
if spinn_version == "2015.005":
ReverseIpTagMultiCastSource.__init__(self,
n_neurons=self._n_neurons,
machine_time_step=machine_time_step,
timescale_factor=timescale_factor,
port=self._local_port,
label=self._label,
virtual_key=virtual_key)
else:
ReverseIpTagMultiCastSource.__init__(self,
n_keys=self._n_neurons,
machine_time_step=machine_time_step,
timescale_factor=timescale_factor,
label=self._label,
receive_port=self._local_port,
virtual_key=virtual_key)
AbstractProvidesOutgoingConstraints.__init__(self)
print "number of neurons for webcam = %d"%self._n_neurons
self._live_conn = SpynnakerLiveSpikesConnection(send_labels = [self._label, ],
local_port = self._local_port)
def init(label, n_neurons, run_time_ms, machine_timestep_ms):
print("Sending %d neuron sources from %s"%(n_neurons, label))
self._live_conn.add_init_callback(self._label, init)
self._live_conn.add_start_callback(self._label, self.run)
self._sender = None
self._save_spikes = save_spikes
self._spike_list = []
def __init__(self,
n_neurons,
machine_time_step,
timescale_factor,
database_socket,
label,
port=12345,
virtual_key=None,
spikes_per_second=0,
ring_buffer_sigma=None,
device_id=0,
fps=60,
mode="128",
scale_img=True,
polarity="MERGED",
inhibition=False,
inh_area_width=2,
threshold=12,
adaptive_threshold=False,
min_threshold=6,
max_threshold=168,
threshold_delta_down=2,
threshold_delta_up=12,
output_type="TIME",
num_bits_per_spike=4,
history_weight=0.99,
save_spikes=None,
run_time_ms=None,
local_port=19876):
"""
:param device_id: int for webcam modes, or string for video file
:param mode: The retina "mode"
:param retina_key: The value of the top 16-bits of the key
:param polarity: The "polarity" of the retina data
:param machine_time_step: The time step of the simulation
:param timescale_factor: The timescale factor of the simulation
:param label: The label for the population
:param n_neurons: The number of neurons in the population
"""
fixed_n_neurons = n_neurons
if mode == ExternalDvsEmulatorDevice.MODE_128 or \
mode == ExternalDvsEmulatorDevice.MODE_64 or \
mode == ExternalDvsEmulatorDevice.MODE_32 or \
mode == ExternalDvsEmulatorDevice.MODE_16:
self._out_res = int(mode)
self._res_2x = self._out_res * 2
else:
raise exceptions.SpynnakerException("the model does not "
"recongise this mode")
if (polarity == ExternalDvsEmulatorDevice.UP_POLARITY
or polarity == ExternalDvsEmulatorDevice.DOWN_POLARITY
or polarity == ExternalDvsEmulatorDevice.RECTIFIED_POLARITY):
fixed_n_neurons = self._out_res**2
else:
fixed_n_neurons = 2 * (self._out_res**2)
if fixed_n_neurons != n_neurons and n_neurons is not None:
logger.warn(
"The specified number of neurons for the DVS emulator"
" device has been ignored {} will be used instead".format(
fixed_n_neurons))
self._video_source = None
self._device_id = device_id
self._is_virtual_cam = False
self._polarity = polarity
self._polarity_n = ExternalDvsEmulatorDevice.POLARITY_DICT[polarity]
self._global_max = int16(0)
self._output_type = output_type
self._raw_frame = None
self._gray_frame = None
self._tmp_frame = None
self._ref_frame = 128 * np.ones(
(self._out_res, self._out_res), dtype=int16)
self._curr_frame = np.zeros((self._out_res, self._out_res),
dtype=int16)
self._spikes_frame = np.zeros((self._out_res, self._out_res, 3),
dtype=uint8)
self._diff = np.zeros((self._out_res, self._out_res), dtype=int16)
self._abs_diff = np.zeros((self._out_res, self._out_res), dtype=int16)
self._spikes = np.zeros((self._out_res, self._out_res), dtype=int16)
self._adaptive_threshold = adaptive_threshold
self._thresh_matrix = None
if adaptive_threshold:
self._thresh_matrix = np.zeros((self._out_res, self._out_res),
dtype=int16)
self._threshold_delta_down = int16(threshold_delta_down)
self._threshold_delta_up = int16(threshold_delta_up)
self._max_threshold = int16(max_threshold)
self._min_threshold = int16(min_threshold)
self._up_spikes = None
self._down_spikes = None
self._spikes_lists = None
self._threshold = int16(threshold)
self._data_shift = uint8(np.log2(self._out_res))
self._up_down_shift = uint8(2 * self._data_shift)
self._data_mask = uint8(self._out_res - 1)
if self._output_type == ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN:
self._num_bins = 8 #8-bit images don't need more
elif self._output_type == ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN_THR:
self._num_bins = 6 #should be enough?
else:
self._num_bins = int(1000. / fps)
self._num_bits_per_spike = min(num_bits_per_spike, self._num_bins)
if self._output_type == ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN or \
self._output_type == ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN_THR:
self._log2_table = gs.generate_log2_table(self._num_bits_per_spike,
self._num_bins)
else:
self._log2_table = gs.generate_log2_table(
self._num_bits_per_spike,
8) #stupid hack, compatibility issues
self._scale_img = scale_img
self._img_height = 0
self._img_height_crop_u = 0
self._img_height_crop_b = 0
self._img_width = 0
self._img_width_crop_l = 0
self._img_width_crop_r = 0
self._img_ratio = 0.
self._img_scaled_width = 0
self._scaled_width = 0
self._fps = fps
self._max_time_ms = 0
self._time_per_frame = 0.
self._time_per_spike_pack_ms = 0
self._get_sizes = True
self._scale_changed = False
self._running = True
self._label = label
self._n_neurons = fixed_n_neurons
self._local_port = local_port
self._inh_area_width = inh_area_width
self._inhibition = inhibition
self._inh_coords = gs.generate_inh_coords(self._out_res, self._out_res,
inh_area_width)
self._history_weight = history_weight
self._run_time_ms = run_time_ms
################################################################
if spinn_version == "2015.005":
ReverseIpTagMultiCastSource.__init__(
self,
n_neurons=self._n_neurons,
machine_time_step=machine_time_step,
timescale_factor=timescale_factor,
port=self._local_port,
label=self._label,
virtual_key=virtual_key)
else:
ReverseIpTagMultiCastSource.__init__(
self,
n_keys=self._n_neurons,
machine_time_step=machine_time_step,
timescale_factor=timescale_factor,
label=self._label,
receive_port=self._local_port,
virtual_key=virtual_key)
AbstractProvidesOutgoingConstraints.__init__(self)
print("number of neurons for webcam = %d" % self._n_neurons)
self._live_conn = SpynnakerLiveSpikesConnection(
send_labels=[
self._label,
], local_port=self._local_port)
def init(label, n_neurons, run_time_ms, machine_timestep_ms):
print("Sending %d neuron sources from %s" % (n_neurons, label))
self._live_conn.add_init_callback(self._label, init)
self._live_conn.add_start_callback(self._label, self.run)
self._sender = None
self._save_spikes = save_spikes
def __init__(
self, n_keys, resources_required, machine_time_step,
timescale_factor, label, constraints=None,
# General input and output parameters
board_address=None,
# Live input parameters
receive_port=None,
receive_sdp_port=(
constants.SDP_PORTS.INPUT_BUFFERING_SDP_PORT.value),
receive_tag=None,
# Key parameters
virtual_key=None, prefix=None,
prefix_type=None, check_keys=False,
# Send buffer parameters
send_buffer_times=None,
send_buffer_max_space=(
constants.MAX_SIZE_OF_BUFFERED_REGION_ON_CHIP),
send_buffer_space_before_notify=640,
send_buffer_notification_ip_address=None,
send_buffer_notification_port=None,
send_buffer_notification_tag=None):
"""
:param n_keys: The number of keys to be sent via this multicast source
:param resources_required: The resources required by the vertex
:param machine_time_step: The time step to be used on the machine
:param timescale_factor: The time scaling to be used in the simulation
:param label: The label of this vertex
:param constraints: Any initial constraints to this vertex
:param board_address: The IP address of the board on which to place\
this vertex if receiving data, either buffered or live (by\
default, any board is chosen)
:param receive_port: The port on the board that will listen for\
incoming event packets (default is to disable this feature;\
set a value to enable it)
:param receive_sdp_port: The SDP port to listen on for incoming event\
packets (defaults to 1)
:param receive_tag: The IP tag to use for receiving live events\
(uses any by default)
:param virtual_key: The base multicast key to send received events\
with (assigned automatically by default)
:param prefix: The prefix to "or" with generated multicast keys\
(default is no prefix)
:param prefix_type: Whether the prefix should apply to the upper or\
lower half of the multicast keys (default is upper half)
:param check_keys: True if the keys of received events should be\
verified before sending (default False)
:param send_buffer_times: An array of arrays of times at which keys\
should be sent (one array for each key, default disabled)
:param send_buffer_max_space: The maximum amount of space to use of\
the SDRAM on the machine (default is 1MB)
:param send_buffer_space_before_notify: The amount of space free in\
the sending buffer before the machine will ask the host for\
more data (default setting is optimised for most cases)
:param send_buffer_notification_ip_address: The IP address of the host\
that will send new buffers (must be specified if a send buffer\
is specified)
:param send_buffer_notification_port: The port that the host that will\
send new buffers is listening on (must be specified if a\
send buffer is specified)
:param send_buffer_notification_tag: The IP tag to use to notify the\
host about space in the buffer (default is to use any tag)
"""
# Set up super types
AbstractDataSpecableVertex.__init__(
self, machine_time_step, timescale_factor)
PartitionedVertex.__init__(
self, resources_required, label, constraints)
AbstractProvidesOutgoingEdgeConstraints.__init__(self)
ReceiveBuffersToHostBasicImpl.__init__(self)
# Set up for receiving live packets
if receive_port is not None:
self.add_constraint(TagAllocatorRequireReverseIptagConstraint(
receive_port, receive_sdp_port, board_address, receive_tag))
# Work out if buffers are being sent
self._first_machine_time_step = 0
self._send_buffer = None
if send_buffer_times is None:
self._send_buffer_times = None
SendsBuffersFromHostPartitionedVertexPreBufferedImpl.__init__(
self, None)
else:
self._send_buffer = BufferedSendingRegion(send_buffer_max_space)
self._send_buffer_times = send_buffer_times
self.add_constraint(TagAllocatorRequireIptagConstraint(
send_buffer_notification_ip_address,
send_buffer_notification_port, True, board_address,
send_buffer_notification_tag))
SendsBuffersFromHostPartitionedVertexPreBufferedImpl.__init__(
self, {self._REGIONS.SEND_BUFFER.value: self._send_buffer})
# buffered out parameters
self._send_buffer_space_before_notify = send_buffer_space_before_notify
self._send_buffer_notification_ip_address = \
send_buffer_notification_ip_address
self._send_buffer_notification_port = send_buffer_notification_port
self._send_buffer_notification_tag = send_buffer_notification_tag
if self._send_buffer_space_before_notify > send_buffer_max_space:
self._send_buffer_space_before_notify = send_buffer_max_space
# Set up for recording (if requested)
self._record_buffer_size = 0
self._buffer_size_before_receive = 0
# Sort out the keys to be used
self._n_keys = n_keys
self._virtual_key = virtual_key
self._mask = None
self._prefix = prefix
self._prefix_type = prefix_type
self._check_keys = check_keys
# Work out the prefix details
if self._prefix is not None:
if self._prefix_type is None:
self._prefix_type = EIEIOPrefix.UPPER_HALF_WORD
if self._prefix_type == EIEIOPrefix.UPPER_HALF_WORD:
self._prefix = prefix << 16
# If the user has specified a virtual key
if self._virtual_key is not None:
# check that virtual key is valid
if self._virtual_key < 0:
raise ConfigurationException(
"Virtual keys must be positive")
# Get a mask and maximum number of keys for the number of keys
# requested
self._mask, max_key = self._calculate_mask(n_keys)
# Check that the number of keys and the virtual key don't interfere
if n_keys > max_key:
raise ConfigurationException(
"The mask calculated from the number of keys will "
"not work with the virtual key specified")
if self._prefix is not None:
# Check that the prefix doesn't change the virtual key in the
# masked area
masked_key = (self._virtual_key | self._prefix) & self._mask
if self._virtual_key != masked_key:
raise ConfigurationException(
"The number of keys, virtual key and key prefix"
" settings don't work together")
else:
# If no prefix was generated, generate one
self._prefix_type = EIEIOPrefix.UPPER_HALF_WORD
self._prefix = self._virtual_key
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, 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
