results

lunch-box. ./bar --bench

running 3 tests
test cas   ... bench:    561344 ns/iter (+/- 116303)
test check ... bench:    194280 ns/iter (+/- 18843)
test inc   ... bench:    156670 ns/iter (+/- 4068)

test result: ok. 0 passed; 0 failed; 0 ignored; 3 measured

lunch-box. ./bar --bench

running 3 tests
test cas   ... bench:    520250 ns/iter (+/- 82140)
test check ... bench:    172600 ns/iter (+/- 1340)
test inc   ... bench:    154067 ns/iter (+/- 1998)

test result: ok. 0 passed; 0 failed; 0 ignored; 3 measured

so somewhere around 10%-20% hit on this machine, acrichto saw better results.

zed.rs

#![feature(core)]
#![feature(test)]

extern crate test;

use std::intrinsics::abort;
use std::thread;
use std::sync::Arc;
use std::sync::atomic::{AtomicIsize, Ordering};

const N: isize = 1000;
const M: isize = 5;

fn cas_inc(slot: &AtomicIsize) {
    loop {
        let val = slot.load(Ordering::SeqCst);
        if slot.compare_and_swap(val, val + 1, Ordering::SeqCst) == val {
            break
        }
    }
}

fn atomic_inc(slot: &AtomicIsize) {
    slot.fetch_add(1, Ordering::SeqCst);
}

fn atomic_inc_check(slot: &AtomicIsize) {
    let x = slot.fetch_add(1, Ordering::SeqCst);
    if x < 0 {
        unsafe { abort(); }
    }
}

fn doit(inc: fn(&AtomicIsize)) {
    let n = Arc::new(AtomicIsize::new(0));
    let children = (0..M).map(|_| {
        let n = n.clone();
        thread::spawn(move || {
            for _ in 0..N {
                inc(&n);
            }
        })
    }).collect::<Vec<_>>();
    for child in children {
        let _ = child.join();
    }
    assert_eq!(n.load(Ordering::SeqCst), N * M);
}

#[bench]
fn cas(b: &mut test::Bencher) {
    b.iter(|| doit(cas_inc));
}

#[bench]
fn inc(b: &mut test::Bencher) {
    b.iter(|| doit(atomic_inc));
}

#[bench]
fn check(b: &mut test::Bencher) {
    b.iter(|| doit(atomic_inc_check));
}