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