def reload_application_data(self, reload_application_data_items, load_data=True): """ :param reload_application_data_items: the application data for each core which needs data to be reloaded to work :param load_data: a boolean which will not reload if set to false. :return: None """ progress = ProgressBar(len(reload_application_data_items), "Reloading Application Data") # fixme need to find a way to remove these private accesses (maybe # when the dsg in partitioned it will clear up) for reload_application_data in reload_application_data_items: if load_data: data_file = FileDataReader(reload_application_data.data_file) self._spinnaker_interface._txrx.write_memory( reload_application_data.chip_x, reload_application_data.chip_y, reload_application_data.base_address, data_file, reload_application_data.data_size) data_file.close() user_0_register_address = self._spinnaker_interface._txrx.\ get_user_0_register_address_from_core( reload_application_data.chip_x, reload_application_data.chip_y, reload_application_data.processor_id) self._spinnaker_interface._txrx.write_memory( reload_application_data.chip_x, reload_application_data.chip_y, user_0_register_address, reload_application_data.base_address) progress.update() self._total_processors += 1 progress.end()
def test_read_five_byte(self): self.reader = FileDataReader(self._file_txt_five_bytes) stream = self.reader.read(5) self.assertEqual(len(stream), 5) self.assertEqual(stream[0], ord('1')) self.assertEqual(stream[1], ord('2')) self.assertEqual(stream[2], ord('3')) self.assertEqual(stream[3], ord('4')) self.assertEqual(stream[4], ord('5'))
def _load_application_data( self, placements, vertex_to_subvertex_mapper, processor_to_app_data_base_address, hostname, app_data_folder, verify=False, ): # go through the placements and see if there's any application data to # load progress_bar = ProgressBar(len(list(placements.placements)), "Loading application data onto the machine") for placement in placements.placements: associated_vertex = vertex_to_subvertex_mapper.get_vertex_from_subvertex(placement.subvertex) if isinstance(associated_vertex, AbstractDataSpecableVertex): logger.debug("loading application data for vertex {}".format(associated_vertex.label)) key = (placement.x, placement.y, placement.p) start_address = processor_to_app_data_base_address[key]["start_address"] memory_written = processor_to_app_data_base_address[key]["memory_written"] file_path_for_application_data = associated_vertex.get_application_data_file_path( placement.x, placement.y, placement.p, hostname, app_data_folder ) application_data_file_reader = SpinnmanFileDataReader(file_path_for_application_data) logger.debug("writing application data for vertex {}".format(associated_vertex.label)) self._txrx.write_memory( placement.x, placement.y, start_address, application_data_file_reader, memory_written ) application_data_file_reader.close() if verify: application_data_file_reader = SpinnmanFileDataReader(file_path_for_application_data) all_data = application_data_file_reader.readall() read_data = self._txrx.read_memory(placement.x, placement.y, start_address, memory_written) if read_data != all_data: raise Exception( "Miswrite of {}, {}, {}, {}".format(placement.x, placement.y, placement.p, start_address) ) application_data_file_reader.close() # update user 0 so that it points to the start of the # applications data region on sdram logger.debug("writing user 0 address for vertex {}".format(associated_vertex.label)) user_o_register_address = self._txrx.get_user_0_register_address_from_core( placement.x, placement.y, placement.p ) self._txrx.write_memory(placement.x, placement.y, user_o_register_address, start_address) # add lines to rerun_script if requested if self._reports_states.transciever_report: self._reload_script.add_application_data(file_path_for_application_data, placement, start_address) progress_bar.update() progress_bar.end()
def __call__( self, processor_to_app_data_base_address, transceiver, placement_to_app_data_files, app_id, verify=False): # go through the placements and see if there's any application data to # load progress_bar = ProgressBar(len(placement_to_app_data_files), "Loading application data onto the machine") for (x, y, p, label) in placement_to_app_data_files: logger.debug( "loading application data for vertex {}".format(label)) key = (x, y, p, label) start_address = \ processor_to_app_data_base_address[key]['start_address'] memory_written = \ processor_to_app_data_base_address[key]['memory_written'] memory_used = \ processor_to_app_data_base_address[key]['memory_used'] # Allocate the SDRAM requirement and replace the start address # assigned via the DSE start_address_malloced = \ transceiver.malloc_sdram(x, y, memory_used, app_id) processor_to_app_data_base_address[key]['start_address'] = \ start_address_malloced # set start address to be that of the allocated version start_address = start_address_malloced application_file_paths = placement_to_app_data_files[key] for file_path_for_application_data in application_file_paths: application_data_file_reader = SpinnmanFileDataReader( file_path_for_application_data) logger.debug( "writing application data for vertex {}".format(label)) transceiver.write_memory( x, y, start_address, application_data_file_reader, memory_written) application_data_file_reader.close() if verify: application_data_file_reader = SpinnmanFileDataReader( file_path_for_application_data) all_data = application_data_file_reader.readall() read_data = transceiver.read_memory( x, y, start_address, memory_written) if read_data != all_data: raise Exception("Miss Write of {}, {}, {}, {}" .format(x, y, p, start_address)) application_data_file_reader.close() # update user 0 so that it points to the start of the # applications data region on SDRAM logger.debug( "writing user 0 address for vertex {}".format(label)) user_o_register_address = \ transceiver.get_user_0_register_address_from_core(x, y, p) transceiver.write_memory( x, y, user_o_register_address, start_address) progress_bar.update() progress_bar.end() return {"LoadedApplicationDataToken": True}
def test_read_truncate(self): self.reader = FileDataReader(self._file_txt_five_bytes) stream = self.reader.read(2) self.assertEqual(len(stream), 2) self.assertEqual(stream[0], 49) self.assertEqual(stream[1], 50)
def test_read_from_empty_file(self): self.reader = FileDataReader(self._file_txt_empty) stream = self.reader.read(1) self.assertEqual(len(stream), 0)
class TestFileDataReader(unittest.TestCase): @classmethod def setUpClass(cls): (os_fd, cls._file_txt_empty) = tempfile.mkstemp(text=False) os.close(os_fd) (os_fd, cls._file_txt_one_byte) = tempfile.mkstemp(text=False) os.write(os_fd, "1") os.close(os_fd) (os_fd, cls._file_txt_five_bytes) = tempfile.mkstemp(text=False) os.write(os_fd, "1") os.write(os_fd, "2") os.write(os_fd, "3") os.write(os_fd, "4") os.write(os_fd, "5") os.close(os_fd) @classmethod def tearDownClass(cls): try: os.remove(cls._file_txt_empty) except OSError: pass try: os.remove(cls._file_txt_one_byte) except OSError: pass try: os.remove(cls._file_txt_five_bytes) except OSError: pass def setUp(self): self.reader = None def tearDown(self): if self.reader is not None: self.reader.close() def test_read_one_byte(self): self.reader = FileDataReader(self._file_txt_one_byte) stream = self.reader.read(1) self.assertEqual(stream[0], ord('1')) def test_readinto_one_byte(self): self.reader = FileDataReader(self._file_txt_one_byte) ba = bytearray(1) stream = self.reader.readinto(ba) self.assertEqual(len(ba), 1) self.assertEqual(ba[0], ord('1')) def test_read_five_byte(self): self.reader = FileDataReader(self._file_txt_five_bytes) stream = self.reader.read(5) self.assertEqual(len(stream), 5) self.assertEqual(stream[0], ord('1')) self.assertEqual(stream[1], ord('2')) self.assertEqual(stream[2], ord('3')) self.assertEqual(stream[3], ord('4')) self.assertEqual(stream[4], ord('5')) def test_read_from_empty_file(self): self.reader = FileDataReader(self._file_txt_empty) stream = self.reader.read(1) self.assertEqual(len(stream), 0) def test_read_truncate(self): self.reader = FileDataReader(self._file_txt_five_bytes) stream = self.reader.read(2) self.assertEqual(len(stream), 2) self.assertEqual(stream[0], 49) self.assertEqual(stream[1], 50)
def test_readinto_one_byte(self): self.reader = FileDataReader(self._file_txt_one_byte) ba = bytearray(1) stream = self.reader.readinto(ba) self.assertEqual(len(ba), 1) self.assertEqual(ba[0], ord('1'))
def test_read_one_byte(self): self.reader = FileDataReader(self._file_txt_one_byte) stream = self.reader.read(1) self.assertEqual(stream[0], ord('1'))