adds specialized impl for sleep_until for windows

Author: dvdsk

library/std/src/sys/pal/windows/thread.rs

@@ -1,3 +1,14 @@
+use crate::io;
+use crate::num::NonZeroUsize;
+use crate::os::windows::io::AsRawHandle;
+use crate::os::windows::io::HandleOrNull;
+use crate::ptr;
+use crate::sys::c;
+use crate::sys::handle::Handle;
+use crate::sys::stack_overflow;
+use crate::sys_common::FromInner;
+use crate::time::{Duration, Instant};
+
 use core::ffi::c_void;
 
 use super::time::WaitableTimer;
@@ -106,11 +117,22 @@ impl Thread {
     }
 
     pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            sleep(delay);
+        fn high_precision_sleep(deadline: Instant) -> Result<(), ()> {
+            let timer = WaitableTimer::high_resolution()?;
+            timer.set_deadline(deadline.into_inner())?;
+            timer.wait()
         }
+        // Attempt to use high-precision sleep (Windows 10, version 1803+).
+        // On error fallback to the standard `Sleep` function.
+        // Also preserves the zero duration behaviour of `Sleep`.
+        if high_precision_sleep(deadline).is_ok() {
+            return;
+        }
+
+        let now = Instant::now();
+        if let Some(dur) = deadline.checked_duration_since(now) {
+            unsafe { c::Sleep(super::dur2timeout(dur)) }
+        };
     }
 
     pub fn handle(&self) -> &Handle {

library/std/src/sys/pal/windows/time.rs

@@ -248,6 +248,12 @@ impl WaitableTimer {
         let result = unsafe { c::SetWaitableTimer(self.handle, &time, 0, None, null(), c::FALSE) };
         if result != 0 { Ok(()) } else { Err(()) }
     }
+    pub fn set_deadline(&self, deadline: Instant) -> Result<(), ()> {
+        // Convert the Instant to a format similar to FILETIME.
+        let time = checked_dur2intervals(&deadline.t).ok_or(())?;
+        let result = unsafe { c::SetWaitableTimer(self.handle, &time, 0, None, null(), c::FALSE) };
+        if result != 0 { Ok(()) } else { Err(()) }
+    }
     pub fn wait(&self) -> Result<(), ()> {
         let result = unsafe { c::WaitForSingleObject(self.handle, c::INFINITE) };
         if result != c::WAIT_FAILED { Ok(()) } else { Err(()) }