Struct shredder::atomic::AtomicGc

pub struct AtomicGc<T: Scan> { /* fields omitted */ }

An atomic Gc<T>, useful for concurrent algorithms

This has more overhead than an AtomicPtr, but cleanly handles memory management. It also is similar to Gc<T> in that it can be cloned, and therefore easily shared.

A good analogy would be to the excellent arc-swap crate. However, we can be more performant, as relying on the collector lets us avoid some synchronization.

AtomicGc should be fairly fast, but you may not assume it does not block. In fact in the presence of an active garbage collection operation, all operations will block. Otherwise it shouldn’t block.

Implementations

impl<T: Scan> AtomicGc<T>

pub fn new(data: &Gc<T>) -> Self

Create a new AtomicGc

The created AtomicGc will point to the same data as data

pub fn load(&self, ordering: Ordering) -> Gc<T>

load the data from this AtomicGc<T>, getting back a Gc<T>

The ordering/atomicity guarantees are identical to AtomicPtr::load

pub fn store(&self, v: &Gc<T>, ordering: Ordering)

store new data into this AtomicGc

The ordering/atomicity guarantees are identical to AtomicPtr::store

pub fn swap(&self, v: &Gc<T>, ordering: Ordering) -> Gc<T>

swap what data is stored in this AtomicGc, getting a Gc to the old data back

The ordering/atomicity guarantees are identical to AtomicPtr::swap

pub fn compare_and_swap(
    &self,
    current: &Gc<T>,
    new: &Gc<T>,
    ordering: Ordering
) -> bool

Do a CAS operation. If this AtomicGc points to the same data as current then after this operation it will point to the same data as new. (And this happens atomically.)

Data is compared for pointer equality. NOT Eq equality. (A swap will only happen if current and this AtomicGc point to the same underlying allocation.)

The ordering/atomicity guarantees are identical to AtomicPtr::compare_and_swap

Returns

Returns true if the swap happened and this AtomicGc now points to new Returns false if the swap failed / this AtomicGc was not pointing to current

pub fn compare_exchange(
    &self,
    current: &Gc<T>,
    new: &Gc<T>,
    success: Ordering,
    failure: Ordering
) -> bool

Do a CAE operation. If this AtomicGc points to the same data as current then after this operation it will point to the same data as new. (And this happens atomically.)

Data is compared for pointer equality. NOT Eq equality. (A swap will only happen if current and this AtomicGc point to the same underlying allocation.)

The ordering/atomicity guarantees are identical to AtomicPtr::compare_exchange, refer to that documentation for documentation about success and failure orderings.

Returns

Returns true if the swap happened and this AtomicGc now points to new Returns false if the swap failed / this AtomicGc was not pointing to current

Trait Implementations

impl<T: Clone + Scan> Clone for AtomicGc<T>

fn clone(&self) -> AtomicGc<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Scan> Debug for AtomicGc<T>

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

Formats the value using the given formatter.

impl<T: Scan> Drop for AtomicGc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Scan> Finalize for AtomicGc<T>

unsafe fn finalize(&mut self)

Do cleanup on this data, potentially leaving it in an invalid state. (See trait documentation for the rules for implementing this method.)

impl<T: Scan> Scan for AtomicGc<T>

fn scan(&self, scanner: &mut Scanner<'_>)

scan should use the scanner to scan all of its directly owned data

impl<T: Scan + Send + Sync> GcDeref for AtomicGc<T>

impl<T: Scan> GcSafe for AtomicGc<T>