Struct jlrs::ccall::CCall

pub struct CCall<'context> { /* private fields */ }

Interact with Julia from a Rust function called through ccall.

When you call Rust from Julia through ccall, Julia has already been initialized and trying to initialize it again causes a crash. In order to still be able to call Julia from Rust you must create a scope first. You can use this struct to do so. It must never be used outside functions called through ccall, and only once for each ccalled function.

Implementations

impl<'context> CCall<'context>

pub unsafe fn new(frame: &'context mut StackFrame<0>) -> Self

Create a new CCall

Safety: This function must never be called outside a function called through ccall from Julia and must only be called once during that call.

pub unsafe fn uv_async_send(handle: *mut c_void) -> bool

Wake the task associated with handle.

The handle must be the handle field of a Base.AsyncCondition in Julia. This can be used to call a long-running Rust function from Julia with ccall in another thread and wait for it to complete in Julia without blocking, an example is available in the repository: ccall_with_threads.

This method is only available if the uv feature is enabled.

Safety: the handle must be acquired from an AsyncCondition.

pub fn scope<T, F>(&mut self, func: F) -> JlrsResult<T>

where for<'scope> F: FnOnce(GcFrame<'scope>) -> JlrsResult<T>,

Create a GcFrame, call the given closure, and return its result.

pub unsafe fn local_scope<T, F, const N: usize>(func: F) -> JlrsResult<T>

where for<'scope> F: FnOnce(LocalGcFrame<'scope, N>) -> JlrsResult<T>,

Create a LocalGcFrame, call the given closure, and return its result.

pub unsafe fn infallible_local_scope<T, F, const N: usize>(func: F) -> T

where for<'scope> F: FnOnce(LocalGcFrame<'scope, N>) -> T,

Create a LocalGcFrame, call the given closure, and return its result.

pub unsafe fn invoke<T, F>(func: F) -> T

where T: 'static + CCallReturn, for<'scope> F: FnOnce(GcFrame<'scope>) -> T,

Create an instance of CCall and use it to invoke the provided closure.

Safety: this method must only be called from ccalled functions. The returned data is unrooted and must be returned to Julia immediately.

pub unsafe fn invoke_fallible<T, F>(func: F) -> JlrsResult<T>

where T: ConstructType, for<'scope> F: FnOnce(GcFrame<'scope>) -> JlrsResult<T>,

Create an instance of CCall and use it to invoke the provided closure.

Safety: this method must only be called from ccalled functions. The returned data is unrooted and must be returned to Julia immediately.

pub unsafe fn stackless_invoke<T, F>(func: F) -> T

where T: 'static + CCallReturn, for<'scope> F: FnOnce(Unrooted<'scope>) -> T,

Invoke the provided closure.

Safety: this method must only be called from ccalled functions. The returned data is unrooted and must be returned to Julia immediately.

pub unsafe fn throw_exception(exception: ValueRet) -> !

Throw an exception.

Safety:

Don’t jump over any frames that have pendings drops. Julia exceptions are implemented with setjmp / longjmp. This means that when an exception is thrown, control flow is returned to a catch block by jumping over intermediate stack frames.

pub unsafe fn throw_borrow_exception() -> !

pub unsafe fn stackless_scope<T, F>(func: F) -> JlrsResult<T>

where for<'scope> F: FnOnce(Unrooted<'scope>) -> JlrsResult<T>,

Create an Unrooted, call the given closure, and return its result.

Unlike CCall::scope this method doesn’t allocate a stack.

Safety: must only be called from a ccalled function that doesn’t need to root any data.

pub fn set_pool_size(&self, size: usize)

Set the size of the internal thread pool.

pub fn dispatch_to_pool<F, T>(func: F) -> Arc<DispatchHandle<T>>

where F: FnOnce(Arc<DispatchHandle<T>>) + Send + 'static, T: IntoJulia + Send + Sync + ConstructType,

Dispatch func to a thread pool.

pub fn init_jlrs( &mut self, install_jlrs_core: &InstallJlrsCore, module: Option<Module<'_>> )

This function must be called before jlrs can be used. When the julia_module macro is used this function is called automatically.

A module can be provided to allow setting the size of the internal thread pool from Julia by calling JlrsCore.set_pool_size.