fuchsia_async/runtime/fuchsia/executor/
time.rs

1// Copyright 2021 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
5use super::common::EHandle;
6use crate::runtime::DurationExt;
7
8use std::ops;
9
10/// A time relative to the executor's clock.
11#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
12#[repr(transparent)]
13pub struct MonotonicInstant(zx::MonotonicInstant);
14
15pub use zx::MonotonicDuration;
16
17impl MonotonicInstant {
18    /// Return the current time according to the global executor.
19    ///
20    /// This function requires that an executor has been set up.
21    pub fn now() -> Self {
22        EHandle::local().inner().now()
23    }
24
25    /// Compute a deadline for the time in the future that is the
26    /// given `Duration` away. Similarly to `zx::MonotonicInstant::after`,
27    /// saturates on overflow instead of wrapping around.
28    ///
29    /// This function requires that an executor has been set up.
30    pub fn after(duration: zx::MonotonicDuration) -> Self {
31        Self::now() + duration
32    }
33
34    /// Convert from `zx::MonotonicInstant`.
35    pub const fn from_zx(t: zx::MonotonicInstant) -> Self {
36        MonotonicInstant(t)
37    }
38
39    /// Convert into `zx::MonotonicInstant`.
40    pub const fn into_zx(self) -> zx::MonotonicInstant {
41        self.0
42    }
43
44    /// Convert from nanoseconds.
45    pub const fn from_nanos(nanos: i64) -> Self {
46        Self::from_zx(zx::MonotonicInstant::from_nanos(nanos))
47    }
48
49    /// Convert to nanoseconds.
50    pub const fn into_nanos(self) -> i64 {
51        self.0.into_nanos()
52    }
53
54    /// The maximum time.
55    pub const INFINITE: MonotonicInstant = MonotonicInstant(zx::MonotonicInstant::INFINITE);
56
57    /// The minimum time.
58    pub const INFINITE_PAST: MonotonicInstant =
59        MonotonicInstant(zx::MonotonicInstant::INFINITE_PAST);
60}
61
62impl From<zx::MonotonicInstant> for MonotonicInstant {
63    fn from(t: zx::MonotonicInstant) -> MonotonicInstant {
64        MonotonicInstant(t)
65    }
66}
67
68impl From<MonotonicInstant> for zx::MonotonicInstant {
69    fn from(t: MonotonicInstant) -> zx::MonotonicInstant {
70        t.0
71    }
72}
73
74impl ops::Add<zx::MonotonicDuration> for MonotonicInstant {
75    type Output = MonotonicInstant;
76    fn add(self, d: zx::MonotonicDuration) -> MonotonicInstant {
77        MonotonicInstant(self.0 + d)
78    }
79}
80
81impl ops::Add<MonotonicInstant> for zx::MonotonicDuration {
82    type Output = MonotonicInstant;
83    fn add(self, t: MonotonicInstant) -> MonotonicInstant {
84        MonotonicInstant(self + t.0)
85    }
86}
87
88impl ops::Sub<zx::MonotonicDuration> for MonotonicInstant {
89    type Output = MonotonicInstant;
90    fn sub(self, d: zx::MonotonicDuration) -> MonotonicInstant {
91        MonotonicInstant(self.0 - d)
92    }
93}
94
95impl ops::Sub<MonotonicInstant> for MonotonicInstant {
96    type Output = zx::MonotonicDuration;
97    fn sub(self, t: MonotonicInstant) -> zx::MonotonicDuration {
98        self.0 - t.0
99    }
100}
101
102impl ops::AddAssign<zx::MonotonicDuration> for MonotonicInstant {
103    fn add_assign(&mut self, d: zx::MonotonicDuration) {
104        self.0.add_assign(d)
105    }
106}
107
108impl ops::SubAssign<zx::MonotonicDuration> for MonotonicInstant {
109    fn sub_assign(&mut self, d: zx::MonotonicDuration) {
110        self.0.sub_assign(d)
111    }
112}
113
114impl DurationExt for zx::MonotonicDuration {
115    fn after_now(self) -> MonotonicInstant {
116        MonotonicInstant::after(self)
117    }
118}
119
120/// A time relative to the executor's clock on the boot timeline.
121#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
122#[repr(transparent)]
123pub struct BootInstant(zx::BootInstant);
124
125impl BootInstant {
126    /// Return the current time according to the system boot clock. Advances while the system
127    /// is suspended.
128    pub fn now() -> Self {
129        EHandle::local().inner().boot_now()
130    }
131
132    /// Compute a deadline for the time in the future that is the
133    /// given `Duration` away. Similar to `zx::BootInstant::after`,
134    /// saturates on overflow instead of wrapping around.
135    pub fn after(duration: zx::BootDuration) -> Self {
136        Self::now() + duration
137    }
138
139    /// Convert from `zx::BootInstant`.
140    pub const fn from_zx(t: zx::BootInstant) -> Self {
141        BootInstant(t)
142    }
143
144    /// Convert into `zx::BootInstant`.
145    pub const fn into_zx(self) -> zx::BootInstant {
146        self.0
147    }
148
149    /// Convert from nanoseconds.
150    pub const fn from_nanos(nanos: i64) -> Self {
151        Self::from_zx(zx::BootInstant::from_nanos(nanos))
152    }
153
154    /// Convert to nanoseconds.
155    pub const fn into_nanos(self) -> i64 {
156        self.0.into_nanos()
157    }
158
159    /// The maximum time.
160    pub const INFINITE: BootInstant = BootInstant(zx::BootInstant::INFINITE);
161
162    /// The minimum time.
163    pub const INFINITE_PAST: BootInstant = BootInstant(zx::BootInstant::INFINITE_PAST);
164}
165
166impl From<zx::BootInstant> for BootInstant {
167    fn from(t: zx::BootInstant) -> BootInstant {
168        BootInstant(t)
169    }
170}
171
172impl From<BootInstant> for zx::BootInstant {
173    fn from(t: BootInstant) -> zx::BootInstant {
174        t.0
175    }
176}
177
178impl ops::Add<zx::BootDuration> for BootInstant {
179    type Output = BootInstant;
180    fn add(self, d: zx::BootDuration) -> BootInstant {
181        BootInstant(self.0 + d)
182    }
183}
184
185impl ops::Add<BootInstant> for zx::BootDuration {
186    type Output = BootInstant;
187    fn add(self, t: BootInstant) -> BootInstant {
188        BootInstant(self + t.0)
189    }
190}
191
192impl ops::Sub<zx::BootDuration> for BootInstant {
193    type Output = BootInstant;
194    fn sub(self, d: zx::BootDuration) -> BootInstant {
195        BootInstant(self.0 - d)
196    }
197}
198
199impl ops::Sub<BootInstant> for BootInstant {
200    type Output = zx::BootDuration;
201    fn sub(self, t: BootInstant) -> zx::BootDuration {
202        self.0 - t.0
203    }
204}
205
206impl ops::AddAssign<zx::BootDuration> for BootInstant {
207    fn add_assign(&mut self, d: zx::BootDuration) {
208        self.0.add_assign(d)
209    }
210}
211
212impl ops::SubAssign<zx::BootDuration> for BootInstant {
213    fn sub_assign(&mut self, d: zx::BootDuration) {
214        self.0.sub_assign(d)
215    }
216}
217
218#[cfg(test)]
219mod tests {
220    use super::*;
221
222    fn time_operations_param(
223        zxt1: zx::MonotonicInstant,
224        zxt2: zx::MonotonicInstant,
225        d: zx::MonotonicDuration,
226    ) {
227        let t1 = MonotonicInstant::from_zx(zxt1);
228        let t2 = MonotonicInstant::from_zx(zxt2);
229        assert_eq!(t1.into_zx(), zxt1);
230
231        assert_eq!(
232            MonotonicInstant::from_zx(zx::MonotonicInstant::INFINITE),
233            MonotonicInstant::INFINITE
234        );
235        assert_eq!(
236            MonotonicInstant::from_zx(zx::MonotonicInstant::INFINITE_PAST),
237            MonotonicInstant::INFINITE_PAST
238        );
239        assert_eq!(zxt1 - zxt2, t1 - t2);
240        assert_eq!(zxt1 + d, (t1 + d).into_zx());
241        assert_eq!(d + zxt1, (d + t1).into_zx());
242        assert_eq!(zxt1 - d, (t1 - d).into_zx());
243
244        let mut zxt = zxt1;
245        let mut t = t1;
246        t += d;
247        zxt += d;
248        assert_eq!(zxt, t.into_zx());
249        t -= d;
250        zxt -= d;
251        assert_eq!(zxt, t.into_zx());
252    }
253
254    #[test]
255    fn time_operations() {
256        time_operations_param(
257            zx::MonotonicInstant::from_nanos(0),
258            zx::MonotonicInstant::from_nanos(1000),
259            zx::MonotonicDuration::from_seconds(12),
260        );
261        time_operations_param(
262            zx::MonotonicInstant::from_nanos(-100000),
263            zx::MonotonicInstant::from_nanos(65324),
264            zx::MonotonicDuration::from_hours(-785),
265        );
266    }
267
268    #[test]
269    fn time_saturating_add() {
270        assert_eq!(
271            MonotonicInstant::from_nanos(10) + zx::MonotonicDuration::from_nanos(30),
272            MonotonicInstant::from_nanos(40)
273        );
274        assert_eq!(
275            MonotonicInstant::from_nanos(10)
276                + zx::MonotonicDuration::from_nanos(MonotonicInstant::INFINITE.into_nanos()),
277            MonotonicInstant::INFINITE
278        );
279        assert_eq!(
280            MonotonicInstant::from_nanos(-10)
281                + zx::MonotonicDuration::from_nanos(MonotonicInstant::INFINITE_PAST.into_nanos()),
282            MonotonicInstant::INFINITE_PAST
283        );
284    }
285}
fuchsia_async/runtime/fuchsia/executor/time.rs

fuchsia_async/runtime/fuchsia/executor/
time.rs
