Struct Local 

#[repr(C)]
pub(crate) struct Local {
    entry: Entry,
    collector: UnsafeCell<ManuallyDrop<Collector>>,
    pub(crate) bag: UnsafeCell<Bag>,
    guard_count: Cell<usize>,
    handle_count: Cell<usize>,
    pin_count: Cell<Wrapping<usize>>,
    epoch: CachePadded<AtomicEpoch>,
}

Participant for garbage collection.

Fields

entry: Entry

A node in the intrusive linked list of Locals.

collector: UnsafeCell<ManuallyDrop<Collector>>

A reference to the global data.

When all guards and handles get dropped, this reference is destroyed.

bag: UnsafeCell<Bag>

The local bag of deferred functions.

guard_count: Cell<usize>

The number of guards keeping this participant pinned.

handle_count: Cell<usize>

The number of active handles.

pin_count: Cell<Wrapping<usize>>

Total number of pinnings performed.

This is just an auxiliary counter that sometimes kicks off collection.

epoch: CachePadded<AtomicEpoch>

The local epoch.

Implementations

impl Local

const PINNINGS_BETWEEN_COLLECT: usize = 128usize

Number of pinnings after which a participant will execute some deferred functions from the global queue.

pub(crate) fn register(collector: &Collector) -> LocalHandle

Registers a new Local in the provided Global.

pub(crate) fn global(&self) -> &Global

Returns a reference to the Global in which this Local resides.

pub(crate) fn collector(&self) -> &Collector

Returns a reference to the Collector in which this Local resides.

pub(crate) fn is_pinned(&self) -> bool

Returns true if the current participant is pinned.

pub(crate) unsafe fn defer(&self, deferred: Deferred, guard: &Guard)

Adds deferred to the thread-local bag.

Safety

It should be safe for another thread to execute the given function.

pub(crate) fn flush(&self, guard: &Guard)

pub(crate) fn pin(&self) -> Guard

Pins the Local.

pub(crate) fn unpin(&self)

Unpins the Local.

pub(crate) fn repin(&self)

Unpins and then pins the Local.

pub(crate) fn acquire_handle(&self)

Increments the handle count.

pub(crate) fn release_handle(&self)

Decrements the handle count.

fn finalize(&self)

Removes the Local from the global linked list.

Trait Implementations

impl IsElement<Local> for Local

fn entry_of(local: &Self) -> &Entry

Returns a reference to this element’s Entry.

unsafe fn element_of(entry: &Entry) -> &Self

Given a reference to an element’s entry, returns that element.

unsafe fn finalize(entry: &Entry, guard: &Guard)

The function that is called when an entry is unlinked from list.