def parse_async(self, structure_files, timeout, model=None,
parser=RegularStructureParser):
"""
Call C{self.parse_structure} for a list of structure files
simultaneously. The actual degree of parallelism will depend on the
number of workers specified while constructing the parser object.
@note: Don't be tempted to pass a large list of structures to this
method. Every time a C{TimeoutError} is encountered, the
corresponding worker process in the pool will hang until the
process terminates on its own. During that time, this worker is
unusable. If a sufficiently high number of timeouts occur, the
whole pool of workers will be unsable. At the end of the method
however a pool cleanup is performed and any unusable workers
are 'reactivated'. However, that only happens at B{the end} of
C{parse_async}.
@param structure_files: a list of structure files
@type structure_files: tuple of str
@param timeout: raise multiprocessing.TimeoutError if C{timeout} seconds
elapse before the parser completes its job
@type timeout: int
@param parser: any implementing L{AbstractStructureParser} class
@type parser: type
@return: a list of L{AsyncParseResult} objects
@rtype: list
"""
pool = self._pool
workers = []
results = []
for file in list(structure_files):
result = pool.apply_async(_parse_async, [parser, file, model])
workers.append(result)
hanging = False
for w in workers:
result = AsyncParseResult(None, None)
try:
result.result = w.get(timeout=timeout)
except KeyboardInterrupt as ki:
pool.terminate()
raise ki
except Exception as ex:
result.exception = ex
if isinstance(ex, multiprocessing.TimeoutError):
hanging = True
results.append(result)
if hanging:
self._recycle()
return results
评论列表
文章目录
