def record(self, driver, inputs, outputs, exc, case_uuid, parent_uuid): """Dump the given run data in a "pretty" form.""" if not self.out: # if self.out is None, just do nothing return in_names, out_names = self._cfg_map[driver] ins = sorted(zip(in_names, inputs)) outs = sorted(zip(out_names, outputs)) write = self.out.write write("Case:\n") write(" uuid: %s\n" % case_uuid) write(" timestamp: %15f\n" % time.time()) if parent_uuid: write(" parent_uuid: %s\n" % parent_uuid) if ins: write(" inputs:\n") for name, val in ins: write(" %s: %s\n" % (name, val)) if outs: write(" outputs:\n") for name, val in outs: write(" %s: %s\n" % (name, val)) if exc: write(" exc: %s\n" % exc) write(" %s\n" % traceback_str(exc))
def __str__(self): if self._outputs: outs = self._outputs.items() outs.sort() else: outs = [] ins = self._inputs.items() ins.sort() stream = StringIO() write = stream.write write("Case:\n") write(" uuid: %s\n" % self.uuid) write(" timestamp: %15f\n" % self.timestamp) if self.parent_uuid: write(" parent_uuid: %s\n" % self.parent_uuid) if ins: write(" inputs:\n") for name, val in ins: write(" %s: %s\n" % (name, val)) if outs: write(" outputs:\n") for name, val in outs: write(" %s: %s\n" % (name, val)) if self.exc: stream.write(" exc: %s\n" % exception_str(self.exc)) stream.write(" %s\n" % traceback_str(self.exc)) return stream.getvalue()
def execute(self): """ Runs all cases and records results in `recorder`. Uses :meth:`setup` and :meth:`resume` with default arguments. """ self._setup() try: if self.sequential: self._logger.info('Start sequential evaluation.') server = self._servers[None] = self._seq_server server.top = self.parent while self._iter is not None: try: case = self._iter.next() self._todo.append(case) server.exception = None server.case = None server.state = _LOADING # 'server' already loaded. while self._server_ready(server): pass except StopIteration: if not self._rerun: self._iter = None break else: self._logger.info('Start concurrent evaluation.') self._start() finally: self._cleanup() if self._abort_exc is not None: msg = "%s: Run aborted: %s" % (self.get_pathname(), traceback_str(self._abort_exc)) newexc = self._abort_exc[0](msg) raise self._abort_exc[0], newexc, self._abort_exc[2]
def __str__(self): if self._outputs: outs = self._outputs.items() outs.sort() else: outs = [] ins = self._inputs.items() ins.sort() stream = StringIO() stream.write("Case: %s\n" % self.label) stream.write(" uuid: %s\n" % self.uuid) stream.write(" timestamp: %15f\n" % self.timestamp) if self.parent_uuid: stream.write(" parent_uuid: %s\n" % self.parent_uuid) if ins: stream.write(" inputs:\n") for name, val in ins: stream.write(" %s: %s\n" % (name, val)) if outs: stream.write(" outputs:\n") for name, val in outs: stream.write(" %s: %s\n" % (name, val)) if self.max_retries is not None: stream.write(" max_retries: %s\n" % self.max_retries) if self.retries is not None: stream.write(" retries: %s\n" % self.retries) if self.msg: stream.write(" msg: %s\n" % self.msg) if self.exc is not None: stream.write(" exc: %s\n" % traceback_str(self.exc)) return stream.getvalue()
def __str__(self): if self._outputs: outs = self._outputs.items() outs.sort() else: outs = [] ins = self._inputs.items() ins.sort() stream = StringIO() stream.write("Case: %s\n" % self.label) stream.write(" uuid: %s\n" % self.uuid) stream.write(" timestamp: %15f\n" % self.timestamp) if self.parent_uuid: stream.write(" parent_uuid: %s\n" % self.parent_uuid) if ins: stream.write(" inputs:\n") for name,val in ins: stream.write(" %s: %s\n" % (name,val)) if outs: stream.write(" outputs:\n") for name,val in outs: stream.write(" %s: %s\n" % (name,val)) if self.max_retries is not None: stream.write(" max_retries: %s\n" % self.max_retries) if self.retries is not None: stream.write(" retries: %s\n" % self.retries) if self.msg: stream.write(" msg: %s\n" % self.msg) if self.exc is not None: stream.write(" exc: %s\n" % traceback_str(self.exc)) return stream.getvalue()
def __str__(self): stream = StringIO() write = stream.write write("Case: %s\n" % self.index) write(" uuid: %s\n" % self.uuid) write(" parent_uuid: %s\n" % self.parent_uuid) write(" inputs:\n") for name, val in sorted(self._inputs.items()): write(" %s: %s\n" % (name, val)) write(" outputs:\n") for name in sorted(self._outputs): write(" %s\n" % name) write(" extra outputs:\n") for name in sorted(self._extra_outputs): write(" %s\n" % name) write(" retries: %s\n" % self.retries) write(" exc: %s\n" % exception_str(self.exc)) if self.exc is not None: write(" %s\n" % traceback_str(self.exc)) return stream.getvalue()
def resume(self, remove_egg=True): """ Resume execution. remove_egg: bool If True, then the egg file created for concurrent evaluation is removed at the end of the run. Re-using the egg file can eliminate a lot of startup overhead. """ self._stop = False self._abort_exc = None if self._iter is None: self.raise_exception('Run already complete', RuntimeError) try: if self.sequential: self._logger.info('Start sequential evaluation.') while self._iter is not None: if self._stop: break try: self.step() except StopIteration: break else: self._logger.info('Start concurrent evaluation.') self._start() finally: self._cleanup(remove_egg) if self._stop: if self._abort_exc is None: self.raise_exception('Run stopped', RunStopped) else: self._iter = None self.raise_exception('Run aborted: %s' % traceback_str(self._abort_exc), RuntimeError) else: self._iter = None
def traceback(self): """Exception traceback.""" return '' if self.exc is None else traceback_str(self.exc)
server.state = _LOADING # 'server' already loaded. while self._server_ready(server): pass except StopIteration: if not self._rerun: self._iter = None break else: self._logger.info('Start concurrent evaluation.') self._start() finally: self._cleanup() if self._abort_exc is not None: msg = "%s: Run aborted: %s" % (self.get_pathname(), traceback_str(self._abort_exc)) newexc = self._abort_exc[0](msg) raise self._abort_exc[0], newexc, self._abort_exc[2] def _setup(self): """ Setup to begin new run. """ # if params have changed we need to setup systems again if self.workflow._system is None: obj = self while obj.parent is not None: obj = obj.parent obj._setup() if not self.sequential: # Save model to egg. # Must do this before creating any locks or queues.
server.case = None server.state = _LOADING # 'server' already loaded. while self._server_ready(server): pass except StopIteration: if not self._rerun: self._iter = None break else: self._logger.info('Start concurrent evaluation.') self._start() finally: self._cleanup() if self._abort_exc is not None: msg = "%s: Run aborted: %s" % (self.get_pathname(), traceback_str(self._abort_exc)) newexc = self._abort_exc[0](msg) raise self._abort_exc[0], newexc, self._abort_exc[2] def _setup(self): """ Setup to begin new run. """ if not self.sequential: # Save model to egg. # Must do this before creating any locks or queues. self._replicants += 1 version = 'replicant.%d' % (self._replicants) # If only local host will be used, we can skip determining # distributions required by the egg. allocators = RAM.list_allocators() need_reqs = False