def __init__(self, resources_required, is_recording, minimum_buffer_sdram_usage, buffered_sdram_per_timestep, label, constraints=None, overflow_sdram=0): """ :param resources_required: :param is_recording: :param minimum_buffer_sdram_usage: :param buffered_sdram_per_timestep: :param label: :param constraints: :param overflow_sdram: Extra sdram that may be required if buffered_sdram_per_timestep is an average :type sampling: bool """ MachineVertex.__init__(self, label, constraints) AbstractRecordable.__init__(self) self._is_recording = is_recording self._resources = resources_required self._minimum_buffer_sdram_usage = minimum_buffer_sdram_usage self._buffered_sdram_per_timestep = buffered_sdram_per_timestep self._overflow_sdram = overflow_sdram
def __init__( self, data, fs, resample_factor, data_partition_name="IHCANData", acknowledge_partition_name="IHCANDataAck"): #TODO:add Fs to params MachineVertex.__init__(self, label="IHCAN Node", constraints=None) self._data = data[0] self._data_partition_name = data_partition_name self._acknowledge_partition_name = acknowledge_partition_name self._fs = fs self._data_size = ((len(self._data) * self._DATA_ELEMENT_TYPE.size) + self._DATA_COUNT_TYPE.size) self._sdram_usage = (self._N_PARAMETER_BYTES + self._data_size) self._resample_factor = resample_factor self._fs = fs self._num_data_points = 2 * len( self._data ) # num of points is double previous calculations due to 2 fibre output of IHCAN model self._recording_size = (self._num_data_points / self._resample_factor ) * 4 #numpy.ceil(self._num_data_points/32.0)# self._placement = list()
def __init__(self, resources_required, constraints=None, label=None): # Superclasses MachineVertex.__init__(self, label, constraints=constraints) # ProvidesProvenanceDataFromMachineImpl.__init__( # self, self._BREAKOUT_REGIONS.PROVENANCE.value, 0) self._resource_required = resources_required
def __init__(self, vertex_slice, resources_required, constraints, label, app_vertex, truth_table, input_sequence, rate_on, rate_off, score_delay, stochastic, incoming_spike_buffer_size, simulation_duration_ms, rand_seed): # resources required self._resources_required = ResourceContainer( sdram=ConstantSDRAM(resources_required)) # **NOTE** n_neurons currently ignored - width and height will be # specified as additional parameters, forcing their product to be # duplicated in n_neurons seems pointless self._label = label # Pass in variables self._truth_table = truth_table self._rate_on = rate_on self._rate_off = rate_off self._stochastic = stochastic self._input_sequence = input_sequence self._no_inputs = len(input_sequence) self._n_neurons = self._no_inputs self._rand_seed = rand_seed self._score_delay = score_delay # used to define size of recording region self._recording_size = int((simulation_duration_ms / 1000.) * 4) # Superclasses MachineVertex.__init__(self, label, constraints, app_vertex, vertex_slice)
def __init__(self, partition_identifier, filter, row_id, constraints=None): label = "retina filter for row {}".format(row_id) MachineVertex.__init__(self, label, constraints) MachineDataSpecableVertex.__init__(self) AbstractHasAssociatedBinary.__init__(self) AbstractProvidesOutgoingPartitionConstraints.__init__(self) self._partition_identifier = partition_identifier self._filter = filter self._row_id = row_id
def __init__(self, resources_required, recorded_region_ids, label, constraints): """ :param resources_required: :param recorded_region_ids: :param label: :param constraints: :type sampling: bool """ MachineVertex.__init__(self, label, constraints) AbstractRecordable.__init__(self) self.__recorded_region_ids = recorded_region_ids self.__resources = resources_required
def __init__( self, resources_required, recorded_region_ids, label, constraints): """ :param resources_required: :param recorded_region_ids: :param label: :param constraints: :type sampling: bool """ MachineVertex.__init__(self, label, constraints) AbstractRecordable.__init__(self) self._recorded_region_ids = recorded_region_ids self._resources = resources_required
def __init__(self, resources_required, is_recording, minimum_buffer_sdram, buffered_sdram_per_timestep, constraints=None, label=None): MachineVertex.__init__(self, label, constraints=constraints) AbstractRecordable.__init__(self) self._is_recording = is_recording self._resources = resources_required self._minimum_buffer_sdram = minimum_buffer_sdram self._buffered_sdram_per_timestep = buffered_sdram_per_timestep
def __init__( self, cf, fs, n_data_points, drnl_index, profile, seq_size, synapse_manager, parent, n_buffers_in_sdram_total, neuron_recorder, timer_period): """ builder of the drnl machine vertex :param cf: ???????? :param fs: sampling freequency of the OME :param n_data_points: the number of elements..... :param drnl_index: the index in the list of drnls (used for slices) :param profile: bool flag saying if this vertex is set to profile :param seq_size: the size of a block :param synapse_manager: the synaptic manager :param parent: the app vertex :param n_buffers_in_sdram_total: the number of buffers in sequence in\ the sdram edge :param neuron_recorder: the recorder for moc :param timer_period: the timer period of this core """ MachineVertex.__init__( self, label="DRNL Node of {}".format(drnl_index), constraints=None) AbstractEarProfiled.__init__(self, profile, self.REGIONS.PROFILE.value) AbstractProvidesNKeysForPartition.__init__(self) # storage for the synapse manager locations self.__on_chip_generatable_offset = None self.__on_chip_generatable_size = None self._cf = cf self._fs = fs self._drnl_index = drnl_index self._seq_size = seq_size self._synapse_manager = synapse_manager self._parent = parent self._n_buffers_in_sdram_total = n_buffers_in_sdram_total self._neuron_recorder = neuron_recorder self._timer_period = timer_period self._sdram_edge_size = ( self._n_buffers_in_sdram_total * self._seq_size * DataType.FLOAT_64.size) self._num_data_points = n_data_points # recording size self._recording_size_per_sim_time_step = ( DataType.FLOAT_64.size * self.MOC_BUFFER_SIZE) # filter params self._filter_params = self._calculate_filter_parameters()
def __init__(self, label, constraints, n_samples_per_recording, sampling_frequency): """ constructor for idle power monitor c code for machine graphs :param label: vertex label :param constraints: constraints on this vertex :param n_samples_per_recording: how may samples between recording entry :type n_samples_per_recording: int :param sampling_frequency: how often to sample :type sampling_frequency: microseconds """ MachineVertex.__init__(self, label=label, constraints=constraints) self._n_samples_per_recording = n_samples_per_recording self._sampling_frequency = sampling_frequency
def __init__(self, resample_factor, seed, n_fibres, ear_index, profile, fs, n_lsr, n_msr, n_hsr, n_buffers_in_sdram_total, seq_size, ihcan_neuron_recorder, ihcan_atom_slice, timer_period): """ constructor :param resample_factor: resample factor :param seed: the seed used for its random number generator in SpiNNaker :param n_fibres: how many fibres to simulate :param ear_index: which ear its based on :param profile: bool flag for profiling :param fs: sample freq :param n_lsr: number of low freq hair cells :param n_msr: number of med freq hair cells :param n_hsr: number of high freq hair cells :param n_buffers_in_sdram_total: the total number of sdram buffers in \ the sdram edge :param seg_size: the seq size :param ihcan_neuron_recorder: recorder for the ihcan recordings :param ihcan_atom_slice: the slice of atoms for the ihcan vertex from \ the global. """ MachineVertex.__init__(self, label="IHCAN Node", constraints=None) AbstractProvidesNKeysForPartition.__init__(self) AbstractEarProfiled.__init__(self, profile, self.REGIONS.PROFILE.value) ProvidesProvenanceDataFromMachineImpl.__init__(self) AbstractHasAssociatedBinary.__init__(self) AbstractGeneratesDataSpecification.__init__(self) AbstractReceiveBuffersToHost.__init__(self) self._ihcan_neuron_recorder = ihcan_neuron_recorder self._ihcan_recording_atom_slice = ihcan_atom_slice self._ear_index = ear_index self._re_sample_factor = resample_factor self._fs = fs self._dt = 1.0 / self._fs self._n_atoms = n_fibres self._n_buffers_in_sdram_total = n_buffers_in_sdram_total self._seq_size = seq_size self._timer_period = timer_period if n_lsr + n_msr + n_hsr > n_fibres: raise Exception( self.N_FIBRES_ERROR.format(n_fibres, n_lsr, n_msr, n_hsr)) self._n_lsr = n_lsr self._n_msr = n_msr self._n_hsr = n_hsr self._seed = seed
def __init__(self, vertex_slice, resources_required, constraints, label, app_vertex, encoding, time_increment, pole_length, pole_angle, reward_based, force_increments, max_firing_rate, number_of_bins, central, bin_overlap, tau_force, incoming_spike_buffer_size, simulation_duration_ms, rand_seed): # Resources required self._resource_required = ResourceContainer( sdram=ConstantSDRAM(resources_required)) # **NOTE** n_neurons currently ignored - width and height will be # specified as additional parameters, forcing their product to be # duplicated in n_neurons seems pointless self._label = label self._encoding = encoding # Pass in variables self._pole_length = pole_length self._pole_angle = pole_angle self._force_increments = force_increments # for rate based it's only 1 neuron per metric # (position, angle, velocity of both) if self._encoding == 0: self._n_neurons = 4 else: self._n_neurons = 4 * number_of_bins self._time_increment = time_increment self._reward_based = reward_based self._max_firing_rate = max_firing_rate self._number_of_bins = number_of_bins self._central = central self._rand_seed = rand_seed self._bin_overlap = bin_overlap self._tau_force = tau_force # used to define size of recording region self._recording_size = int((simulation_duration_ms / 1000.) * 4) # Superclasses MachineVertex.__init__(self, label, constraints, app_vertex, vertex_slice)
def __init__(self, label, state): MachineVertex.__init__(self, label) config = globals_variables.get_simulator().config self._buffer_size_before_receive = None if config.getboolean("Buffers", "enable_buffered_recording"): self._buffer_size_before_receive = config.getint( "Buffers", "buffer_size_before_receive") self._time_between_requests = config.getint("Buffers", "time_between_requests") self._receive_buffer_host = config.get("Buffers", "receive_buffer_host") self._receive_buffer_port = helpful_functions.read_config_int( config, "Buffers", "receive_buffer_port") # app specific data items self._state = state
def __init__(self, label, 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, hostname=None, port=None, strip_sdp=None, board_address=None, tag=None, constraints=None): # inheritance MachineVertex.__init__(self, label, constraints=constraints) self._resources_required = ResourceContainer( cpu_cycles=CPUCyclesPerTickResource(self.get_cpu_usage()), dtcm=DTCMResource(self.get_dtcm_usage()), sdram=SDRAMResource(self.get_sdram_usage()), iptags=[ IPtagResource(ip_address=hostname, port=port, strip_sdp=strip_sdp, tag=tag, traffic_identifier="LPG_EVENT_STREAM") ]) # app specific data items self._use_prefix = use_prefix self._key_prefix = key_prefix self._prefix_type = prefix_type self._message_type = message_type self._right_shift = right_shift self._payload_as_time_stamps = payload_as_time_stamps self._use_payload_prefix = use_payload_prefix self._payload_prefix = payload_prefix self._payload_right_shift = payload_right_shift self._number_of_packets_sent_per_time_step = \ number_of_packets_sent_per_time_step
def __init__(self, vertex, model): """ :param vertex: The MCMC vertex associated with this vertex :param model: The model being simulated """ MachineVertex.__init__(self, label="MCMC RF Node", constraints=None) self._vertex = vertex self._model = model vertex.coordinator.register_processor(self) # Other parameters need to be added here self._n_other_params = 1 self._n_parameter_bytes = self._n_other_params * 4 self._sdram_usage = (self._n_parameter_bytes)
def __init__(self, label, constraints=None): MachineVertex.__init__(self, label=label, constraints=constraints) config = globals_variables.get_simulator().config self._buffer_size_before_receive = None if config.getboolean("Buffers", "enable_buffered_recording"): self._buffer_size_before_receive = config.getint( "Buffers", "buffer_size_before_receive") self._time_between_requests = config.getint("Buffers", "time_between_requests") self._receive_buffer_host = config.get("Buffers", "receive_buffer_host") self._receive_buffer_port = helpful_functions.read_config_int( config, "Buffers", "receive_buffer_port") self._string_data_size = 5000 self.placement = None
def __init__(self, coordinator, model, parameter_partition_name="MCMCParameter", result_partition_name="MCMCResultAck", cholesky_partition_name="MCMCCholeskyParameter", cholesky_result_partition_name="MCMCCholeskyResultAck"): """ :param coordinator: The coordinator vertex :param model: The model being simulated """ MachineVertex.__init__(self, label="MCMC Node", constraints=None) self._coordinator = coordinator self._model = model self._parameter_partition_name = parameter_partition_name self._result_partition_name = result_partition_name self._cholesky_partition_name = cholesky_partition_name self._cholesky_result_partition_name = cholesky_result_partition_name self._coordinator.register_processor(self) state = self._get_model_state_array() self._recording_size = self._coordinator.n_samples * len(state) * 4 params = self._get_model_parameters_array() # The number of bytes for the parameters # (11 * uint32) + (5 * seed array) + (1 * d.o.f.) self._n_parameter_bytes = 0 if (model.get_parameters()[0].data_type is numpy.float64): self._n_parameter_bytes = (11 * 4) + (5 * 4) + (1 * 8) else: self._n_parameter_bytes = (11 * 4) + (5 * 4) + (1 * 4) self._sdram_usage = ( self._n_parameter_bytes + self._recording_size + recording_utilities.get_recording_header_size(1) + (len(params) * 4) ) self._data_receiver = dict() self._cholesky_data_receiver = dict()
def __init__(self, label, columns, rows, string_size, num_string_cols, entries, initiate, function_id, state, constraints=None): MachineVertex.__init__(self, label=label, constraints=constraints) config = globals_variables.get_simulator().config self._buffer_size_before_receive = None if config.getboolean("Buffers", "enable_buffered_recording"): self._buffer_size_before_receive = config.getint( "Buffers", "buffer_size_before_receive") self._time_between_requests = config.getint("Buffers", "time_between_requests") self._receive_buffer_host = config.get("Buffers", "receive_buffer_host") self._receive_buffer_port = helpful_functions.read_config_int( config, "Buffers", "receive_buffer_port") ''' all the data that will be transfered to the vertex''' self.columns = columns self.rows = rows self.string_size = string_size self.num_string_cols = num_string_cols self.entries = entries self.initiate = initiate self.function_id = function_id ''' allocate space for entries and 24 bytes for the 6 integers that make up the header information''' self._input_data_size = (string_size * rows * num_string_cols) + \ (4 * rows * (columns - num_string_cols)) + 28 self._output_data_size = 10 * 1000 # app specific elements self.placement = None self.state = state
def __init__(self, label, machine_time_step, time_scale_factor, heat_temperature=0, constraints=None): config = globals_variables.get_simulator().config # resources used by a heat element vertex sdram = SDRAMResource(23 + config.getint("Buffers", "minimum_buffer_sdram")) self._resources = \ ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(45), dtcm=DTCMResource(34), sdram=sdram) MachineVertex.__init__(self, label=label, constraints=constraints) # app specific data items self._heat_temperature = heat_temperature self._time_between_requests = config.getint("Buffers", "time_between_requests")
def __init__(self, vertex_slice, resources_required, constraints, label, app_vertex, arms, reward_delay, reward_based, rate_on, rate_off, stochastic, constant_input, incoming_spike_buffer_size, simulation_duration_ms, rand_seed): # Resources required self._resource_required = ResourceContainer( sdram=ConstantSDRAM(resources_required)) # **NOTE** n_neurons currently ignored - width and height will be # specified as additional parameters, forcing their product to be # duplicated in n_neurons seems pointless self._label = label # Pass in variables arms_list = [] for arm in arms: arms_list.append(numpy.uint32(arm*0xffffffff)) self._arms = arms_list self._no_arms = len(arms) self._n_neurons = self._no_arms self._rand_seed = rand_seed self._reward_delay = reward_delay self._reward_based = reward_based self._rate_on = rate_on self._rate_off = rate_off self._stochastic = stochastic self._constant_input = constant_input # used to define size of recording region self._recording_size = int((simulation_duration_ms / 1000.) * 4) # Superclasses MachineVertex.__init__( self, label, constraints, app_vertex, vertex_slice)
def __init__(self, x, y, r, n_particles, batch_size, label, part_id, main_particle, constraints=None): MachineVertex.__init__(self, label=label, constraints=constraints) AbstractProvidesNKeysForPartition.__init__(self) self._x = x self._y = y self._r = r self._n_particles = n_particles self._batch_size = batch_size self._placement = None self._part_id = part_id self._main = main_particle
def __init__(self, vertex_slice, resources_required, constraints, label, app_vertex, x_factor, y_factor, width, height, colour_bits, incoming_spike_buffer_size, simulation_duration_ms, bricking, random_seed): # **NOTE** n_neurons currently ignored - width and height will be # specified as additional parameters, forcing their product to be # duplicated in n_neurons seems pointless self._resources_required = ResourceContainer( sdram=ConstantSDRAM(resources_required)) self._label = label self._x_factor = x_factor self._y_factor = y_factor self._width = width / x_factor self._height = height / y_factor self._colour_bits = colour_bits self._width_bits = numpy.uint32(numpy.ceil(numpy.log2(self._width))) self._height_bits = numpy.uint32(numpy.ceil(numpy.log2(self._height))) self._n_neurons = ( 1 << (self._width_bits + self._height_bits + self._colour_bits)) self._bricking = bricking self._rand_seed = random_seed # print self._rand_seed # print "# width =", self._width # print "# width bits =", self._width_bits # print "# height =", self._height # print "# height bits =", self._height_bits # print "# neurons =", self._n_neurons # Define size of recording region self._recording_size = int((simulation_duration_ms / 10000.) * 4) # Superclasses MachineVertex.__init__(self, label, constraints, app_vertex, vertex_slice)
def __init__(self, data, fs, n_channels, seq_size, timer_period, profile=False): """ constructor for OME vertex :param data: the input data :param fs: the sampling freq :param n_channels: how many channels to process :param profile: bool stating if profiling or now """ MachineVertex.__init__(self, label="OME Node", constraints=None) AbstractProvidesNKeysForPartition.__init__(self) AbstractEarProfiled.__init__(self, profile, self.REGIONS.PROFILE.value) AbstractMachineSupportsAutoPauseAndResume.__init__(self) self._data = data self._fs = fs self._n_channels = n_channels self._seq_size = seq_size # size then list of doubles self._data_size = ((len(self._data) * DataType.FLOAT_64.size) + DataType.UINT32.size) # write timer period self._timer_period = timer_period # calculate stapes hpf coefficients wn = 1.0 / self._fs * 2.0 * self.MAGIC_TWO # noinspection PyTypeChecker [self._shb, self._sha] = sig.butter(2, wn, 'high')
def __init__(self, resources_required, recorded_region_ids, label, constraints, app_vertex, vertex_slice, drop_late_spikes, binary_file_name): """ :param ~pacman.model.resources.ResourceContainer resources_required: :param iterable(int) recorded_region_ids: :param str label: :param bool drop_late_spikes: control flag for dropping packets. :param list(~pacman.model.constraints.AbstractConstraint) constraints: :param AbstractPopulationVertex app_vertex: The associated application vertex :param ~pacman.model.graphs.common.Slice vertex_slice: The slice of the population that this implements @param str binary_file_name: binary name to be run for this verte """ MachineVertex.__init__(self, label, constraints, app_vertex, vertex_slice) self.__binary_file_name = binary_file_name AbstractRecordable.__init__(self) self.__recorded_region_ids = recorded_region_ids self.__resources = resources_required self.__drop_late_spikes = drop_late_spikes self.__on_chip_generatable_offset = None self.__on_chip_generatable_size = None
def __init__(self, vertex_slice, resources_required, constraints, label, app_vertex, rate_on, rate_off, pop_size, prob_command, prob_in_change, time_period, stochastic, reward, incoming_spike_buffer_size, simulation_duration_ms, rand_seed): # Resources required self._resource_required = ResourceContainer( sdram=ConstantSDRAM(resources_required)) # **NOTE** n_neurons currently ignored - width and height will be # specified as additional parameters, forcing their product to be # duplicated in n_neurons seems pointless self._label = label # Pass in variables self._rate_on = rate_on self._rate_off = rate_off self._stochastic = stochastic self._reward = reward self._pop_size = pop_size self._prob_command = prob_command self._prob_in_change = prob_in_change self._n_neurons = pop_size * 4 self._rand_seed = rand_seed self._time_period = time_period # used to define size of recording region self._recording_size = int((simulation_duration_ms / 1000.) * 4) # Superclasses MachineVertex.__init__(self, label, constraints, app_vertex, vertex_slice)
def __init__( self, n_keys, 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, receive_rate=10, # Key parameters virtual_key=None, prefix=None, prefix_type=None, check_keys=False, # Send buffer parameters send_buffer_times=None, send_buffer_partition_id=None, send_buffer_max_space=(constants.MAX_SIZE_OF_BUFFERED_REGION_ON_CHIP), send_buffer_space_before_notify=640, # Buffer notification details buffer_notification_ip_address=None, buffer_notification_port=None, buffer_notification_tag=None, # Extra flag for receiving packets without a port reserve_reverse_ip_tag=False): """ :param n_keys: The number of keys to be sent via this multicast source :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 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 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 buffer_notification_tag: The IP tag to use to notify the\ host about space in the buffer (default is to use any tag) """ MachineVertex.__init__(self, label, constraints) AbstractReceiveBuffersToHost.__init__(self) AbstractProvidesOutgoingPartitionConstraints.__init__(self) self._iptags = None self._reverse_iptags = None # Set up for receiving live packets if receive_port is not None or reserve_reverse_ip_tag: self._reverse_iptags = [ ReverseIPtagResource(port=receive_port, sdp_port=receive_sdp_port, tag=receive_tag) ] if board_address is not None: self.add_constraint(BoardConstraint(board_address)) self._receive_rate = receive_rate self._receive_sdp_port = receive_sdp_port # Work out if buffers are being sent self._send_buffer = None self._send_buffer_partition_id = send_buffer_partition_id if send_buffer_times is None: self._send_buffer_times = None self._send_buffer_max_space = send_buffer_max_space self._send_buffers = None else: self._send_buffer_max_space = send_buffer_max_space self._send_buffer = BufferedSendingRegion(send_buffer_max_space) self._send_buffer_times = send_buffer_times self._iptags = [ IPtagResource(ip_address=buffer_notification_ip_address, port=buffer_notification_port, strip_sdp=True, tag=buffer_notification_tag, traffic_identifier=TRAFFIC_IDENTIFIER) ] if board_address is not None: self.add_constraint(BoardConstraint(board_address)) self._send_buffers = { self._REGIONS.SEND_BUFFER.value: self._send_buffer } # buffered out parameters self._send_buffer_space_before_notify = send_buffer_space_before_notify 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 self._time_between_triggers = 0 self._maximum_recording_buffer = 0 # Set up for buffering self._buffer_notification_ip_address = buffer_notification_ip_address self._buffer_notification_port = buffer_notification_port self._buffer_notification_tag = buffer_notification_tag # set flag for checking if in injection mode self._in_injection_mode = receive_port is not None # 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, label=None, constraints=None): MachineVertex.__init__(self, label=label, constraints=constraints) AbstractProvidesOutgoingPartitionConstraints.__init__(self)
def __init__(self): MachineVertex.__init__(self)
def __init__(self, label, state): MachineVertex.__init__(self, label) # app specific elements self._state = state
def __init__(self, resources_required, label, constraints=None): MachineVertex.__init__( self, label, constraints=constraints) self._resources = resources_required
def __init__(self, model, data, n_samples, burn_in, thinning, degrees_of_freedom, seed=None, send_timer=1000, receive_timer=1000, window_size=1024, n_sequences=2048, data_partition_name="MCMCData", acknowledge_partition_name="MCMCDataAck", data_tag=1): """ :param model: The model being simulated :param data: The data to sample :param n_samples: The number of samples to generate :param burn_in:\ no of MCMC transitions to reach apparent equilibrium before\ generating inference samples :param thinning:\ sampling rate i.e. 5 = 1 sample for 5 generated steps :param degrees_of_freedom:\ The number of degrees of freedom to jump around with :param seed: The random seed to use """ MachineVertex.__init__(self, label="MCMC Node", constraints=None) self._model = model self._data = data self._n_samples = n_samples self._burn_in = burn_in self._thinning = thinning self._degrees_of_freedom = degrees_of_freedom self._seed = seed self._send_timer = send_timer self._receive_timer = receive_timer self._window_size = window_size self._n_sequences = n_sequences self._data_partition_name = data_partition_name self._acknowledge_partition_name = acknowledge_partition_name self._data_tag = data_tag # The data type of each data element if (self._model.get_parameters()[0].data_type is numpy.float64): self._data_element_type = DataType.FLOAT_64 elif (self._model.get_parameters()[0].data_type is numpy.float32): self._data_element_type = DataType.FLOAT_32 elif (self._model.get_parameters()[0].data_type is DataType.S1615): self._data_element_type = DataType.S1615 # The numpy data type of each data element if (self._model.get_parameters()[0].data_type is numpy.float64): self._numpy_data_element_type = numpy.float64 elif (self._model.get_parameters()[0].data_type is numpy.float32): self._numpy_data_element_type = numpy.float32 elif (self._model.get_parameters()[0].data_type is DataType.S1615): self._numpy_data_element_type = numpy.uint32 self._data_size = ((len(self._data) * self._data_element_type.size) + self._DATA_COUNT_TYPE.size) self._sdram_usage = (self._N_PARAMETER_BYTES + self._data_size) self._mcmc_vertices = list() self._mcmc_placements = list() self._data_receiver = dict()