Struct crossbeam::mem::epoch::Atomic

pub struct Atomic<T> { /* fields omitted */ }

Like std::sync::atomic::AtomicPtr.

Provides atomic access to a (nullable) pointer of type T, interfacing with the Owned and Shared types.

Methods

impl<T> Atomic<T>

fn null() -> Atomic<T>

fn new(data: T) -> Atomic<T>

Create a new atomic pointer

fn load<'a>(&self, ord: Ordering, _: &'a Guard) -> Option<Shared<'a, T>>

Do an atomic load with the given memory ordering.

In order to perform the load, we must pass in a borrow of a Guard. This is a way of guaranteeing that the thread has pinned the epoch for the entire lifetime 'a. In return, you get an optional Shared pointer back (None if the Atomic is currently null), with lifetime tied to the guard.

Panics

Panics if ord is Release or AcqRel.

fn store(&self, val: Option<Owned<T>>, ord: Ordering)

Do an atomic store with the given memory ordering.

Transfers ownership of the given Owned pointer, if any. Since no lifetime information is acquired, no Guard value is needed.

Panics

Panics if ord is Acquire or AcqRel.

fn store_and_ref<'a>(
    &self,
    val: Owned<T>,
    ord: Ordering,
    _: &'a Guard
) -> Shared<'a, T>

Do an atomic store with the given memory ordering, immediately yielding a shared reference to the pointer that was stored.

Transfers ownership of the given Owned pointer, yielding a Shared reference to it. Since the reference is valid only for the curent epoch, it's lifetime is tied to a Guard value.

Panics

Panics if ord is Acquire or AcqRel.

fn store_shared(&self, val: Option<Shared<T>>, ord: Ordering)

Do an atomic store of a Shared pointer with the given memory ordering.

This operation does not require a guard, because it does not yield any new information about the lifetime of a pointer.

Panics

Panics if ord is Acquire or AcqRel.

fn cas(
    &self,
    old: Option<Shared<T>>,
    new: Option<Owned<T>>,
    ord: Ordering
) -> Result<(), Option<Owned<T>>>

Do a compare-and-set from a Shared to an Owned pointer with the given memory ordering.

As with store, this operation does not require a guard; it produces no new lifetime information. The Result indicates whether the CAS succeeded; if not, ownership of the new pointer is returned to the caller.

fn cas_and_ref<'a>(
    &self,
    old: Option<Shared<T>>,
    new: Owned<T>,
    ord: Ordering,
    _: &'a Guard
) -> Result<Shared<'a, T>, Owned<T>>

Do a compare-and-set from a Shared to an Owned pointer with the given memory ordering, immediatley acquiring a new Shared reference to the previously-owned pointer if successful.

This operation is analogous to store_and_ref.

fn cas_shared(
    &self,
    old: Option<Shared<T>>,
    new: Option<Shared<T>>,
    ord: Ordering
) -> bool

Do a compare-and-set from a Shared to another Shared pointer with the given memory ordering.

The boolean return value is true when the CAS is successful.

fn swap<'a>(
    &self,
    new: Option<Owned<T>>,
    ord: Ordering,
    _: &'a Guard
) -> Option<Shared<'a, T>>

Do an atomic swap with an Owned pointer with the given memory ordering.

fn swap_shared<'a>(
    &self,
    new: Option<Shared<T>>,
    ord: Ordering,
    _: &'a Guard
) -> Option<Shared<'a, T>>

Do an atomic swap with a Shared pointer with the given memory ordering.

Trait Implementations

impl<T: Debug> Debug for Atomic<T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Sync> Send for Atomic<T>

impl<T: Sync> Sync for Atomic<T>