Struct peril::HazardScope

pub struct HazardScope<'registry, 'hazard, T: Send + 'registry> { /* fields omitted */ }

is the scope where the HazardPointer can be safely read

Examples

use peril::{HazardRegistry, HazardValue, HazardRecord, HazardPointer, Ordering};

let registry = HazardRegistry::default();
let hp = HazardPointer::new(HazardValue::boxed("test"), &registry);
let mut record = HazardRecord::default();
loop {
    let scope = hp.protect(&mut record);
    // ...
    if scope.compare_exchange_weak(HazardValue::dummy(0), Ordering::Relaxed, Ordering::Relaxed).is_ok()
    {
        break;
    }
}

Implementations

impl<'registry, 'hazard, T: Send + 'registry> HazardScope<'registry, 'hazard, T>

pub fn compare_exchange_weak(
    self,
    new: HazardValue<'registry, T>,
    success: Ordering,
    failure: Ordering
) -> Result<HazardValue<'registry, T>, HazardValue<'registry, T>>

compare_exchange_weak version of HazardPointer that needs to use a protected HazardScope as the current value (comperator) is saved when the potection starts so that the value can be safely read and copied. When the CAS succeeds it will return the previous value held by the HazardPointer and when the CAS fails it will return the new value we just provided. for more detail see compare_exchange_weak

Arguments

• new - the new value the HazardPointer should have when the CAS succeeds (and returned when the CAS fails)
• success - the Ordering when the CAS succeeds
• failure - the Ordering when the CAS fails
• return - Result wrapping the old value if the CAS succeeds or the new value if it failed

Examples

use peril::{HazardRegistry, HazardValue, HazardRecord, HazardPointer, Ordering};

let registry = HazardRegistry::default();
let hp = HazardPointer::new(HazardValue::boxed("test"), &registry);
let mut record = HazardRecord::default();
loop {
    let scope = hp.protect(&mut record);
    // ...
    if scope.compare_exchange_weak(HazardValue::dummy(0), Ordering::Relaxed, Ordering::Relaxed).is_ok()
    {
        break;
    }
}

pub fn compare_exchange(
    self,
    new: HazardValue<'registry, T>,
    success: Ordering,
    failure: Ordering
) -> Result<HazardValue<'registry, T>, HazardValue<'registry, T>>

compare_exchange version of HazardPointer that needs to use a protected HazardScope as the current value (comperator) is saved when the potection starts so that the value can be safely read and copied. When the CAS succeeds it will return the previous value held by the HazardPointer and when the CAS fails it will return the new value we just provided. for more detail see compare_exchange

Arguments

• new - the new value the HazardPointer should have when the CAS succeeds (and returned when the CAS fails)
• success - the Ordering when the CAS succeeds
• failure - the Ordering when the CAS fails
• return - Result wrapping the old value if the CAS succeeds or the new value if it failed

Examples

use peril::{HazardRegistry, HazardValue, HazardRecord, HazardPointer, Ordering};

let registry = HazardRegistry::default();
let hp = HazardPointer::new(HazardValue::boxed("test"), &registry);
let mut record = HazardRecord::default();
loop {
    let scope = hp.protect(&mut record);
    // ...
    if scope.compare_exchange(HazardValue::dummy(0), Ordering::Relaxed, Ordering::Relaxed).is_ok()
    {
        break;
    }
}

pub fn is_dummy(&self) -> bool

check if the protected value is a dummy

Examples

use peril::{HazardRegistry, HazardValue, HazardRecord, HazardPointer};

let registry = HazardRegistry::<usize>::default();
let hp = HazardPointer::new(HazardValue::dummy(0), &registry);
let mut record = HazardRecord::default();
loop {
    let scope = hp.protect(&mut record);
    assert!(scope.is_dummy());
    // ...
    break;
}

pub fn as_dummy(&self) -> Option<usize>

read the dummy (pointer) value of a HazardPointer

Examples

use peril::{HazardRegistry, HazardValue, HazardRecord, HazardPointer};

let registry = HazardRegistry::<usize>::default();
let hp = HazardPointer::new(HazardValue::dummy(1337), &registry);
let mut record = HazardRecord::default();
loop {
    let scope = hp.protect(&mut record);
    assert!(scope.as_dummy().unwrap() == 1337);
    // ...
    break;
}

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

read the boxed value of a HazardPointer and returns None if the value is a dummy

Examples

use peril::{HazardRegistry, HazardValue, HazardRecord, HazardPointer, Ordering};

let registry = HazardRegistry::default();
let hp = HazardPointer::new(HazardValue::boxed(0), &registry);
let mut record = HazardRecord::default();
loop {
    let scope = hp.protect(&mut record);
    let new = *(scope.as_ref().unwrap()) + 1;
    match scope.compare_exchange(HazardValue::boxed(new), Ordering::Relaxed, Ordering::Relaxed)
    {
        Ok(old) =>
        {
            assert!(old.as_ref().unwrap() == &0);
            break;
        }
        Err(_) => assert!(false),
    }
}

Trait Implementations

impl<'registry, 'hazard, T: Send + 'registry> Drop for HazardScope<'registry, 'hazard, T>

pub fn drop(&mut self)

Executes the destructor for this type.