def inner(*args, **kw):
t = time.perf_counter()
res = viewfunc(*args, **kw)
print("Done %s: %s sec" %
(inner.__name__, Decimal(time.perf_counter() - t).quantize(
Decimal("0.000000"))))
return res
def recv_abortable(socket,
timeout=None,
abort_check_period=0.1,
abort_event=None,
**kwargs):
if not socket.bound:
raise SocketException("ZMQ socket not bound.")
if timeout and timeout < 0:
raise ValueError("Timeout must be a positive number.")
retry = 0
start = time.perf_counter()
# fix inconsistencies
if timeout and abort_check_period > timeout:
abort_check_period = timeout
abort_check_period = 1000.0 * abort_check_period
while True:
if socket.zmq_socket.poll(timeout=abort_check_period) > 0:
try:
return recv_method(socket, flags=zmq.NOBLOCK, **kwargs)
# just in case there is more than one consumer.
except zmq.Again:
pass
retry += 1
if abort_event:
if abort_event.is_set():
raise SocketAborted("Socket operation aborted.")
if timeout and (time.perf_counter() - start > timeout):
break
raise SocketOperationTimeout(
"Failed to read any message from socket %s after %.1f seconds and %i retries."
% (socket.uri, time.perf_counter() - start, retry))
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 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])
def _do_evaluate(self, wxf, future, result_update_callback):
start = time.perf_counter()
self.kernel_socket_out.send(zmq.Frame(wxf))
if logger.isEnabledFor(logging.DEBUG):
logger.debug("Expression sent to kernel in %.06fsec", time.perf_counter() - start)
start = time.perf_counter()
wxf_eval_data = self.kernel_socket_in.recv_abortable(copy=False)
if logger.isEnabledFor(logging.DEBUG):
logger.debug(
"Expression received from kernel after %.06fsec", time.perf_counter() - start
)
self.evaluation_count += 1
result = WolframKernelEvaluationResult(wxf_eval_data.buffer, consumer=self.consumer)
if logger.isEnabledFor(logging.WARNING):
for msg in result.iter_messages():
logger.warning(msg)
if result_update_callback:
result = result_update_callback(result)
future.set_result(result)
def _kernel_start(self):
"""Start a new kernel process and open sockets to communicate with it."""
# Socket to which we push new expressions for evaluation.
if self.kernel_socket_out is None:
self.kernel_socket_out = Socket(zmq_type=zmq.PUSH)
if self.kernel_socket_in is None:
self.kernel_socket_in = Socket(zmq_type=zmq.PULL)
# start the evaluation zmq sockets
self.kernel_socket_out.bind()
self.kernel_socket_in.bind()
if logger.isEnabledFor(logging.INFO):
logger.info('Kernel writes commands to socket: %s',
self.kernel_socket_out)
logger.info(
'Kernel receives evaluated expressions from socket: %s',
self.kernel_socket_in)
# start the kernel process
cmd = [self.kernel, '-noprompt', "-initfile", self.initfile]
if self.loglevel != logging.NOTSET:
self.kernel_logger = KernelLogger(name='wolfram-kernel-logger-%i' %
self.id,
level=self.loglevel)
self.kernel_logger.start()
cmd.append('-run')
cmd.append(
'ClientLibrary`Private`SlaveKernelPrivateStart["%s", "%s", "%s", %i];'
% (self.kernel_socket_out.uri, self.kernel_socket_in.uri,
self.kernel_logger.socket.uri,
FROM_PY_LOG_LEVEL[self.loglevel]))
else:
cmd.append('-run')
cmd.append(
'ClientLibrary`Private`SlaveKernelPrivateStart["%s", "%s"];' %
(self.kernel_socket_out.uri, self.kernel_socket_in.uri))
if logger.isEnabledFor(logging.DEBUG):
logger.debug('Kernel called using command: %s.' % ' '.join(cmd))
# hide the WolframKernel window.
if six.WINDOWS and self.get_parameter('HIDE_SUBPROCESS_WINDOW'):
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
else:
startupinfo = None
try:
self.kernel_proc = Popen(cmd,
stdin=self._stdin,
stdout=self._stdout,
stderr=self._stderr,
startupinfo=startupinfo)
if logger.isEnabledFor(logging.INFO):
logger.info('Kernel process started with PID: %s' %
self.kernel_proc.pid)
t_start = time.perf_counter()
except Exception as e:
logger.exception(e)
raise WolframKernelException('Failed to start kernel process.')
try:
# First message must be "OK", acknowledging everything is up and running
# on the kernel side.
response = self.kernel_socket_in.recv_abortable(
timeout=self.get_parameter('STARTUP_TIMEOUT'),
abort_event=_StartEvent(self.kernel_proc,
self.trigger_termination_requested))
if response == self._KERNEL_OK:
if logger.isEnabledFor(logging.INFO):
logger.info(
'Kernel %s is ready. Startup took %.2f seconds.' %
(self.pid, time.perf_counter() - t_start))
else:
raise WolframKernelException(
'Kernel %s failed to start properly.' % self.kernel)
except (SocketAborted, SocketOperationTimeout) as se:
if self.kernel_proc.returncode == self._KERNEL_VERSION_NOT_SUPPORTED:
raise WolframKernelException(
'Wolfram kernel version is not supported. Please consult library prerequisites.'
)
logger.warning('Socket exception: %s', se)
raise WolframKernelException(
'Failed to communicate with kernel: %s.' % self.kernel)
def inner(*args, **opts):
t = time.perf_counter()
value = function(*args, **opts)
return time.perf_counter() - t, value
