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