Benchmarks for various Atomic and non-Atomic operations

bench.rs

#![feature(test, integer_atomics)]

// On my computer.
//
// test bench_increment_arc_data                        ... bench:  28,315,200 ns/iter (+/- 3,614,573)
// test bench_increment_cell_data                       ... bench:   3,905,437 ns/iter (+/- 826,350)
// test bench_increment_raw_data                        ... bench:   3,895,535 ns/iter (+/- 1,103,250)
// test bench_increment_rc_data                         ... bench:   3,771,218 ns/iter (+/- 682,398)
// test bench_spawn_thread_and_increment                ... bench:  34,876,612 ns/iter (+/- 4,553,297)
// test bench_spawn_thread_and_increment_f64            ... bench:  55,028,376 ns/iter (+/- 6,402,499)
// test bench_spawn_thread_and_increment_in_main_thread ... bench:  34,017,719 ns/iter (+/- 4,072,940)
// test bench_test_equality                             ... bench:  15,395,895 ns/iter (+/- 2,963,628)
// test bench_test_none                                 ... bench:  15,121,100 ns/iter (+/- 2,915,482)
//
// test result: ok. 0 passed; 0 failed; 0 ignored; 9 measured; 0 filtered out
//

extern crate test;

use test::Bencher;
use std::cell::Cell;
use std::rc::Rc;

use std::sync::Arc;
use std::f64;
use std::sync::atomic::{Ordering, AtomicPtr, AtomicU64};

#[bench]
fn bench_increment_cell_data(b: &mut Bencher) {
    b.iter(|| {
        let cell = Cell::new(0u64);
        for _ in 0..10_000_000 {
            let x = cell.get();
            test::black_box(cell.set(x + 1));
        }
    });
}

#[bench]
fn bench_spawn_thread_and_increment(b: &mut Bencher) {
    let mut val = 0.0f64;
    let cell = Arc::new(AtomicPtr::new(&mut val as *mut f64));
    let another = cell.clone();
    b.iter(|| {
        let child = std::thread::spawn(move || {
            test::black_box(0);
        });
        for _ in 0..10_000_000 {
            let x = another.load(Ordering::Relaxed);
            unsafe {
                test::black_box(*x = *x + 1.0);
            }
        }
        child.join();
    });
}

#[bench]
fn bench_spawn_thread_and_increment_in_main_thread(b: &mut Bencher) {
    let cell = Rc::new(Cell::new(0f64));
    let another = cell.clone();
    b.iter(|| {
        let child = std::thread::spawn(move || {
            test::black_box(0);
        });

        for _ in 0..10_000_000 {
            let x = another.get();
            test::black_box(another.set(x + 1.0));
        }
        child.join();
    });
}

#[bench]
fn bench_spawn_thread_and_increment_f64(b: &mut Bencher) {
    let cell = Arc::new(AtomicU64::new(0));
    let another = cell.clone();
    b.iter(|| {
        let child = std::thread::spawn(move || {
            test::black_box(0);
        });

        for _ in 0..10_000_000 {
            let f: f64 = f64::from_bits((*another).load(Ordering::Relaxed)); 
            test::black_box((*another).store((f + 1.0).to_bits(), Ordering::Relaxed));
        }
        child.join();
    });
}

#[bench]
fn bench_increment_raw_data(b: &mut Bencher) {
    b.iter(|| {
        let mut val = 0u64;
        for _ in 0..10_000_000 {
            let x = val;
            test::black_box(val = x + 1);
        }
    });
}

#[bench]
fn bench_increment_rc_data(b: &mut Bencher) {
    b.iter(|| {
        let cell = Rc::new(Cell::new(0u64));
        let another = cell.clone();
        for _ in 0..10_000_000 {
            let x = another.get();
            test::black_box(another.set(x + 1));
        }
    });
}

#[bench]
fn bench_increment_arc_data(b: &mut Bencher) {
    b.iter(|| {
        let cell = Arc::new(Cell::new(0u64));
        let another = cell.clone();
        for _ in 0..10_000_000 {
            let x = another.get();
            test::black_box(another.set(x + 1));
        }
    });
}

#[bench]
fn bench_test_equality(b: &mut Bencher) {
    let one = 1.0;
    let one_plus_one = 1.0 + 1.0;
    b.iter(|| {
        for _ in 0..10_000_000 {
            if one_plus_one == one {
                panic!()
            }
            test::black_box(one);
        }
    });
}

#[bench]
fn bench_test_none(b: &mut Bencher) {
    let none: Option<f64> = None;
    b.iter(|| {
        for _ in 0..10_000_000 {
            if let Some(s) = none {
                panic!();
            }
            test::black_box(none);
        }
    });
}