Code shared from the Rust Playground

playground.rs

fn main() {
    use loom::sync::atomic::AtomicU32;
    use loom::sync::atomic::Ordering::*;
    use loom::sync::Mutex;

    loom::model(|| {
        println!("========");
        loom::lazy_static! {
            static ref LOCK: AtomicU32 = AtomicU32::new(0);
            static ref DATA: AtomicU32 = AtomicU32::new(0);
            static ref OBSERVED: Mutex<u32> = Mutex::new(21);
        }

        fn t1() {
            DATA.store(42, Relaxed);
            println!("t1 STORE DATA = 42 (relaxed)");
            LOCK.store(1, Release);
            println!("t1 STORE LOCK = 1 (release)");
        }

        fn t2() {
            let prev = LOCK.swap(2, AcqRel);
            println!("t2 SWAP LOCK {} to 2 (acqrel)", prev);
            let loaded = DATA.load(Relaxed);
            println!("t2 LOAD DATA = {} (relaxed)", loaded);
            *OBSERVED.lock().unwrap() = loaded;
            println!("t2 STORE OBSERVED = {} (mutex)", loaded);
        }

        fn t3() {
            let v1 = LOCK.fetch_add(0, Relaxed);
            println!("t3 LOAD LOCK = {} (relaxed)", v1);
            let v2 = LOCK.fetch_add(0, Relaxed);
            println!("t3 LOAD LOCK = {} (relaxed)", v2);
            match [v1, v2] {
                [1, 2] => {
                    loop {
                        let val = *OBSERVED.lock().unwrap();
                        if val != 21 {
                            println!("t3 LOAD OBSERVED = {} (mutex)", val);
                            break;
                        }
                        println!("t3 LOAD OBSERVED = 21 (mutex)");
                        loom::thread::yield_now();
                    }
                    let x = *OBSERVED.lock().unwrap();
                    println!("t3 LOAD OBSERVED = {} (mutex)", x);
                    assert_eq!(x, 42, "x is {:?}", x);
                }
                _ => (),
            }
        }

        let t1 = loom::thread::spawn(t1);
        let t2 = loom::thread::spawn(t2);
        let t3 = loom::thread::spawn(t3);
        t1.join().unwrap();
        t2.join().unwrap();
        t3.join().unwrap();
    });
}