Struct crossbeam_epoch::Shared

pub struct Shared<'g, T: 'g> { /* fields omitted */ }

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.

Methods

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

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

Returns a new null pointer.

Examples

use crossbeam_epoch::Shared;

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

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());

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);

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 possiblity 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);
}

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 possiblity 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));
}

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());
}

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(5));
let guard = &epoch::pin();
let p = a.load(SeqCst, guard);
assert_eq!(p.tag(), 5);

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(5);

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

Trait Implementations

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

impl<'g, T> From<*const T> for Shared<'g, 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 = unsafe { Shared::from(Box::into_raw(Box::new(1234)) as *const _) };
assert!(!p.is_null());

impl<'g, T> 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 ==.

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

This method tests for !=.

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

impl<'g, T> 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.

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

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

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

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

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

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

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<'g, T> Ord for Shared<'g, T>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the "default value" for a type.