sel4_async_time/
lib.rs

Help
1//
2// Copyright 2023, Colias Group, LLC
3//
4// SPDX-License-Identifier: BSD-2-Clause
5//
6
7#![no_std]
8
9extern crate alloc;
10
11use alloc::rc::Rc;
12use core::cell::RefCell;
13use core::fmt;
14use core::future::Future;
15use core::pin::Pin;
16use core::task::{Context, Poll, Waker};
17
18use pin_project::pin_project;
19
20mod instant;
21mod sub_key;
22mod timer_queue;
23
24use sub_key::SubKey;
25use timer_queue::{Key, TimerQueue};
26
27pub use instant::Instant;
28
29#[derive(Clone)]
30pub struct TimerManager {
31    shared: Rc<RefCell<TimerManagerShared>>,
32}
33
34struct TimerManagerShared {
35    pending: TimerQueue<Instant, usize, Rc<RefCell<TimerShared>>>,
36}
37
38struct TimerShared {
39    expired: bool,
40    waker: Option<Waker>,
41}
42
43impl TimerShared {
44    fn mark_expired(&mut self) {
45        assert!(!self.expired);
46        self.expired = true;
47        if let Some(waker) = self.waker.take() {
48            waker.wake();
49        };
50    }
51}
52
53impl TimerManagerShared {
54    fn new() -> Self {
55        Self {
56            pending: TimerQueue::new(),
57        }
58    }
59
60    fn poll(&mut self, timestamp: Instant) -> bool {
61        let mut activity = false;
62        for expired in self.pending.iter_expired(timestamp) {
63            expired.value().borrow_mut().mark_expired();
64            activity = true;
65        }
66        activity
67    }
68
69    fn poll_at(&mut self) -> Option<Instant> {
70        self.pending.peek_next_absolute_expiry().copied()
71    }
72}
73
74impl TimerManager {
75    #![allow(clippy::new_without_default)]
76    pub fn new() -> Self {
77        Self {
78            shared: Rc::new(RefCell::new(TimerManagerShared::new())),
79        }
80    }
81
82    fn shared(&self) -> &RefCell<TimerManagerShared> {
83        &self.shared
84    }
85
86    pub fn poll(&self, timestamp: Instant) -> bool {
87        self.shared().borrow_mut().poll(timestamp)
88    }
89
90    pub fn poll_at(&self) -> Option<Instant> {
91        self.shared().borrow_mut().poll_at()
92    }
93
94    pub fn sleep_until(&self, absolute_expiry: Instant) -> Sleep {
95        let timer_shared = Rc::new(RefCell::new(TimerShared {
96            expired: false,
97            waker: None,
98        }));
99        let timer_key = self
100            .shared()
101            .borrow_mut()
102            .pending
103            .insert(absolute_expiry, timer_shared.clone());
104        Sleep {
105            timer_manager: self.clone(),
106            timer_key,
107            timer_shared,
108        }
109    }
110
111    pub fn timeout_at<F: Future>(&self, absolute_deadline: Instant, future: F) -> Timeout<F> {
112        Timeout {
113            value: future,
114            sleep: self.sleep_until(absolute_deadline),
115        }
116    }
117}
118
119pub struct Sleep {
120    timer_manager: TimerManager,
121    timer_key: Key<Instant, usize>,
122    timer_shared: Rc<RefCell<TimerShared>>,
123}
124
125impl Future for Sleep {
126    type Output = ();
127
128    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
129        let mut timer_shared = self.timer_shared.borrow_mut();
130        if timer_shared.expired {
131            Poll::Ready(())
132        } else {
133            timer_shared.waker = Some(cx.waker().clone());
134            Poll::Pending
135        }
136    }
137}
138
139impl Drop for Sleep {
140    fn drop(&mut self) {
141        if !self.timer_shared.borrow().expired {
142            self.timer_manager
143                .shared()
144                .borrow_mut()
145                .pending
146                .remove(&self.timer_key);
147        }
148    }
149}
150
151#[pin_project]
152pub struct Timeout<F> {
153    #[pin]
154    value: F,
155    #[pin]
156    sleep: Sleep,
157}
158
159impl<F: Future> Future for Timeout<F> {
160    type Output = Result<F::Output, Elapsed>;
161
162    #[allow(clippy::redundant_pattern_matching)]
163    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
164        let this = self.project();
165        if let Poll::Ready(v) = this.value.poll(cx) {
166            return Poll::Ready(Ok(v));
167        }
168        if let Poll::Ready(_) = this.sleep.poll(cx) {
169            return Poll::Ready(Err(Elapsed::new()));
170        }
171        Poll::Pending
172    }
173}
174
175/// Error returned by `Timeout`.
176///
177/// This error is returned when a timeout expires before the function was able to finish.
178#[derive(Debug, PartialEq, Eq)]
179pub struct Elapsed(());
180
181impl Elapsed {
182    fn new() -> Self {
183        Elapsed(())
184    }
185}
186
187impl fmt::Display for Elapsed {
188    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
189        write!(f, "deadline has elapsed")
190    }
191}
sel4_async_time/lib.rs

sel4_async_time/
lib.rs
