async def stop(self):
if self.stopped:
return
self.stopped = True
# make sure all init tasks are finished.
if len(self._pending_init_tasks) > 0:
for task in self._pending_init_tasks:
task.cancel()
await asyncio.wait(self._pending_init_tasks)
if len(self._started_tasks) > 0:
try:
# request for loop termination.
for _ in range(len(self._started_tasks)):
await self._queue.put(None)
# wait for loop to finish before terminating the kernels
await asyncio.wait(self._started_tasks, loop=self._loop)
except CancelledError:
pass
except Exception as e:
logger.warning("Exception raised while terminating loop: %s", e)
# terminate the kernel instances, if any started.
tasks = {asyncio.create_task(kernel.stop()) for kernel in self._evaluators}
# `wait` raises the first exception, but wait for all tasks to finish.
await asyncio.wait(tasks, loop=self._loop)
async def test_failed_expr(self):
tasks = [
asyncio.create_task(self.pool.evaluate(wlexpr("Pause[.1]; 1/0")))
for i in range(1, 10)
]
res = await asyncio.gather(*tasks)
self.assertEqual(res, [wl.DirectedInfinity() for _ in range(1, 10)])
async def _async_start_kernel(self, kernel):
kernel_started = False
try:
# start the kernel
await kernel.start()
kernel_started = True
except asyncio.CancelledError:
logger.info("Cancelled signal during kernel start.")
except Exception as e:
try:
if logger.isEnabledFor(logging.INFO):
logger.info(
"A kernel from pool failed to start: %s. Reason is %s", kernel, e
)
await kernel.stop()
except asyncio.CancelledError:
logger.info("Cancelled signal.")
except Exception as e2:
logger.info("Exception raised during clean-up after failed start: %s", e2)
if kernel_started:
# schedule the infinite evaluation loop
task = asyncio.create_task(self._kernel_loop(kernel))
if logger.isEnabledFor(logging.INFO):
logger.info("New kernel started in pool: %s.", kernel)
# register the task. The loop is not always started at this point.
self._started_tasks.append(task)
async def test_eval_parallel(self):
tasks = [
asyncio.create_task(self.async_session.evaluate(i + 1))
for i in range(10)
]
res = await asyncio.gather(*tasks)
self.assertEqual(res, list(range(1, 11)))
async def test_eval_wrap(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate_wrap(wlexpr("Pause[.1]; Range[3]")))
timer = time.perf_counter() - start
self.assertTrue(timer < 0.1)
res = await task
numpy.assert_array_equal(res.get(), numpy.arange(1, 4))
async def _pool_evaluation_check(self, pool):
tasks = [
asyncio.create_task(pool.evaluate(wl.FromLetterNumber(i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
self.assertEqual({*res},
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
async def test_eval_wlsymbol(self):
tasks = [
asyncio.create_task(self.pool.evaluate(wl.FromLetterNumber(i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
self.assertEqual({*res},
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
async def test_eval_wrap(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate_wrap(wlexpr('Pause[.1]; Range[3]')))
timer = time.perf_counter() - start
self.assertTrue(timer < .1)
res = await task
self.assertEqual(res.get(), [1, 2, 3])
async def test_eval_wxf(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate_wxf(wlexpr("Pause[.1]; Range[3]")))
timer = time.perf_counter() - start
self.assertTrue(timer < 0.1)
wxf = await task
res = binary_deserialize(wxf)
numpy.assert_array_equal(res, numpy.arange(1, 4))
async def test_eval_wlsymbol(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate(
wl.CompoundExpression(wl.Pause(0.1), wl.Range(2))))
timer = time.perf_counter() - start
self.assertTrue(timer < 0.1)
res = await task
numpy.assert_array_equal(res, numpy.arange(1, 3))
async def test_eval_wlsymbol(self):
start = time.perf_counter()
task = asyncio.create_task(
self.async_session.evaluate(
wl.CompoundExpression(wl.Pause(.1), wl.Range(2))))
timer = time.perf_counter() - start
self.assertTrue(timer < .1)
res = await task
self.assertEqual(res, [1, 2])
async def test_eval_wxf(self):
tasks = [
asyncio.create_task(
self.pool.evaluate_wxf(wlexpr("FromLetterNumber[%i]" % i)))
for i in range(1, 11)
]
res = await asyncio.gather(*tasks)
res = {binary_deserialize(wxf, consumer=WXFConsumer()) for wxf in res}
self.assertEqual(res,
{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"})
async def _evaluate_all(self, iterable):
tasks = [asyncio.create_task(self.evaluate(expr)) for expr in iterable]
return await asyncio.gather(*tasks)
