Struct jlrs::runtime::async_rt::AsyncJulia

pub struct AsyncJulia<R> { /* private fields */ }

A handle to the async runtime.

This handle can be used to include files and send new tasks to the runtime. The runtime shuts down when the last handle is dropped and all active tasks have completed.

Implementations

impl<R> AsyncJulia<R>

where R: AsyncRuntime,

pub fn resize_queue<'own>( &'own self, capacity: usize ) -> Option<impl 'own + Future<Output = ()>>

Resize the task queue.

No tasks are dropped if the queue is shrunk. This method return a future that doesn´t resolve until the queue can be resized without dropping any tasks.

pub async fn resize_queue_async(&self, capacity: usize) -> Option<()>

Resize the task queue.

See AsyncJulia::resize_queue for more info, the only difference is that this is an async method.

pub fn resize_main_queue<'own>( &'own self, capacity: usize ) -> impl 'own + Future<Output = ()>

Resize the task queue of the main runtime thread.

No tasks are dropped if the queue is shrunk. This method return a future that doesn´t resolve until the queue can be resized without dropping any tasks.

pub async fn resize_main_queue_async(&self, capacity: usize)

Resize the task queue of the main runtime thread.

See AsyncJulia::resize_main_queue for more info, the only difference is that this is an async method.

pub fn resize_worker_queue<'own>( &'own self, capacity: usize ) -> Option<impl 'own + Future<Output = ()>>

Resize the task queue of the worker threads.

No tasks are dropped if the queue is shrunk. This method return a future that doesn´t resolve until the queue can be resized without dropping any tasks.

pub async fn resize_worker_queue_async(&self, capacity: usize) -> Option<()>

Resize the task queue of the worker threads.

See AsyncJulia::resize_main_queue for more info, the only difference is that this is an async method.

pub fn task<A, O>(&self, task: A, res_sender: O) -> Dispatch<'_, A::Affinity>

where A: AsyncTask, O: OneshotSender<JlrsResult<A::Output>>,

Send a new async task to the runtime.

This method waits if there’s no room in the channel. It takes two arguments, the task and the sending half of a channel which is used to send the result back after the task has completed.

pub fn register_task<A, O>(&self, res_sender: O) -> Dispatch<'_, A::Affinity>

where A: AsyncTask, O: OneshotSender<JlrsResult<()>>,

Register an async task.

This method waits if there’s no room in the channel. It takes one argument, the sending half of a channel which is used to send the result back after the registration has completed.

pub fn blocking_task<T, O, F>( &self, task: F, res_sender: O ) -> Dispatch<'_, DispatchAny>

where for<'base> F: 'static + Send + FnOnce(GcFrame<'base>) -> JlrsResult<T>, O: OneshotSender<JlrsResult<T>>, T: Send + 'static,

Send a new blocking task to the runtime.

This method waits if there’s no room in the channel. It takes two arguments, the first is a closure that takes a GcFrame and must return a JlrsResult whose inner type implements Send. The second is the sending half of a channel which is used to send the result back after the task has completed. This task is executed as soon as possible and can’t call async methods, so it blocks the runtime.

pub fn blocking_task_with_affinity<A, T, O, F>( &self, task: F, res_sender: O ) -> Dispatch<'_, A>

where A: Affinity, for<'base> F: 'static + Send + FnOnce(GcFrame<'base>) -> JlrsResult<T>, O: OneshotSender<JlrsResult<T>>, T: Send + 'static,

Send a new blocking task to the runtime.

This method waits if there’s no room in the channel. It takes two arguments, the first is a closure that takes a GcFrame and must return a JlrsResult whose inner type implements Send. The second is the sending half of a channel which is used to send the result back after the task has completed. This task is executed as soon as possible and can’t call async methods, so it blocks the runtime.

pub fn post_blocking_task<T, O, F>( &self, task: F, res_sender: O ) -> Dispatch<'_, DispatchAny>

where for<'base> F: 'static + Send + FnOnce(GcFrame<'base>) -> JlrsResult<T>, O: OneshotSender<JlrsResult<T>>, T: Send + 'static,

Send a new blocking task to the runtime and schedule it on another thread.

This method waits if there’s no room in the channel. It takes two arguments, the first is a closure that takes a GcFrame and must return a JlrsResult whose inner type implements Send. The second is the sending half of a channel which is used to send the result back after the task has completed. This task not called directly, but executed in a spawned task.

pub fn persistent<C, P, O>( &self, task: P, handle_sender: O ) -> Dispatch<'_, P::Affinity>

where C: Channel<PersistentMessage<P>>, P: PersistentTask, O: OneshotSender<JlrsResult<PersistentHandle<P>>>,

Send a new persistent task to the runtime.

This method waits if there’s no room in the channel. It takes a two arguments, the task and a OneshotSender to send a PersistentHandle after the task’s init method has completed. You must also provide an implementation of Channel as a type parameter. This channel is used by the handle to communicate with the persistent task.

pub fn register_persistent<P, O>( &self, res_sender: O ) -> Dispatch<'_, P::Affinity>

where P: PersistentTask, O: OneshotSender<JlrsResult<()>>,

Register a persistent task.

This method waits if there’s no room in the channel. It takes one argument, the sending half of a channel which is used to send the result back after the registration has completed.

pub unsafe fn include<P, O>( &self, path: P, res_sender: O ) -> JlrsResult<Dispatch<'_, DispatchMain>>

where P: AsRef<Path>, O: OneshotSender<JlrsResult<()>>,

Include a Julia file by calling Main.include as a blocking task.

This method waits if there’s no room in the channel. It takes two arguments, the path to the file and the sending half of a channel which is used to send the result back after the file has been included.

Safety: this method evaluates the contents of the file if it exists, which can’t be checked for correctness.

pub fn error_color<O>( &self, enable: bool, res_sender: O ) -> Dispatch<'_, DispatchMain>

where O: OneshotSender<JlrsResult<()>>,

Enable or disable colored error messages originating from Julia as a blocking task.

This method waits if there’s no room in the channel. It takes two arguments, a bool to enable or disable colored error messages and the sending half of a channel which is used to send the result back after the option is set.

This feature is disabled by default.