zx/
time.rs

1// Copyright 2016 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5//! Type-safe bindings for Zircon timer objects.
6
7use crate::{
8    object_get_info_single, ok, sys, AsHandleRef, Handle, HandleBased, HandleRef, ObjectQuery,
9    Status, Topic,
10};
11use std::cmp::{Eq, Ord, PartialEq, PartialOrd};
12use std::hash::Hash;
13use std::{ops, time as stdtime};
14use zerocopy::{FromBytes, Immutable, IntoBytes};
15
16/// A timestamp from the monontonic clock. Does not advance while the system is suspended.
17pub type MonotonicInstant = Instant<MonotonicTimeline, NsUnit>;
18
19/// A timestamp from a user-defined clock with arbitrary behavior.
20pub type SyntheticInstant = Instant<SyntheticTimeline, NsUnit>;
21
22/// A timestamp from the boot clock. Advances while the system is suspended.
23pub type BootInstant = Instant<BootTimeline>;
24
25/// A timestamp from system ticks. Has an arbitrary unit that can be measured with
26/// `Ticks::per_second()`.
27pub type Ticks<T> = Instant<T, TicksUnit>;
28
29/// A timestamp from system ticks on the monotonic timeline. Does not advance while the system is
30/// suspended.
31pub type MonotonicTicks = Instant<MonotonicTimeline, TicksUnit>;
32
33/// A timestamp from system ticks on the boot timeline. Advances while the system is suspended.
34pub type BootTicks = Instant<BootTimeline, TicksUnit>;
35
36/// A duration on the monotonic timeline.
37pub type MonotonicDuration = Duration<MonotonicTimeline>;
38
39/// A duration on the boot timeline.
40pub type BootDuration = Duration<BootTimeline>;
41
42/// A duration from a user-defined clock with arbitrary behavior.
43pub type SyntheticDuration = Duration<SyntheticTimeline, NsUnit>;
44
45/// A duration between two system ticks monotonic timestamps.
46pub type MonotonicDurationTicks = Duration<MonotonicTimeline, TicksUnit>;
47
48/// A duration between two system ticks boot timestamps.
49pub type BootDurationTicks = Duration<BootTimeline, TicksUnit>;
50
51/// A timestamp from the kernel. Generic over both the timeline and the units it is measured in.
52#[derive(
53    Clone, Copy, Default, Hash, PartialEq, Eq, PartialOrd, Ord, FromBytes, IntoBytes, Immutable,
54)]
55#[repr(transparent)]
56pub struct Instant<T, U = NsUnit>(sys::zx_time_t, std::marker::PhantomData<(T, U)>);
57
58impl<T, U> std::fmt::Debug for Instant<T, U> {
59    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
60        // Avoid line noise from the marker type but do include the timeline in the output.
61        let timeline_name = std::any::type_name::<T>();
62        let short_timeline_name =
63            timeline_name.rsplit_once("::").map(|(_, n)| n).unwrap_or(timeline_name);
64        let units_name = std::any::type_name::<U>();
65        let short_units_name = units_name.rsplit_once("::").map(|(_, n)| n).unwrap_or(units_name);
66        f.debug_tuple(&format!("Instant<{short_timeline_name}, {short_units_name}>"))
67            .field(&self.0)
68            .finish()
69    }
70}
71
72impl MonotonicInstant {
73    /// Get the current monotonic time which does not advance during system suspend.
74    ///
75    /// Wraps the
76    /// [zx_clock_get_monotonic](https://fuchsia.dev/fuchsia-src/reference/syscalls/clock_get_monotonic.md)
77    /// syscall.
78    pub fn get() -> Self {
79        unsafe { Self::from_nanos(sys::zx_clock_get_monotonic()) }
80    }
81
82    /// Compute a deadline for the time in the future that is the given `Duration` away.
83    ///
84    /// Wraps the
85    /// [zx_deadline_after](https://fuchsia.dev/fuchsia-src/reference/syscalls/deadline_after.md)
86    /// syscall.
87    pub fn after(duration: MonotonicDuration) -> Self {
88        unsafe { Self::from_nanos(sys::zx_deadline_after(duration.0)) }
89    }
90
91    /// Sleep until the given time.
92    ///
93    /// Wraps the
94    /// [zx_nanosleep](https://fuchsia.dev/fuchsia-src/reference/syscalls/nanosleep.md)
95    /// syscall.
96    pub fn sleep(self) {
97        unsafe {
98            sys::zx_nanosleep(self.0);
99        }
100    }
101}
102
103impl BootInstant {
104    /// Get the current boot time which advances during system suspend.
105    pub fn get() -> Self {
106        // SAFETY: FFI call that is always sound to call.
107        unsafe { Self::from_nanos(sys::zx_clock_get_boot()) }
108    }
109
110    /// Compute a deadline for the time in the future that is the given `Duration` away.
111    pub fn after(duration: BootDuration) -> Self {
112        Self::from_nanos(Self::get().into_nanos().saturating_add(duration.0))
113    }
114}
115
116impl<T: Timeline, U: TimeUnit> Instant<T, U> {
117    pub const ZERO: Instant<T, U> = Instant(0, std::marker::PhantomData);
118}
119
120impl<T: Timeline> Instant<T> {
121    pub const INFINITE: Instant<T, NsUnit> =
122        Instant(sys::ZX_TIME_INFINITE, std::marker::PhantomData);
123    pub const INFINITE_PAST: Instant<T, NsUnit> =
124        Instant(sys::ZX_TIME_INFINITE_PAST, std::marker::PhantomData);
125
126    /// Returns the number of nanoseconds since the epoch contained by this `Time`.
127    pub const fn into_nanos(self) -> i64 {
128        self.0
129    }
130
131    /// Return a strongly-typed `Time` from a raw number of nanoseconds.
132    pub const fn from_nanos(nanos: i64) -> Self {
133        Instant(nanos, std::marker::PhantomData)
134    }
135}
136
137impl MonotonicTicks {
138    /// Read the number of high-precision timer ticks on the monotonic timeline. These ticks may be
139    /// processor cycles, high speed timer, profiling timer, etc. They do not advance while the
140    /// system is suspended.
141    ///
142    /// Wraps the
143    /// [zx_ticks_get](https://fuchsia.dev/fuchsia-src/reference/syscalls/ticks_get.md)
144    /// syscall.
145    pub fn get() -> Self {
146        // SAFETY: FFI call that is always sound to call.
147        Self(unsafe { sys::zx_ticks_get() }, std::marker::PhantomData)
148    }
149}
150
151impl BootTicks {
152    /// Read the number of high-precision timer ticks on the boot timeline. These ticks may be
153    /// processor cycles, high speed timer, profiling timer, etc. They advance while the
154    /// system is suspended.
155    pub fn get() -> Self {
156        // SAFETY: FFI call that is always sound to call.
157        Self(unsafe { sys::zx_ticks_get_boot() }, std::marker::PhantomData)
158    }
159}
160
161impl<T: Timeline> Ticks<T> {
162    /// Return the number of ticks contained by this `Ticks`.
163    pub const fn into_raw(self) -> i64 {
164        self.0
165    }
166
167    /// Return a strongly-typed `Ticks` from a raw number of system ticks.
168    pub const fn from_raw(raw: i64) -> Self {
169        Self(raw, std::marker::PhantomData)
170    }
171
172    /// Return the number of high-precision timer ticks in a second.
173    ///
174    /// Wraps the
175    /// [zx_ticks_per_second](https://fuchsia.dev/fuchsia-src/reference/syscalls/ticks_per_second.md)
176    /// syscall.
177    pub fn per_second() -> i64 {
178        // SAFETY: FFI call that is always sound to call.
179        unsafe { sys::zx_ticks_per_second() }
180    }
181}
182
183impl<T: Timeline, U: TimeUnit> ops::Add<Duration<T, U>> for Instant<T, U> {
184    type Output = Instant<T, U>;
185    fn add(self, dur: Duration<T, U>) -> Self::Output {
186        Self(self.0.saturating_add(dur.0), std::marker::PhantomData)
187    }
188}
189
190impl<T: Timeline, U: TimeUnit> ops::Sub<Duration<T, U>> for Instant<T, U> {
191    type Output = Instant<T, U>;
192    fn sub(self, dur: Duration<T, U>) -> Self::Output {
193        Self(self.0.saturating_sub(dur.0), std::marker::PhantomData)
194    }
195}
196
197impl<T: Timeline, U: TimeUnit> ops::Sub<Instant<T, U>> for Instant<T, U> {
198    type Output = Duration<T, U>;
199    fn sub(self, rhs: Instant<T, U>) -> Self::Output {
200        Duration(self.0.saturating_sub(rhs.0), std::marker::PhantomData)
201    }
202}
203
204impl<T: Timeline, U: TimeUnit> ops::AddAssign<Duration<T, U>> for Instant<T, U> {
205    fn add_assign(&mut self, dur: Duration<T, U>) {
206        self.0 = self.0.saturating_add(dur.0);
207    }
208}
209
210impl<T: Timeline, U: TimeUnit> ops::SubAssign<Duration<T, U>> for Instant<T, U> {
211    fn sub_assign(&mut self, dur: Duration<T, U>) {
212        self.0 = self.0.saturating_sub(dur.0);
213    }
214}
215
216/// A marker trait for times to prevent accidental comparison between different timelines.
217pub trait Timeline: Default + Copy + Clone + PartialEq + Eq {}
218
219/// A marker type for the system's monotonic timeline which pauses during suspend.
220#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
221pub struct MonotonicTimeline;
222impl Timeline for MonotonicTimeline {}
223
224/// A marker type for the system's boot timeline which continues running during suspend.
225#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
226pub struct BootTimeline;
227impl Timeline for BootTimeline {}
228
229/// A marker type representing a synthetic timeline defined by a kernel clock object.
230#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
231pub struct SyntheticTimeline;
232impl Timeline for SyntheticTimeline {}
233
234/// A marker trait for times and durations to prevent accidental comparison between different units.
235pub trait TimeUnit {}
236
237/// A marker type representing nanoseconds.
238#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
239pub struct NsUnit;
240impl TimeUnit for NsUnit {}
241
242/// A marker type representing system ticks.
243#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
244pub struct TicksUnit;
245impl TimeUnit for TicksUnit {}
246
247#[derive(
248    Debug,
249    Default,
250    Copy,
251    Clone,
252    Eq,
253    PartialEq,
254    Ord,
255    PartialOrd,
256    Hash,
257    FromBytes,
258    IntoBytes,
259    Immutable,
260)]
261#[repr(transparent)]
262pub struct Duration<T, U = NsUnit>(sys::zx_duration_t, std::marker::PhantomData<(T, U)>);
263
264impl<T: Timeline> From<stdtime::Duration> for Duration<T, NsUnit> {
265    fn from(dur: stdtime::Duration) -> Self {
266        Duration::from_seconds(dur.as_secs() as i64)
267            + Duration::from_nanos(dur.subsec_nanos() as i64)
268    }
269}
270
271impl<T: Timeline, U: TimeUnit> ops::Add<Instant<T, U>> for Duration<T, U> {
272    type Output = Instant<T, U>;
273    fn add(self, time: Instant<T, U>) -> Self::Output {
274        Instant(self.0.saturating_add(time.0), std::marker::PhantomData)
275    }
276}
277
278impl<T: Timeline, U: TimeUnit> ops::Add for Duration<T, U> {
279    type Output = Duration<T, U>;
280    fn add(self, rhs: Duration<T, U>) -> Self::Output {
281        Self(self.0.saturating_add(rhs.0), std::marker::PhantomData)
282    }
283}
284
285impl<T: Timeline, U: TimeUnit> ops::Sub for Duration<T, U> {
286    type Output = Duration<T, U>;
287    fn sub(self, rhs: Duration<T, U>) -> Duration<T, U> {
288        Self(self.0.saturating_sub(rhs.0), std::marker::PhantomData)
289    }
290}
291
292impl<T: Timeline, U: TimeUnit> ops::AddAssign for Duration<T, U> {
293    fn add_assign(&mut self, rhs: Duration<T, U>) {
294        self.0 = self.0.saturating_add(rhs.0);
295    }
296}
297
298impl<T: Timeline, U: TimeUnit> ops::SubAssign for Duration<T, U> {
299    fn sub_assign(&mut self, rhs: Duration<T, U>) {
300        self.0 = self.0.saturating_sub(rhs.0);
301    }
302}
303
304impl<T: Timeline, S: Into<i64>, U: TimeUnit> ops::Mul<S> for Duration<T, U> {
305    type Output = Self;
306    fn mul(self, mul: S) -> Self {
307        Self(self.0.saturating_mul(mul.into()), std::marker::PhantomData)
308    }
309}
310
311impl<S: Into<i64>, T: Timeline, U: TimeUnit> ops::Div<S> for Duration<T, U> {
312    type Output = Self;
313    fn div(self, div: S) -> Self {
314        Self(self.0.saturating_div(div.into()), std::marker::PhantomData)
315    }
316}
317
318impl<T: Timeline, U: TimeUnit> ops::Neg for Duration<T, U> {
319    type Output = Self;
320
321    fn neg(self) -> Self::Output {
322        Self(self.0.saturating_neg(), std::marker::PhantomData)
323    }
324}
325
326impl<T: Timeline> Duration<T, NsUnit> {
327    pub const INFINITE: Duration<T> = Duration(sys::zx_duration_t::MAX, std::marker::PhantomData);
328    pub const INFINITE_PAST: Duration<T> =
329        Duration(sys::zx_duration_t::MIN, std::marker::PhantomData);
330    pub const ZERO: Duration<T> = Duration(0, std::marker::PhantomData);
331
332    /// Returns the number of nanoseconds contained by this `Duration`.
333    pub const fn into_nanos(self) -> i64 {
334        self.0
335    }
336
337    /// Returns the total number of whole microseconds contained by this `Duration`.
338    pub const fn into_micros(self) -> i64 {
339        self.0 / 1_000
340    }
341
342    /// Returns the total number of whole milliseconds contained by this `Duration`.
343    pub const fn into_millis(self) -> i64 {
344        self.into_micros() / 1_000
345    }
346
347    /// Returns the total number of whole seconds contained by this `Duration`.
348    pub const fn into_seconds(self) -> i64 {
349        self.into_millis() / 1_000
350    }
351
352    /// Returns the duration as a floating-point value in seconds.
353    pub fn into_seconds_f64(self) -> f64 {
354        self.into_nanos() as f64 / 1_000_000_000f64
355    }
356
357    /// Returns the total number of whole minutes contained by this `Duration`.
358    pub const fn into_minutes(self) -> i64 {
359        self.into_seconds() / 60
360    }
361
362    /// Returns the total number of whole hours contained by this `Duration`.
363    pub const fn into_hours(self) -> i64 {
364        self.into_minutes() / 60
365    }
366
367    pub const fn from_nanos(nanos: i64) -> Self {
368        Duration(nanos, std::marker::PhantomData)
369    }
370
371    pub const fn from_micros(micros: i64) -> Self {
372        Duration(micros.saturating_mul(1_000), std::marker::PhantomData)
373    }
374
375    pub const fn from_millis(millis: i64) -> Self {
376        Duration::from_micros(millis.saturating_mul(1_000))
377    }
378
379    pub const fn from_seconds(secs: i64) -> Self {
380        Duration::from_millis(secs.saturating_mul(1_000))
381    }
382
383    pub const fn from_minutes(min: i64) -> Self {
384        Duration::from_seconds(min.saturating_mul(60))
385    }
386
387    pub const fn from_hours(hours: i64) -> Self {
388        Duration::from_minutes(hours.saturating_mul(60))
389    }
390}
391
392impl<T: Timeline> Duration<T, TicksUnit> {
393    /// Return the raw number of ticks represented by this `Duration`.
394    pub const fn into_raw(self) -> i64 {
395        self.0
396    }
397
398    /// Return a typed wrapper around the provided number of ticks.
399    pub const fn from_raw(raw: i64) -> Self {
400        Self(raw, std::marker::PhantomData)
401    }
402}
403
404impl MonotonicDuration {
405    /// Sleep for the given amount of time.
406    pub fn sleep(self) {
407        MonotonicInstant::after(self).sleep()
408    }
409}
410
411/// An object representing a Zircon timer, such as the one returned by
412/// [zx_timer_create](https://fuchsia.dev/fuchsia-src/reference/syscalls/timer_create.md).
413///
414/// As essentially a subtype of `Handle`, it can be freely interconverted.
415#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
416#[repr(transparent)]
417// TODO(https://fxbug.dev/361661898) remove default type when FIDL understands mono vs. boot timers
418pub struct Timer<T = MonotonicTimeline>(Handle, std::marker::PhantomData<T>);
419
420#[repr(C)]
421#[derive(Debug, Copy, Clone, Eq, PartialEq, FromBytes, Immutable)]
422pub struct TimerInfo<T: Timeline> {
423    pub options: u32,
424    // NB: Currently, this field is irrelevant, because the clock ID will always match the timeline
425    // of the Timer which is represented by this TimerInfo.  For example, with a MonotonicTimer,
426    // clock_id is always 0 (ZX_CLOCK_MONOTONIC).  If the timer syscalls eventually allow arbitrary
427    // clock IDs, we can make this field public.
428    clock_id: u32,
429    pub deadline: Instant<T>,
430    pub slack: Duration<T>,
431}
432
433pub type MonotonicTimerInfo = TimerInfo<MonotonicTimeline>;
434pub type BootTimerInfo = TimerInfo<BootTimeline>;
435pub type SyntheticTimerInfo = TimerInfo<SyntheticTimeline>;
436
437static_assertions::assert_eq_size!(MonotonicTimerInfo, sys::zx_info_timer_t);
438static_assertions::assert_eq_size!(BootTimerInfo, sys::zx_info_timer_t);
439static_assertions::assert_eq_size!(SyntheticTimerInfo, sys::zx_info_timer_t);
440
441impl<T: Timeline> Default for TimerInfo<T> {
442    fn default() -> Self {
443        Self::from_raw(sys::zx_info_timer_t::default())
444    }
445}
446
447impl<T: Timeline> TimerInfo<T> {
448    fn from_raw(info: sys::zx_info_timer_t) -> Self {
449        zerocopy::transmute!(info)
450    }
451}
452
453struct TimerInfoQuery;
454unsafe impl ObjectQuery for TimerInfoQuery {
455    const TOPIC: Topic = Topic::TIMER;
456    type InfoTy = sys::zx_info_timer_t;
457}
458
459/// A timer that measures its deadlines against the monotonic clock.
460pub type MonotonicTimer = Timer<MonotonicTimeline>;
461
462/// A timer that measures its deadlines against the boot clock.
463pub type BootTimer = Timer<BootTimeline>;
464
465impl<T: Timeline> Timer<T> {
466    /// Wraps the
467    /// [zx_object_get_info](https://fuchsia.dev/fuchsia-src/reference/syscalls/object_get_info.md)
468    /// syscall for the ZX_INFO_TIMER_T topic.
469    pub fn info(&self) -> Result<TimerInfo<T>, Status> {
470        Ok(TimerInfo::from_raw(object_get_info_single::<TimerInfoQuery>(self.as_handle_ref())?))
471    }
472}
473
474impl Timer<MonotonicTimeline> {
475    /// Create a timer, an object that can signal when a specified point on the monotonic clock has
476    /// been reached. Wraps the
477    /// [zx_timer_create](https://fuchsia.dev/fuchsia-src/reference/syscalls/timer_create.md)
478    /// syscall.
479    ///
480    /// # Panics
481    ///
482    /// If the kernel reports no memory available to create a timer or the process' job policy
483    /// denies timer creation.
484    pub fn create() -> Self {
485        let mut out = 0;
486        let opts = 0;
487        let status = unsafe { sys::zx_timer_create(opts, sys::ZX_CLOCK_MONOTONIC, &mut out) };
488        ok(status)
489            .expect("timer creation always succeeds except with OOM or when job policy denies it");
490        unsafe { Self::from(Handle::from_raw(out)) }
491    }
492}
493
494impl Timer<BootTimeline> {
495    /// Create a timer, an object that can signal when a specified point on the boot clock has been
496    /// reached. Wraps the
497    /// [zx_timer_create](https://fuchsia.dev/fuchsia-src/reference/syscalls/timer_create.md)
498    /// syscall.
499    ///
500    /// If the timer elapses while the system is suspended it will not wake the system.
501    ///
502    /// # Panics
503    ///
504    /// If the kernel reports no memory available to create a timer or the process' job policy
505    /// denies timer creation.
506    pub fn create() -> Self {
507        let mut out = 0;
508        let opts = 0;
509        let status = unsafe { sys::zx_timer_create(opts, sys::ZX_CLOCK_BOOT, &mut out) };
510        ok(status)
511            .expect("timer creation always succeeds except with OOM or when job policy denies it");
512        unsafe { Self::from(Handle::from_raw(out)) }
513    }
514}
515
516impl<T: Timeline> Timer<T> {
517    /// Start a one-shot timer that will fire when `deadline` passes. Wraps the
518    /// [zx_timer_set](https://fuchsia.dev/fuchsia-src/reference/syscalls/timer_set.md)
519    /// syscall.
520    pub fn set(&self, deadline: Instant<T>, slack: Duration<T, NsUnit>) -> Result<(), Status> {
521        let status = unsafe {
522            sys::zx_timer_set(self.raw_handle(), deadline.into_nanos(), slack.into_nanos())
523        };
524        ok(status)
525    }
526
527    /// Cancels a pending timer that was started with set(). Wraps the
528    /// [zx_timer_cancel](https://fuchsia.dev/fuchsia-src/reference/syscalls/timer_cancel.md)
529    /// syscall.
530    pub fn cancel(&self) -> Result<(), Status> {
531        let status = unsafe { sys::zx_timer_cancel(self.raw_handle()) };
532        ok(status)
533    }
534}
535
536impl<T: Timeline> AsHandleRef for Timer<T> {
537    fn as_handle_ref(&self) -> HandleRef<'_> {
538        self.0.as_handle_ref()
539    }
540}
541
542impl<T: Timeline> From<Handle> for Timer<T> {
543    fn from(handle: Handle) -> Self {
544        Timer(handle, std::marker::PhantomData)
545    }
546}
547
548impl<T: Timeline> From<Timer<T>> for Handle {
549    fn from(x: Timer<T>) -> Handle {
550        x.0
551    }
552}
553
554impl<T: Timeline> HandleBased for Timer<T> {}
555
556#[cfg(test)]
557mod tests {
558    use super::*;
559    use crate::Signals;
560
561    #[test]
562    fn time_debug_repr_is_short() {
563        assert_eq!(
564            format!("{:?}", MonotonicInstant::from_nanos(0)),
565            "Instant<MonotonicTimeline, NsUnit>(0)"
566        );
567        assert_eq!(
568            format!("{:?}", SyntheticInstant::from_nanos(0)),
569            "Instant<SyntheticTimeline, NsUnit>(0)"
570        );
571    }
572
573    #[test]
574    fn monotonic_time_increases() {
575        let time1 = MonotonicInstant::get();
576        Duration::from_nanos(1_000).sleep();
577        let time2 = MonotonicInstant::get();
578        assert!(time2 > time1);
579    }
580
581    #[test]
582    fn ticks_increases() {
583        let ticks1 = MonotonicTicks::get();
584        Duration::from_nanos(1_000).sleep();
585        let ticks2 = MonotonicTicks::get();
586        assert!(ticks2 > ticks1);
587    }
588
589    #[test]
590    fn boot_time_increases() {
591        let time1 = BootInstant::get();
592        Duration::from_nanos(1_000).sleep();
593        let time2 = BootInstant::get();
594        assert!(time2 > time1);
595    }
596
597    #[test]
598    fn boot_ticks_increases() {
599        let ticks1 = BootTicks::get();
600        Duration::from_nanos(1_000).sleep();
601        let ticks2 = BootTicks::get();
602        assert!(ticks2 > ticks1);
603    }
604
605    #[test]
606    fn tick_length() {
607        let sleep_time = Duration::from_millis(1);
608        let ticks1 = MonotonicTicks::get();
609        sleep_time.sleep();
610        let ticks2 = MonotonicTicks::get();
611
612        // The number of ticks should have increased by at least 1 ms worth
613        let sleep_ticks = MonotonicDurationTicks::from_raw(
614            sleep_time.into_millis() * (MonotonicTicks::per_second() / 1000),
615        );
616        assert!(ticks2 >= (ticks1 + sleep_ticks));
617    }
618
619    #[test]
620    fn sleep() {
621        let sleep_ns = Duration::from_millis(1);
622        let time1 = MonotonicInstant::get();
623        sleep_ns.sleep();
624        let time2 = MonotonicInstant::get();
625        assert!(time2 > time1 + sleep_ns);
626    }
627
628    #[test]
629    fn from_std() {
630        let std_dur = stdtime::Duration::new(25, 25);
631        let dur = MonotonicDuration::from(std_dur);
632        let std_dur_nanos = (1_000_000_000 * std_dur.as_secs()) + std_dur.subsec_nanos() as u64;
633        assert_eq!(std_dur_nanos as i64, dur.into_nanos());
634    }
635
636    #[test]
637    fn i64_conversions() {
638        let nanos_in_one_hour = 3_600_000_000_000;
639        let dur_from_nanos = MonotonicDuration::from_nanos(nanos_in_one_hour);
640        let dur_from_hours = MonotonicDuration::from_hours(1);
641        assert_eq!(dur_from_nanos, dur_from_hours);
642        assert_eq!(dur_from_nanos.into_nanos(), dur_from_hours.into_nanos());
643        assert_eq!(dur_from_nanos.into_nanos(), nanos_in_one_hour);
644        assert_eq!(dur_from_nanos.into_hours(), 1);
645    }
646
647    #[test]
648    fn monotonic_timer_basic() {
649        let slack = Duration::from_millis(0);
650        let ten_ms = Duration::from_millis(10);
651        let five_secs = Duration::from_seconds(5);
652
653        // Create a timer
654        let timer = MonotonicTimer::create();
655
656        let info = timer.info().expect("info() failed");
657        assert_eq!(info.clock_id, sys::ZX_CLOCK_MONOTONIC);
658        assert_eq!(info.deadline, Instant::ZERO);
659        // NB: We don't check slack, because the kernel can change it based on its own policies.
660
661        // Should not signal yet.
662        assert_eq!(
663            timer.wait_handle(Signals::TIMER_SIGNALED, MonotonicInstant::after(ten_ms)),
664            Err(Status::TIMED_OUT)
665        );
666
667        // Set it, and soon it should signal.
668        let instant = MonotonicInstant::after(five_secs);
669        assert_eq!(timer.set(instant, slack), Ok(()));
670        assert_eq!(
671            timer.wait_handle(Signals::TIMER_SIGNALED, Instant::INFINITE),
672            Ok(Signals::TIMER_SIGNALED)
673        );
674        // Once the timer has fired, its deadline is reset to zero.
675        assert_eq!(timer.info().expect("info() failed").deadline, Instant::ZERO);
676
677        // Cancel it, and it should stop signalling.
678        assert_eq!(timer.cancel(), Ok(()));
679        assert_eq!(
680            timer.wait_handle(Signals::TIMER_SIGNALED, MonotonicInstant::after(ten_ms)),
681            Err(Status::TIMED_OUT)
682        );
683        assert_eq!(timer.info().expect("info() failed").deadline, Instant::ZERO);
684
685        assert_eq!(timer.set(Instant::INFINITE, slack), Ok(()));
686        assert_eq!(timer.info().expect("info() failed").deadline, Instant::INFINITE);
687    }
688
689    #[test]
690    fn boot_timer_basic() {
691        let slack = Duration::from_millis(0);
692        let ten_ms = Duration::from_millis(10);
693        let five_secs = Duration::from_seconds(5);
694
695        // Create a timer
696        let timer = BootTimer::create();
697
698        let info = timer.info().expect("info() failed");
699        assert_eq!(info.clock_id, sys::ZX_CLOCK_BOOT);
700        assert_eq!(info.deadline, Instant::ZERO);
701        // NB: We don't check slack, because the kernel can change it based on its own policies.
702
703        // Should not signal yet.
704        assert_eq!(
705            timer.wait_handle(Signals::TIMER_SIGNALED, MonotonicInstant::after(ten_ms)),
706            Err(Status::TIMED_OUT)
707        );
708
709        // Set it, and soon it should signal.
710        let instant = BootInstant::after(five_secs);
711        assert_eq!(timer.set(instant, slack), Ok(()));
712        assert_eq!(
713            timer.wait_handle(Signals::TIMER_SIGNALED, Instant::INFINITE),
714            Ok(Signals::TIMER_SIGNALED)
715        );
716        // Once the timer has fired, its deadline is reset to zero.
717        assert_eq!(timer.info().expect("info() failed").deadline, Instant::ZERO);
718
719        // Cancel it, and it should stop signalling.
720        assert_eq!(timer.cancel(), Ok(()));
721        assert_eq!(
722            timer.wait_handle(Signals::TIMER_SIGNALED, MonotonicInstant::after(ten_ms)),
723            Err(Status::TIMED_OUT)
724        );
725        assert_eq!(timer.info().expect("info() failed").deadline, Instant::ZERO);
726
727        assert_eq!(timer.set(Instant::INFINITE, slack), Ok(()));
728        assert_eq!(timer.info().expect("info() failed").deadline, Instant::INFINITE);
729    }
730
731    #[test]
732    fn time_minus_time() {
733        let lhs = MonotonicInstant::from_nanos(10);
734        let rhs = MonotonicInstant::from_nanos(30);
735        assert_eq!(lhs - rhs, Duration::from_nanos(-20));
736    }
737
738    #[test]
739    fn time_saturation() {
740        // Addition
741        assert_eq!(
742            MonotonicInstant::from_nanos(10) + Duration::from_nanos(30),
743            MonotonicInstant::from_nanos(40)
744        );
745        assert_eq!(
746            MonotonicInstant::from_nanos(10) + Duration::INFINITE,
747            MonotonicInstant::INFINITE
748        );
749        assert_eq!(
750            MonotonicInstant::from_nanos(-10) + Duration::INFINITE_PAST,
751            MonotonicInstant::INFINITE_PAST
752        );
753
754        // Subtraction
755        assert_eq!(
756            MonotonicInstant::from_nanos(10) - Duration::from_nanos(30),
757            MonotonicInstant::from_nanos(-20)
758        );
759        assert_eq!(
760            MonotonicInstant::from_nanos(-10) - Duration::INFINITE,
761            MonotonicInstant::INFINITE_PAST
762        );
763        assert_eq!(
764            MonotonicInstant::from_nanos(10) - Duration::INFINITE_PAST,
765            MonotonicInstant::INFINITE
766        );
767
768        // Assigning addition
769        {
770            let mut t = MonotonicInstant::from_nanos(10);
771            t += Duration::from_nanos(30);
772            assert_eq!(t, MonotonicInstant::from_nanos(40));
773        }
774        {
775            let mut t = MonotonicInstant::from_nanos(10);
776            t += Duration::INFINITE;
777            assert_eq!(t, MonotonicInstant::INFINITE);
778        }
779        {
780            let mut t = MonotonicInstant::from_nanos(-10);
781            t += Duration::INFINITE_PAST;
782            assert_eq!(t, MonotonicInstant::INFINITE_PAST);
783        }
784
785        // Assigning subtraction
786        {
787            let mut t = MonotonicInstant::from_nanos(10);
788            t -= Duration::from_nanos(30);
789            assert_eq!(t, MonotonicInstant::from_nanos(-20));
790        }
791        {
792            let mut t = MonotonicInstant::from_nanos(-10);
793            t -= Duration::INFINITE;
794            assert_eq!(t, MonotonicInstant::INFINITE_PAST);
795        }
796        {
797            let mut t = MonotonicInstant::from_nanos(10);
798            t -= Duration::INFINITE_PAST;
799            assert_eq!(t, MonotonicInstant::INFINITE);
800        }
801    }
802
803    #[test]
804    fn duration_saturation() {
805        // Addition
806        assert_eq!(
807            MonotonicDuration::from_nanos(10) + Duration::from_nanos(30),
808            Duration::from_nanos(40)
809        );
810        assert_eq!(MonotonicDuration::from_nanos(10) + Duration::INFINITE, Duration::INFINITE);
811        assert_eq!(
812            MonotonicDuration::from_nanos(-10) + Duration::INFINITE_PAST,
813            Duration::INFINITE_PAST
814        );
815
816        // Subtraction
817        assert_eq!(
818            MonotonicDuration::from_nanos(10) - Duration::from_nanos(30),
819            Duration::from_nanos(-20)
820        );
821        assert_eq!(
822            MonotonicDuration::from_nanos(-10) - Duration::INFINITE,
823            Duration::INFINITE_PAST
824        );
825        assert_eq!(MonotonicDuration::from_nanos(10) - Duration::INFINITE_PAST, Duration::INFINITE);
826
827        // Multiplication
828        assert_eq!(MonotonicDuration::from_nanos(10) * 3, Duration::from_nanos(30));
829        assert_eq!(MonotonicDuration::from_nanos(10) * i64::MAX, Duration::INFINITE);
830        assert_eq!(MonotonicDuration::from_nanos(10) * i64::MIN, Duration::INFINITE_PAST);
831
832        // Division
833        assert_eq!(MonotonicDuration::from_nanos(30) / 3, Duration::from_nanos(10));
834        assert_eq!(MonotonicDuration::INFINITE_PAST / -1, Duration::INFINITE);
835
836        // Negation
837        assert_eq!(-MonotonicDuration::from_nanos(30), Duration::from_nanos(-30));
838        assert_eq!(-MonotonicDuration::INFINITE_PAST, Duration::INFINITE);
839
840        // Assigning addition
841        {
842            let mut t = MonotonicDuration::from_nanos(10);
843            t += Duration::from_nanos(30);
844            assert_eq!(t, Duration::from_nanos(40));
845        }
846        {
847            let mut t = MonotonicDuration::from_nanos(10);
848            t += Duration::INFINITE;
849            assert_eq!(t, Duration::INFINITE);
850        }
851        {
852            let mut t = MonotonicDuration::from_nanos(-10);
853            t += Duration::INFINITE_PAST;
854            assert_eq!(t, Duration::INFINITE_PAST);
855        }
856
857        // Assigning subtraction
858        {
859            let mut t = MonotonicDuration::from_nanos(10);
860            t -= Duration::from_nanos(30);
861            assert_eq!(t, Duration::from_nanos(-20));
862        }
863        {
864            let mut t = MonotonicDuration::from_nanos(-10);
865            t -= Duration::INFINITE;
866            assert_eq!(t, Duration::INFINITE_PAST);
867        }
868        {
869            let mut t = MonotonicDuration::from_nanos(10);
870            t -= Duration::INFINITE_PAST;
871            assert_eq!(t, Duration::INFINITE);
872        }
873    }
874
875    #[test]
876    fn time_minus_time_saturates() {
877        assert_eq!(
878            MonotonicInstant::INFINITE - MonotonicInstant::INFINITE_PAST,
879            Duration::INFINITE
880        );
881    }
882
883    #[test]
884    fn time_and_duration_defaults() {
885        assert_eq!(MonotonicInstant::default(), MonotonicInstant::from_nanos(0));
886        assert_eq!(Duration::default(), MonotonicDuration::from_nanos(0));
887    }
888}
zx/time.rs

zx/
time.rs
