Struct Waiter 

struct Waiter {
    state: AtomicUsize,
    waker: UnsafeCell<Option<Waker>>,
    pointers: Pointers<Waiter>,
    _p: PhantomPinned,
}

An entry in the wait queue.

Fields

state: AtomicUsize

The current state of the waiter.

This is either the number of remaining permits required by the waiter, or a flag indicating that the waiter is not yet queued.

waker: UnsafeCell<Option<Waker>>

The waker to notify the task awaiting permits.

Safety

This may only be accessed while the wait queue is locked.

pointers: Pointers<Waiter>

Intrusive linked-list pointers.

Safety

This may only be accessed while the wait queue is locked.

TODO: Ideally, we would be able to use loom to enforce that this isn’t accessed concurrently. However, it is difficult to use a UnsafeCell here, since the Link trait requires returning references to Pointers, and UnsafeCell requires that checked access take place inside a closure. We should consider changing Pointers to use UnsafeCell internally.

_p: PhantomPinned

Should not be Unpin.

Implementations

impl Waiter

unsafe fn addr_of_pointers(me: NonNull<Self>) -> NonNull<Pointers<Waiter>>

impl Waiter

fn new(num_permits: usize) -> Self

fn assign_permits(&self, n: &mut usize) -> bool

Assign permits to the waiter.

Returns true if the waiter should be removed from the queue

Trait Implementations

impl Link for Waiter

Safety

Waiter is forced to be !Unpin.

type Handle = NonNull<Waiter>

Handle to the list entry.

type Target = Waiter

Node type.

fn as_raw(handle: &Self::Handle) -> NonNull<Waiter>

Convert the handle to a raw pointer without consuming the handle.

unsafe fn from_raw(ptr: NonNull<Waiter>) -> NonNull<Waiter>

Convert the raw pointer to a handle

unsafe fn pointers(target: NonNull<Waiter>) -> NonNull<Pointers<Waiter>>

Return the pointers for a node