Questions about "crossbeam_epoch" about crossbeam HOT 10 CLOSED

Unlike std's compare_exchange, Atomic::compare_exchange returns the value that was written. Not sure why it behaves differently from std.

from crossbeam.

This is an occasional problem that will recur after executing "cargo run" multiple times.

from crossbeam.

I believe the error itself is the result of use-after-free.

It is wrong to use the Relaxed ordering everywhere when handling pointers, and the orderings of load in the first spawn and the success ordering of compare_exchange in the second spawn have to be Acquire (load), AcqRel (compare_exchange). The problem may not be only that, though.

from crossbeam.

It seems that this is not the problem. I changed the code to use SeqCst and still get the same error.

from crossbeam.

I tried changing it to this

a.load(Ordering::Acquire, guard)

a.compare_exchange(shared, Owned::new(A(i.to_string())),
                                          Ordering::AcqRel, Ordering::AcqRel, guard)

It results in an error every time it is executed

If 'SeqCst' is used, the probability of errors will be much lower, but there will still be errors

from crossbeam.

            loop {
                let shared = a.load(Ordering::Relaxed, guard);
                match a.compare_exchange(shared, Owned::new(A(i.to_string())),
                                         Ordering::Relaxed, Ordering::Relaxed, guard) {
                    Ok(rs) => {
                        unsafe {
                            guard.defer_destroy(rs);
                        }
                        break;
                    }
                    Err(_e) => {
                        // shared = e.current;
                    }
                }
            }

Writing like this still leads to errors.If possible, please tell me how to modify it, thank you

from crossbeam.

defer_destroy(shared)

from crossbeam.

defer_destroy(shared)

Am I using the wrong method

from crossbeam.

struct A(String);

fn main() {
    let a = Arc::new(Atomic::new(A("0".to_string())));
    for _ in 1..100 {
        let a = a.clone();
        thread::spawn(move || {
            let guard = &crossbeam_epoch::pin();
-            let mut shared = a.load(Ordering::Relaxed, guard);
+            let mut shared = a.load(Ordering::Acquire, guard);
            unsafe {
                println!("{}",shared.as_ref().unwrap().0);
            }
        });
    }
    for i in 1..100 {
        let a = a.clone();
        thread::spawn(move || {
            let guard = &crossbeam_epoch::pin();
            let mut shared = a.load(Ordering::Relaxed, guard);
            loop {
                match a.compare_exchange(shared, Owned::new(A(i.to_string())),
-                                          Ordering::Relaxed, Ordering::Relaxed, guard) {
+                                          Ordering::AcqRel, Ordering::Relaxed, guard) {
                    Ok(rs) => {
                        unsafe {
-                            guard.defer_destroy(rs);
+                            guard.defer_destroy(shared);
                        }
                        break;
                    }
                    Err(e) => {
                        shared = e.current;
                    }
                }
            }
        });
    }
}

from crossbeam.

                        unsafe {
-                            guard.defer_destroy(rs);
+                            guard.defer_destroy(shared);
                        }

Thank you. This has solved the above problem

from crossbeam.