clean up downgrade test

Author: connortsui20

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

@@ -591,29 +591,34 @@ fn test_downgrade_readers() {
     }
 }
 
+#[test]
 fn test_downgrade_atomic() {
+    // Spawns many evil writer threads that will try and write to the locked value before the
+    // intial writer who has the exlusive lock can read after it downgrades.
+    // If the `RwLock` behaves correctly, then the initial writer should read the value it wrote
+    // itself as no other thread should get in front of it.
+
     // 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);
-    }
+    // Spawn all of the evil writer threads.
+    let handles: Vec<_> = (0..W)
+        .map(|_| {
+            let w = rw.clone();
+            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;
+            })
+        })
+        .collect();
 
     // Wait for a good amount of time so that evil threads go to sleep.
-    // Note that this is not striclty necessary.
+    // (Note that this is not striclty necessary...)
     let eternity = time::Duration::from_secs(1);
     thread::sleep(eternity);
 
@@ -627,112 +632,12 @@ fn test_downgrade_atomic() {
     // read and change the value to be non-negative.
     assert_eq!(*main_read_guard, -1, "`downgrade` was not atomic");
 
+    // Clean up everything now
     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 have observed the correct value.
-    let observers = Arc::new(AtomicUsize::new(0));
-
-    let w = r.clone();
-    let mut main_write_guard = w.write().unwrap();
-
-    // While the current thread is holding the write lock, spawn several reader threads and an evil
-    // writer thread.
-    // Each of the threads will attempt to read the `RwLock` and go to sleep because we have the
-    // write lock.
-    // We need at least 1 reader thread to observe what the main thread writes, otherwise that means
-    // the evil writer thread got in front of every single reader.
-
-    // FIXME
-    // Should we actually require that every reader observe the first change?
-    // This is a matter of protocol rather than correctness...
-
-    let mut reader_handles = Vec::with_capacity(R);
-
-    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);
-            }
-        });
-
-        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;
-    });
-
-    // Make sure that everyone else is actually sleeping.
-    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 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
-    // readers and change the value to 2 instead.
-    assert_eq!(*main_read_guard, 1, "`downgrade` was not atomic");
-
-    // By dropping all of the read guards, we allow the evil thread to make the change.
-    drop(main_read_guard);
-
-    for handle in reader_handles {
-        handle.join().unwrap();
-    }
-
-    // Wait for the evil thread to set the value to 2.
-    evil_handle.join().unwrap();
-
-    let final_check = r.read().unwrap();
-    assert_eq!(*final_check, 2);
-
-    assert_ne!(observers.load(Ordering::Relaxed), 0, "No readers observed the correct value");
-}