std: move time implementations to sys (Windows)

Windows has a similar problem as UEFI: some internals are also used for implementing other things. Thus I've left everything except for the actual `Instant` and `SystemTime` implementations inside the PAL.

I've also taken the liberty of improving the code clarity a bit: there were a number of manual `SystemTime` conversions (including one that masked an `i64` to 32-bits before casting to `u32`, yikes) that now just call `from_intervals`. Also, defining a `PerformanceCounterInstant` just to convert it to a regular `Instant` immediately doesn't really make sense to me. I've thus changed the `perf_counter` module to contain only free functions that wrap system functionality. The actual conversion now happens in `Instant::now`.

Author: joboet

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

@@ -1,214 +1,36 @@
-use core::hash::{Hash, Hasher};
-use core::ops::Neg;
-
-use crate::cmp::Ordering;
+use crate::ops::Neg;
 use crate::ptr::null;
-use crate::sys::{IntoInner, c};
+use crate::sys::pal::c;
 use crate::time::Duration;
-use crate::{fmt, mem};
 
 const NANOS_PER_SEC: u64 = 1_000_000_000;
-const INTERVALS_PER_SEC: u64 = NANOS_PER_SEC / 100;
-
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
-pub struct Instant {
-    // This duration is relative to an arbitrary microsecond epoch
-    // from the winapi QueryPerformanceCounter function.
-    t: Duration,
-}
-
-#[derive(Copy, Clone)]
-pub struct SystemTime {
-    t: c::FILETIME,
-}
-
-const INTERVALS_TO_UNIX_EPOCH: u64 = 11_644_473_600 * INTERVALS_PER_SEC;
-
-pub const UNIX_EPOCH: SystemTime = SystemTime {
-    t: c::FILETIME {
-        dwLowDateTime: INTERVALS_TO_UNIX_EPOCH as u32,
-        dwHighDateTime: (INTERVALS_TO_UNIX_EPOCH >> 32) as u32,
-    },
-};
-
-impl Instant {
-    pub fn now() -> Instant {
-        // High precision timing on windows operates in "Performance Counter"
-        // units, as returned by the WINAPI QueryPerformanceCounter function.
-        // These relate to seconds by a factor of QueryPerformanceFrequency.
-        // In order to keep unit conversions out of normal interval math, we
-        // measure in QPC units and immediately convert to nanoseconds.
-        perf_counter::PerformanceCounterInstant::now().into()
-    }
-
-    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
-        // On windows there's a threshold below which we consider two timestamps
-        // equivalent due to measurement error. For more details + doc link,
-        // check the docs on epsilon.
-        let epsilon = perf_counter::PerformanceCounterInstant::epsilon();
-        if other.t > self.t && other.t - self.t <= epsilon {
-            Some(Duration::new(0, 0))
-        } else {
-            self.t.checked_sub(other.t)
-        }
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
-        Some(Instant { t: self.t.checked_add(*other)? })
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
-        Some(Instant { t: self.t.checked_sub(*other)? })
-    }
-}
-
-impl SystemTime {
-    pub const MAX: SystemTime = SystemTime {
-        t: c::FILETIME {
-            dwLowDateTime: (i64::MAX & 0xFFFFFFFF) as u32,
-            dwHighDateTime: (i64::MAX >> 32) as u32,
-        },
-    };
-
-    pub const MIN: SystemTime =
-        SystemTime { t: c::FILETIME { dwLowDateTime: 0, dwHighDateTime: 0 } };
-
-    pub fn now() -> SystemTime {
-        unsafe {
-            let mut t: SystemTime = mem::zeroed();
-            c::GetSystemTimePreciseAsFileTime(&mut t.t);
-            t
-        }
-    }
-
-    fn from_intervals(intervals: i64) -> SystemTime {
-        SystemTime {
-            t: c::FILETIME {
-                dwLowDateTime: intervals as u32,
-                dwHighDateTime: (intervals >> 32) as u32,
-            },
-        }
-    }
-
-    fn intervals(&self) -> i64 {
-        (self.t.dwLowDateTime as i64) | ((self.t.dwHighDateTime as i64) << 32)
-    }
-
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        let me = self.intervals();
-        let other = other.intervals();
-        if me >= other {
-            Ok(intervals2dur((me - other) as u64))
-        } else {
-            Err(intervals2dur((other - me) as u64))
-        }
-    }
-
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;
-        Some(SystemTime::from_intervals(intervals))
-    }
-
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
-        // Windows does not support times before 1601, hence why we don't
-        // support negatives. In order to tackle this, we try to convert the
-        // resulting value into an u64, which should obviously fail in the case
-        // that the value is below zero.
-        let intervals: u64 =
-            self.intervals().checked_sub(checked_dur2intervals(other)?)?.try_into().ok()?;
-        Some(SystemTime::from_intervals(intervals as i64))
-    }
-}
-
-impl PartialEq for SystemTime {
-    fn eq(&self, other: &SystemTime) -> bool {
-        self.intervals() == other.intervals()
-    }
-}
-
-impl Eq for SystemTime {}
-
-impl PartialOrd for SystemTime {
-    fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
+pub const INTERVALS_PER_SEC: u64 = NANOS_PER_SEC / 100;
 
-impl Ord for SystemTime {
-    fn cmp(&self, other: &SystemTime) -> Ordering {
-        self.intervals().cmp(&other.intervals())
-    }
-}
-
-impl fmt::Debug for SystemTime {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("SystemTime").field("intervals", &self.intervals()).finish()
-    }
-}
-
-impl From<c::FILETIME> for SystemTime {
-    fn from(t: c::FILETIME) -> SystemTime {
-        SystemTime { t }
-    }
-}
-
-impl IntoInner<c::FILETIME> for SystemTime {
-    fn into_inner(self) -> c::FILETIME {
-        self.t
-    }
-}
-
-impl Hash for SystemTime {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.intervals().hash(state)
-    }
-}
-
-fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
+pub fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
     dur.as_secs()
         .checked_mul(INTERVALS_PER_SEC)?
         .checked_add(dur.subsec_nanos() as u64 / 100)?
         .try_into()
         .ok()
 }
 
-fn intervals2dur(intervals: u64) -> Duration {
+pub fn intervals2dur(intervals: u64) -> Duration {
     Duration::new(intervals / INTERVALS_PER_SEC, ((intervals % INTERVALS_PER_SEC) * 100) as u32)
 }
 
-mod perf_counter {
+pub mod perf_counter {
     use super::NANOS_PER_SEC;
     use crate::sync::atomic::{Atomic, AtomicU64, Ordering};
-    use crate::sys::helpers::mul_div_u64;
     use crate::sys::{c, cvt};
     use crate::time::Duration;
 
-    pub struct PerformanceCounterInstant {
-        ts: i64,
-    }
-    impl PerformanceCounterInstant {
-        pub fn now() -> Self {
-            Self { ts: query() }
-        }
-
-        // Per microsoft docs, the margin of error for cross-thread time comparisons
-        // using QueryPerformanceCounter is 1 "tick" -- defined as 1/frequency().
-        // Reference: https://docs.microsoft.com/en-us/windows/desktop/SysInfo
-        //                   /acquiring-high-resolution-time-stamps
-        pub fn epsilon() -> Duration {
-            let epsilon = NANOS_PER_SEC / (frequency() as u64);
-            Duration::from_nanos(epsilon)
-        }
-    }
-    impl From<PerformanceCounterInstant> for super::Instant {
-        fn from(other: PerformanceCounterInstant) -> Self {
-            let freq = frequency() as u64;
-            let instant_nsec = mul_div_u64(other.ts as u64, NANOS_PER_SEC, freq);
-            Self { t: Duration::from_nanos(instant_nsec) }
-        }
+    pub fn now() -> i64 {
+        let mut qpc_value: i64 = 0;
+        cvt(unsafe { c::QueryPerformanceCounter(&mut qpc_value) }).unwrap();
+        qpc_value
     }
 
-    fn frequency() -> i64 {
+    pub fn frequency() -> i64 {
         // Either the cached result of `QueryPerformanceFrequency` or `0` for
         // uninitialized. Storing this as a single `AtomicU64` allows us to use
         // `Relaxed` operations, as we are only interested in the effects on a
@@ -230,17 +52,21 @@ mod perf_counter {
         frequency
     }
 
-    fn query() -> i64 {
-        let mut qpc_value: i64 = 0;
-        cvt(unsafe { c::QueryPerformanceCounter(&mut qpc_value) }).unwrap();
-        qpc_value
+    // Per microsoft docs, the margin of error for cross-thread time comparisons
+    // using QueryPerformanceCounter is 1 "tick" -- defined as 1/frequency().
+    // Reference: https://docs.microsoft.com/en-us/windows/desktop/SysInfo
+    //                   /acquiring-high-resolution-time-stamps
+    pub fn epsilon() -> Duration {
+        let epsilon = NANOS_PER_SEC / (frequency() as u64);
+        Duration::from_nanos(epsilon)
     }
 }
 
 /// A timer you can wait on.
 pub(crate) struct WaitableTimer {
     handle: c::HANDLE,
 }
+
 impl WaitableTimer {
     /// Creates a high-resolution timer. Will fail before Windows 10, version 1803.
     pub fn high_resolution() -> Result<Self, ()> {
@@ -254,6 +80,7 @@ impl WaitableTimer {
         };
         if !handle.is_null() { Ok(Self { handle }) } else { Err(()) }
     }
+
     pub fn set(&self, duration: Duration) -> Result<(), ()> {
         // Convert the Duration to a format similar to FILETIME.
         // Negative values are relative times whereas positive values are absolute.
@@ -262,11 +89,13 @@ impl WaitableTimer {
         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(()) }
     }
 }
+
 impl Drop for WaitableTimer {
     fn drop(&mut self) {
         unsafe { c::CloseHandle(self.handle) };

library/std/src/sys/time/mod.rs

@@ -24,6 +24,10 @@ cfg_select! {
             pub use super::unsupported::{SystemTime, UNIX_EPOCH};
         }
     }
+    target_os = "windows" => {
+        mod windows;
+        use windows as imp;
+    }
     target_os = "xous" => {
         mod xous;
         use xous as imp;