Struct BackgroundExecutor 

pub struct BackgroundExecutor { /* private fields */ }

A pointer to the executor that is currently running, for spawning background tasks.

Implementations

impl BackgroundExecutor

pub fn new(dispatcher: Arc<dyn PlatformDispatcher>) -> BackgroundExecutor

Creates a new BackgroundExecutor from the given PlatformDispatcher.

pub fn scheduler_executor(&self) -> BackgroundExecutor

Returns the underlying scheduler::BackgroundExecutor.

This is used by Ex to pass the executor to thread/worktree code.

pub fn spawn_dedicated<F, Fut>(&self, f: F) -> Task<<Fut as Future>::Output>

where F: FnOnce(LocalExecutor) -> Fut + Send + 'static, Fut: Future + 'static, <Fut as Future>::Output: Send + Sync + 'static,

Spawn a closure on a fresh session pinned to its own SchedulerLocalExecutor. The closure runs on a new OS thread under the platform scheduler, or on the test scheduler’s loop in tests.

Prefer this over Self::spawn for futures whose polls need more stack than shared background threads guarantee. Dedicated threads get the standard library’s default 2 MiB, while spawn polls futures on whatever threads the platform dispatcher provides — on macOS those are GCD workers whose stacks are fixed at 512 KiB by the kernel (see PTH_DEFAULT_STACKSIZE in https://github.com/apple-oss-distributions/libpthread/blob/42d026df5b07825070f60134b980a1ec2552dfee/kern/kern_internal.h#L154), the tightest background-stack budget of any platform.

pub fn spawn<R>( &self, future: impl Future<Output = R> + Send + 'static, ) -> Task<R>

where R: Send + 'static,

Enqueues the given future to be run to completion on a background thread.

pub fn spawn_with_priority<R>( &self, priority: Priority, future: impl Future<Output = R> + Send + 'static, ) -> Task<R>

where R: Send + 'static,

Enqueues the given future to be run to completion on a background thread with the given priority.

When Priority::RealtimeAudio is used, the task runs on a dedicated thread with realtime scheduling priority, suitable for audio processing.

pub async fn scoped<'scope, F>(&self, scheduler: F)

where F: FnOnce(&mut Scope<'scope>),

Runs background tasks that may borrow from their environment and waits for all of them to complete.

Dropping the returned future cancels its tasks and synchronously waits for their futures to be destroyed before returning.

pub async fn scoped_priority<'scope, F>(&self, priority: Priority, scheduler: F)

where F: FnOnce(&mut Scope<'scope>),

Runs prioritized background tasks that may borrow from their environment and waits for all of them to complete.

Dropping the returned future cancels its tasks and synchronously waits for their futures to be destroyed before returning.

pub fn now(&self) -> Instant

Get the current time.

Calling this instead of std::time::Instant::now allows the use of fake timers in tests.

pub fn timer(&self, duration: Duration) -> Task<()>

Returns a task that will complete after the given duration. Depending on other concurrent tasks the elapsed duration may be longer than requested.

pub fn num_cpus(&self) -> usize

How many CPUs are available to the dispatcher.

pub fn is_main_thread(&self) -> bool

Whether we’re on the main thread.

Trait Implementations

impl Clone for BackgroundExecutor

fn clone(&self) -> BackgroundExecutor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.