Struct hytra::TrAdder

pub struct TrAdder<T: Copy + Zero + Add<T, Output = T> + Send>(_);

The threaded add allows to increment and decrement an integer from multiple threads without contention, which allows performance to scale well with the number of thread/processors. TrAdder can wrap any primitive integer type.

Overflow behavior. Overflow may occur if the sum of the increments in any subset of the threads overflows, even if the total leads to no overflow. Overflow semantic is the same as for primitive types (panic or wrapping).

See TrAcc for a discussion of performance characteristics.

use hytra::TrAdder;
let adder: TrAdder<i64> = TrAdder::new();
crossbeam_utils::thread::scope(|s| {
    for _ in 0..10 {
        s.spawn(|_| {
            for _ in 0..10 {
                adder.inc(1);
            }
        });
    }
})
.unwrap();
assert_eq!(adder.get(), 100);

Implementations

impl<T: Copy + Zero + Add<T, Output = T> + Send> TrAdder<T>

pub fn new() -> Self

Create a new TrAdder initialized to 0.

pub fn inc(&self, x: T)

Increment the TrAdder.

pub fn get(&self) -> T

Return the value of the TrAdder.

Trait Implementations

impl<T: Debug + Copy + Zero + Add<T, Output = T> + Send> Debug for TrAdder<T>

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

Formats the value using the given formatter.

impl<T: Copy + Zero + Add<T, Output = T> + Send> Default for TrAdder<T>

fn default() -> Self

Returns the “default value” for a type.