Struct crossbeam_epoch::Shared

pub struct Shared<'g, T: 'g + ?Sized + Pointable> { /* private fields */ }

A pointer to an object protected by the epoch GC.

The pointer is valid for use only during the lifetime 'g.

The pointer must be properly aligned. Since it is aligned, a tag can be stored into the unused least significant bits of the address.

Implementations

impl<'g, T> Shared<'g, T>

pub fn as_raw(&self) -> *const T

Converts the pointer to a raw pointer (without the tag).

Examples

use crossbeam_epoch::{self as epoch, Atomic, Owned};
use std::sync::atomic::Ordering::SeqCst;

let o = Owned::new(1234);
let raw = &*o as *const _;
let a = Atomic::from(o);

let guard = &epoch::pin();
let p = a.load(SeqCst, guard);
assert_eq!(p.as_raw(), raw);

impl<'g, T: ?Sized + Pointable> Shared<'g, T>

pub fn null() -> Shared<'g, T>

Returns a new null pointer.

Examples

use crossbeam_epoch::Shared;

let p = Shared::<i32>::null();
assert!(p.is_null());

pub fn is_null(&self) -> bool

Returns true if the pointer is null.

Examples

use crossbeam_epoch::{self as epoch, Atomic, Owned};
use std::sync::atomic::Ordering::SeqCst;

let a = Atomic::null();
let guard = &epoch::pin();
assert!(a.load(SeqCst, guard).is_null());
a.store(Owned::new(1234), SeqCst);
assert!(!a.load(SeqCst, guard).is_null());

pub unsafe fn deref(&self) -> &'g T

Dereferences the pointer.

Returns a reference to the pointee that is valid during the lifetime 'g.

Safety

Dereferencing a pointer is unsafe because it could be pointing to invalid memory.

Another concern is the possibility of data races due to lack of proper synchronization. For example, consider the following scenario:

1. A thread creates a new object: a.store(Owned::new(10), Relaxed)
2. Another thread reads it: *a.load(Relaxed, guard).as_ref().unwrap()

The problem is that relaxed orderings don’t synchronize initialization of the object with the read from the second thread. This is a data race. A possible solution would be to use Release and Acquire orderings.

Examples

use crossbeam_epoch::{self as epoch, Atomic};
use std::sync::atomic::Ordering::SeqCst;

let a = Atomic::new(1234);
let guard = &epoch::pin();
let p = a.load(SeqCst, guard);
unsafe {
    assert_eq!(p.deref(), &1234);
}

pub unsafe fn deref_mut(&mut self) -> &'g mut T

Dereferences the pointer.

Returns a mutable reference to the pointee that is valid during the lifetime 'g.

Safety

• There is no guarantee that there are no more threads attempting to read/write from/to the actual object at the same time.

  The user must know that there are no concurrent accesses towards the object itself.

• Other than the above, all safety concerns of deref() applies here.

Examples

use crossbeam_epoch::{self as epoch, Atomic};
use std::sync::atomic::Ordering::SeqCst;

let a = Atomic::new(vec![1, 2, 3, 4]);
let guard = &epoch::pin();

let mut p = a.load(SeqCst, guard);
unsafe {
    assert!(!p.is_null());
    let b = p.deref_mut();
    assert_eq!(b, &vec![1, 2, 3, 4]);
    b.push(5);
    assert_eq!(b, &vec![1, 2, 3, 4, 5]);
}

let p = a.load(SeqCst, guard);
unsafe {
    assert_eq!(p.deref(), &vec![1, 2, 3, 4, 5]);
}

pub unsafe fn as_ref(&self) -> Option<&'g T>

Converts the pointer to a reference.

Returns None if the pointer is null, or else a reference to the object wrapped in Some.

Safety

Dereferencing a pointer is unsafe because it could be pointing to invalid memory.

Another concern is the possibility of data races due to lack of proper synchronization. For example, consider the following scenario:

1. A thread creates a new object: a.store(Owned::new(10), Relaxed)
2. Another thread reads it: *a.load(Relaxed, guard).as_ref().unwrap()

The problem is that relaxed orderings don’t synchronize initialization of the object with the read from the second thread. This is a data race. A possible solution would be to use Release and Acquire orderings.

Examples

use crossbeam_epoch::{self as epoch, Atomic};
use std::sync::atomic::Ordering::SeqCst;

let a = Atomic::new(1234);
let guard = &epoch::pin();
let p = a.load(SeqCst, guard);
unsafe {
    assert_eq!(p.as_ref(), Some(&1234));
}

pub unsafe fn into_owned(self) -> Owned<T>

Takes ownership of the pointee.

Panics

Panics if this pointer is null, but only in debug mode.

Safety

This method may be called only if the pointer is valid and nobody else is holding a reference to the same object.

Examples

use crossbeam_epoch::{self as epoch, Atomic};
use std::sync::atomic::Ordering::SeqCst;

let a = Atomic::new(1234);
unsafe {
    let guard = &epoch::unprotected();
    let p = a.load(SeqCst, guard);
    drop(p.into_owned());
}

pub unsafe fn try_into_owned(self) -> Option<Owned<T>>

Takes ownership of the pointee if it is not null.

Safety

This method may be called only if the pointer is valid and nobody else is holding a reference to the same object, or if the pointer is null.

Examples

use crossbeam_epoch::{self as epoch, Atomic};
use std::sync::atomic::Ordering::SeqCst;

let a = Atomic::new(1234);
unsafe {
    let guard = &epoch::unprotected();
    let p = a.load(SeqCst, guard);
    if let Some(x) = p.try_into_owned() {
        drop(x);
    }
}

pub fn tag(&self) -> usize

Returns the tag stored within the pointer.

Examples

use crossbeam_epoch::{self as epoch, Atomic, Owned};
use std::sync::atomic::Ordering::SeqCst;

let a = Atomic::<u64>::from(Owned::new(0u64).with_tag(2));
let guard = &epoch::pin();
let p = a.load(SeqCst, guard);
assert_eq!(p.tag(), 2);

pub fn with_tag(&self, tag: usize) -> Shared<'g, T>

Returns the same pointer, but tagged with tag. tag is truncated to be fit into the unused bits of the pointer to T.

Examples

use crossbeam_epoch::{self as epoch, Atomic};
use std::sync::atomic::Ordering::SeqCst;

let a = Atomic::new(0u64);
let guard = &epoch::pin();
let p1 = a.load(SeqCst, guard);
let p2 = p1.with_tag(2);

assert_eq!(p1.tag(), 0);
assert_eq!(p2.tag(), 2);
assert_eq!(p1.as_raw(), p2.as_raw());

Trait Implementations

impl<T: ?Sized + Pointable> Clone for Shared<'_, T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized + Pointable> Debug for Shared<'_, T>

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

Formats the value using the given formatter.

impl<T: ?Sized + Pointable> Default for Shared<'_, T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<*const T> for Shared<'_, T>

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

Returns a new pointer pointing to raw.

Panics

Panics if raw is not properly aligned.

Examples

use crossbeam_epoch::Shared;

let p = Shared::from(Box::into_raw(Box::new(1234)) as *const _);
assert!(!p.is_null());

impl<'g, T: ?Sized + Pointable> From<Shared<'g, T>> for Atomic<T>

fn from(ptr: Shared<'g, T>) -> Self

Returns a new atomic pointer pointing to ptr.

Examples

use crossbeam_epoch::{Atomic, Shared};

let a = Atomic::<i32>::from(Shared::<i32>::null());

impl<T: ?Sized + Pointable> Ord for Shared<'_, T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an [Ordering] between self and other.

const fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

const fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

const fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl<'g, T: ?Sized + Pointable> PartialEq<Shared<'g, T>> for Shared<'g, T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'g, T: ?Sized + Pointable> PartialOrd<Shared<'g, T>> for Shared<'g, T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: ?Sized + Pointable> Pointer<T> for Shared<'_, T>

fn into_usize(self) -> usize

Returns the machine representation of the pointer.

unsafe fn from_usize(data: usize) -> Self

Returns a new pointer pointing to the tagged pointer data.

impl<T: ?Sized + Pointable> Pointer for Shared<'_, T>

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

Formats the value using the given formatter.

impl<T: ?Sized + Pointable> Copy for Shared<'_, T>

impl<T: ?Sized + Pointable> Eq for Shared<'_, T>