You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
66 lines
2.8 KiB
Rust
66 lines
2.8 KiB
Rust
/// Set if the task is scheduled for running.
|
|
///
|
|
/// A task is considered to be scheduled whenever its `Task` reference exists. It is in scheduled
|
|
/// state at the moment of creation and when it gets unapused either by its `JoinHandle` or woken
|
|
/// by a `Waker`.
|
|
///
|
|
/// This flag can't be set when the task is completed. However, it can be set while the task is
|
|
/// running, in which case it will be rescheduled as soon as polling finishes.
|
|
pub(crate) const SCHEDULED: usize = 1 << 0;
|
|
|
|
/// Set if the task is running.
|
|
///
|
|
/// A task is running state while its future is being polled.
|
|
///
|
|
/// This flag can't be set when the task is completed. However, it can be in scheduled state while
|
|
/// it is running, in which case it will be rescheduled when it stops being polled.
|
|
pub(crate) const RUNNING: usize = 1 << 1;
|
|
|
|
/// Set if the task has been completed.
|
|
///
|
|
/// This flag is set when polling returns `Poll::Ready`. The output of the future is then stored
|
|
/// inside the task until it becomes stopped. In fact, `JoinHandle` picks the output up by marking
|
|
/// the task as stopped.
|
|
///
|
|
/// This flag can't be set when the task is scheduled or completed.
|
|
pub(crate) const COMPLETED: usize = 1 << 2;
|
|
|
|
/// Set if the task is closed.
|
|
///
|
|
/// If a task is closed, that means its either cancelled or its output has been consumed by the
|
|
/// `JoinHandle`. A task becomes closed when:
|
|
///
|
|
/// 1. It gets cancelled by `Task::cancel()` or `JoinHandle::cancel()`.
|
|
/// 2. Its output is awaited by the `JoinHandle`.
|
|
/// 3. It panics while polling the future.
|
|
/// 4. It is completed and the `JoinHandle` is dropped.
|
|
pub(crate) const CLOSED: usize = 1 << 3;
|
|
|
|
/// Set if the `JoinHandle` still exists.
|
|
///
|
|
/// The `JoinHandle` is a special case in that it is only tracked by this flag, while all other
|
|
/// task references (`Task` and `Waker`s) are tracked by the reference count.
|
|
pub(crate) const HANDLE: usize = 1 << 4;
|
|
|
|
/// Set if the `JoinHandle` is awaiting the output.
|
|
///
|
|
/// This flag is set while there is a registered awaiter of type `Waker` inside the task. When the
|
|
/// task gets closed or completed, we need to wake the awaiter. This flag can be used as a fast
|
|
/// check that tells us if we need to wake anyone without acquiring the lock inside the task.
|
|
pub(crate) const AWAITER: usize = 1 << 5;
|
|
|
|
/// Set if the awaiter is locked.
|
|
///
|
|
/// This lock is acquired before a new awaiter is registered or the existing one is woken.
|
|
pub(crate) const LOCKED: usize = 1 << 6;
|
|
|
|
/// A single reference.
|
|
///
|
|
/// The lower bits in the state contain various flags representing the task state, while the upper
|
|
/// bits contain the reference count. The value of `REFERENCE` represents a single reference in the
|
|
/// total reference count.
|
|
///
|
|
/// Note that the reference counter only tracks the `Task` and `Waker`s. The `JoinHandle` is
|
|
/// tracked separately by the `HANDLE` flag.
|
|
pub(crate) const REFERENCE: usize = 1 << 7;
|