Struct reclaim::AtomicMarkedPtr

pub struct AtomicMarkedPtr<T, N> { /* fields omitted */ }

A raw pointer type which can be safely shared between threads, which can store additional information in its lower (unused) bits.

This type has the same in-memory representation as a *mut T. It is mostly identical to AtomicPtr, except that all of its methods involve a MarkedPtr instead of *mut T.

Methods

impl<T, N> AtomicMarkedPtr<T, N>

pub const fn new(ptr: MarkedPtr<T, N>) -> Self

Creates a new AtomicMarkedPtr.

pub const fn null() -> Self

Creates a new & unmarked null pointer.

impl<T, N: Unsigned> AtomicMarkedPtr<T, N>

pub const MARK_BITS: usize

The number of available mark bits for this type.

pub const MARK_MASK: usize

The bitmask for the lower markable bits.

pub const POINTER_MASK: usize

The bitmask for the (higher) pointer bits.

pub fn into_inner(self) -> MarkedPtr<T, N>

Consumes self and returns the inner MarkedPtr

pub fn load(&self, order: Ordering) -> MarkedPtr<T, N>

Loads a value from the pointer.

load takes an Ordering argument which describes the memory ordering of this operation. Possible values are SeqCst, Acquire and Relaxed.

Panics

Panics if order is Release or AcqRel.

Examples

use std::sync::atomic::Ordering;

type MarkedPtr<T> = reclaim::MarkedPtr<T, reclaim::typenum::U1>;
type AtomicMarkedPtr<T> = reclaim::AtomicMarkedPtr<T, reclaim::typenum::U1>;

let ptr = &mut 5;
let marked = MarkedPtr::compose(ptr, 0b1);
let atomic = AtomicMarkedPtr::new(marked);

let value = atomic.load(Ordering::Relaxed);
assert_eq!((Some(&mut 5), 0b1), unsafe { value.decompose_mut() });

pub fn store(&self, ptr: MarkedPtr<T, N>, order: Ordering)

Stores a value into the pointer.

store takes an Ordering argument which describes the memory ordering of this operation. Possible values are SeqCst, Release and Relaxed.

Panics

Panics if order is Acquire or AcqRel.

Examples

use std::sync::atomic::Ordering;

type MarkedPtr<T> = reclaim::MarkedPtr<T, reclaim::typenum::U0>;
type AtomicMarkedPtr<T> = reclaim::AtomicMarkedPtr<T, reclaim::typenum::U0>;

let ptr = &mut 5;
let marked = MarkedPtr::new(ptr);
let atomic = AtomicMarkedPtr::new(marked);

let other_marked = MarkedPtr::new(&mut 10);

atomic.store(other_marked, Ordering::Relaxed);

pub fn swap(&self, ptr: MarkedPtr<T, N>, order: Ordering) -> MarkedPtr<T, N>

Stores a value into the pointer, returning the previous value.

pub fn compare_and_swap(
    &self,
    current: MarkedPtr<T, N>,
    new: MarkedPtr<T, N>,
    order: Ordering
) -> MarkedPtr<T, N>

Stores a value into the pointer if the current value is the same as current.

pub fn compare_exchange(
    &self,
    current: MarkedPtr<T, N>,
    new: MarkedPtr<T, N>,
    success: Ordering,
    failure: Ordering
) -> Result<MarkedPtr<T, N>, MarkedPtr<T, N>>

Stores a value into the pointer if the current value is the same as current.

pub fn compare_exchange_weak(
    &self,
    current: MarkedPtr<T, N>,
    new: MarkedPtr<T, N>,
    success: Ordering,
    failure: Ordering
) -> Result<MarkedPtr<T, N>, MarkedPtr<T, N>>

Stores a value into the pointer if the current value is the same as current.

Trait Implementations

impl<T, N: Unsigned> From<*const T> for AtomicMarkedPtr<T, N>

fn from(ptr: *const T) -> Self

Performs the conversion.

impl<T, N: Unsigned> From<*mut T> for AtomicMarkedPtr<T, N>

fn from(ptr: *mut T) -> Self

Performs the conversion.

impl<T, N: Unsigned> From<MarkedPtr<T, N>> for AtomicMarkedPtr<T, N>

fn from(ptr: MarkedPtr<T, N>) -> Self

Performs the conversion.

impl<T, N: Unsigned> Default for AtomicMarkedPtr<T, N>

fn default() -> Self

Returns the "default value" for a type.

impl<T, N: Unsigned> Debug for AtomicMarkedPtr<T, N>

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

Formats the value using the given formatter.

impl<T, N: Unsigned> Pointer for AtomicMarkedPtr<T, N>

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

Formats the value using the given formatter.