Struct Atomic 

pub struct Atomic<T> { /* private fields */ }

A pointer to a heap-allocated value with atomic operations.

This type provides atomic load, store, and compare-exchange operations on pointers to T. Memory reclamation is handled automatically through the guard-based protocol.

Examples

use kovan::{Atomic, pin};
use std::sync::atomic::Ordering;

let atomic = Atomic::new(Box::into_raw(Box::new(42)));
let guard = pin();
let ptr = atomic.load(Ordering::Acquire, &guard);

Implementations

impl<T> Atomic<T>

pub fn new(ptr: *mut T) -> Self

Creates a new atomic pointer.

Examples

use kovan::Atomic;

let atomic: Atomic<i32> = Atomic::new(std::ptr::null_mut());

pub fn null() -> Self

Creates a null atomic pointer.

pub fn load<'g>(&self, order: Ordering, _guard: &'g Guard) -> Shared<'g, T>

Loads a pointer from the atomic.

This operation has zero overhead - it’s just a single atomic load.

Examples

use kovan::{Atomic, pin};
use std::sync::atomic::Ordering;

let atomic = Atomic::new(Box::into_raw(Box::new(42)));
let guard = pin();
let ptr = atomic.load(Ordering::Acquire, &guard);

pub fn store(&self, ptr: Shared<'_, T>, order: Ordering)

Stores a pointer into the atomic.

Examples

use kovan::{Atomic, Shared};
use std::sync::atomic::Ordering;

let atomic = Atomic::new(std::ptr::null_mut());
let ptr = Box::into_raw(Box::new(42));
unsafe {
    atomic.store(Shared::from_raw(ptr), Ordering::Release);
}

pub fn compare_exchange<'g>( &self, current: Shared<'_, T>, new: Shared<'_, T>, success: Ordering, failure: Ordering, _guard: &'g Guard, ) -> Result<Shared<'g, T>, Shared<'g, T>>

Compares and exchanges the pointer.

Examples

use kovan::{Atomic, Shared, pin};
use std::sync::atomic::Ordering;

let atomic = Atomic::new(Box::into_raw(Box::new(42)));
let guard = pin();
let current = atomic.load(Ordering::Acquire, &guard);
let new = Box::into_raw(Box::new(43));
unsafe {
    atomic.compare_exchange(
        current,
        Shared::from_raw(new),
        Ordering::AcqRel,
        Ordering::Acquire,
        &guard
    );
}

pub fn compare_exchange_weak<'g>( &self, current: Shared<'_, T>, new: Shared<'_, T>, success: Ordering, failure: Ordering, _guard: &'g Guard, ) -> Result<Shared<'g, T>, Shared<'g, T>>

Compares and exchanges the pointer (weak version).

This version may spuriously fail even when the comparison succeeds.

pub fn swap<'g>( &self, new: Shared<'_, T>, order: Ordering, _guard: &'g Guard, ) -> Shared<'g, T>

Swaps the pointer with a new value.

Trait Implementations

impl<T> Default for Atomic<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Send + Sync> Send for Atomic<T>

impl<T: Send + Sync> Sync for Atomic<T>