slide-rs / atom Goto Github PK

    // https://doc.rust-lang.org/std/sync/atomic/struct.AtomicPtr.html#method.compare_and_swap
    pub fn compare_and_swap(
        &self,
        current: Option<&P>,
        new: Option<P>,
        order: Ordering,
    ) -> Result<Option<P>, (Option<P>, *mut P)>;

    // https://doc.rust-lang.org/std/sync/atomic/struct.AtomicPtr.html#method.compare_exchange
    pub fn compare_exchange(
        &self,
        current: Option<&P>,
        new: Option<P>,
        success: Ordering,
        failure: Ordering,
    ) -> Result<Option<P>, (Option<P>, *mut P)>;

    // https://doc.rust-lang.org/std/sync/atomic/struct.AtomicPtr.html#method.compare_exchange_weak
    pub fn compare_exchange_weak(
        &self,
        current: Option<&P>,
        new: Option<P>,
        success: Ordering,
        failure: Ordering,
    ) -> Result<Option<P>, (Option<P>, *mut P)>;

#![deny(unsafe_code)]
use atom::Atom;
use std::sync::atomic::Ordering;

fn main() {
    let channel = &*Box::leak(Box::new(Atom::<&&'static u32>::new(&&42u32)));

    std::thread::spawn(move || loop {
        if let Some(ptr) = channel.take(Ordering::Relaxed) {
            assert_eq!(**ptr, 42);
        }
    });

    for i in 0..10000000 {
        let b = Box::leak(Box::new(&42u32));
        channel.swap(b, Ordering::Relaxed);
    }
}

#![forbid(unsafe_code)]

extern crate atom;

use atom::Atom;
use std::rc::Rc;
use std::sync::mpsc;
use std::{thread, time, mem};

const NUM_CLONES: usize = 10000000;

fn main() {
    let x = Rc::new(());
    let y = Rc::clone(&x);

    // Place our Rc in the Atom through a Box.
    let shared_atom = Atom::empty();
    shared_atom.swap(Box::new(x));

    let child = thread::spawn(move || {
        // We now have the Rc shared across a thread.
        let x = shared_atom.take().unwrap();
        for _ in 0..NUM_CLONES {
            let clone = x.clone();
            mem::forget(clone);
        }
    });

    for _ in 0..NUM_CLONES {
        let clone = y.clone();
        mem::forget(clone);
    }

    // Wait for the spawned thread to finish its cloning.
    child.join().unwrap();

    // We made NUM_CLONES on both threads plus 2 references in the main thread.
    // But in reality we'll see that the strong_count varies across every run.
    assert_eq!(Rc::strong_count(&y), (NUM_CLONES * 2) + 2);
}

#[test]
fn dup_panic_safety() {
    struct WeirdTy(String);

    impl Clone for WeirdTy {
        fn clone(&self) -> Self {
            panic!("")
        }
    }

    let x = AtomSetOnce::new(Box::new(WeirdTy("hoge".to_owned())));
    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        x.dup(Ordering::Acquire); // `v.clone()` panics, skipping `mem::forget(v)` and dropping `Box<WeirdTy>`
    }));
    // The `Box<WeirdTy>` is dropped again, causing a double-free
}

trait Engine {
    fn eval(&self) -> String;
}

struct JSEngine {
    name: String,
}

impl Engine for JSEngine {
    fn eval(&self) -> String {
        "js eval".to_string()
    }
}

fn main() {
    let engine: Arc<dyn Engine> = Arc::new(JSEngine {
        name: "js1".to_string(),
    });
    println!("Results: {}", engine.eval());

    let shared_atom = Atom::new(engine);
}