dope-core 0.15.0

The manifold runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::{cell, pin, task, time};

use crate::driver::schedule::{
    ready::completion,
    timer::{self, overflow},
};

/// An owning timer registration.
/// Its fixed-slot fast path overflows to an intrusive deadline queue.
/// Timer capacity is a performance bound, never a correctness bound.
#[pin_project::pin_project(PinnedDrop, !Unpin)]
pub struct Registration<'timer, 'd> {
    deadline: cell::Cell<Option<time::Instant>>,
    ticket: cell::Cell<Option<timer::Ticket>>,
    #[pin]
    waiter: overflow::Waiter<'timer, 'd>,
}

impl<'timer, 'd> Registration<'timer, 'd> {
    pub fn new(timer: &'timer timer::Timer<'d>) -> Self {
        Self {
            deadline: cell::Cell::new(None),
            ticket: cell::Cell::new(None),
            waiter: timer.waiter(),
        }
    }

    pub fn with_deadline(timer: &'timer timer::Timer<'d>, deadline: timer::Deadline<'d>) -> Self {
        Self {
            deadline: cell::Cell::new(Some(deadline.at)),
            ticket: cell::Cell::new(None),
            waiter: timer.waiter(),
        }
    }

    pub fn is_armed(self: pin::Pin<&Self>) -> bool {
        self.project_ref().deadline.get().is_some()
    }

    pub fn arm(self: pin::Pin<&Self>, deadline: timer::Deadline<'d>, wake: completion::Waker<'d>) {
        let this = self.project_ref();
        let timer = this.waiter.as_ref().timer();
        if let Some(ticket) = this.ticket.take() {
            timer.cancel(ticket);
        }
        this.waiter.as_ref().unregister();
        this.deadline.set(Some(deadline.at));
        self.register(wake);
    }

    pub fn poll(
        self: pin::Pin<&Self>,
        now: timer::Deadline<'d>,
        wake: completion::Waker<'d>,
    ) -> task::Poll<()> {
        use std::task::Poll;
        let this = self.project_ref();
        let Some(deadline) = this.deadline.get() else {
            return Poll::Pending;
        };
        let timer = this.waiter.as_ref().timer();
        if now.at >= deadline
            || this
                .ticket
                .get()
                .is_some_and(|ticket| timer.is_fired(ticket))
        {
            if let Some(ticket) = this.ticket.take() {
                timer.cancel(ticket);
            }
            this.waiter.as_ref().unregister();
            this.deadline.set(None);
            return Poll::Ready(());
        }
        if let Some(ticket) = this.ticket.get() {
            timer.replace_waker(ticket, wake);
            this.waiter.as_ref().unregister();
        } else {
            self.register(wake);
        }
        Poll::Pending
    }

    pub fn cancel(self: pin::Pin<&Self>) -> bool {
        let this = self.project_ref();
        let was_armed = this.deadline.take().is_some();
        if let Some(ticket) = this.ticket.take() {
            this.waiter.as_ref().timer().cancel(ticket);
        }
        this.waiter.as_ref().unregister();
        was_armed
    }

    fn register(self: pin::Pin<&Self>, wake: completion::Waker<'d>) {
        let this = self.project_ref();
        let Some(deadline) = this.deadline.get() else {
            return;
        };
        let waiter = this.waiter.as_ref();
        match waiter.timer().try_arm(deadline, wake) {
            Ok(armed) => {
                this.ticket.set(Some(armed));
                waiter.unregister();
            }
            Err(wake) => waiter.register(deadline, wake),
        }
    }
}

#[pin_project::pinned_drop]
impl PinnedDrop for Registration<'_, '_> {
    fn drop(self: pin::Pin<&mut Self>) {
        self.as_ref().cancel();
    }
}