kovan 0.1.12

High-performance wait-free memory reclamation for lock-free data structures. Bounded memory usage, predictable latency.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

//! Simple example demonstrating Kovan's basic API

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

fn main() {
    // Create an atomic pointer to a heap-allocated value
    let atomic = Atomic::new(Box::into_raw(Box::new(42)));

    // Enter a critical section
    let guard = pin();

    // Load the pointer (zero overhead - single atomic read)
    let ptr = atomic.load(Ordering::Acquire, &guard);

    // Access the value safely within the guard's lifetime
    unsafe {
        if let Some(value) = ptr.as_ref() {
            println!("Value: {}", value);
            assert_eq!(*value, 42);
        }
    }

    // Update the value using compare-exchange
    let new_value = Box::into_raw(Box::new(100));
    match atomic.compare_exchange(
        ptr,
        unsafe { Shared::from_raw(new_value) },
        Ordering::AcqRel,
        Ordering::Acquire,
        &guard,
    ) {
        Ok(_) => println!("Successfully updated value"),
        Err(_) => println!("Update failed"),
    }

    // Load the new value
    let new_ptr = atomic.load(Ordering::Acquire, &guard);
    unsafe {
        if let Some(value) = new_ptr.as_ref() {
            println!("New value: {}", value);
            assert_eq!(*value, 100);
        }
    }

    // Guard is dropped here, allowing memory reclamation
    drop(guard);

    println!("Example completed successfully!");
}