def test_single_broker(self):
""" Testing a single broker is instantiated no matter how many
Publishers or Subscribers we have """
publishers = [Publisher() for _ in range(10)]
subscribers = [DummySubscriber() for _ in range(10)]
for pub, sub in zip(publishers, subscribers):
self.assertEqual(id(pub._broker), id(sub._broker))
def test_pusbsub(self):
""" Test subscribing works"""
sub = DummySubscriber()
def action_callback(test):
""" Callback called when 'publisher.action` event occurs """
test.assertTrue(True)
sub.subscribe("publisher.action", action_callback)
Publisher().publish("publisher.action", self)
def test_unsubscribe_simple(self):
""" Testing a simple unsubscribe works """
sub = DummySubscriber()
def callback(_who, test):
""" This should have ever been called """
test.fail("We shouldn't have reach this code!")
sub.subscribe("publisher.action", callback)
sub.unsubscribe("publisher.action", callback)
Publisher().publish("publisher.action", self)
def test_unsubscribe_multiple(self):
""" Testing unsubscribe works with many other subscribed event works """
sub = DummySubscriber()
def callback(test):
""" This should have ever been called """
test.fail("We shouldn't have reach this code!")
def dummy_callback(_test):
""" Just a dummy callback, it won't be executed"""
pass
sub.subscribe("publisher.action", callback)
sub.subscribe("publisher.action", dummy_callback)
sub.unsubscribe("publisher.action", callback)
Publisher().publish("publisher.action", self)
def _callback(_):
nfinished[0] += 1
Publisher().publish("terra.transpiler.parallel.done", nfinished[0])
def parallel_map(
task,
values,
task_args=tuple(),
task_kwargs={}, # pylint: disable=W0102
num_processes=CPU_COUNT):
"""
Parallel execution of a mapping of `values` to the function `task`. This
is functionally equivalent to::
result = [task(value, *task_args, **task_kwargs) for value in values]
On Windows this function defaults to a serial implementation to avoid the
overhead from spawning processes in Windows.
Args:
task (func): Function that is to be called for each value in ``task_vec``.
values (array_like): List or array of values for which the ``task``
function is to be evaluated.
task_args (list): Optional additional arguments to the ``task`` function.
task_kwargs (dict): Optional additional keyword argument to the ``task`` function.
num_processes (int): Number of processes to spawn.
Returns:
result: The result list contains the value of
``task(value, *task_args, **task_kwargs)`` for
each value in ``values``.
Raises:
QISKitError: If user interrupts via keyboard.
Events:
terra.transpiler.parallel.start: The collection of parallel tasks are about to start.
terra.transpiler.parallel.update: One of the parallel task has finished.
terra.transpiler.parallel.finish: All the parallel tasks have finished.
"""
Publisher().publish("terra.transpiler.parallel.start", len(values))
if len(values) == 1:
Publisher().publish("terra.transpiler.parallel.finish")
return [task(values[0], *task_args, **task_kwargs)]
nfinished = [0]
def _callback(_):
nfinished[0] += 1
Publisher().publish("terra.transpiler.parallel.done", nfinished[0])
# Run in parallel if not Win and not in parallel already
if platform.system() != 'Windows' and num_processes > 1 \
and os.getenv('QISKIT_IN_PARALLEL') == 'FALSE':
os.environ['QISKIT_IN_PARALLEL'] = 'TRUE'
try:
pool = Pool(processes=num_processes)
async_res = [
pool.apply_async(task, (value, ) + task_args, task_kwargs,
_callback) for value in values
]
while not all([item.ready() for item in async_res]):
for item in async_res:
item.wait(timeout=0.1)
pool.terminate()
pool.join()
except KeyboardInterrupt:
pool.terminate()
pool.join()
Publisher().publish("terra.parallel.parallel.finish")
raise QISKitError('Keyboard interrupt in parallel_map.')
Publisher().publish("terra.transpiler.parallel.finish")
os.environ['QISKIT_IN_PARALLEL'] = 'FALSE'
return [ar.get() for ar in async_res]
# Cannot do parallel on Windows , if another parallel_map is running in parallel,
# or len(values) == 1.
results = []
for _, value in enumerate(values):
result = task(value, *task_args, **task_kwargs)
results.append(result)
_callback(0)
Publisher().publish("terra.transpiler.parallel.finish")
return results
def _emmit_finish():
""" Emmit a dag transpilation finish event
Arg:
progress: The dag number that just has finshed transpile"""
Publisher().publish("terra.transpiler.transpile_dag.finish")
def _emmit_done(progress):
""" Emmit a dag transpilation done event
Arg:
progress: The dag number that just has finshed transpile"""
Publisher().publish("terra.transpiler.transpile_dag.done", progress)
def _emmit_start(num_dags):
""" Emmit a dag transpilation start event
Arg:
num_dags: Number of dags to be transpiled"""
Publisher().publish("terra.transpiler.transpile_dag.start", num_dags)