fix miri weak memory tests

Author: joboet

src/tools/miri/tests/fail/weak_memory/weak_uninit.rs

@@ -24,14 +24,11 @@ fn static_uninit_atomic() -> &'static AtomicUsize {
 
 fn relaxed() {
     let x = static_uninit_atomic();
-    let j1 = spawn(move || {
-        x.store(1, Ordering::Relaxed);
-    });
+    let j = spawn(move || x.load(Ordering::Relaxed)); //~ERROR: using uninitialized data
 
-    let j2 = spawn(move || x.load(Ordering::Relaxed)); //~ERROR: using uninitialized data
+    x.store(1, Ordering::Relaxed);
 
-    j1.join().unwrap();
-    j2.join().unwrap();
+    j.join().unwrap();
 }
 
 pub fn main() {

src/tools/miri/tests/fail/weak_memory/weak_uninit.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
   --> tests/fail/weak_memory/weak_uninit.rs:LL:CC
    |
-LL |     let j2 = spawn(move || x.load(Ordering::Relaxed));
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^ using uninitialized data, but this operation requires initialized memory
+LL |     let j = spawn(move || x.load(Ordering::Relaxed));
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ using uninitialized data, but this operation requires initialized memory
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

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;
+use std::thread::{spawn, yield_now};
 
 #[allow(dead_code)]
 #[derive(Copy, Clone)]
@@ -33,69 +33,67 @@ fn reads_value(loc: &AtomicUsize, val: usize) -> usize {
 
 fn relaxed(initial_read: bool) -> bool {
     let x = static_atomic(0);
-    let j1 = spawn(move || {
-        x.store(1, Relaxed);
-        // Preemption is disabled, so the store above will never be the
-        // latest store visible to another thread.
-        x.store(2, Relaxed);
-    });
+    let j = spawn(move || x.load(Relaxed));
 
-    let j2 = 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);
 
-    j1.join().unwrap();
-    let r2 = j2.join().unwrap();
+    let r = j.join().unwrap();
 
     // 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.
-    r2 == if initial_read { 0 } else { 1 }
+    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() -> bool {
+fn seq_cst(relaxed_write: bool) -> bool {
     let x = static_atomic(0);
 
     let j1 = spawn(move || {
-        x.store(1, Relaxed);
+        // 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));
 
-    let j2 = spawn(move || {
-        x.store(2, SeqCst);
-        x.store(3, SeqCst);
-    });
+    // Make the first thread execute.
+    yield_now();
+    x.store(2, SeqCst);
+    x.store(3, SeqCst);
 
-    let j3 = spawn(move || x.load(SeqCst));
-
-    j1.join().unwrap();
     j2.join().unwrap();
-    let r3 = j3.join().unwrap();
+    let r = j1.join().unwrap();
 
-    r3 == 1
+    assert_ne!(r, 2);
+    r == if relaxed_write { 1 } else { 3 }
 }
 
 fn initialization_write(add_fence: bool) -> bool {
     let x = static_atomic(11);
 
     let wait = static_atomic(0);
 
-    let j1 = spawn(move || {
-        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 j2 = spawn(move || {
+    let j = spawn(move || {
         reads_value(wait, 1);
         if add_fence {
             fence(AcqRel);
         }
         x.load(Relaxed)
     });
 
-    j1.join().unwrap();
-    let r2 = j2.join().unwrap();
+    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();
 
-    r2 == 11
+    r == 11
 }
 
 fn faa_replaced_by_load() -> bool {
@@ -119,12 +117,16 @@ fn faa_replaced_by_load() -> bool {
     let go = static_atomic(0);
 
     let t1 = spawn(move || {
-        while go.load(Relaxed) == 0 {}
+        while go.load(Relaxed) == 0 {
+            yield_now();
+        }
         rdmw(y, x, z)
     });
 
     let t2 = spawn(move || {
-        while go.load(Relaxed) == 0 {}
+        while go.load(Relaxed) == 0 {
+            yield_now();
+        }
         rdmw(z, x, y)
     });
 
@@ -144,7 +146,8 @@ fn assert_once(f: fn() -> bool) {
 pub fn main() {
     assert_once(|| relaxed(false));
     assert_once(|| relaxed(true));
-    assert_once(seq_cst);
+    assert_once(|| seq_cst(false));
+    assert_once(|| seq_cst(true));
     assert_once(|| initialization_write(false));
     assert_once(|| initialization_write(true));
     assert_once(faa_replaced_by_load);