1 use crate::cmp::Ordering;
5 use crate::time::Duration;
6 use crate::convert::TryInto;
8 use core::hash::{Hash, Hasher};
10 const NANOS_PER_SEC: u64 = 1_000_000_000;
11 const INTERVALS_PER_SEC: u64 = NANOS_PER_SEC / 100;
13 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
15 // This duration is relative to an arbitrary microsecond epoch
16 // from the winapi QueryPerformanceCounter function.
20 #[derive(Copy, Clone)]
21 pub struct SystemTime {
25 const INTERVALS_TO_UNIX_EPOCH: u64 = 11_644_473_600 * INTERVALS_PER_SEC;
27 pub const UNIX_EPOCH: SystemTime = SystemTime {
29 dwLowDateTime: INTERVALS_TO_UNIX_EPOCH as u32,
30 dwHighDateTime: (INTERVALS_TO_UNIX_EPOCH >> 32) as u32,
35 pub fn now() -> Instant {
36 // High precision timing on windows operates in "Performance Counter"
37 // units, as returned by the WINAPI QueryPerformanceCounter function.
38 // These relate to seconds by a factor of QueryPerformanceFrequency.
39 // In order to keep unit conversions out of normal interval math, we
40 // measure in QPC units and immediately convert to nanoseconds.
41 perf_counter::PerformanceCounterInstant::now().into()
44 pub fn actually_monotonic() -> bool {
48 pub const fn zero() -> Instant {
49 Instant { t: Duration::from_secs(0) }
52 pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
53 // On windows there's a threshold below which we consider two timestamps
54 // equivalent due to measurement error. For more details + doc link,
55 // check the docs on epsilon.
57 perf_counter::PerformanceCounterInstant::epsilon();
58 if other.t > self.t && other.t - self.t <= epsilon {
59 Some(Duration::new(0, 0))
61 self.t.checked_sub(other.t)
65 pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
67 t: self.t.checked_add(*other)?
71 pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
73 t: self.t.checked_sub(*other)?
79 pub fn now() -> SystemTime {
81 let mut t: SystemTime = mem::zeroed();
82 c::GetSystemTimeAsFileTime(&mut t.t);
87 fn from_intervals(intervals: i64) -> SystemTime {
90 dwLowDateTime: intervals as c::DWORD,
91 dwHighDateTime: (intervals >> 32) as c::DWORD,
96 fn intervals(&self) -> i64 {
97 (self.t.dwLowDateTime as i64) | ((self.t.dwHighDateTime as i64) << 32)
100 pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
101 let me = self.intervals();
102 let other = other.intervals();
104 Ok(intervals2dur((me - other) as u64))
106 Err(intervals2dur((other - me) as u64))
110 pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
111 let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;
112 Some(SystemTime::from_intervals(intervals))
115 pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
116 let intervals = self.intervals().checked_sub(checked_dur2intervals(other)?)?;
117 Some(SystemTime::from_intervals(intervals))
121 impl PartialEq for SystemTime {
122 fn eq(&self, other: &SystemTime) -> bool {
123 self.intervals() == other.intervals()
127 impl Eq for SystemTime {}
129 impl PartialOrd for SystemTime {
130 fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering> {
131 Some(self.cmp(other))
135 impl Ord for SystemTime {
136 fn cmp(&self, other: &SystemTime) -> Ordering {
137 self.intervals().cmp(&other.intervals())
141 impl fmt::Debug for SystemTime {
142 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
143 f.debug_struct("SystemTime")
144 .field("intervals", &self.intervals())
149 impl From<c::FILETIME> for SystemTime {
150 fn from(t: c::FILETIME) -> SystemTime {
155 impl Hash for SystemTime {
156 fn hash<H : Hasher>(&self, state: &mut H) {
157 self.intervals().hash(state)
161 fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
163 .checked_mul(INTERVALS_PER_SEC)?
164 .checked_add(dur.subsec_nanos() as u64 / 100)?
169 fn intervals2dur(intervals: u64) -> Duration {
170 Duration::new(intervals / INTERVALS_PER_SEC,
171 ((intervals % INTERVALS_PER_SEC) * 100) as u32)
175 use super::{NANOS_PER_SEC};
176 use crate::sync::atomic::{AtomicUsize, Ordering::SeqCst};
177 use crate::sys_common::mul_div_u64;
180 use crate::time::Duration;
182 pub struct PerformanceCounterInstant {
185 impl PerformanceCounterInstant {
186 pub fn now() -> Self {
192 // Per microsoft docs, the margin of error for cross-thread time comparisons
193 // using QueryPerformanceCounter is 1 "tick" -- defined as 1/frequency().
194 // Reference: https://docs.microsoft.com/en-us/windows/desktop/SysInfo
195 // /acquiring-high-resolution-time-stamps
196 pub fn epsilon() -> Duration {
197 let epsilon = NANOS_PER_SEC / (frequency() as u64);
198 Duration::from_nanos(epsilon)
201 impl From<PerformanceCounterInstant> for super::Instant {
202 fn from(other: PerformanceCounterInstant) -> Self {
203 let freq = frequency() as u64;
204 let instant_nsec = mul_div_u64(other.ts as u64, NANOS_PER_SEC, freq);
206 t: Duration::from_nanos(instant_nsec)
211 fn frequency() -> c::LARGE_INTEGER {
212 static mut FREQUENCY: c::LARGE_INTEGER = 0;
213 static STATE: AtomicUsize = AtomicUsize::new(0);
216 // If a previous thread has filled in this global state, use that.
217 if STATE.load(SeqCst) == 2 {
221 // ... otherwise learn for ourselves ...
222 let mut frequency = 0;
223 cvt(c::QueryPerformanceFrequency(&mut frequency)).unwrap();
225 // ... and attempt to be the one thread that stores it globally for
227 if STATE.compare_exchange(0, 1, SeqCst, SeqCst).is_ok() {
228 FREQUENCY = frequency;
229 STATE.store(2, SeqCst);
235 fn query() -> c::LARGE_INTEGER {
236 let mut qpc_value: c::LARGE_INTEGER = 0;
238 c::QueryPerformanceCounter(&mut qpc_value)