f use _while variants

Author: TheBlueMatt

lightning/src/sync/debug_sync.rs

@@ -40,24 +40,13 @@ impl Condvar {
 		Condvar { inner: StdCondvar::new() }
 	}
 
-	pub fn wait<'a, T>(&'a self, guard: MutexGuard<'a, T>) -> LockResult<MutexGuard<'a, T>> {
-		let mutex: &'a Mutex<T> = guard.mutex;
-		self.inner.wait(guard.into_inner()).map(|lock| MutexGuard { mutex, lock }).map_err(|_| ())
-	}
-
 	pub fn wait_while<'a, T, F: FnMut(&mut T) -> bool>(&'a self, guard: MutexGuard<'a, T>, condition: F)
 	-> LockResult<MutexGuard<'a, T>> {
 		let mutex: &'a Mutex<T> = guard.mutex;
 		self.inner.wait_while(guard.into_inner(), condition).map(|lock| MutexGuard { mutex, lock })
 			.map_err(|_| ())
 	}
 
-	#[allow(unused)]
-	pub fn wait_timeout<'a, T>(&'a self, guard: MutexGuard<'a, T>, dur: Duration) -> LockResult<(MutexGuard<'a, T>, ())> {
-		let mutex = guard.mutex;
-		self.inner.wait_timeout(guard.into_inner(), dur).map(|(lock, _)| (MutexGuard { mutex, lock }, ())).map_err(|_| ())
-	}
-
 	#[allow(unused)]
 	pub fn wait_timeout_while<'a, T, F: FnMut(&mut T) -> bool>(&'a self, guard: MutexGuard<'a, T>, dur: Duration, condition: F)
 	-> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)> {

lightning/src/util/wakers.rs

@@ -240,15 +240,8 @@ impl Sleeper {
 	/// Wait until one of the [`Future`]s registered with this [`Sleeper`] has completed.
 	pub fn wait(&self) {
 		let (cv, notified_fut_mtx) = self.setup_wait();
-		let notified_fut = {
-			let mut notified_fut_lck = notified_fut_mtx.lock().unwrap();
-			loop {
-				if let Some(notified_fut) = notified_fut_lck.take() {
-					break notified_fut;
-				}
-				notified_fut_lck = cv.wait(notified_fut_lck).unwrap();
-			}
-		};
+		let notified_fut = cv.wait_while(notified_fut_mtx.lock().unwrap(), |fut_opt| fut_opt.is_none())
+			.unwrap().take().expect("CV wait shouldn't have returned until the notifying future was set");
 		notified_fut.lock().unwrap().callbacks_made = true;
 	}
 
@@ -257,19 +250,14 @@ impl Sleeper {
 	/// elapsed.
 	#[cfg(any(test, feature = "std"))]
 	pub fn wait_timeout(&self, max_wait: Duration) -> bool {
-		let start_time = Instant::now();
 		let (cv, notified_fut_mtx) = self.setup_wait();
-		let notified_fut = {
-			let mut notified_fut_lck = notified_fut_mtx.lock().unwrap();
-			loop {
-				if let Some(notified_fut) = notified_fut_lck.take() {
-					break notified_fut;
-				}
-				let sleep_time = max_wait.checked_sub(start_time.elapsed()).unwrap_or(Duration::from_secs(0));
-				if sleep_time == Duration::from_secs(0) { return false; }
-				notified_fut_lck = cv.wait_timeout(notified_fut_lck, max_wait).unwrap().0;
-			}
-		};
+		let notified_fut =
+			match cv.wait_timeout_while(notified_fut_mtx.lock().unwrap(), max_wait, |fut_opt| fut_opt.is_none()) {
+				Ok((_, e)) if e.timed_out() => return false,
+				Ok((mut notified_fut, _)) =>
+					notified_fut.take().expect("CV wait shouldn't have returned until the notifying future was set"),
+				Err(_) => panic!("Previous panic while a lock was held led to a lock panic"),
+			};
 		notified_fut.lock().unwrap().callbacks_made = true;
 		true
 	}