Struct RuntimeManager

pub struct RuntimeManager { /* private fields */ }

Available on crate feature async only.

Implementations

impl RuntimeManager

pub fn block_on_potential_spawn<F>(&'static self, future: F) -> F::Output

where F: Future + Send, F::Output: Send,

Keep track of rayon threads that drive the runtime. Every thread only allows a single runtime. If this thread calls block_on and this rayon thread is already driving an async execution we must start a new thread otherwise we panic. This can happen when we parallelize reads over 100s of files.

Safety

The tokio runtime flavor is multi-threaded.

pub fn block_on<F>(&self, future: F) -> F::Output

where F: Future,

pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a future onto the Tokio runtime (see [tokio::runtime::Runtime::spawn]).

pub fn spawn_blocking<F, R>(&self, f: F) -> JoinHandle<R>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

pub async fn spawn_rayon<F, O>(&self, func: F) -> O

where F: FnOnce() -> O + Send + Sync + 'static, O: Send + Sync + 'static,

Run a task on the rayon threadpool. To avoid deadlocks, if the current thread is already a rayon thread, the task is executed on the current thread after tokio’s block_in_place is used to spawn another thread to poll futures.