def read_eieio_data_message(data, offset): eieio_header = EIEIODataHeader.from_bytestring(data, offset) offset += eieio_header.size eieio_type = eieio_header.eieio_type prefix = eieio_header.prefix payload_base = eieio_header.payload_base prefix_type = eieio_header.prefix_type is_time = eieio_header.is_time if eieio_type == EIEIOType.KEY_16_BIT: return _read_16_bit_message( prefix, payload_base, prefix_type, is_time, data, offset, eieio_header) elif eieio_type == EIEIOType.KEY_PAYLOAD_16_BIT: return _read_16_bit_payload_message( prefix, payload_base, prefix_type, is_time, data, offset, eieio_header) elif eieio_type == EIEIOType.KEY_32_BIT: return _read_32_bit_message( prefix, payload_base, prefix_type, is_time, data, offset, eieio_header) elif eieio_type == EIEIOType.KEY_PAYLOAD_32_BIT: return _read_32_bit_payload_message( prefix, payload_base, prefix_type, is_time, data, offset, eieio_header) return EIEIODataMessage(eieio_header, data, offset)
def read_eieio_data_message(data, offset): """ Reads the content of an EIEIO data message and returns an object\ identifying the data which was contained in the packet :param data: data received from the network :type data: bytestring :param offset: offset at which the parsing operation should start :type offset: int :return: an object which inherits from EIEIODataMessage which contains\ parsed data received from the network :rtype:\ :py:class:`spinnman.messages.eieio.data_messages.eieio_data_message.EIEIODataMessage` """ eieio_header = EIEIODataHeader.from_bytestring(data, offset) offset += eieio_header.size eieio_type = eieio_header.eieio_type prefix = eieio_header.prefix payload_base = eieio_header.payload_base prefix_type = eieio_header.prefix_type is_time = eieio_header.is_time if eieio_type == EIEIOType.KEY_16_BIT: return _read_16_bit_message(prefix, payload_base, prefix_type, is_time, data, offset, eieio_header) elif eieio_type == EIEIOType.KEY_PAYLOAD_16_BIT: return _read_16_bit_payload_message(prefix, payload_base, prefix_type, is_time, data, offset, eieio_header) elif eieio_type == EIEIOType.KEY_32_BIT: return _read_32_bit_message(prefix, payload_base, prefix_type, is_time, data, offset, eieio_header) elif eieio_type == EIEIOType.KEY_PAYLOAD_32_BIT: return _read_32_bit_payload_message(prefix, payload_base, prefix_type, is_time, data, offset, eieio_header) return EIEIODataMessage(eieio_header, data, offset)
def get_spikes(self, label, buffer_manager, region, placements, graph_mapper, application_vertex, base_key_function, machine_time_step): results = list() missing_str = "" ms_per_tick = machine_time_step / 1000.0 vertices = \ graph_mapper.get_machine_vertices(application_vertex) progress_bar = ProgressBar(len(vertices), "Getting spikes for {}".format(label)) for vertex in vertices: placement = placements.get_placement_of_vertex(vertex) vertex_slice = graph_mapper.get_slice(vertex) x = placement.x y = placement.y p = placement.p # Read the spikes raw_spike_data, data_missing = \ buffer_manager.get_data_for_vertex(placement, region) if data_missing: missing_str += "({}, {}, {}); ".format(x, y, p) spike_data = str(raw_spike_data.read_all()) number_of_bytes_written = len(spike_data) offset = 0 while offset < number_of_bytes_written: eieio_header = EIEIODataHeader.from_bytestring( spike_data, offset) offset += eieio_header.size timestamp = eieio_header.payload_base * ms_per_tick timestamps = numpy.repeat([timestamp], eieio_header.count) keys = numpy.frombuffer(spike_data, dtype="<u4", count=eieio_header.count, offset=offset) neuron_ids = ((keys - base_key_function(vertex)) + vertex_slice.lo_atom) offset += eieio_header.count * 4 results.append(numpy.dstack((neuron_ids, timestamps))[0]) progress_bar.update() progress_bar.end() if len(missing_str) > 0: logger.warn( "Population {} is missing spike data in region {} from the" " following cores: {}".format(label, region, missing_str)) if len(results) != 0: result = numpy.vstack(results) result = result[numpy.lexsort((result[:, 1], result[:, 0]))] else: result = [] return result
def get_spikes(self, label, buffer_manager, region, state_region, placements, graph_mapper, partitionable_vertex, base_key_function): results = list() missing_str = "" ms_per_tick = self._machine_time_step / 1000.0 subvertices = \ graph_mapper.get_subvertices_from_vertex(partitionable_vertex) progress_bar = ProgressBar(len(subvertices), "Getting spikes for {}".format(label)) for subvertex in subvertices: placement = placements.get_placement_of_subvertex(subvertex) subvertex_slice = graph_mapper.get_subvertex_slice(subvertex) x = placement.x y = placement.y p = placement.p # Read the spikes raw_spike_data, data_missing = \ buffer_manager.get_data_for_vertex( x, y, p, region, state_region) if data_missing: missing_str += "({}, {}, {}); ".format(x, y, p) spike_data = raw_spike_data.read_all() number_of_bytes_written = len(spike_data) offset = 0 while offset < number_of_bytes_written: eieio_header = EIEIODataHeader.from_bytestring( spike_data, offset) offset += eieio_header.size timestamp = eieio_header.payload_base * ms_per_tick timestamps = numpy.repeat([timestamp], eieio_header.count) keys = numpy.frombuffer( spike_data, dtype="<u4", count=eieio_header.count, offset=offset) neuron_ids = ((keys - base_key_function(subvertex)) + subvertex_slice.lo_atom) offset += eieio_header.count * 4 results.append(numpy.dstack((neuron_ids, timestamps))[0]) progress_bar.update() progress_bar.end() if len(missing_str) > 0: logger.warn( "Population {} is missing spike data in region {} from the" " following cores: {}".format(label, region, missing_str)) if len(results) != 0: result = numpy.vstack(results) result = result[numpy.lexsort((result[:, 1], result[:, 0]))] else: result = [] return result
def get_spikes(self, label, transceiver, region, placements, graph_mapper, partitionable_vertex): results = list() ms_per_tick = self._machine_time_step / 1000.0 subvertices = \ graph_mapper.get_subvertices_from_vertex(partitionable_vertex) progress_bar = ProgressBar(len(subvertices), "Getting spikes for {}".format(label)) for subvertex in subvertices: placement = placements.get_placement_of_subvertex(subvertex) subvertex_slice = graph_mapper.get_subvertex_slice(subvertex) # Read the spikes spike_data = recording_utils.get_data( transceiver, placement, region, subvertex.region_size) number_of_bytes_written = len(spike_data) offset = 0 while offset < number_of_bytes_written: eieio_header = EIEIODataHeader.from_bytestring( spike_data, offset) offset += eieio_header.size timestamp = eieio_header.payload_base * ms_per_tick timestamps = numpy.repeat([timestamp], eieio_header.count) keys = numpy.frombuffer( spike_data, dtype="<u4", count=eieio_header.count, offset=offset) neuron_ids = \ (keys - subvertex.base_key) + subvertex_slice.lo_atom offset += eieio_header.count * 4 results.append(numpy.dstack((neuron_ids, timestamps))[0]) progress_bar.update() progress_bar.end() result = numpy.vstack(results) result = result[numpy.lexsort((result[:, 1], result[:, 0]))] return result
def get_spikes( self, txrx, placements, graph_mapper, compatible_output=False): """ Return a 2-column numpy array containing cell ids and spike times for recorded cells. This is read directly from the memory for the board. :param transceiver: :param placements: :param graph_mapper: :param compatible_output: """ logger.info("Getting spikes for {}".format(self._label)) # Find all the sub-vertices that this pynn_population.py exists on subvertices = graph_mapper.get_subvertices_from_vertex(self) progress_bar = ProgressBar(len(subvertices), "Getting spikes") results = list() for subvertex in subvertices: placement = placements.get_placement_of_subvertex(subvertex) (x, y, p) = placement.x, placement.y, placement.p subvertex_slice = graph_mapper.get_subvertex_slice(subvertex) lo_atom = subvertex_slice.lo_atom hi_atom = subvertex_slice.hi_atom logger.debug("Reading spikes from chip {}, {}, core {}, " "lo_atom {} hi_atom {}".format( x, y, p, lo_atom, hi_atom)) # Get the App Data for the core app_data_base_address = \ txrx.get_cpu_information_from_core(x, y, p).user[0] # Get the position of the spike buffer spike_region_base_address_offset = \ dsg_utility_calls.get_region_base_address_offset( app_data_base_address, self._SPIKE_SOURCE_REGIONS .SPIKE_DATA_RECORDED_REGION.value) spike_region_base_address_buf = buffer(txrx.read_memory( x, y, spike_region_base_address_offset, 4)) spike_region_base_address = struct.unpack_from( "<I", spike_region_base_address_buf)[0] spike_region_base_address += app_data_base_address # Read the spike data size number_of_bytes_written_buf = buffer(txrx.read_memory( x, y, spike_region_base_address, 4)) number_of_bytes_written = struct.unpack_from( "<I", number_of_bytes_written_buf)[0] # check that the number of spikes written is smaller or the same as # the size of the memory region we allocated for spikes send_buffer = self._get_spike_send_buffer(subvertex_slice) if number_of_bytes_written > send_buffer.total_region_size: raise exceptions.MemReadException( "the amount of memory written ({}) was larger than was " "allocated for it ({})" .format(number_of_bytes_written, send_buffer.total_region_size)) # Read the spikes logger.debug("Reading {} ({}) bytes starting at {} + 4" .format(number_of_bytes_written, hex(number_of_bytes_written), hex(spike_region_base_address))) spike_data_block = txrx.read_memory( x, y, spike_region_base_address + 4, number_of_bytes_written) # translate block of spikes into EIEIO messages offset = 0 while offset <= number_of_bytes_written - 4: eieio_header = EIEIODataHeader.from_bytestring( spike_data_block, offset) offset += eieio_header.size timestamps = numpy.repeat([eieio_header.payload_base], eieio_header.count) keys = numpy.frombuffer( spike_data_block, dtype="<u4", count=eieio_header.count, offset=offset) neuron_ids = ((keys - subvertex.base_key) + subvertex_slice.lo_atom) offset += eieio_header.count * 4 results.append(numpy.dstack((neuron_ids, timestamps))[0]) # complete the buffer progress_bar.update() progress_bar.end() result = numpy.vstack(results) result = result[numpy.lexsort((result[:, 1], result[:, 0]))] return result