Struct Task 

pub struct Task {
    pub clock: VectorClock,
    pub step_span: Span,
    pub backtrace: Option<Backtrace>,
    pub signature: TaskSignature,
    /* private fields */
}

A Task represents a user-level unit of concurrency. Each task has an id that is unique within the execution, and a state reflecting whether the task is runnable (enabled) or not.

Fields

clock: VectorClock

step_span: Span

backtrace: Option<Backtrace>

If crate::CAPTURE_BACKTRACE is set then this will be populated on task block. If the test then fails, then each task’s backtrace will be printed.

signature: TaskSignature

The signature of a Task; this is an identifier that is not guaranteed to be unique but should be mostly stable across iterations in a single Shuttle test. Tasks with the same signature are very likely to exhibit similar behavior

Implementations

impl Task

pub fn from_closure( f: Box<dyn FnOnce() + 'static>, stack_size: usize, id: TaskId, name: Option<String>, clock: VectorClock, parent_span_id: Option<Id>, schedule_len: usize, tag: Option<Arc<dyn Tag>>, parent_task_id: Option<TaskId>, signature: TaskSignature, ) -> Self

pub fn from_future<F>( future: F, stack_size: usize, id: TaskId, name: Option<String>, clock: VectorClock, parent_span_id: Option<Id>, schedule_len: usize, tag: Option<Arc<dyn Tag>>, parent_task_id: Option<TaskId>, signature: TaskSignature, ) -> Self

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

pub fn id(&self) -> TaskId

Returns the identifier of this task.

pub fn parent_task_id(&self) -> Option<TaskId>

Returns the identifier of the task that spawned this task.

pub fn runnable(&self) -> bool

pub fn blocked(&self) -> bool

pub fn can_spuriously_wakeup(&self) -> bool

pub fn sleeping(&self) -> bool

pub fn finished(&self) -> bool

pub fn is_detached(&self) -> bool

pub fn detach(&mut self)

pub fn abort(&mut self)

Wake this task so the Wrapper future can observe the abort flag on its next poll.

pub fn waker(&self) -> Waker

pub fn block(&mut self, allow_spurious_wakeups: bool)

Block the current thread. If allow_spurious_wakeups is true, then the scheduler is permitted to spuriously wake up the thread (though it will still not count as a live thread for deadlock detection purposes for as long as it remains blocked).

pub fn sleep(&mut self)

pub fn unblock(&mut self)

pub fn finish(&mut self)

pub fn sleep_unless_woken(&mut self)

Potentially put this task to sleep after it was polled by the executor, unless someone has called its waker first.

A synchronous Task should never call this, because we want threads to be enabled-by-default to avoid bugs where Shuttle incorrectly omits a potential execution.

pub fn set_waiter(&mut self, waiter: TaskId) -> bool

Register a waiter for this thread to terminate. Returns a boolean indicating whether the waiter should block or not. If false, this task has already finished, and so the waiter need not block.

pub fn take_waiter(&mut self) -> Option<TaskId>

pub fn name(&self) -> Option<String>

pub fn local<T: 'static>( &self, key: &'static LocalKey<T>, ) -> Option<Result<&T, AlreadyDestructedError>>

Retrieve a reference to the given thread-local storage slot.

Returns Some(Err(_)) if the slot has already been destructed. Returns None if the slot has not yet been initialized.

pub fn init_local<T: 'static>(&mut self, key: &'static LocalKey<T>, value: T)

Initialize the given thread-local storage slot with a new value.

Panics if the slot has already been initialized.

pub fn pop_local(&mut self) -> Option<Box<dyn Any>>

Return ownership of the next still-initialized thread-local storage slot, to be used when running thread-local storage destructors.

TLS destructors are a little tricky:

1. Their code can perform synchronization operations (and so require Shuttle to call back into ExecutionState), so we can’t drop them from within an ExecutionState borrow. Instead we move the contents of a slot to the caller to be dropped outside the borrow.
2. It’s valid for destructors to read other TLS slots, although destructor order is undefined. This also means it’s valid for a destructor to initialize another TLS slot. To make this work, we run the destructors incrementally, so one destructor can initialize another slot that just gets added via init_local like normal, and then will be available to be popped on a future call to pop_local. To prevent an infinite loop, we forbid reinitializing a TLS slot whose destructor has already run, or is currently being run.

pub fn park(&mut self) -> bool

Park the task if its park token is unavailable. If the task blocks, then it will be woken up when the token becomes available or spuriously without consuming the token (see the documentation for std::thread::park, which says that “it may also return spuriously, without consuming the token”). Returns true if the execution should switch to a different task (e.g., if the token was unavailable).

pub fn unpark(&mut self)

Make the task’s park token available, and unblock the task if it was parked.

pub fn get_tag(&self) -> Option<Arc<dyn Tag>>

pub fn set_tag(&mut self, tag: Arc<dyn Tag>) -> Option<Arc<dyn Tag>>

Sets the tag field of the current task. Returns the tag which was there previously.

pub fn format_for_deadlock(&self) -> String

Trait Implementations

impl Debug for Task

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

Formats the value using the given formatter.