adds specialized impl of sleep_until for unix and wasi

Author: dvdsk

library/backtrace

@@ -86,6 +86,14 @@ impl Thread {
         }
     }
 
+    pub fn sleep_until(deadline: Instant) {
+        let now = Instant::now();
+
+        if let Some(delay) = deadline.checked_duration_since(now) {
+            sleep(delay);
+        }
+    }
+
     pub fn join(self) {
         unsafe {
             let _ = hermit_abi::join(self.tid);

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

@@ -205,6 +205,14 @@ impl Thread {
         }
     }
 
+    pub fn sleep_until(deadline: Instant) {
+        let now = Instant::now();
+
+        if let Some(delay) = deadline.checked_duration_since(now) {
+            sleep(delay);
+        }
+    }
+
     pub fn join(self) {
         // Safety: `ThreadInner` is alive at this point
         let inner = unsafe { self.p_inner.as_ref() };

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

@@ -131,6 +131,14 @@ impl Thread {
         usercalls::wait_timeout(0, dur, || true);
     }
 
+    pub fn sleep_until(deadline: Instant) {
+        let now = Instant::now();
+
+        if let Some(delay) = deadline.checked_duration_since(now) {
+            sleep(delay);
+        }
+    }
+
     pub fn join(self) {
         self.0.wait();
     }

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

@@ -303,6 +303,54 @@ impl Thread {
         }
     }
 
+    #[cfg(not(any(
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "linux",
+        target_os = "android",
+        target_os = "solaris",
+        target_os = "illumos",
+    )))]
+    pub fn sleep_until(deadline: Instant) {
+        let now = Instant::now();
+
+        if let Some(delay) = deadline.checked_duration_since(now) {
+            sleep(delay);
+        }
+    }
+
+    // Note depends on clock_nanosleep (not supported on macos/ios/watchos/tvos)
+    #[cfg(any(
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "linux",
+        target_os = "android",
+        target_os = "solaris",
+        target_os = "illumos",
+    ))]
+    pub fn sleep_until(deadline: crate::time::Instant) {
+        let mut ts = deadline
+            .into_inner()
+            .into_timespec()
+            .to_timespec()
+            .expect("Timespec is narrower then libc::timespec thus conversion can't fail");
+        let ts_ptr = &mut ts as *mut _;
+
+        // If we're awoken with a signal and the return value is -1
+        // clock_nanosleep needs to be called again.
+        unsafe {
+            while libc::clock_nanosleep(libc::CLOCK_MONOTONIC, libc::TIMER_ABSTIME, ts_ptr, ts_ptr)
+                == -1
+            {
+                assert_eq!(
+                    os::errno(),
+                    libc::EINTR,
+                    "clock nanosleep should only return an error if interrupted"
+                );
+            }
+        }
+    }
+
     pub fn join(self) {
         let id = self.into_id();
         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };

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

@@ -287,6 +287,10 @@ impl Instant {
     pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
         Some(Instant { t: self.t.checked_sub_duration(other)? })
     }
+
+    pub(in crate::sys::unix) fn into_timespec(self) -> Timespec {
+        self.t
+    }
 }
 
 impl fmt::Debug for Instant {

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

@@ -3,7 +3,7 @@
 use crate::ffi::CStr;
 use crate::num::NonZero;
 use crate::sys::unsupported;
-use crate::time::Duration;
+use crate::time::{Duration, Instant};
 use crate::{io, mem};
 
 cfg_if::cfg_if! {
@@ -136,41 +136,25 @@ impl Thread {
     }
 
     pub fn sleep(dur: Duration) {
-        let mut nanos = dur.as_nanos();
+        let mut nanos_all = dur.as_nanos();
         while nanos > 0 {
-            const USERDATA: wasi::Userdata = 0x0123_45678;
-
-            let clock = wasi::SubscriptionClock {
-                id: wasi::CLOCKID_MONOTONIC,
-                timeout: u64::try_from(nanos).unwrap_or(u64::MAX),
-                precision: 0,
-                flags: 0,
-            };
-            nanos -= u128::from(clock.timeout);
-
-            let in_ = wasi::Subscription {
-                userdata: USERDATA,
-                u: wasi::SubscriptionU { tag: 0, u: wasi::SubscriptionUU { clock } },
-            };
-            unsafe {
-                let mut event: wasi::Event = mem::zeroed();
-                let res = wasi::poll_oneoff(&in_, &mut event, 1);
-                match (res, event) {
-                    (
-                        Ok(1),
-                        wasi::Event {
-                            userdata: USERDATA,
-                            error: wasi::ERRNO_SUCCESS,
-                            type_: wasi::EVENTTYPE_CLOCK,
-                            ..
-                        },
-                    ) => {}
-                    _ => panic!("thread::sleep(): unexpected result of poll_oneoff"),
-                }
-            }
+            let nanos_sleepable = u64::try_from(full_nanos).unwrap_or(u64::MAX);
+            nanos_all -= u128::from(nanos_sleepable);
+            sleep_with(nanos_sleepable, wasi::CLOCKID_MONOTONIC, 0);
         }
     }
 
+    pub fn sleep_until(deadline: Instant) {
+        let nanos = deadline.into_inner().into_inner().as_nanos();
+        assert!(nanos <= u64::MAX as u128);
+
+        sleep_with(
+            nanos as u64,
+            wasi::CLOCKID_MONOTONIC,
+            wasi::SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME,
+        );
+    }
+
     pub fn join(self) {
         cfg_if::cfg_if! {
             if #[cfg(target_feature = "atomics")] {
@@ -186,6 +170,33 @@ impl Thread {
     }
 }
 
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
+fn sleep_with(nanos: u64, clock_id: wasi::Clockid, flags: u16) {
+    const USERDATA: wasi::Userdata = 0x0123_45678;
+
+    let clock = wasi::SubscriptionClock { id: clock_id, timeout: nanos, precision: 0, flags };
+
+    let in_ = wasi::Subscription {
+        userdata: USERDATA,
+        u: wasi::SubscriptionU { tag: 0, u: wasi::SubscriptionUU { clock } },
+    };
+    unsafe {
+        let mut event: wasi::Event = mem::zeroed();
+        let res = wasi::poll_oneoff(&in_, &mut event, 1);
+        match (res, event) {
+            (
+                Ok(1),
+                wasi::Event {
+                    userdata: USERDATA,
+                    error: wasi::ERRNO_SUCCESS,
+                    type_: wasi::EVENTTYPE_CLOCK,
+                    ..
+                },
+            ) => {}
+            _ => panic!("thread::sleep(): unexpected result of poll_oneoff"),
+        }
+    }
+}
+
+pub fn available_parallelism() -> io::Result<NonZeroUsize> {
     unsupported()
 }

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

@@ -36,6 +36,10 @@ impl Instant {
     pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
         Some(Instant(self.0.checked_sub(*other)?))
     }
+
+    pub(crate) fn into_inner(self) -> Duration {
+        self.0
+    }
 }
 
 impl SystemTime {

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

@@ -105,6 +105,14 @@ impl Thread {
         }
     }
 
+    pub fn sleep_until(deadline: Instant) {
+        let now = Instant::now();
+
+        if let Some(delay) = deadline.checked_duration_since(now) {
+            sleep(delay);
+        }
+    }
+
     pub fn handle(&self) -> &Handle {
         &self.handle
     }

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

@@ -128,6 +128,14 @@ impl Thread {
         }
     }
 
+    pub fn sleep_until(deadline: Instant) {
+        let now = Instant::now();
+
+        if let Some(delay) = deadline.checked_duration_since(now) {
+            sleep(delay);
+        }
+    }
+
     pub fn join(self) {
         join_thread(self.tid).unwrap();
     }