simplify miri weak memory test

Author: joboet

src/tools/miri/tests/pass/weak_memory/weak.rs

@@ -9,7 +9,7 @@
 
 use std::sync::atomic::Ordering::*;
 use std::sync::atomic::{AtomicUsize, fence};
-use std::thread::{spawn, yield_now};
+use std::thread::{spawn, scope, yield_now};
 
 #[allow(dead_code)]
 #[derive(Copy, Clone)]
@@ -31,67 +31,97 @@ fn reads_value(loc: &AtomicUsize, val: usize) -> usize {
     val
 }
 
+/// Runs a, b and c in order, but without establishing any synchronization
+/// between them.
+fn execute_unsynchronized<R: Send>(
+    a: impl FnOnce() + Send,
+    b: impl FnOnce() + Send,
+    c: impl FnOnce() -> R + Send,
+) -> R {
+    scope(|s| {
+        let t1 = s.spawn(|| {
+            // Make sure that T2 starts...
+            yield_now();
+            a();
+            // ... and run T2.
+            yield_now();
+        });
+        let t2 = s.spawn(|| {
+            // Make sure that T2 starts...
+            yield_now();
+            b();
+            // ... and run T2.
+            yield_now();
+        });
+        let t3 = s.spawn(|| {
+            // Continue with T1.
+            yield_now();
+            c()
+        });
+
+        // This will cause T1 to be run.
+        t1.join().unwrap();
+        t2.join().unwrap();
+        t3.join().unwrap()
+    })
+}
+
 fn relaxed(initial_read: bool) -> bool {
     let x = static_atomic(0);
-    let j = spawn(move || x.load(Relaxed));
 
-    x.store(1, Relaxed);
-    // Preemption is disabled, so the store above will never be the
-    // latest store visible to the other thread.
-    x.store(2, Relaxed);
-
-    let r = j.join().unwrap();
+    let r = execute_unsynchronized(
+        || {
+            x.store(1, Relaxed);
+            // Preemption is disabled, so the store above will never be the
+            // latest store visible to the other thread.
+            x.store(2, Relaxed);
+        },
+        || {},
+        || x.load(Relaxed)
+    );
 
     // There are three possible values here: 0 (from the initial read), 1 (from the first relaxed
     // read), and 2 (the last read). The last case is boring and we cover the other two.
     r == if initial_read { 0 } else { 1 }
 }
 
 // https://www.doc.ic.ac.uk/~afd/homepages/papers/pdfs/2017/POPL.pdf Figure 8
-fn seq_cst(relaxed_write: bool) -> bool {
+fn seq_cst() -> bool {
     let x = static_atomic(0);
 
-    let j1 = spawn(move || {
-        // Make the second thread execute without synchronizing with it.
-        // After that, the initial thread will continue executing.
-        yield_now();
-        // This can either load the relaxed write or the second SC-write, but
-        // not the first, as that would violate the ordering guarantee.
-        x.load(SeqCst)
-    });
-    let j2 = spawn(move || x.store(1, Relaxed));
-
-    // Make the first thread execute.
-    yield_now();
-    x.store(2, SeqCst);
-    x.store(3, SeqCst);
-
-    j2.join().unwrap();
-    let r = j1.join().unwrap();
+    let r = execute_unsynchronized(
+        || x.store(1, Relaxed),
+        || {
+            x.store(2, SeqCst);
+            x.store(3, SeqCst);
+        },
+        || x.load(SeqCst),
+    );
 
-    assert_ne!(r, 2);
-    r == if relaxed_write { 1 } else { 3 }
+    r == 1
 }
 
 fn initialization_write(add_fence: bool) -> bool {
     let x = static_atomic(11);
 
     let wait = static_atomic(0);
 
-    let j = spawn(move || {
-        reads_value(wait, 1);
-        if add_fence {
-            fence(AcqRel);
+    let r = execute_unsynchronized(
+        || {
+            x.store(22, Relaxed);
+            // Relaxed is intentional. We want to test if the other thread reads
+            // the initialisation write after a relaxed write
+            wait.store(1, Relaxed);
+        },
+        || {},
+        || {
+            reads_value(wait, 1);
+            if add_fence {
+                fence(AcqRel);
+            }
+            x.load(Relaxed)
         }
-        x.load(Relaxed)
-    });
-
-    x.store(22, Relaxed);
-    // Relaxed is intentional. We want to test if the thread 2 reads the initialisation write
-    // after a relaxed write
-    wait.store(1, Relaxed);
-
-    let r = j.join().unwrap();
+    );
 
     r == 11
 }
@@ -146,8 +176,7 @@ fn assert_once(f: fn() -> bool) {
 pub fn main() {
     assert_once(|| relaxed(false));
     assert_once(|| relaxed(true));
-    assert_once(|| seq_cst(false));
-    assert_once(|| seq_cst(true));
+    assert_once(seq_cst);
     assert_once(|| initialization_write(false));
     assert_once(|| initialization_write(true));
     assert_once(faa_replaced_by_load);