def __init__(self, transceiver):
self._x = 0
self._y = 0
self._cpu = 0
self._node = (self._x << 8) | self._y
self.transceiver = transceiver
self.signal_states = {0: 'init', 1: 'pwrdn', 2: 'stop', 3: 'start',
4: 'sync0', 5: 'sync1', 6: 'pause', 7: 'cont',
8: 'exit', 9: 'timer', 10: 'usr0', 11: 'usr1',
12: 'usr2', 13: 'usr3', 16: 'or', 17: 'and',
18: 'count'}
self.states = {0: 'dead', 1: 'pwrdn', 2: 'rte', 3: 'wdog', 4: 'init',
5: 'ready', 6: 'c_main', 7: 'run', 8: 'sync0',
9: 'sync1', 10: 'pause', 11: 'exit', 15: 'idle'}
self.sig_type = {'init': 2, 'pwrdn': 2, 'stop': 2, 'start': 2,
'sync0': 0, 'sync1': 0, 'pause': 0, 'cont': 0,
'exit': 2, 'timer': 0, 'usr0': 0, 'usr1': 0,
'usr2': 0, 'usr3': 0, 'or': 1, 'and': 1, 'count': 1}
self.spinnaker_utility = Utility()
def __init__(self, transceiver):
self._x = 0
self._y = 0
self._cpu = 0
self._node = (self._x << 8) | self._y
self.transceiver = transceiver
self.signal_states = {
0: 'init',
1: 'pwrdn',
2: 'stop',
3: 'start',
4: 'sync0',
5: 'sync1',
6: 'pause',
7: 'cont',
8: 'exit',
9: 'timer',
10: 'usr0',
11: 'usr1',
12: 'usr2',
13: 'usr3',
16: 'or',
17: 'and',
18: 'count'
}
self.states = {
0: 'dead',
1: 'pwrdn',
2: 'rte',
3: 'wdog',
4: 'init',
5: 'ready',
6: 'c_main',
7: 'run',
8: 'sync0',
9: 'sync1',
10: 'pause',
11: 'exit',
15: 'idle'
}
self.sig_type = {
'init': 2,
'pwrdn': 2,
'stop': 2,
'start': 2,
'sync0': 0,
'sync1': 0,
'pause': 0,
'cont': 0,
'exit': 2,
'timer': 0,
'usr0': 0,
'usr1': 0,
'usr2': 0,
'usr3': 0,
'or': 1,
'and': 1,
'count': 1
}
self.spinnaker_utility = Utility()
class AppCalls(object):
def __init__(self, transceiver):
self._x = 0
self._y = 0
self._cpu = 0
self._node = (self._x << 8) | self._y
self.transceiver = transceiver
self.signal_states = {0: 'init', 1: 'pwrdn', 2: 'stop', 3: 'start',
4: 'sync0', 5: 'sync1', 6: 'pause', 7: 'cont',
8: 'exit', 9: 'timer', 10: 'usr0', 11: 'usr1',
12: 'usr2', 13: 'usr3', 16: 'or', 17: 'and',
18: 'count'}
self.states = {0: 'dead', 1: 'pwrdn', 2: 'rte', 3: 'wdog', 4: 'init',
5: 'ready', 6: 'c_main', 7: 'run', 8: 'sync0',
9: 'sync1', 10: 'pause', 11: 'exit', 15: 'idle'}
self.sig_type = {'init': 2, 'pwrdn': 2, 'stop': 2, 'start': 2,
'sync0': 0, 'sync1': 0, 'pause': 0, 'cont': 0,
'exit': 2, 'timer': 0, 'usr0': 0, 'usr1': 0,
'usr2': 0, 'usr3': 0, 'or': 1, 'and': 1, 'count': 1}
self.spinnaker_utility = Utility()
#self.states = {'dead': 0, 'pwrdn' :1, 'rte': 2, 'wdog': 3,
# 'init': 4, 'ready': 5, 'c_main': 6, 'run': 7,
# 'sync0': 8, 'sync1': 9, 'pause': 10, 'exit': 11,
# 'idle': 15}
#self.signal_states = {'init': 0, 'pwrdn': 1, 'stop': 2, 'start': 3,
#'sync0': 4, 'sync1': 5, 'pause': 6, 'cont': 7,
# 'exit': 8, 'timer': 9, 'usr0': 10, 'usr1': 11,
# 'usr2': 12, 'usr3': 13, 'or': 16, 'and': 17,
# 'count': 18}
def set_view(self, new_x, new_y, new_cpu, new_node):
self._x = new_x
self._y = new_y
self._cpu = new_cpu
self._node = new_node
def app_load(self, filename, region, cores, app_id, flags=None):
'''
loads a .aplx file onto a collection of cores based off the region given
'''
logger.debug("Loading %s to region %s, cores %s, appid %s", filename,
region, cores, app_id)
app_flags = 0
if flags != None and flags == "wait":
app_flags |= 1
region = self.spinnaker_utility.parse_region(region, self._x, self._y)
mask = self.spinnaker_utility.parse_cores(cores)
data = self.spinnaker_utility.read_file(filename)
try:
self.transceiver.packet_calls.flood_fill(data, region,
mask, app_id,
app_flags)
except exceptions.SpinnManException as e:
print "failed to flood fill the machine due " \
"to {}".format(e.message)
def app_signal(self, app_id, signal_id, state_id=None, x=None,
y=None, range=None):
'''
method that allows signals to be polled and sent to areas of a board
'''
#define the region
region = ""
if(x is None and y is None):
region = "all"
if signal_id not in self.signal_states:
raise exceptions.SpinnManException("signal definition does not "
"exist for {}. List is {}"
.format(signal_id,
self.signal_states))
region = self.spinnaker_utility.parse_region(region, x, y)
#locate signal name id
signal = self.signal_states[signal_id]
#locate state id
state = None
if signal_id >= 16:
if state_id is not None:
if state_id in self.states:
state = self.states[state_id]
else:
raise exceptions.SpinnManException("No state with that id")
else:
raise exceptions.SpinnManException("state was defined as None "
"when using a and/or/count "
"signal")
#locate type of signal
signal_type = self.sig_type[signal]
#parse the apps for a app mask
app_mask = self.spinnaker_utility.parse_apps(app_id, range)
mask = int(region) & 0xffff
data = (app_mask << 8) + app_id
#if signal type is 1
if signal_type == 1:
level = (region >> 16) & 3
op, mode = 2, 2
#if signal is a and/or/count
if signal_id >= 16:
op = 1
mode = signal_id - 16
data += (level << 26) + (op << 22) + (mode << 20)
if op == 1:
data += state_id << 16
if op != 1:
data += signal_id << 16
# logger.debug("Level {} op {} mode {}".format(level, op, mode))
else:
data += signal_id << 16
# logger.debug("Type {} data {} mask {}".format(signal_type, data, mask))
# logger.debug("Region {} signal {} state {}".format(region, signal, state))
#send scp message and catch the return data
msg = SCPMessage(cmd_rc=scamp.CMD_SIG)
msg._arg1 = signal_type
msg._arg2 = data
msg._arg3 = mask
return_data = self.transceiver.conn.send_scp_msg(msg).data
# if the signal requires a repsonse, output resposne and return it
if signal_type == 1:
r = struct.unpack("<I", return_data)[0]
if signal_id == 18: #count
#logger.debug("count {}".format(r))
return r
# else:
#logger.debug("mask {}".format(r))
return 0
def app_fill(self):
pass
def app_stop(self):
pass
def exec_app_start(self, start_addr, cpu_mask):
"""
Simultaneously executes APLX images on several processors in the target
SpiNNaker node.
:param int start_addr: memory address of the APLX image
:param int cpu_mask: bit-mask of processors on which to execute the image
:raises: SCPError
``cpu_mask`` is an integer *mask* where each bit corresponds to a
processor on the target SpiNNaker node, i.e. bit N implies that the
program should be executed on processor N.
.. warning::
The monitor processor **is** included in the ``cpu_mask`` which can
lead to errors if the APLX image was not designed to run on the
monitor pacman.
"""
# simple packet:
# arg1 = address of program in memory
# arg2 = cpu mask - each bit corresponds to a pacman in the chip
# arg3 = unused
msg = SCPMessage()
msg.cmd_rc = scamp.CMD_AS
msg.arg1 = start_addr
msg.arg2 = cpu_mask
self.transceiver.conn.send_scp_msg(msg)
def exec_aplx (self, start_addr):
"""
Executes an APLX image on the target SpiNNaker node.
:param int start_addr: memory address of the APLX image
:raises: SCPError
"""
# simple packet:
# arg1 = address of "table" (i.e. program start in SDRAM)
# arg2 = unused parameter - must be 0
# arg3 = unused
msg = SCPMessage ()
msg.cmd_rc = scamp.CMD_APLX
msg.arg1 = start_addr
self.transceiver.conn.send_scp_msg (msg)
class AppCalls(object):
def __init__(self, transceiver):
self._x = 0
self._y = 0
self._cpu = 0
self._node = (self._x << 8) | self._y
self.transceiver = transceiver
self.signal_states = {
0: 'init',
1: 'pwrdn',
2: 'stop',
3: 'start',
4: 'sync0',
5: 'sync1',
6: 'pause',
7: 'cont',
8: 'exit',
9: 'timer',
10: 'usr0',
11: 'usr1',
12: 'usr2',
13: 'usr3',
16: 'or',
17: 'and',
18: 'count'
}
self.states = {
0: 'dead',
1: 'pwrdn',
2: 'rte',
3: 'wdog',
4: 'init',
5: 'ready',
6: 'c_main',
7: 'run',
8: 'sync0',
9: 'sync1',
10: 'pause',
11: 'exit',
15: 'idle'
}
self.sig_type = {
'init': 2,
'pwrdn': 2,
'stop': 2,
'start': 2,
'sync0': 0,
'sync1': 0,
'pause': 0,
'cont': 0,
'exit': 2,
'timer': 0,
'usr0': 0,
'usr1': 0,
'usr2': 0,
'usr3': 0,
'or': 1,
'and': 1,
'count': 1
}
self.spinnaker_utility = Utility()
#self.states = {'dead': 0, 'pwrdn' :1, 'rte': 2, 'wdog': 3,
# 'init': 4, 'ready': 5, 'c_main': 6, 'run': 7,
# 'sync0': 8, 'sync1': 9, 'pause': 10, 'exit': 11,
# 'idle': 15}
#self.signal_states = {'init': 0, 'pwrdn': 1, 'stop': 2, 'start': 3,
#'sync0': 4, 'sync1': 5, 'pause': 6, 'cont': 7,
# 'exit': 8, 'timer': 9, 'usr0': 10, 'usr1': 11,
# 'usr2': 12, 'usr3': 13, 'or': 16, 'and': 17,
# 'count': 18}
def set_view(self, new_x, new_y, new_cpu, new_node):
self._x = new_x
self._y = new_y
self._cpu = new_cpu
self._node = new_node
def app_load(self, filename, region, cores, app_id, flags=None):
'''
loads a .aplx file onto a collection of cores based off the region given
'''
logger.debug("Loading %s to region %s, cores %s, appid %s", filename,
region, cores, app_id)
app_flags = 0
if flags != None and flags == "wait":
app_flags |= 1
region = self.spinnaker_utility.parse_region(region, self._x, self._y)
mask = self.spinnaker_utility.parse_cores(cores)
data = self.spinnaker_utility.read_file(filename)
try:
self.transceiver.packet_calls.flood_fill(data, region, mask,
app_id, app_flags)
except exceptions.SpinnManException as e:
print "failed to flood fill the machine due " \
"to {}".format(e.message)
def app_signal(self,
app_id,
signal_id,
state_id=None,
x=None,
y=None,
range=None):
'''
method that allows signals to be polled and sent to areas of a board
'''
#define the region
region = ""
if (x is None and y is None):
region = "all"
if signal_id not in self.signal_states:
raise exceptions.SpinnManException(
"signal definition does not "
"exist for {}. List is {}".format(signal_id,
self.signal_states))
region = self.spinnaker_utility.parse_region(region, x, y)
#locate signal name id
signal = self.signal_states[signal_id]
#locate state id
state = None
if signal_id >= 16:
if state_id is not None:
if state_id in self.states:
state = self.states[state_id]
else:
raise exceptions.SpinnManException("No state with that id")
else:
raise exceptions.SpinnManException("state was defined as None "
"when using a and/or/count "
"signal")
#locate type of signal
signal_type = self.sig_type[signal]
#parse the apps for a app mask
app_mask = self.spinnaker_utility.parse_apps(app_id, range)
mask = int(region) & 0xffff
data = (app_mask << 8) + app_id
#if signal type is 1
if signal_type == 1:
level = (region >> 16) & 3
op, mode = 2, 2
#if signal is a and/or/count
if signal_id >= 16:
op = 1
mode = signal_id - 16
data += (level << 26) + (op << 22) + (mode << 20)
if op == 1:
data += state_id << 16
if op != 1:
data += signal_id << 16
# logger.debug("Level {} op {} mode {}".format(level, op, mode))
else:
data += signal_id << 16
# logger.debug("Type {} data {} mask {}".format(signal_type, data, mask))
# logger.debug("Region {} signal {} state {}".format(region, signal, state))
#send scp message and catch the return data
msg = SCPMessage(cmd_rc=scamp.CMD_SIG)
msg._arg1 = signal_type
msg._arg2 = data
msg._arg3 = mask
return_data = self.transceiver.conn.send_scp_msg(msg).data
# if the signal requires a repsonse, output resposne and return it
if signal_type == 1:
r = struct.unpack("<I", return_data)[0]
if signal_id == 18: #count
#logger.debug("count {}".format(r))
return r
# else:
#logger.debug("mask {}".format(r))
return 0
def app_fill(self):
pass
def app_stop(self):
pass
def exec_app_start(self, start_addr, cpu_mask):
"""
Simultaneously executes APLX images on several processors in the target
SpiNNaker node.
:param int start_addr: memory address of the APLX image
:param int cpu_mask: bit-mask of processors on which to execute the image
:raises: SCPError
``cpu_mask`` is an integer *mask* where each bit corresponds to a
processor on the target SpiNNaker node, i.e. bit N implies that the
program should be executed on processor N.
.. warning::
The monitor processor **is** included in the ``cpu_mask`` which can
lead to errors if the APLX image was not designed to run on the
monitor pacman.
"""
# simple packet:
# arg1 = address of program in memory
# arg2 = cpu mask - each bit corresponds to a pacman in the chip
# arg3 = unused
msg = SCPMessage()
msg.cmd_rc = scamp.CMD_AS
msg.arg1 = start_addr
msg.arg2 = cpu_mask
self.transceiver.conn.send_scp_msg(msg)
def exec_aplx(self, start_addr):
"""
Executes an APLX image on the target SpiNNaker node.
:param int start_addr: memory address of the APLX image
:raises: SCPError
"""
# simple packet:
# arg1 = address of "table" (i.e. program start in SDRAM)
# arg2 = unused parameter - must be 0
# arg3 = unused
msg = SCPMessage()
msg.cmd_rc = scamp.CMD_APLX
msg.arg1 = start_addr
self.transceiver.conn.send_scp_msg(msg)
def run_raw(self, machine, targets, run_time, app_id, iptags, dao):
"""
Uses the SCP connection to trigger simulation.
:param `pacman103.lib.lib_machine.Machine` machine:
machine to run the simulation on.
:param list targets:
list of :py:class:`pacman103.lib.lib_map.ExecutableTarget`
instances.
:param int run_time: run time of the simulation (milliseconds)
"""
# Select monitor pacman on ethernet-adjacent chip
self.select(0, 0)
# Set IP tags
for iptag in iptags:
retries = 0
while retries < 3:
try:
logger.info("Setting up ip tag {} to {}:{}".format(
iptag.tag, iptag.hostname, iptag.port))
self.conn.set_iptag(iptag.tag, iptag.hostname,
iptag.port)
retries = 3
except Exception as e:
if retries == 3:
exceptions.SpinnManException("IPTags failed to be set "
"due to {}".
format(e.message))
retries += 1
time.sleep(0.1)
total_processors = 0
targets = self.organise_targets(targets)
for key in targets.keys():
chips = targets[key]
core_mask = 0
for chip in chips:
processors = chips[chip]
core_part_of_region = ""
first = True
for processor in processors:
core_mask += processor
if first:
core_part_of_region += "{}".format(processor)
first = False
else:
core_part_of_region += ",{}".format(processor)
total_processors += 1
(x, y) = chip.split(",")
region = Utility.calculate_region_id(int(x), int(y))
if conf.config.get("Reports", "write_reload_steps"):
self.utility.write_app_load_command(key, region,
core_part_of_region,
app_id)
self.app_calls.app_load(key, region, core_part_of_region, app_id)
processors_ready = 0
logger.debug("checking that the processors currently"
" flood filled are ready for future flood fills")
while processors_ready < total_processors:
processors_ready = self.app_calls.app_signal(app_id,
scamp.SIGNAL_COUNT, scamp.PROCESSOR_SYNC0)
logger.debug("{} processors out of {} "
"processors are ready".format(processors_ready,
total_processors))
logger.info("Waiting for application to finish loading")
if conf.config.get("Reports", "write_reload_steps"):
self.utility.write_extra_data(run_time, total_processors)
self.utility.close()
self.check_synco_and_run(total_processors, app_id, run_time, dao)
def run_raw(self, machine, targets, run_time, app_id, iptags, dao):
"""
Uses the SCP connection to trigger simulation.
:param `pacman103.lib.lib_machine.Machine` machine:
machine to run the simulation on.
:param list targets:
list of :py:class:`pacman103.lib.lib_map.ExecutableTarget`
instances.
:param int run_time: run time of the simulation (milliseconds)
"""
# Select monitor pacman on ethernet-adjacent chip
self.select(0, 0)
# Set IP tags
for iptag in iptags:
retries = 0
while retries < 3:
try:
logger.info("Setting up ip tag {} to {}:{}".format(
iptag.tag, iptag.hostname, iptag.port))
self.conn.set_iptag(iptag.tag, iptag.hostname, iptag.port)
retries = 3
except Exception as e:
if retries == 3:
exceptions.SpinnManException("IPTags failed to be set "
"due to {}".format(
e.message))
retries += 1
time.sleep(0.1)
total_processors = 0
targets = self.organise_targets(targets)
for key in targets.keys():
chips = targets[key]
core_mask = 0
for chip in chips:
processors = chips[chip]
core_part_of_region = ""
first = True
for processor in processors:
core_mask += processor
if first:
core_part_of_region += "{}".format(processor)
first = False
else:
core_part_of_region += ",{}".format(processor)
total_processors += 1
(x, y) = chip.split(",")
region = Utility.calculate_region_id(int(x), int(y))
if conf.config.get("Reports", "write_reload_steps"):
self.utility.write_app_load_command(
key, region, core_part_of_region, app_id)
self.app_calls.app_load(key, region, core_part_of_region,
app_id)
processors_ready = 0
logger.debug("checking that the processors currently"
" flood filled are ready for future flood fills")
while processors_ready < total_processors:
processors_ready = self.app_calls.app_signal(
app_id, scamp.SIGNAL_COUNT, scamp.PROCESSOR_SYNC0)
logger.debug("{} processors out of {} "
"processors are ready".format(
processors_ready, total_processors))
logger.info("Waiting for application to finish loading")
if conf.config.get("Reports", "write_reload_steps"):
self.utility.write_extra_data(run_time, total_processors)
self.utility.close()
self.check_synco_and_run(total_processors, app_id, run_time, dao)
real_file = os.path.basename(filename)
real_file = os.path.join(binary_path, filename)
core_mask = 0
for chip in chips:
print("Loading on", chip, file=sys.stderr)
processors = chips[chip]
core_part_of_region = ""
first = True
for processor in processors:
core_mask += processor
if first:
core_part_of_region += "{}".format(processor)
first = False
else:
core_part_of_region += ",{}".format(processor)
total_processors += 1
(x, y) = chip.split(",")
region = Utility.calculate_region_id(int(x), int(y))
txrx.app_calls.app_load(real_file, region, core_part_of_region,
app_id)
processors_ready = 0
while processors_ready < total_processors:
processors_ready = txrx.app_calls.app_signal(
app_id, scamp.SIGNAL_COUNT, scamp.PROCESSOR_SYNC0)
txrx.app_calls.app_signal(app_id, scamp.SIGNAL_SYNC0)
chips = targets[filename]
real_file = os.path.basename(filename)
real_file = os.path.join(binary_path, filename)
core_mask = 0
for chip in chips:
print("Loading on", chip, file=sys.stderr)
processors = chips[chip]
core_part_of_region = ""
first = True
for processor in processors:
core_mask += processor
if first:
core_part_of_region += "{}".format(processor)
first = False
else:
core_part_of_region += ",{}".format(processor)
total_processors += 1
(x, y) = chip.split(",")
region = Utility.calculate_region_id(int(x), int(y))
txrx.app_calls.app_load(real_file, region, core_part_of_region, app_id)
processors_ready = 0
while processors_ready < total_processors:
processors_ready = txrx.app_calls.app_signal(
app_id, scamp.SIGNAL_COUNT, scamp.PROCESSOR_SYNC0)
txrx.app_calls.app_signal(app_id, scamp.SIGNAL_SYNC0)
