class Simulator(object):
"""SpiNNaker simulator for Nengo models.
The simulator period determines how much data will be stored on SpiNNaker
and is the maximum length of simulation allowed before data is transferred
between the machine and the host PC. If the period is set to `None`
function of time Nodes will not be optimised and probes will be disabled.
For any other value simulation lengths of less than or equal to the period
will be in real-time, longer simulations will be possible but will include
short gaps when data is transferred between SpiNNaker and the host.
:py:meth:`~.close` should be called when the simulator will no longer be
used. This will close all sockets used to communicate with the SpiNNaker
machine and will leave the machine in a clean state. Failure to call
`close` may result in later failures. Alternatively `with` may be used::
sim = nengo_spinnaker.Simulator(network)
with sim:
sim.run(10.0)
"""
_open_simulators = set()
@classmethod
def _add_simulator(cls, simulator):
cls._open_simulators.add(simulator)
@classmethod
def _remove_simulator(cls, simulator):
cls._open_simulators.remove(simulator)
def __init__(self,
network,
dt=0.001,
period=10.0,
timescale=1.0,
hostname=None,
use_spalloc=None,
allocation_fudge_factor=0.6):
"""Create a new Simulator with the given network.
Parameters
----------
period : float or None
Duration of one period of the simulator. This determines how much
memory will be allocated to store precomputed and probed data.
timescale : float
Scaling factor to apply to the simulation, e.g., a value of `0.5`
will cause the simulation to run at half real-time.
hostname : string or None
Hostname of the SpiNNaker machine to use; if None then the machine
specified in the config file will be used.
use_spalloc : bool or None
Allocate a SpiNNaker machine for the simulator using ``spalloc``.
If None then the setting specified in the config file will be used.
Other Parameters
----------------
allocation_fudge_factor:
Fudge factor to allocate more cores than really necessary when using
`spalloc` to ensure that (a) there are sufficient "live" cores in
the allocated machine, (b) there is sufficient room for a good place
and route solution. This should generally be more than 0.1 (10% more
cores than necessary) to account for the usual rate of missing
chips.
"""
# Add this simulator to the set of open simulators
Simulator._add_simulator(self)
# Create the IO controller
io_cls = getconfig(network.config, Simulator, "node_io", Ethernet)
io_kwargs = getconfig(network.config, Simulator, "node_io_kwargs",
dict())
self.io_controller = io_cls(**io_kwargs)
# Calculate the machine timestep, this is measured in microseconds
# (hence the 1e6 scaling factor).
self.timescale = timescale
machine_timestep = int((dt / timescale) * 1e6)
# Determine the maximum run-time
self.max_steps = None if period is None else int(period / dt)
self.steps = 0 # Steps simulated
# If the simulator is in "run indefinite" mode (i.e., max_steps=None)
# then we modify the builders to ignore function of time Nodes and
# probes.
builder_kwargs = self.io_controller.builder_kwargs
if self.max_steps is None:
raise NotImplementedError
# Create a model from the network, using the IO controller
logger.debug("Building model")
start_build = time.time()
self.model = Model(dt=dt,
machine_timestep=machine_timestep,
decoder_cache=get_default_decoder_cache())
self.model.build(network, **builder_kwargs)
logger.info("Build took {:.3f} seconds".format(time.time() -
start_build))
self.model.decoder_cache.shrink()
self.dt = self.model.dt
self._closed = False # Whether the simulator has been closed or not
self.host_sim = self._create_host_sim()
# Holder for probe data
self.data = {}
# Holder for profiling data
self.profiler_data = {}
# Convert the model into a netlist
logger.info("Building netlist")
start = time.time()
self.netlist = self.model.make_netlist(self.max_steps or 0)
# Determine whether to use a spalloc machine or not
if use_spalloc is None:
# Default is to not use spalloc; this is indicated by either the
# absence of the option in the config file OR the option being set
# to false.
use_spalloc = (rc.has_option("spinnaker_machine", "use_spalloc")
and rc.getboolean("spinnaker_machine",
"use_spalloc"))
# Create a controller for the machine and boot if necessary
self.job = None
if not use_spalloc or hostname is not None:
# Use the specified machine rather than trying to get one
# allocated.
if hostname is None:
hostname = rc.get("spinnaker_machine", "hostname")
else:
# Attempt to get a machine allocated to us
from spalloc import Job
# Determine how many boards to ask for (assuming 16 usable cores
# per chip and 48 chips per board).
n_cores = self.netlist.n_cores * (1.0 + allocation_fudge_factor)
n_boards = int(np.ceil((n_cores / 16.) / 48.))
# Request the job
self.job = Job(n_boards)
logger.info("Allocated job ID %d...", self.job.id)
# Wait until we're given the machine
logger.info("Waiting for machine allocation...")
self.job.wait_until_ready()
# spalloc recommends a slight delay before attempting to boot the
# machine, later versions of spalloc server may relax this
# requirement.
time.sleep(5.0)
# Store the hostname
hostname = self.job.hostname
logger.info("Using %d board(s) of \"%s\" (%s)",
len(self.job.boards), self.job.machine_name, hostname)
self.controller = MachineController(hostname)
self.controller.boot()
# Get a system-info object to place & route against
logger.info("Getting SpiNNaker machine specification")
system_info = self.controller.get_system_info()
# Place & Route
logger.info("Placing and routing")
self.netlist.place_and_route(
system_info,
place=getconfig(network.config, Simulator, 'placer',
rig.place_and_route.place),
place_kwargs=getconfig(network.config, Simulator, 'placer_kwargs',
{}),
)
logger.info("{} cores in use".format(len(self.netlist.placements)))
chips = set(six.itervalues(self.netlist.placements))
logger.info("Using {}".format(chips))
# Prepare the simulator against the placed, allocated and routed
# netlist.
self.io_controller.prepare(self.model, self.controller, self.netlist)
# Load the application
logger.info("Loading application")
self.netlist.load_application(self.controller, system_info)
# Check if any cores are in bad states
if self.controller.count_cores_in_state(
["exit", "dead", "watchdog", "runtime_exception"]):
for vertex, (x, y) in six.iteritems(self.netlist.placements):
p = self.netlist.allocations[vertex][Cores].start
status = self.controller.get_processor_status(p, x, y)
if status.cpu_state is not AppState.sync0:
print("Core ({}, {}, {}) in state {!s}".format(
x, y, p, status))
print(self.controller.get_iobuf(p, x, y))
raise Exception("Unexpected core failures.")
logger.info("Preparing and loading machine took {:3f} seconds".format(
time.time() - start))
logger.info("Setting router timeout to 16 cycles")
for x, y in system_info.chips():
with self.controller(x=x, y=y):
data = self.controller.read(0xf1000000, 4)
self.controller.write(0xf1000000, data[:-1] + b'\x10')
def __enter__(self):
"""Enter a context which will close the simulator when exited."""
# Return self to allow usage like:
#
# with nengo_spinnaker.Simulator(model) as sim:
# sim.run(1.0)
return self
def __exit__(self, exception_type, exception_value, traceback):
"""Exit a context and close the simulator."""
self.close()
def run(self, time_in_seconds):
"""Simulate for the given length of time."""
# Determine how many steps to simulate for
steps = int(np.round(float(time_in_seconds) / self.dt))
self.run_steps(steps)
def run_steps(self, steps):
"""Simulate a give number of steps."""
while steps > 0:
n_steps = min((steps, self.max_steps))
self._run_steps(n_steps)
steps -= n_steps
def _run_steps(self, steps):
"""Simulate for the given number of steps."""
if self._closed:
raise Exception("Simulator has been closed and can't be used to "
"run further simulations.")
if steps is None:
if self.max_steps is not None:
raise Exception(
"Cannot run indefinitely if a simulator period was "
"specified. Create a new simulator with Simulator(model, "
"period=None) to perform indefinite time simulations.")
else:
assert steps <= self.max_steps
# Prepare the simulation
self.netlist.before_simulation(self, steps)
# Wait for all cores to hit SYNC0 (either by remaining it or entering
# it from init)
self._wait_for_transition(AppState.init, AppState.sync0,
self.netlist.n_cores)
self.controller.send_signal("sync0")
# Get a new thread for the IO
io_thread = self.io_controller.spawn()
# Run the simulation
try:
# Prep
exp_time = steps * self.dt / self.timescale
io_thread.start()
# Wait for all cores to hit SYNC1
self._wait_for_transition(AppState.sync0, AppState.sync1,
self.netlist.n_cores)
logger.info("Running simulation...")
self.controller.send_signal("sync1")
# Execute the local model
host_steps = 0
start_time = time.time()
run_time = 0.0
local_timestep = self.dt / self.timescale
while run_time < exp_time:
# Run a step
self.host_sim.step()
run_time = time.time() - start_time
# If that step took less than timestep then spin
time.sleep(0.0001)
while run_time < host_steps * local_timestep:
time.sleep(0.0001)
run_time = time.time() - start_time
finally:
# Stop the IO thread whatever occurs
io_thread.stop()
# Wait for cores to re-enter sync0
self._wait_for_transition(AppState.run, AppState.sync0,
self.netlist.n_cores)
# Retrieve simulation data
start = time.time()
logger.info("Retrieving simulation data")
self.netlist.after_simulation(self, steps)
logger.info("Retrieving data took {:3f} seconds".format(time.time() -
start))
# Increase the steps count
self.steps += steps
def _wait_for_transition(self, from_state, desired_to_state, num_verts):
while True:
# If no cores are still in from_state, stop
if self.controller.count_cores_in_state(from_state) == 0:
break
# Wait a bit
time.sleep(1.0)
# Check if any cores haven't exited cleanly
num_ready = self.controller.wait_for_cores_to_reach_state(
desired_to_state, num_verts, timeout=5.0)
if num_ready != num_verts:
# Loop through all placed vertices
for vertex, (x, y) in six.iteritems(self.netlist.placements):
p = self.netlist.allocations[vertex][Cores].start
status = self.controller.get_processor_status(p, x, y)
if status.cpu_state is not desired_to_state:
print("Core ({}, {}, {}) in state {!s}".format(
x, y, p, status.cpu_state))
print(self.controller.get_iobuf(p, x, y))
raise Exception("Unexpected core failures before reaching %s "
"state." % desired_to_state)
def _create_host_sim(self):
# change node_functions to reflect time
# TODO: improve the reference simulator so that this is not needed
# by adding a realtime option
node_functions = {}
node_info = dict(start=None)
for node in self.io_controller.host_network.all_nodes:
if callable(node.output):
old_func = node.output
if node.size_in == 0:
def func(t, f=old_func):
now = time.time()
if node_info['start'] is None:
node_info['start'] = now
t = (now - node_info['start']) * self.timescale
return f(t)
else:
def func(t, x, f=old_func):
now = time.time()
if node_info['start'] is None:
node_info['start'] = now
t = (now - node_info['start']) * self.timescale
return f(t, x)
node.output = func
node_functions[node] = old_func
# Build the host simulator
host_sim = nengo.Simulator(self.io_controller.host_network, dt=self.dt)
# reset node functions
for node, func in node_functions.items():
node.output = func
return host_sim
def close(self):
"""Clean the SpiNNaker board and prevent further simulation."""
if not self._closed:
# Stop the application
self._closed = True
self.io_controller.close()
self.controller.send_signal("stop")
# Destroy the job if we allocated one
if self.job is not None:
self.job.destroy()
# Remove this simulator from the list of open simulators
Simulator._remove_simulator(self)
def trange(self, dt=None):
return np.arange(1, self.steps + 1) * (self.dt or dt)
class Simulator(object):
"""SpiNNaker simulator for Nengo models.
The simulator period determines how much data will be stored on SpiNNaker
and is the maximum length of simulation allowed before data is transferred
between the machine and the host PC. If the period is set to `None`
function of time Nodes will not be optimised and probes will be disabled.
For any other value simulation lengths of less than or equal to the period
will be in real-time, longer simulations will be possible but will include
short gaps when data is transferred between SpiNNaker and the host.
:py:meth:`~.close` should be called when the simulator will no longer be
used. This will close all sockets used to communicate with the SpiNNaker
machine and will leave the machine in a clean state. Failure to call
`close` may result in later failures. Alternatively `with` may be used::
sim = nengo_spinnaker.Simulator(network)
with sim:
sim.run(10.0)
"""
_open_simulators = set()
@classmethod
def _add_simulator(cls, simulator):
cls._open_simulators.add(simulator)
@classmethod
def _remove_simulator(cls, simulator):
cls._open_simulators.remove(simulator)
def __init__(self, network, dt=0.001, period=10.0):
"""Create a new Simulator with the given network.
Parameters
----------
period : float or None
Duration of one period of the simulator. This determines how much
memory will be allocated to store precomputed and probed data.
"""
# Add this simulator to the set of open simulators
Simulator._add_simulator(self)
# Create a controller for the machine and boot if necessary
hostname = rc.get("spinnaker_machine", "hostname")
machine_width = rc.getint("spinnaker_machine", "width")
machine_height = rc.getint("spinnaker_machine", "height")
self.controller = MachineController(hostname)
test_and_boot(self.controller, hostname, machine_width, machine_height)
# Create the IO controller
io_cls = getconfig(network.config, Simulator, "node_io", Ethernet)
io_kwargs = getconfig(network.config, Simulator, "node_io_kwargs",
dict())
self.io_controller = io_cls(**io_kwargs)
# Determine the maximum run-time
self.max_steps = None if period is None else int(period / dt)
self.steps = 0 # Steps simulated
# Create the IO controller. Function of time nodes are only enabled if
# the simulator period is not None.
io_cls = getconfig(network.config, Simulator, "node_io", Ethernet)
io_kwargs = getconfig(network.config, Simulator, "node_io_kwargs",
dict())
self.io_controller = io_cls(
function_of_time_nodes=self.max_steps is not None, **io_kwargs
)
# Create a model from the network, using the IO controller. Probes are
# only built if the simulator period is not None.
logger.debug("Building model")
start_build = time.time()
self.model = Model(dt, decoder_cache=get_default_decoder_cache())
self.model.build(network, build_probes=self.max_steps is not None,
**self.io_controller.builder_kwargs)
model_optimisations.remove_childless_filters(self.model)
logger.info("Build took {:.3f} seconds".format(time.time() -
start_build))
self.model.decoder_cache.shrink()
self.dt = self.model.dt
self._closed = False # Whether the simulator has been closed or not
self._running = False
self._halt = False
self.host_sim = self._create_host_sim()
# Holder for probe data
self.data = {}
# Holder for profiling data
self.profiler_data = {}
# Convert the model into a netlist
logger.info("Building netlist")
start = time.time()
self.netlist = self.model.make_netlist(self.max_steps or 0)
# Get a machine object to place & route against
logger.info("Getting SpiNNaker machine specification")
machine = self.controller.get_machine()
# Place & Route
logger.info("Placing and routing")
self.netlist.place_and_route(machine)
logger.info("{} cores in use".format(len(self.netlist.placements)))
chips = set(six.itervalues(self.netlist.placements))
logger.info("Using {}".format(chips))
# Prepare the simulator against the placed, allocated and routed
# netlist.
self.io_controller.prepare(self.model, self.controller, self.netlist)
# Load the application
logger.info("Loading application")
self.netlist.load_application(self.controller)
# Check if any cores are in bad states
if self.controller.count_cores_in_state(["exit", "dead", "watchdog",
"runtime_exception"]):
for vertex in self.netlist.vertices:
x, y = self.netlist.placements[vertex]
p = self.netlist.allocations[vertex][Cores].start
status = self.controller.get_processor_status(p, x, y)
if status.cpu_state is not AppState.sync0:
print("Core ({}, {}, {}) in state {!s}".format(
x, y, p, status.cpu_state))
raise Exception("Unexpected core failures.")
logger.info("Preparing and loading machine took {:3f} seconds".format(
time.time() - start
))
logger.info("Setting router timeout to 16 cycles")
for x in range(machine_width):
for y in range(machine_height):
with self.controller(x=x, y=y):
if (x, y) in machine:
data = self.controller.read(0xf1000000, 4)
self.controller.write(0xf1000000, data[:-1] + b'\x10')
def __enter__(self):
"""Enter a context which will close the simulator when exited."""
# Return self to allow usage like:
#
# with nengo_spinnaker.Simulator(model) as sim:
# sim.run(1.0)
return self
def __exit__(self, exception_type, exception_value, traceback):
"""Exit a context and close the simulator."""
self.close()
def run(self, time_in_seconds):
"""Simulate for the given length of time."""
if time_in_seconds is not None:
# Determine how many steps to simulate for
steps = int(np.round(float(time_in_seconds) / self.dt))
self.run_steps(steps)
else:
self._run_steps(None)
def run_steps(self, steps):
"""Simulate a give number of steps."""
if steps is not None and self.max_steps is not None:
# Fixed time simulation in either fixed-period or indefinite mode
while steps > 0:
n_steps = min((steps, self.max_steps))
self._run_steps(n_steps)
steps -= n_steps
else:
self._run_steps(steps)
def _run_steps(self, steps):
"""Simulate for the given number of steps."""
if self._closed:
raise Exception("Simulator has been closed and can't be used to "
"run further simulations.")
if self.max_steps is not None:
# The simulator is in "fixed-period, fixed-duration" mode.
assert steps <= self.max_steps
# Prepare the simulation
self.netlist.before_simulation(self, steps)
# Wait for all cores to hit SYNC0
self.controller.wait_for_cores_to_reach_state(
"sync0", len(self.netlist.vertices)
)
self.controller.send_signal("sync0")
# Get a new thread for the IO
io_thread = self.io_controller.spawn()
# Run the simulation
self._running = True
try:
# Prep
exp_time = steps * (self.model.machine_timestep / float(1e6))
io_thread.start()
# Wait for all cores to hit SYNC1
self.controller.wait_for_cores_to_reach_state(
"sync1", len(self.netlist.vertices)
)
logger.info("Running simulation...")
self.controller.send_signal("sync1")
# Execute the local model
host_steps = 0
start_time = time.time()
run_time = 0.0
while run_time < exp_time:
# Run a step
self.host_sim.step()
run_time = time.time() - start_time
# If that step took less than timestep then spin
time.sleep(0.0001)
while run_time < host_steps * self.dt:
time.sleep(0.0001)
run_time = time.time() - start_time
finally:
# Stop the IO thread whatever occurs
io_thread.stop()
# Check if any cores are in bad states
if self.controller.count_cores_in_state(["dead", "watchdog",
"runtime_exception"]):
for vertex in self.netlist.vertices:
x, y = self.netlist.placements[vertex]
p = self.netlist.allocations[vertex][Cores].start
status = self.controller.get_processor_status(p, x, y)
if status.cpu_state is not AppState.sync0:
print("Core ({}, {}, {}) in state {!s}".format(
x, y, p, status.cpu_state))
raise Exception("Unexpected core failures.")
# Retrieve simulation data
start = time.time()
logger.info("Retrieving simulation data")
self.netlist.after_simulation(self, steps)
logger.info("Retrieving data took {:3f} seconds".format(
time.time() - start
))
# Increase the steps count
self.steps += steps
else:
# The simulator is in "indefinite duration" mode.
if steps is not None:
raise ValueError("Cannot run an indefinite duration simulator "
"for a fixed period of time.")
# Prepare the simulation
self.netlist.before_simulation(self, None)
# Get a new thread for the IO
io_thread = self.io_controller.spawn()
if not self._running:
# If not already running then start things up
self.controller.wait_for_cores_to_reach_state(
"sync0", len(self.netlist.vertices)
)
self.controller.send_signal("sync0")
self._running = True
else:
# Otherwise continue a running simulation
self.controller.send_signal("cont")
# Allow the local simulator to run
self._halt = False
# Run the simulation
try:
# Prep
io_thread.start()
# Wait for all cores to hit SYNC1
self.controller.wait_for_cores_to_reach_state(
"sync1", len(self.netlist.vertices)
)
logger.info("Running simulation...")
self.controller.send_signal("sync1")
# Execute the local model
host_steps = 0
start_time = time.time()
run_time = 0.0
while not self._halt:
# Run a step
self.host_sim.step()
run_time = time.time() - start_time
# If that step took less than timestep then spin
time.sleep(0.0001)
while run_time < host_steps * self.dt:
time.sleep(0.0001)
run_time = time.time() - start_time
finally:
# Stop the IO thread whatever occurs
io_thread.stop()
def stop(self):
"""Stop a continuously running simulation."""
self._halt = True
def _create_host_sim(self):
# change node_functions to reflect time
# TODO: improve the reference simulator so that this is not needed
# by adding a realtime option
node_functions = {}
node_info = dict(start=None)
for node in self.io_controller.host_network.all_nodes:
if callable(node.output):
old_func = node.output
if node.size_in == 0:
def func(t, f=old_func):
now = time.time()
if node_info['start'] is None:
node_info['start'] = now
return f(now - node_info['start'])
else:
def func(t, x, f=old_func):
now = time.time()
if node_info['start'] is None:
node_info['start'] = now
return f(now - node_info['start'], x)
node.output = func
node_functions[node] = old_func
# Build the host simulator
host_sim = nengo.Simulator(self.io_controller.host_network,
dt=self.dt)
# reset node functions
for node, func in node_functions.items():
node.output = func
return host_sim
def close(self):
"""Clean the SpiNNaker board and prevent further simulation."""
# Stop the application
self._closed = True
if not self._halt:
self.stop()
self.io_controller.close()
self.controller.send_signal("stop")
# Remove this simulator from the list of open simulators
Simulator._remove_simulator(self)
def trange(self, dt=None):
return np.arange(1, self.steps + 1) * (self.dt or dt)
class Simulator(object):
"""SpiNNaker simulator for Nengo models.
The simulator period determines how much data will be stored on SpiNNaker
and is the maximum length of simulation allowed before data is transferred
between the machine and the host PC. If the period is set to `None`
function of time Nodes will not be optimised and probes will be disabled.
For any other value simulation lengths of less than or equal to the period
will be in real-time, longer simulations will be possible but will include
short gaps when data is transferred between SpiNNaker and the host.
:py:meth:`~.close` should be called when the simulator will no longer be
used. This will close all sockets used to communicate with the SpiNNaker
machine and will leave the machine in a clean state. Failure to call
`close` may result in later failures. Alternatively `with` may be used::
sim = nengo_spinnaker.Simulator(network)
with sim:
sim.run(10.0)
"""
_open_simulators = set()
@classmethod
def _add_simulator(cls, simulator):
cls._open_simulators.add(simulator)
@classmethod
def _remove_simulator(cls, simulator):
cls._open_simulators.remove(simulator)
def __init__(self, network, dt=0.001, period=10.0, timescale=1.0,
hostname=None, use_spalloc=None,
allocation_fudge_factor=0.6):
"""Create a new Simulator with the given network.
Parameters
----------
period : float or None
Duration of one period of the simulator. This determines how much
memory will be allocated to store precomputed and probed data.
timescale : float
Scaling factor to apply to the simulation, e.g., a value of `0.5`
will cause the simulation to run at half real-time.
hostname : string or None
Hostname of the SpiNNaker machine to use; if None then the machine
specified in the config file will be used.
use_spalloc : bool or None
Allocate a SpiNNaker machine for the simulator using ``spalloc``.
If None then the setting specified in the config file will be used.
Other Parameters
----------------
allocation_fudge_factor:
Fudge factor to allocate more cores than really necessary when using
`spalloc` to ensure that (a) there are sufficient "live" cores in
the allocated machine, (b) there is sufficient room for a good place
and route solution. This should generally be more than 0.1 (10% more
cores than necessary) to account for the usual rate of missing
chips.
"""
# Add this simulator to the set of open simulators
Simulator._add_simulator(self)
# Create the IO controller
io_cls = getconfig(network.config, Simulator, "node_io", Ethernet)
io_kwargs = getconfig(network.config, Simulator, "node_io_kwargs",
dict())
self.io_controller = io_cls(**io_kwargs)
# Calculate the machine timestep, this is measured in microseconds
# (hence the 1e6 scaling factor).
self.timescale = timescale
machine_timestep = int((dt / timescale) * 1e6)
# Determine the maximum run-time
self.max_steps = None if period is None else int(period / dt)
self.steps = 0 # Steps simulated
# If the simulator is in "run indefinite" mode (i.e., max_steps=None)
# then we modify the builders to ignore function of time Nodes and
# probes.
builder_kwargs = self.io_controller.builder_kwargs
if self.max_steps is None:
raise NotImplementedError
# Create a model from the network, using the IO controller
logger.debug("Building model")
start_build = time.time()
self.model = Model(dt=dt, machine_timestep=machine_timestep,
decoder_cache=get_default_decoder_cache())
self.model.build(network, **builder_kwargs)
logger.info("Build took {:.3f} seconds".format(time.time() -
start_build))
self.model.decoder_cache.shrink()
self.dt = self.model.dt
self._closed = False # Whether the simulator has been closed or not
self.host_sim = self._create_host_sim()
# Holder for probe data
self.data = {}
# Holder for profiling data
self.profiler_data = {}
# Convert the model into a netlist
logger.info("Building netlist")
start = time.time()
self.netlist = self.model.make_netlist(self.max_steps or 0)
# Determine whether to use a spalloc machine or not
if use_spalloc is None:
# Default is to not use spalloc; this is indicated by either the
# absence of the option in the config file OR the option being set
# to false.
use_spalloc = (
rc.has_option("spinnaker_machine", "use_spalloc") and
rc.getboolean("spinnaker_machine", "use_spalloc"))
# Create a controller for the machine and boot if necessary
self.job = None
if not use_spalloc or hostname is not None:
# Use the specified machine rather than trying to get one
# allocated.
if hostname is None:
hostname = rc.get("spinnaker_machine", "hostname")
else:
# Attempt to get a machine allocated to us
from spalloc import Job
# Determine how many boards to ask for (assuming 16 usable cores
# per chip and 48 chips per board).
n_cores = self.netlist.n_cores * (1.0 + allocation_fudge_factor)
n_boards = int(np.ceil((n_cores / 16.) / 48.))
# Request the job
self.job = Job(n_boards)
logger.info("Allocated job ID %d...", self.job.id)
# Wait until we're given the machine
logger.info("Waiting for machine allocation...")
self.job.wait_until_ready()
# spalloc recommends a slight delay before attempting to boot the
# machine, later versions of spalloc server may relax this
# requirement.
time.sleep(5.0)
# Store the hostname
hostname = self.job.hostname
logger.info("Using %d board(s) of \"%s\" (%s)",
len(self.job.boards), self.job.machine_name, hostname)
self.controller = MachineController(hostname)
self.controller.boot()
# Get a system-info object to place & route against
logger.info("Getting SpiNNaker machine specification")
system_info = self.controller.get_system_info()
# Place & Route
logger.info("Placing and routing")
self.netlist.place_and_route(
system_info,
place=getconfig(network.config, Simulator,
'placer', rig.place_and_route.place),
place_kwargs=getconfig(network.config, Simulator,
'placer_kwargs', {}),
)
logger.info("{} cores in use".format(len(self.netlist.placements)))
chips = set(six.itervalues(self.netlist.placements))
logger.info("Using {}".format(chips))
# Prepare the simulator against the placed, allocated and routed
# netlist.
self.io_controller.prepare(self.model, self.controller, self.netlist)
# Load the application
logger.info("Loading application")
self.netlist.load_application(self.controller, system_info)
# Check if any cores are in bad states
if self.controller.count_cores_in_state(["exit", "dead", "watchdog",
"runtime_exception"]):
for vertex, (x, y) in six.iteritems(self.netlist.placements):
p = self.netlist.allocations[vertex][Cores].start
status = self.controller.get_processor_status(p, x, y)
if status.cpu_state is not AppState.sync0:
print("Core ({}, {}, {}) in state {!s}".format(
x, y, p, status))
print(self.controller.get_iobuf(p, x, y))
raise Exception("Unexpected core failures.")
logger.info("Preparing and loading machine took {:3f} seconds".format(
time.time() - start
))
logger.info("Setting router timeout to 16 cycles")
for x, y in system_info.chips():
with self.controller(x=x, y=y):
data = self.controller.read(0xf1000000, 4)
self.controller.write(0xf1000000, data[:-1] + b'\x10')
def __enter__(self):
"""Enter a context which will close the simulator when exited."""
# Return self to allow usage like:
#
# with nengo_spinnaker.Simulator(model) as sim:
# sim.run(1.0)
return self
def __exit__(self, exception_type, exception_value, traceback):
"""Exit a context and close the simulator."""
self.close()
def run(self, time_in_seconds):
"""Simulate for the given length of time."""
# Determine how many steps to simulate for
steps = int(np.round(float(time_in_seconds) / self.dt))
self.run_steps(steps)
def run_steps(self, steps):
"""Simulate a give number of steps."""
while steps > 0:
n_steps = min((steps, self.max_steps))
self._run_steps(n_steps)
steps -= n_steps
def _run_steps(self, steps):
"""Simulate for the given number of steps."""
if self._closed:
raise Exception("Simulator has been closed and can't be used to "
"run further simulations.")
if steps is None:
if self.max_steps is not None:
raise Exception(
"Cannot run indefinitely if a simulator period was "
"specified. Create a new simulator with Simulator(model, "
"period=None) to perform indefinite time simulations."
)
else:
assert steps <= self.max_steps
# Prepare the simulation
self.netlist.before_simulation(self, steps)
# Wait for all cores to hit SYNC0 (either by remaining it or entering
# it from init)
self._wait_for_transition(AppState.init, AppState.sync0,
self.netlist.n_cores)
self.controller.send_signal("sync0")
# Get a new thread for the IO
io_thread = self.io_controller.spawn()
# Run the simulation
try:
# Prep
exp_time = steps * self.dt / self.timescale
io_thread.start()
# Wait for all cores to hit SYNC1
self._wait_for_transition(AppState.sync0, AppState.sync1,
self.netlist.n_cores)
logger.info("Running simulation...")
self.controller.send_signal("sync1")
# Execute the local model
host_steps = 0
start_time = time.time()
run_time = 0.0
local_timestep = self.dt / self.timescale
while run_time < exp_time:
# Run a step
self.host_sim.step()
run_time = time.time() - start_time
# If that step took less than timestep then spin
time.sleep(0.0001)
while run_time < host_steps * local_timestep:
time.sleep(0.0001)
run_time = time.time() - start_time
finally:
# Stop the IO thread whatever occurs
io_thread.stop()
# Wait for cores to re-enter sync0
self._wait_for_transition(AppState.run, AppState.sync0,
self.netlist.n_cores)
# Retrieve simulation data
start = time.time()
logger.info("Retrieving simulation data")
self.netlist.after_simulation(self, steps)
logger.info("Retrieving data took {:3f} seconds".format(
time.time() - start
))
# Increase the steps count
self.steps += steps
def _wait_for_transition(self, from_state, desired_to_state, num_verts):
while True:
# If no cores are still in from_state, stop
if self.controller.count_cores_in_state(from_state) == 0:
break
# Wait a bit
time.sleep(1.0)
# Check if any cores haven't exited cleanly
num_ready = self.controller.wait_for_cores_to_reach_state(
desired_to_state, num_verts, timeout=5.0)
if num_ready != num_verts:
# Loop through all placed vertices
for vertex, (x, y) in six.iteritems(self.netlist.placements):
p = self.netlist.allocations[vertex][Cores].start
status = self.controller.get_processor_status(p, x, y)
if status.cpu_state is not desired_to_state:
print("Core ({}, {}, {}) in state {!s}".format(
x, y, p, status.cpu_state))
print(self.controller.get_iobuf(p, x, y))
raise Exception("Unexpected core failures before reaching %s "
"state." % desired_to_state)
def _create_host_sim(self):
# change node_functions to reflect time
# TODO: improve the reference simulator so that this is not needed
# by adding a realtime option
node_functions = {}
node_info = dict(start=None)
for node in self.io_controller.host_network.all_nodes:
if callable(node.output):
old_func = node.output
if node.size_in == 0:
def func(t, f=old_func):
now = time.time()
if node_info['start'] is None:
node_info['start'] = now
t = (now - node_info['start']) * self.timescale
return f(t)
else:
def func(t, x, f=old_func):
now = time.time()
if node_info['start'] is None:
node_info['start'] = now
t = (now - node_info['start']) * self.timescale
return f(t, x)
node.output = func
node_functions[node] = old_func
# Build the host simulator
host_sim = nengo.Simulator(self.io_controller.host_network,
dt=self.dt)
# reset node functions
for node, func in node_functions.items():
node.output = func
return host_sim
def close(self):
"""Clean the SpiNNaker board and prevent further simulation."""
if not self._closed:
# Stop the application
self._closed = True
self.io_controller.close()
self.controller.send_signal("stop")
# Destroy the job if we allocated one
if self.job is not None:
self.job.destroy()
# Remove this simulator from the list of open simulators
Simulator._remove_simulator(self)
def trange(self, dt=None):
return np.arange(1, self.steps + 1) * (self.dt or dt)
class MainWindow(QtGui.QMainWindow, QtMainWindow.Ui_QtMainWindow):
""" It inherits QMainWindow and uses pyuic4-generated python files from the .ui """
pltDataRdy = pyqtSignal(list) # for streaming data to the plotter/calibrator
def __init__(self, mIP=None, logFName=None, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.setCentralWidget(self.mdiArea);
self.statusTxt = QtGui.QLabel("")
self.statusBar().addWidget(self.statusTxt)
# load setting
self.loadSettings()
# if machine IP is provided, check if it is booted and/or if the profiler has been loaded
if mIP is not None:
self.mIP = mIP
self.checkSpiNN4()
else:
self.mIP = None
self.connect(self.actionShow_Chips, SIGNAL("triggered()"), SLOT("showChips()"))
"""
Scenario:
- sw and pw send data to MainWindow
- MainWindow do the averaging on sw data, then send avg_sw and pw to plotter
At the same time, MainWindow store the data
"""
#-------------------- GUI setup ---------------------
# Dump raw data in arduConsole widget (cw).
self.cw = ifaceArduSpiNN(logFName,self)
self.subWinConsole = QtGui.QMdiSubWindow(self)
self.subWinConsole.setWidget(self.cw)
self.mdiArea.addSubWindow(self.subWinConsole)
self.subWinConsole.setGeometry(0,0,self.cw.width(),500)
self.cw.show()
# Power plot widget (pw).
self.pw = Pwidget(self)
self.subWinPW = QtGui.QMdiSubWindow(self)
self.subWinPW.setWidget(self.pw)
self.mdiArea.addSubWindow(self.subWinPW)
self.subWinPW.setGeometry(self.cw.width()+10,0,760,500)
self.pw.show()
# SpiNNaker profiler plot widget (sw).
self.sw = Swidget(self)
self.subWinSW = QtGui.QMdiSubWindow(self)
self.subWinSW.setWidget(self.sw)
self.mdiArea.addSubWindow(self.subWinSW)
self.subWinSW.setGeometry(self.subWinPW.x(), self.subWinPW.y()+self.subWinPW.height(),760,500)
self.sw.show()
# initially, we don't show chip visualizer
self.vis = None
# SIGNAL-SLOT connection
self.cw.spinUpdate.connect(self.sw.readPltData)
self.cw.arduUpdate.connect(self.pw.readPltData)
# just for debugging:
# self.cw.arduUpdate.connect(self.readArduData)
# self.cw.spinUpdate.connect(self.readSpinData)
def loadSettings(self):
"""
Load configuration setting from file.
Let's use INI format and UserScope
:return:
"""
#init value
self.conf = config()
#if used before, then load from previous one; otherwise, it use the initial value above
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, "APT", "SpiNN-4 Power Profiler")
self.conf.xPos,ok = self.settings.value(self.conf.xPosKey, self.conf.xPos).toInt()
self.conf.yPos,ok = self.settings.value(self.conf.yPosKey, self.conf.yPos).toInt()
self.conf.width,ok = self.settings.value(self.conf.widthKey, self.conf.width).toInt()
self.conf.height,ok = self.settings.value(self.conf.heightKey, self.conf.height).toInt()
#print "isWritable?", self.settings.isWritable()
#print "conf filename", self.settings.fileName()
#then apply to self
self.setGeometry(self.conf.xPos, self.conf.yPos, self.conf.width, self.conf.height)
def checkSpiNN4(self, alwaysAsk=True):
#return #go out immediately for experiment with Basab
"""
if the MainWindow class is called with an IP, then check if the machine is ready
"""
loadProfiler = False
# first, check if the machine is booted
print "Check the machine: ",
self.mc = MachineController(self.mIP)
bootByMe = self.mc.boot()
# if bootByMe is true, then the machine is booted by readSpin4Pwr.py, otherwise it is aleady booted
# if rig cannot boot the machine (eq. the machine is not connected or down), the you'll see error
# message in the arduConsole
if bootByMe is False:
print "it is booted already!"
else:
print "it is now booted!"
loadProfiler = True
alwaysAsk = False # because the machine is just booted, then force it load profiler
# second, ask if profilers need to be loaded
cpustat = self.mc.get_processor_status(1,0,0) #core-1 in chip <0,0>
profName = cpustat.app_name
profState = int(cpustat.cpu_state)
profVersion = cpustat.user_vars[0] # read from sark.vcpu->user0
#print "Profiler name: ", profName
#print "Profiler state: ", profState
#print "Profiler version: ", profVersion
if profName.upper()==DEF.REQ_PROF_NAME.upper() and profState==7 and profVersion==DEF.REQ_PROF_VER:
print "Required profiler.aplx is running!"
loadProfiler = False
else:
if alwaysAsk:
askQ = raw_input('Load the correct profiler.aplx? [Y/n]')
if len(askQ) == 0 or askQ.upper() == 'Y':
loadProfiler = True
else:
loadProfiler = False
print "[WARNING] profiler.aplx is not ready or invalid version"
# third, load the profilers
if loadProfiler:
# then load the correct profiler version
print "Loading profiler from", DEF.REQ_PROF_APLX
# populate all chips in the board
chips = self.mc.get_system_info().keys()
dest = dict()
for c in chips:
dest[c] = [1] # the profiler.aplx goes to core-1
self.mc.load_application(DEF.REQ_PROF_APLX, dest, app_id=DEF.REQ_PROF_APLX_ID)
print "Profilers are sent to SpiNN4!"
else:
print "No valid profiler! This program might not work correctly!"
# Last but important: MAKE SURE IPTAG 3 IS SET
iptag = self.mc.iptag_get(DEF.REPORT_IPTAG,0,0)
if iptag.addr is '0.0.0.0' or iptag.port is not DEF.REPORT_IPTAG:
#iptag DEF.REPORT_IPTAG is not defined yet
self.mc.iptag_set(DEF.REPORT_IPTAG, DEF.HOST_PC, DEF.RECV_PORT, 0, 0)
@pyqtSlot()
def reactiveShopCipMenu(self):
self.actionShow_Chips.setEnabled(True)
del self.subWinVis
@pyqtSlot()
def showChips(self):
"""
Show chip layout
:return:
"""
if self.mIP is None:
"""
i.e., the IP is not defined when this menu is clicked
"""
# first, ask the IP of the machine
mIP, ok = QtGui.QInputDialog.getText(self, "SpiNN4 Location", "SpiNN4 IP address",
QtGui.QLineEdit.Normal, DEF.MACHINE)
if ok is True:
self.mIP = mIP
self.checkSpiNN4(False) # after this, self.mc is available
# then open the widget
mInfo = self.mc.get_system_info()
w = mInfo.width
h = mInfo.height
chipList = mInfo.keys()
#self.vis = visWidget(w, h, chipList) # Segmentation fault
self.vis = visWidget(w, h, chipList, self)
self.subWinVis = QtGui.QMdiSubWindow(self)
self.subWinVis.setWidget(self.vis)
self.mdiArea.addSubWindow(self.subWinVis)
#self.subWinVis.setGeometry(self.subWinPW.x(), self.subWinPW.y()+self.subWinPW.height(),760,500)
# connect to the source of temperature data
# masih salah: self.cw.spinUpdate.connect(self.vis.readSpinData)
self.vis.show()
# and disable the menu item
self.actionShow_Chips.setEnabled(False) # the menu will be reset to enable if the widget is closed
self.vis.visWidgetTerminated.connect(self.reactiveShopCipMenu)
"""
######################### GUI callback ###########################
"""
# readSpinData and readArduData are just for debugging
@pyqtSlot(list)
def readSpinData(self, prfData):
"""
Read profiler data and prepare for saving.
prfData is a list of 48 "Integer" item that should be decoded as:
freq, nActive, temp
Hence, fmt = "<2BH"
"""
#print len(prfData)
#print type(prfData[0])
#return
fmt = "<2BH"
#fmt = "<H2B"
print "{",
for i in range(len(prfData)):
cpu = struct.pack("<I",prfData[i])
#print "0x%x " % cpu,
#f,nA,T = struct.unpack(fmt, prfData[i])
f,nA,T = struct.unpack(fmt, cpu)
#print "[{},{},{}]".format(f,nA,T),
if i < (len(prfData)-1):
print "[{},{},{}],".format(f, nA, T),
else:
print "[{},{},{}]".format(f, nA, T),
print "}"
@pyqtSlot(list)
def readArduData(self, pwrData):
"""
Read power data from Arduino and prepare for saving.
"""
def closeEvent(self, event):
#print "x, y, w, h =",self.x(),self.y(),self.width(),self.height()
# save the current configuration
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, "APT", "SpiNN-4 Power Profiler")
self.settings.setValue(self.conf.xPosKey, self.x())
self.settings.setValue(self.conf.yPosKey, self.y())
self.settings.setValue(self.conf.widthKey, self.width())
self.settings.setValue(self.conf.heightKey, self.height())
self.settings.sync()
#print "Conf saved!"
# Notify ifaceArduSpiNN to stop the thread:
self.cw.stop() # to avoid QThread being destroyed while thread is still running
event.accept()
