Struct TaskScheduler 

pub struct TaskScheduler { /* private fields */ }

Scheduler that tracks spawned async tasks by their future ID.

The VM’s SpawnTask opcode registers a callable here. When the VM later suspends on WaitType::Future { id }, the host looks up the callable, executes it, and stores the result so the VM can resume.

Supports both inline tasks (callable executed synchronously at await-time) and external tasks (completed by background Tokio tasks via oneshot channels).

Implementations

impl TaskScheduler

pub fn new() -> Self

Create a new, empty scheduler.

pub fn register(&mut self, task_id: u64, callable: ValueWord)

Register a callable for a given task_id.

Called by op_spawn_task when a new task is spawned.

pub fn take_callable(&mut self, task_id: u64) -> Option<ValueWord>

Take (remove) the callable for task_id so it can be executed.

Returns None if the task was already consumed or never registered.

pub fn complete(&mut self, task_id: u64, value: ValueWord)

Record a completed result for a task.

pub fn cancel(&mut self, task_id: u64)

Mark a task as cancelled.

pub fn get_result(&self, task_id: u64) -> Option<&TaskStatus>

Get the result for a task, if it has completed.

pub fn is_resolved(&self, task_id: u64) -> bool

Check whether a task has a stored result (completed or cancelled).

pub fn register_external( &mut self, task_id: u64, ) -> Sender<Result<ValueWord, String>>

Register an externally-completed task (e.g., remote call).

Returns a oneshot::Sender that the background task uses to deliver the result. The scheduler marks the task as Pending and stores the receiver.

pub fn try_resolve_external( &mut self, task_id: u64, ) -> Option<Result<ValueWord, VMError>>

Try to resolve an external task (non-blocking check).

Returns Some(Ok(val)) if the external task completed successfully, Some(Err(..)) on error/cancellation, or None if still pending.

pub fn has_external(&self, task_id: u64) -> bool

Check whether a task has an external receiver (is externally-completed).

pub fn take_external_receiver( &mut self, task_id: u64, ) -> Option<Receiver<Result<ValueWord, String>>>

Take the external receiver for async awaiting.

Used by execute_with_async when it needs to truly .await an external task’s completion.

pub fn resolve_task<F>( &mut self, task_id: u64, executor_fn: F, ) -> Result<ValueWord, VMError>

where F: FnOnce(ValueWord) -> Result<ValueWord, VMError>,

Resolve a single task by executing its callable on a fresh VM executor.

This is the synchronous (inline) strategy: the callable is executed immediately when awaited. Returns the result value, or an error.

The executor_fn callback receives the callable ValueWord and must execute it, returning the result.

pub fn resolve_task_group<F>( &mut self, kind: u8, task_ids: &[u64], executor_fn: F, ) -> Result<ValueWord, VMError>

where F: FnMut(ValueWord) -> Result<ValueWord, VMError>,

Resolve a task group according to the join strategy.

Join kinds (encoded in the high 2 bits of JoinInit’s packed operand): 0 = All — wait for all tasks, return array of results 1 = Race — return first completed result 2 = Any — return first successful result (skip errors) 3 = AllSettled — return array of {status, value/error} for every task

Since we execute synchronously, “race” and “any” still run all tasks sequentially but return early on the first applicable result.

Trait Implementations

impl Debug for TaskScheduler

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

Formats the value using the given formatter.

impl Default for TaskScheduler

fn default() -> Self

Returns the “default value” for a type.