make sleep_until platform specific and add impl for unix

Author: dvdsk

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

@@ -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/itron/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/sgx/thread.rs

@@ -132,6 +132,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/unix/thread.rs

@@ -296,6 +296,63 @@ impl Thread {
  }
  }
 
+ #[cfg(not(any(
+ target_vendor = "apple",
+ target_os = "freebsd",
+ target_os = "netbsd",
+ target_os = "linux",
+ target_os = "android",
+ target_os = "solaris",
+ target_os = "illumos",
+ target_os = "dragonfly",
+ target_os = "hurd",
+ target_os = "fuchsia",
+ target_os = "vxworks",
+ )))]
+ 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 os's by apple)
+ #[cfg(any(
+ target_os = "freebsd",
+ target_os = "netbsd",
+ target_os = "linux",
+ target_os = "android",
+ target_os = "solaris",
+ target_os = "illumos",
+ target_os = "dragonfly",
+ target_os = "hurd",
+ target_os = "fuchsia",
+ target_os = "vxworks",
+ ))]
+ 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/time.rs

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

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

@@ -171,6 +171,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) {
  cfg_if::cfg_if! {
  if #[cfg(target_feature = "atomics")] {

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

@@ -8,7 +8,7 @@ use crate::os::windows::io::{AsRawHandle, HandleOrNull};
 use crate::sys::handle::Handle;
 use crate::sys::{c, stack_overflow};
 use crate::sys_common::FromInner;
-use crate::time::Duration;
+use crate::time::{Duration, Instant};
 use crate::{io, ptr};
 
 pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024;
@@ -106,6 +106,14 @@ impl Thread {
  }
  }
 
+ pub fn sleep_until(deadline: Instant) {
+ let now = Instant::now();
+
+ if let Some(delay) = deadline.checked_duration_since(now) {
+ Self::sleep(delay);
+ }
+ }
+
  pub fn handle(&self) -> &Handle {
  &self.handle
  }

library/std/src/sys/pal/xous/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();
  }

library/std/src/thread/mod.rs

@@ -897,8 +897,33 @@ pub fn sleep(dur: Duration) {
 ///
 /// # Platform-specific behavior
 ///
-/// This function uses [`sleep`] internally, see its platform-specific behavior.
-///
+/// In most cases this function will call an OS specific function. Where that
+/// is not supported [`sleep`] is used. Those platforms are referred to as other
+/// in the table below.
+///
+/// # Underlying System calls
+///
+/// The following system calls are [currently] being used:
+///
+/// | Platform | System call |
+/// |-----------|----------------------------------------------------------------------|
+/// | Linux | [clock_nanosleep] (Monotonic clock) |
+/// | BSD except OpenBSD | [clock_nanosleep] (Monotonic Clock)] |
+/// | Android | [clock_nanosleep] (Monotonic Clock)] |
+/// | Solaris | [clock_nanosleep] (Monotonic Clock)] |
+/// | Illumos | [clock_nanosleep] (Monotonic Clock)] |
+/// | Dragonfly | [clock_nanosleep] (Monotonic Clock)] |
+/// | Hurd | [clock_nanosleep] (Monotonic Clock)] |
+/// | Fuchsia | [clock_nanosleep] (Monotonic Clock)] |
+/// | Vxworks | [clock_nanosleep] (Monotonic Clock)] |
+/// | Other | `sleep_until` uses [`sleep`] and does not issue a syscall itself |
+///
+/// [currently]: crate::io#platform-specific-behavior
+/// [clock_nanosleep]: https://linux.die.net/man/3/clock_nanosleep
+/// [subscription_clock]: https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md#-subscription_clock-record
+/// [mach_wait_until]: https://developer.apple.com/library/archive/technotes/tn2169/_index.html
+///
+/// **Disclaimer:** These system calls might change over time.
 ///
 /// # Examples
 ///
@@ -923,9 +948,9 @@ pub fn sleep(dur: Duration) {
 /// }
 /// ```
 ///
-/// A slow api we must not call too fast and which takes a few
+/// A slow API we must not call too fast and which takes a few
 /// tries before succeeding. By using `sleep_until` the time the
-/// api call takes does not influence when we retry or when we give up
+/// API call takes does not influence when we retry or when we give up
 ///
 /// ```no_run
 /// #![feature(thread_sleep_until)]
@@ -960,11 +985,7 @@ pub fn sleep(dur: Duration) {
 /// ```
 #[unstable(feature = "thread_sleep_until", issue = "113752")]
 pub fn sleep_until(deadline: Instant) {
- let now = Instant::now();
-
- if let Some(delay) = deadline.checked_duration_since(now) {
- sleep(delay);
- }
+ imp::Thread::sleep_until(deadline)
 }
 
 /// Used to ensure that `park` and `park_timeout` do not unwind, as that can

library/std/src/time.rs

@@ -407,6 +407,13 @@ impl Instant {
  pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
  self.0.checked_sub_duration(&duration).map(Instant)
  }
+
+ // used by platform specific `sleep_until` implementations.
+ // reason for #[allow(unused)]: not every platform has a specific `sleep_until`.
+ #[allow(unused)]
+ pub(crate) fn into_inner(self) -> time::Instant {
+ self.0
+ }
 }
 
 #[stable(feature = "time2", since = "1.8.0")]