Struct scc::ebr::Guard

pub struct Guard { /* private fields */ }

Guard allows the user to read AtomicShared and keeps the underlying instance pinned to the thread.

Guard internally prevents the global epoch value from passing through the value announced by the current thread, thus keeping reachable instances in the thread from being garbage collected.

Implementations

impl Guard

pub fn new() -> Self

Creates a new Guard.

Panics

The maximum number of Guard instances in a thread is limited to u32::MAX; a thread panics when the number of Guard instances in the thread exceeds the limit.

Examples

use scc::ebr::Guard;

let guard = Guard::new();

pub fn defer(&self, collectible: Box<dyn Collectible>)

Defers dropping and memory reclamation of the supplied Box of a type implementing Collectible.

Examples

use scc::ebr::{Guard, Collectible};
use std::ptr::NonNull;

struct C(usize, Option<NonNull<dyn Collectible>>);

impl Collectible for C {
    fn next_ptr_mut(&mut self) -> &mut Option<NonNull<dyn Collectible>> {
        &mut self.1
    }
}

let boxed: Box<C> = Box::new(C(7, None));

let static_ref: &'static C = unsafe { std::mem::transmute(&*boxed) };

let guard = Guard::new();
guard.defer(boxed);

assert_eq!(static_ref.0, 7);

pub fn defer_execute<F: 'static + FnOnce() + Sync>(&self, f: F)

Executes the supplied closure at a later point of time.

It is guaranteed that the closure will be executed after every Guard at the moment when the method was invoked is dropped, however it is totally non-deterministic when exactly the closure will be executed.

Note that the supplied closure is stored in the heap memory, and it has to be Sync as it can be referred to by another thread.

Examples

use scc::ebr::Guard;

let guard = Guard::new();
guard.defer_execute(|| println!("deferred"));

Trait Implementations

impl Default for Guard

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Guard

fn drop(&mut self)

Executes the destructor for this type.

impl UnwindSafe for Guard