Struct maitake::scheduler::LocalStaticSpawner

pub struct LocalStaticSpawner(/* private fields */);

A handle to a LocalStaticScheduler that implements Send.

The LocalScheduler and LocalStaticScheduler types are capable of spawning futures which do not implement Send. Because of this, those scheduler types themselves are also !Send and !Sync, as as ticking them from another thread would cause its tasks to be polled from that thread, violating the Send and Sync contracts.

However, tasks which are Send may still be spawned on a !Send scheduler, alongside !Send tasks. Because the scheduler types are !Sync, other threads may not reference them in order to spawn remote tasks on those schedulers. This type is a handle to a !Sync scheduler which can be sent across thread boundaries, as it does not have the capacity to poll tasks or reference the current task.

This type is returned by LocalStaticScheduler::spawner.

Implementations

impl LocalStaticSpawner

pub fn spawn_allocated<F, STO>( &self, task: STO::StoredTask ) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static, STO: Storage<&'static LocalStaticScheduler, F>,

Spawn a pre-allocated task on the LocalStaticScheduler this spawner references.

Unlike LocalScheduler::spawn_allocated and LocalStaticScheduler::spawn_allocated, this method requires that the spawned Future implement Send, as the LocalSpawner type is Send and Sync, and therefore allows tasks to be spawned on a local scheduler from other threads.

This method is used to spawn a task that requires some bespoke procedure of allocation, typically of a custom Storage implementor. See the documentation for the Storage trait for more details on using custom task storage.

This method returns a JoinHandle that can be used to await the task’s output. Dropping the JoinHandle detaches the spawned task, allowing it to run in the background without awaiting its output.

When tasks are spawned on a scheduler, the scheduler must be ticked in order to drive those tasks to completion. See the module-level documentation for more information on implementing a system’s run loop.

impl LocalStaticSpawner

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

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

Available on crate feature alloc only.

Spawn a task on the LocalStaticScheduler this handle references.

Unlike LocalStaticScheduler::spawn, this method requires that the spawned Future implement Send, as the LocalStaticSpawner type is Send and Sync, and therefore allows tasks to be spawned on a local scheduler from other threads.

This method returns a JoinHandle that can be used to await the task’s output. Dropping the JoinHandle detaches the spawned task, allowing it to run in the background without awaiting its output.

When tasks are spawned on a scheduler, the scheduler must be ticked in order to drive those tasks to completion. See the module-level documentation for more information on implementing a system’s run loop.

Trait Implementations

impl Debug for LocalStaticSpawner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Send for LocalStaticSpawner

Safety

A LocalStaticSpawner cannot be used to access any !Send tasks on the local scheduler it references. It can only push tasks to that scheduler’s run queue, which is thread safe.

impl Sync for LocalStaticSpawner