Struct incr::AtomicIncr

pub struct AtomicIncr(/* private fields */);

AtomicIncr is a threadsafe, yet very fast counter, utilizing compare and swap instructions to provide speed and safety in the same package. There are some cases where 5ns matters. But in many, many other situations, it’s a perfectly good decision to just use the AtomicIncr, knowing it can handle anything, and move on to other problems.

Examples

use std::thread::{spawn, JoinHandle};
use std::sync::{Arc, Barrier};
use incr::AtomicIncr;

let last: AtomicIncr = Default::default();
let barrier = Arc::new(Barrier::new(2));
let thread: JoinHandle<u64> = {
    let barrier = Arc::clone(&barrier);
    let last = last.clone();
    spawn(move || {
        assert_eq!(last.is_new(2), true);
        assert_eq!(last.is_new(3), true);
        assert_eq!(last.is_new(3), false);
        barrier.wait();
        last.get()
    })
};
barrier.wait();
assert_eq!(last.is_new(3), false);
assert_eq!(thread.join().unwrap(), 3);

It’s also possible to access the inner Arc<AtomicU64> by consuming the outer wrapper:

use incr::AtomicIncr;

#[cfg(feature = "nightly")]
type Atomic = AtomicU64;
#[cfg(not(feature = "nightly"))]
type Atomic = AtomicUsize;

let stop = Arc::new(AtomicBool::new(false));
let last: AtomicIncr = Default::default();
let mut threads = Vec::new();
for _ in 0..5 {
    let val: Arc<Atomic> = last.clone().into_inner();
    let stop = Arc::clone(&stop);
    threads.push(thread::spawn(move || {
        loop {
            val.fetch_add(1, Ordering::Relaxed);
            thread::yield_now();
            if stop.load(Ordering::Relaxed) { break }
        }
    }));
}

let mut i = 1;

for _ in 0..100 {
    i = match last.is_new(i) {
        true => i + 1,
        false => i.max(last.get()),
    };
}
stop.store(true, Ordering::SeqCst);

Implementations

impl AtomicIncr

pub fn is_new(&self, val: u64) -> bool

Returns true if val is greater than the highest previously observed value. If val is a new maximum, it is stored in self for checks against future values subsequent calls Self::get(&self) will return val until a new max is observed.

pub fn get(&self) -> u64

Returns the current value of self, which is the maximum observed value.

pub fn into_inner(self) -> Arc<AtomicU64>

Consumes the outer struct, returning the inner Arc<Atomic>.

Trait Implementations

impl Clone for AtomicIncr

fn clone(&self) -> AtomicIncr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AtomicIncr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AtomicIncr

fn default() -> AtomicIncr

Returns the “default value” for a type.

impl From<u64> for AtomicIncr

fn from(val: u64) -> Self

Converts to this type from the input type.

impl PartialEq<AtomicIncr> for AtomicIncr

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<AtomicIncr> for AtomicIncr

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for AtomicIncr