Struct crossbeam_epoch::Shared [−][src]
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>
[src]
pub fn as_raw(&self) -> *const T
[src]
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>
[src]
pub fn null() -> Shared<'g, T>
[src]
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
[src]
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
[src]
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:
- A thread creates a new object:
a.store(Owned::new(10), Relaxed)
- 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
[src]
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>
[src]
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:
- A thread creates a new object:
a.store(Owned::new(10), Relaxed)
- 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>
[src]
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 fn tag(&self) -> usize
[src]
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>
[src]
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>
[src]
fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: ?Sized + Pointable> Copy for Shared<'_, T>
[src]
impl<T: ?Sized + Pointable> Debug for Shared<'_, T>
[src]
impl<T: ?Sized + Pointable> Default for Shared<'_, T>
[src]
impl<T: ?Sized + Pointable> Eq for Shared<'_, T>
[src]
impl<T> From<*const T> for Shared<'_, T>
[src]
impl<'g, T: ?Sized + Pointable> From<Shared<'g, T>> for Atomic<T>
[src]
fn from(ptr: Shared<'g, T>) -> Self
[src]
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>
[src]
fn cmp(&self, other: &Self) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<'g, T: ?Sized + Pointable> PartialEq<Shared<'g, T>> for Shared<'g, T>
[src]
impl<'g, T: ?Sized + Pointable> PartialOrd<Shared<'g, T>> for Shared<'g, T>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T: ?Sized + Pointable> Pointer for Shared<'_, T>
[src]
impl<T: ?Sized + Pointable> Pointer<T> for Shared<'_, T>
[src]
fn into_usize(self) -> usize
[src]
unsafe fn from_usize(data: usize) -> Self
[src]
Auto Trait Implementations
impl<'g, T: ?Sized> RefUnwindSafe for Shared<'g, T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<'g, T> !Send for Shared<'g, T>
impl<'g, T> !Sync for Shared<'g, T>
impl<'g, T: ?Sized> Unpin for Shared<'g, T>
impl<'g, T: ?Sized> UnwindSafe for Shared<'g, T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,