Struct ExecutionState 

pub struct ExecutionState {
    pub config: Config,
    pub steps_reset_at: usize,
    pub top_level_span: Span,
    /* private fields */
}

ExecutionState contains the portion of a single execution’s state that needs to be reachable from within a task’s execution. It tracks which tasks exist and their states, as well as which tasks are pending spawn.

Fields

config: Config

steps_reset_at: usize

top_level_span: Span

Implementations

impl ExecutionState

pub fn with<F, T>(f: F) -> T

where F: FnOnce(&mut ExecutionState) -> T,

Invoke a closure with access to the current execution state. Library code uses this to gain access to the state of the execution to influence scheduling (e.g. to register a task as blocked).

pub fn try_with<F, T>(f: F) -> Result<T, ExecutionStateBorrowError>

where F: FnOnce(&mut ExecutionState) -> T,

Like with, but returns None instead of panicking if there is no current ExecutionState or if the current ExecutionState is already borrowed.

pub fn me() -> TaskId

A shortcut to get the current task ID

pub fn exit_current_truncates_execution(&self) -> bool

If there is only one attached, unfinished task and there is at least one detached, unfinished task then exiting the attached task will cause the whole execution to exit. As a result, the unfinished detached tasks are truncated – their remaining events will not be executed because the program itself has exited. This is relevant because it means that exiting a task can be a visible operation in that it affects which events are executed.

pub fn spawn_main_thread( f: Box<dyn FnOnce() + 'static>, stack_size: usize, caller: &'static Location<'static>, ) -> TaskId

pub fn spawn_future<F>( future: F, stack_size: usize, name: Option<String>, caller: &'static Location<'static>, ) -> TaskId

where F: Future<Output = ()> + 'static,

Spawn a new task for a future. This doesn’t create a yield point; the caller should do that if it wants to give the new task a chance to run immediately.

pub fn spawn_thread( f: Box<dyn FnOnce() + 'static>, stack_size: usize, name: Option<String>, initial_clock: Option<VectorClock>, caller: &'static Location<'static>, ) -> TaskId

pub fn is_finished(&self) -> bool

Determine whether the execution has finished.

pub fn maybe_yield() -> bool

Invoke the scheduler to decide which task to schedule next. Returns true if the chosen task is different from the currently running task, indicating that the current task should yield its execution.

pub fn request_yield()

Tell the scheduler that the next context switch is an explicit yield requested by the current task. Some schedulers use this as a hint to influence scheduling.

pub fn should_stop() -> bool

Check whether the current execution has stopped. Call from Drop handlers to early exit if they are being invoked because an execution has stopped.

We also stop if we are currently panicking (e.g., perhaps we’re unwinding the stack for a panic triggered while someone held a Mutex, and so are executing the Drop handler for MutexGuard). This avoids calling back into the scheduler during a panic, because the state may be poisoned or otherwise invalid.

pub fn failing_task() -> String

Generate some diagnostic information used when persisting failures.

Because this method may be called from a panic hook, it must not panic.

pub fn next_u64() -> u64

Generate a random u64 from the current scheduler and return it.

pub fn current(&self) -> &Task

pub fn current_mut(&mut self) -> &mut Task

pub fn try_current(&self) -> Option<&Task>

pub fn get(&self, id: TaskId) -> &Task

pub fn get_mut(&mut self, id: TaskId) -> &mut Task

pub fn try_get(&self, id: TaskId) -> Option<&Task>

pub fn in_cleanup(&self) -> bool

pub fn context_switches() -> usize

pub fn new_resource_signature(resource_type: ResourceType) -> ResourceSignature

pub fn get_storage<K: Into<StorageKey>, T: 'static>(&self, key: K) -> Option<&T>

pub fn init_storage<K: Into<StorageKey>, T: 'static>( &mut self, key: K, value: T, )

pub fn get_clock(&self, id: TaskId) -> &VectorClock

pub fn get_clock_mut(&mut self, id: TaskId) -> &mut VectorClock

pub fn update_clock(&mut self, clock: &VectorClock)

Increment the current thread’s clock entry and update its clock with the one provided.

pub fn increment_clock(&mut self) -> &VectorClock

Increment the current thread’s clock and return a shared reference to it

pub fn increment_clock_mut(&mut self) -> &mut VectorClock

Increment the current thread’s clock and return a mutable reference to it

pub fn set_tag_for_current_task(tag: Arc<dyn Tag>) -> Option<Arc<dyn Tag>>

pub fn get_tag_for_current_task() -> Option<Arc<dyn Tag>>

pub fn set_tag_for_task(task: TaskId, tag: Arc<dyn Tag>) -> Option<Arc<dyn Tag>>

Trait Implementations

impl Debug for ExecutionState

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

Formats the value using the given formatter.

impl Drop for ExecutionState

Available on debug-assertions enabled only.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.