From e348c21528d14c226442186c96612dee2e30a209 Mon Sep 17 00:00:00 2001
From: Niko Matsakis <niko@alum.mit.edu>
Date: Fri, 19 Oct 2018 05:59:19 -0400
Subject: [PATCH] move `signal` into its own module

---
 tests/parallel/main.rs   |  1 +
 tests/parallel/setup.rs  | 41 +---------------------------------------
 tests/parallel/signal.rs | 40 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 42 insertions(+), 40 deletions(-)
 create mode 100644 tests/parallel/signal.rs

diff --git a/tests/parallel/main.rs b/tests/parallel/main.rs
index 46081046..5ae83ddb 100644
--- a/tests/parallel/main.rs
+++ b/tests/parallel/main.rs
@@ -3,4 +3,5 @@ mod setup;
 mod cancellation;
 mod independent;
 mod race;
+mod signal;
 mod true_parallel;
diff --git a/tests/parallel/setup.rs b/tests/parallel/setup.rs
index dea4f08e..9aa7fe7a 100644
--- a/tests/parallel/setup.rs
+++ b/tests/parallel/setup.rs
@@ -1,4 +1,4 @@
-use parking_lot::{Condvar, Mutex};
+use crate::signal::Signal;
 use salsa::Database;
 use salsa::ParallelDatabase;
 use std::cell::Cell;
@@ -70,45 +70,6 @@ pub(crate) struct KnobsStruct {
     pub(crate) sum_signal_on_exit: Cell<usize>,
 }
 
-#[derive(Default)]
-pub(crate) struct Signal {
-    value: Mutex<usize>,
-    cond_var: Condvar,
-}
-
-impl Signal {
-    pub(crate) fn signal(&self, stage: usize) {
-        log::debug!("signal({})", stage);
-
-        // This check avoids acquiring the lock for things that will
-        // clearly be a no-op. Not *necessary* but helps to ensure we
-        // are more likely to encounter weird race conditions;
-        // otherwise calls to `sum` will tend to be unnecessarily
-        // synchronous.
-        if stage > 0 {
-            let mut v = self.value.lock();
-            if stage > *v {
-                *v = stage;
-                self.cond_var.notify_all();
-            }
-        }
-    }
-
-    /// Waits until the given condition is true; the fn is invoked
-    /// with the current stage.
-    pub(crate) fn wait_for(&self, stage: usize) {
-        log::debug!("wait_for({})", stage);
-
-        // As above, avoid lock if clearly a no-op.
-        if stage > 0 {
-            let mut v = self.value.lock();
-            while *v < stage {
-                self.cond_var.wait(&mut v);
-            }
-        }
-    }
-}
-
 fn sum(db: &impl ParDatabase, key: &'static str) -> usize {
     let mut sum = 0;
 
diff --git a/tests/parallel/signal.rs b/tests/parallel/signal.rs
new file mode 100644
index 00000000..4072a30a
--- /dev/null
+++ b/tests/parallel/signal.rs
@@ -0,0 +1,40 @@
+use parking_lot::{Condvar, Mutex};
+
+#[derive(Default)]
+pub(crate) struct Signal {
+    value: Mutex<usize>,
+    cond_var: Condvar,
+}
+
+impl Signal {
+    pub(crate) fn signal(&self, stage: usize) {
+        log::debug!("signal({})", stage);
+
+        // This check avoids acquiring the lock for things that will
+        // clearly be a no-op. Not *necessary* but helps to ensure we
+        // are more likely to encounter weird race conditions;
+        // otherwise calls to `sum` will tend to be unnecessarily
+        // synchronous.
+        if stage > 0 {
+            let mut v = self.value.lock();
+            if stage > *v {
+                *v = stage;
+                self.cond_var.notify_all();
+            }
+        }
+    }
+
+    /// Waits until the given condition is true; the fn is invoked
+    /// with the current stage.
+    pub(crate) fn wait_for(&self, stage: usize) {
+        log::debug!("wait_for({})", stage);
+
+        // As above, avoid lock if clearly a no-op.
+        if stage > 0 {
+            let mut v = self.value.lock();
+            while *v < stage {
+                self.cond_var.wait(&mut v);
+            }
+        }
+    }
+}