def run_steps(self, N, progress_bar=True):
if self.closed:
raise SimulatorClosed("Simulator cannot run because it is closed.")
if self.n_steps + N >= 2**24:
# since n_steps is float32, point at which `n_steps == n_steps + 1`
raise ValueError("Cannot handle more than 2**24 steps")
if self._cl_probe_plan is not None:
# -- precondition: the probe buffers have been drained
bufpositions = self._cl_probe_plan.cl_bufpositions.get()
assert np.all(bufpositions == 0)
if progress_bar is None:
progress_bar = self.progress_bar
try:
progress = ProgressTracker(N, progress_bar, "Simulating")
except TypeError:
progress = ProgressTracker(N, progress_bar)
with progress:
# -- we will go through N steps of the simulator
# in groups of up to B at a time, draining
# the probe buffers after each group of B
while N:
B = min(N, self._max_steps_between_probes)
self._plans.call_n_times(B)
self._probe()
N -= B
progress.step(n=B)
if self.profiling > 1:
self.print_profiling()
def run_steps(self, steps):
"""Simulate for the given number of ``dt`` steps.
Parameters
----------
steps : int
Number of steps to run the simulation for.
"""
if self.closed:
raise SimulatorClosed("Simulator cannot run because it is closed.")
self._make_run_steps()
try:
self._run_steps(steps)
except Exception:
if "loihi" in self.sims and self.sims["loihi"].use_snips:
# Need to write to board, otherwise it will wait indefinitely
h2c = self.sims["loihi"].nengo_io_h2c
c2h = self.sims["loihi"].nengo_io_c2h
print(traceback.format_exc())
print("\nAttempting to end simulation...")
for _ in range(steps):
h2c.write(h2c.numElements, [0] * h2c.numElements)
c2h.read(c2h.numElements)
self.sims["loihi"].wait_for_completion()
self.sims["loihi"].n2board.nxDriver.stopExecution()
self.sims["loihi"].n2board.nxDriver.stopDriver()
raise
self._n_steps += steps
logger.info("Finished running for %d steps", steps)
self._probe()
def reset(self, seed=None):
"""Reset the simulator state.
Parameters
----------
seed : int, optional
A seed for all stochastic operators used in the simulator.
This will change the random sequences generated for noise
or inputs (e.g. from processes), but not the built objects
(e.g. ensembles, connections).
"""
if self.closed:
raise SimulatorClosed("Cannot reset closed Simulator.")
if seed is not None:
self.seed = seed
# reset signals
for key in self.signals:
self.signals.reset(key)
# rebuild steps (resets ops with their own state, like Processes)
self.rng = np.random.RandomState(self.seed)
self._steps = [
op.make_step(self.signals, self.dt, self.rng)
for op in self._step_order
]
# clear probe data
for probe in self.model.probes:
self._probe_outputs[probe] = []
self.data.reset()
self._probe_step_time()
def reset(self, seed=None):
if self.closed:
raise SimulatorClosed("Cannot reset closed Simulator.")
if seed is not None:
raise NotImplementedError("Seed changing not implemented")
# reset signals
for base in self.all_bases:
# TODO: copy all data on at once
if not base.readonly:
self.all_data[self.sidx[base]] = base.initial_value
for clra, ra in iteritems(self._raggedarrays_to_reset):
# TODO: copy all data on at once
for i in range(len(clra)):
clra[i] = ra[i]
# clear probe data
if self._cl_probe_plan is not None:
self._cl_probe_plan.cl_bufpositions.fill(0)
for probe in self.model.probes:
del self._probe_outputs[probe][:]
self._reset_rng()
self._reset_cl_rngs()
self._probe_step_time()
def step(self):
"""Advance the simulator by 1 step (``dt`` seconds)."""
if self.closed:
raise SimulatorClosed("Simulator cannot run because it is closed.")
old_err = np.seterr(invalid='raise', divide='ignore')
try:
for step_fn in self._steps:
step_fn()
finally:
np.seterr(**old_err)
self._probe()
def run_steps(self, steps):
"""Simulate for the given number of ``dt`` steps.
Parameters
----------
steps : int
Number of steps to run the simulation for.
"""
if self.closed:
raise SimulatorClosed("Simulator cannot run because it is closed.")
self._runner.run_steps(steps)
self._n_steps += steps
logger.info("Finished running for %d steps", steps)
self._probe()
def reset(self, seed=None):
"""Reset the simulator state.
Parameters
----------
seed : int, optional
A seed for all stochastic operators used in the simulator.
This will change the random sequences generated for noise
or inputs (e.g. from processes), but not the built objects
(e.g. ensembles, connections).
"""
if self.closed:
raise SimulatorClosed("Cannot reset closed Simulator.")
raise NotImplementedError()
def reset(self, seed=None):
"""Reset the simulator state.
Parameters
----------
seed : int, optional
A seed for all stochastic operators used in the simulator.
This will change the random sequences generated for noise
or inputs (e.g. from processes), but not the built objects
(e.g. ensembles, connections).
"""
if self.closed:
raise SimulatorClosed("Cannot reset closed Simulator.")
# TODO: this will involve adding a probe reset function that resets the probe
# synapse state/time back to initial (e.g. `filter_functions` and
# `filter_step_counters` in `emulator.interface.ProbeState`
raise NotImplementedError()
def reset(self, seed=None):
if self.closed:
raise SimulatorClosed("Cannot reset closed Simulator.")
if seed is not None:
raise NotImplementedError("Seed changing not implemented")
# reset signals
for base in self.all_bases:
# TODO: copy all data on at once
if not base.readonly:
self.all_data[self.sidx[base]] = base.initial_value
for clra, ra in iteritems(self._raggedarrays_to_reset):
# TODO: copy all data on at once
for i in range(len(clra)):
clra[i] = ra[i]
self._reset_rngs()
self._reset_probes()
def reset(self, seed=None):
"""Reset the simulator state.
Parameters
----------
seed : int, optional
A seed for all stochastic operators used in the simulator.
This will change the random sequences generated for noise
or inputs (e.g. from processes), but not the built objects
(e.g. ensembles, connections).
"""
if self.closed:
raise SimulatorClosed("Cannot reset closed Simulator.")
if seed is not None:
self.seed = seed
self._n_steps = 0
self._time = 0
# clear probe data
for probe in self.model.probes:
self._probe_outputs[probe] = []
self.data.reset()
def __enter__(self):
if self.closed:
raise SimulatorClosed("Cannot re-open after simulator is closed")
return self
