add atomic downgrade test

Author: connortsui20

library/std/src/sync/rwlock/tests.rs

@@ -1,13 +1,12 @@
-use rand::Rng;
-
-use crate::hint::spin_loop;
 use crate::sync::atomic::{AtomicUsize, Ordering};
 use crate::sync::mpsc::channel;
 use crate::sync::{
     Arc, Barrier, MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock, RwLockReadGuard,
     RwLockWriteGuard, TryLockError,
 };
 use crate::thread;
+use crate::time;
+use rand::Rng;
 
 #[derive(Eq, PartialEq, Debug)]
 struct NonCopy(i32);
@@ -592,12 +591,68 @@ fn test_downgrade_readers() {
     }
 }
 
-#[test]
 fn test_downgrade_atomic() {
+    // The number of evil writer threads.
+    const W: usize = 1024;
+    let rw = Arc::new(RwLock::new(0i32));
+
+    // Put the lock in write mode, making all future threads trying to access this go to sleep.
+    let mut main_write_guard = rw.write().unwrap();
+
+    let mut handles = Vec::with_capacity(W);
+
+    for _ in 0..W {
+        let w = rw.clone();
+        let evil_handle = thread::spawn(move || {
+            // Will go to sleep since the main thread initially has the write lock.
+            let mut evil_guard = w.write().unwrap();
+            *evil_guard += 1;
+        });
+
+        handles.push(evil_handle);
+    }
+
+    // Wait for a good amount of time so that evil threads go to sleep.
+    // Note that this is not striclty necessary.
+    let eternity = time::Duration::from_secs(1);
+    thread::sleep(eternity);
+
+    // Once everyone is asleep, set the value to -1.
+    *main_write_guard = -1;
+
+    // Atomically downgrade the write guard into a read guard.
+    let main_read_guard = RwLockWriteGuard::downgrade(main_write_guard);
+
+    // If the above is not atomic, then it is possible for an evil thread to get in front of this
+    // read and change the value to be non-negative.
+    assert_eq!(*main_read_guard, -1, "`downgrade` was not atomic");
+
+    drop(main_read_guard);
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    let final_check = rw.read().unwrap();
+    assert_eq!(*final_check, W as i32 - 1);
+}
+
+#[test]
+#[ignore]
+fn test_downgrade_atomic_many() {
+    for _ in 0..10 {
+        test_downgrade_atomic();
+    }
+}
+
+#[test]
+#[ignore]
+fn test_downgrade_wake_readers() {
+    // The number of reader threads.
     const R: usize = 16;
 
     let r = Arc::new(RwLock::new(0));
-    // The number of reader threads that observe the correct value.
+    // The number of reader threads that have observed the correct value.
     let observers = Arc::new(AtomicUsize::new(0));
 
     let w = r.clone();
@@ -619,9 +674,13 @@ fn test_downgrade_atomic() {
     for _ in 0..R {
         let r = r.clone();
         let observers = observers.clone();
+
+        // Spawn a thread that wants to observe the value that the main thread writes (not evil).
         let handle = thread::spawn(move || {
             // Will go to sleep since the main thread initially has the write lock.
             let read_guard = r.read().unwrap();
+            eprintln!("\tObserved {}", *read_guard);
+
             if *read_guard == 1 {
                 observers.fetch_add(1, Ordering::Relaxed);
             }
@@ -630,25 +689,32 @@ fn test_downgrade_atomic() {
         reader_handles.push(handle);
     }
 
+    // FIXME Come up with a better way to make sure everyone is sleeping.
+    let eternity = time::Duration::from_secs(5);
+
+    // Make sure that everyone else is actually sleeping.
+    thread::sleep(eternity);
+
+    // Spawn an evil thread that will try to write before the readers have read.
     let evil = r.clone();
     let evil_handle = thread::spawn(move || {
         // Will go to sleep since the main thread initially has the write lock.
         let mut evil_guard = evil.write().unwrap();
+        eprintln!("Evil thread is writing now");
         *evil_guard = 2;
     });
 
-    // FIXME Come up with a better way to make sure everyone is sleeping.
     // Make sure that everyone else is actually sleeping.
-    let spin = 1000000;
-    for _ in 0..spin {
-        spin_loop();
-    }
+    thread::sleep(eternity);
 
     // Once everyone is asleep, set the value to 1.
     *main_write_guard = 1;
 
+    // As of now, the `R` reader threads and the 1 evil thread _should_ be sleeping.
+    eprintln!("\n\nBeginning Test\n\n");
+
     // Atomically downgrade the write guard into a read guard.
-    // This should wake up all of the reader threads, and allow them to also take the read lock.
+    // This should wake up some of the reader threads, and allow them to also take the read lock.
     let main_read_guard = RwLockWriteGuard::downgrade(main_write_guard);
 
     // If the above is not atomic, then it is possible for the evil thread to get in front of the
@@ -668,5 +734,5 @@ fn test_downgrade_atomic() {
     let final_check = r.read().unwrap();
     assert_eq!(*final_check, 2);
 
-    assert!(observers.load(Ordering::Relaxed) > 0, "No readers observed the correct value");
+    assert_ne!(observers.load(Ordering::Relaxed), 0, "No readers observed the correct value");
 }