dope-manifold 0.22.0

Owned application and service composition for dope
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

use std::{pin, task};

use dope_core::driver::{route, route::Identity, schedule};

use crate::{app::dispatch, timing::watchdog::Watchdog};

// SAFETY: the pinned timer registration and kernel timer remain owned by the
// exact installed application through shutdown and finalization.
unsafe impl<'d, ID: Identity> dispatch::raw::Manifold<'d> for Watchdog<'d, ID> {
    const COORDS: usize = 0;

    type Route = ID;
    type Dispatch = dispatch::raw::Omit;
    type Install = dispatch::raw::Plain;
    type Finish = Self;
    type Activate = dispatch::raw::Plain;
    type Probe = Self;
    type PrePark = dispatch::raw::Plain;
    type Shutdown = dispatch::raw::Plain;

    unsafe fn pre_park<'a, 'turn, 'root>(
        self: pin::Pin<&'a mut Self>,
        _: schedule::Turn<'turn, 'd>,
        _: &mut dispatch::raw::Context<'_, 'root, 'd, Self::PrePark>,
    ) -> pin::Pin<&'a mut Self>
    where
        Self: 'root,
    {
        self
    }

    fn shutdown<'a, 'turn, 'root>(
        mut self: pin::Pin<&'a mut Self>,
        _: schedule::Turn<'turn, 'd>,
        _: &mut dispatch::raw::Context<'_, 'root, 'd, Self::Shutdown>,
    ) -> pin::Pin<&'a mut Self>
    where
        Self: 'root,
    {
        let this = self.as_mut().project();
        this.route.as_ref().cancel();
        *this.next = None;
        self
    }
}

// SAFETY: unit selection binds every query to this exact pinned watchdog.
unsafe impl<'d, ID: Identity> dispatch::raw::Probe<'d, Self> for Watchdog<'d, ID> {
    type Plan = ();

    fn select() -> Option<Self::Plan> {
        Some(())
    }

    fn run(call: dispatch::raw::Call<'_, '_, '_, 'd, Self, ()>) -> schedule::Progress<'d> {
        match *call.owner().project_ref().next {
            Some(deadline) => schedule::Progress::until(deadline),
            None => schedule::Progress::Quiescent,
        }
    }
}

// SAFETY: the pinned timer registration and kernel timer remain owned by the
// exact installed application through every activation.
unsafe impl<'d, ID: Identity> dispatch::raw::Activate<'d, ID> for Watchdog<'d, ID> {
    type Access = dispatch::raw::Plain;

    unsafe fn activate<'turn>(
        self: pin::Pin<&mut Self>,
        _: route::Target<'d, ID>,
        _: schedule::Turn<'turn, 'd>,
        driver: &mut dispatch::raw::Context<'_, '_, 'd, Self::Access>,
    ) {
        let this = self.project();
        let Some(deadline) = this.next else {
            return;
        };
        let now = driver.driver_ref().clock().now();
        if this.route.as_ref().poll(now) == task::Poll::Ready(()) {
            this.kernel.refresh(driver.reborrow());
        } else if this.route.as_ref().is_armed() {
            return;
        }
        let next = now.clamp_add(*this.period);
        if next <= now {
            // The route is no longer armed; the kernel timer remains armed
            // until exact-root finalization even when protocol time cannot advance.
            *this.next = None;
            return;
        }
        *deadline = next;
        this.route.as_ref().arm(next);
    }
}