Struct RcuCell

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

A concurrent data structure that allows for safe, read-copy-update (RCU) style access to its value.

Implementations

impl<T> RcuCell<T>

pub fn new(value: T) -> Self

Creates a new RcuCell with the given initial value.

This function initializes a new RcuCell instance, setting its initial value to the provided value.

Arguments

• value - The initial value to store in the RcuCell.

Returns

A new instance of RcuCell containing the provided initial value.

Example

let rcu_cell = rcu_128::RcuCell::new(42);

Examples found in repository

examples/example.rs (line 6)

fn main() {
    let x = rcu_128::RcuCell::new(0);
    std::thread::scope(|s| {
        s.spawn(|| {
            for i in 0..40 {
                let t = Instant::now();
                if i < 20 {
                    x.write(i);
                } else {
                    x.update(|v| v + 1);
                }
                println!("Update {i} used time: {:?}", t.elapsed());
                sleep((t + Duration::from_millis(100)).duration_since(Instant::now()));
            }
        });
        s.spawn(|| {
            // Always has 4 guards alive
            let mut guards = [x.read(), x.read(), x.read(), x.read()];
            for idx in 0..400 {
                let r = x.read();
                println!("Read value: {}", *r);
                guards[idx % 4] = r;
                sleep(Duration::from_millis(10));
            }
        });
    })
}

pub fn read(&self) -> RcuGuard<'_, T>

Provides read access to the value stored in the RcuCell.

This function returns an RcuGuard, which allows for safe, concurrent read access to the RcuCell’s value.

Once all RcuGuard instances referencing a particular value are dropped, the value can be safely released during an update or write.

Example

let rcu_cell = rcu_128::RcuCell::new(42);
{
    let guard = rcu_cell.read();
    assert_eq!(*guard, 42);
}

Examples found in repository

examples/example.rs (line 22)

fn main() {
    let x = rcu_128::RcuCell::new(0);
    std::thread::scope(|s| {
        s.spawn(|| {
            for i in 0..40 {
                let t = Instant::now();
                if i < 20 {
                    x.write(i);
                } else {
                    x.update(|v| v + 1);
                }
                println!("Update {i} used time: {:?}", t.elapsed());
                sleep((t + Duration::from_millis(100)).duration_since(Instant::now()));
            }
        });
        s.spawn(|| {
            // Always has 4 guards alive
            let mut guards = [x.read(), x.read(), x.read(), x.read()];
            for idx in 0..400 {
                let r = x.read();
                println!("Read value: {}", *r);
                guards[idx % 4] = r;
                sleep(Duration::from_millis(10));
            }
        });
    })
}

pub fn write(&self, value: T)

Writes a new value into the RcuCell.

This function immediately writes the new value into the RcuCell. It will block until all current readers have finished reading the old value.

Once all readers have completed their read operations, the old value will be safely released.

Arguments

• value - The new value to store in the RcuCell.

Example

let rcu_cell = rcu_128::RcuCell::new(42);
rcu_cell.write(100);
{
    let guard = rcu_cell.read();
    assert_eq!(*guard, 100);
}

Examples found in repository

examples/example.rs (line 12)

fn main() {
    let x = rcu_128::RcuCell::new(0);
    std::thread::scope(|s| {
        s.spawn(|| {
            for i in 0..40 {
                let t = Instant::now();
                if i < 20 {
                    x.write(i);
                } else {
                    x.update(|v| v + 1);
                }
                println!("Update {i} used time: {:?}", t.elapsed());
                sleep((t + Duration::from_millis(100)).duration_since(Instant::now()));
            }
        });
        s.spawn(|| {
            // Always has 4 guards alive
            let mut guards = [x.read(), x.read(), x.read(), x.read()];
            for idx in 0..400 {
                let r = x.read();
                println!("Read value: {}", *r);
                guards[idx % 4] = r;
                sleep(Duration::from_millis(10));
            }
        });
    })
}

pub fn update(&self, f: impl FnOnce(&T) -> T)

Updates the value stored in the RcuCell using a provided function.

This function applies the given closure f to the current value stored in the RcuCell, replacing it with the new value returned by the closure. It will block until all current readers have finished reading the old value.

Once all readers have completed their read operations, the old value will be safely released.

Arguments

• f - A closure that takes a reference to the current value and returns a new value to store in the RcuCell.

Example

let rcu_cell = rcu_128::RcuCell::new(42);
rcu_cell.update(|&old_value| old_value + 1);
{
    let guard = rcu_cell.read();
    assert_eq!(*guard, 43);
}

Examples found in repository

examples/example.rs (line 14)

fn main() {
    let x = rcu_128::RcuCell::new(0);
    std::thread::scope(|s| {
        s.spawn(|| {
            for i in 0..40 {
                let t = Instant::now();
                if i < 20 {
                    x.write(i);
                } else {
                    x.update(|v| v + 1);
                }
                println!("Update {i} used time: {:?}", t.elapsed());
                sleep((t + Duration::from_millis(100)).duration_since(Instant::now()));
            }
        });
        s.spawn(|| {
            // Always has 4 guards alive
            let mut guards = [x.read(), x.read(), x.read(), x.read()];
            for idx in 0..400 {
                let r = x.read();
                println!("Read value: {}", *r);
                guards[idx % 4] = r;
                sleep(Duration::from_millis(10));
            }
        });
    })
}