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'))
