dope-runtime 0.24.0

Thread-per-core execution and process lifecycle 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

use std::{mem, pin};

use dope_core::driver::{
    retained,
    route::{self, kind},
    schedule,
};

use crate::executor;

/// Route activation authority for one exact retained root and scheduler turn.
#[must_use]
pub struct Activate<'driver, 'turn, 'root, 'd: 'root> {
    drive: executor::raw::Drive<'driver, 'turn, 'root, 'd>,
    target: route::Erased<'d, kind::Any>,
}

impl<'driver, 'turn, 'root, 'd: 'root> Activate<'driver, 'turn, 'root, 'd> {
    pub(crate) const fn new(
        target: route::Erased<'d, kind::Any>,
        turn: schedule::Turn<'turn, 'd>,
        driver: retained::Context<'driver, 'root, 'd>,
    ) -> Self {
        Self {
            drive: executor::raw::Drive { turn, driver },
            target,
        }
    }

    pub const fn target(&self) -> route::Erased<'d, kind::Any> {
        self.target
    }

    pub fn reborrow(&mut self) -> Activate<'_, '_, 'root, 'd> {
        Activate {
            drive: self.drive.reborrow(),
            target: self.target,
        }
    }

    pub(crate) fn wake<R>(self, app: pin::Pin<&mut R>)
    where
        R: executor::raw::App<'d>,
    {
        if !R::WAKE_ROUTES.has_route(self.target.route()) {
            return;
        }
        // SAFETY: the session view admits only a target declared by the
        // activation route set and supplies its exact installed pinned root.
        unsafe { R::activate(app, self) };
    }

    pub fn into_driver(
        self,
    ) -> (
        route::Erased<'d, kind::Any>,
        retained::Context<'driver, 'root, 'd>,
    ) {
        (self.target, self.drive.driver)
    }

    pub fn map<R>(
        self,
        map: impl FnOnce(
            route::Erased<'d, kind::Any>,
            schedule::Turn<'turn, 'd>,
            retained::Context<'driver, 'root, 'd>,
        ) -> R,
    ) -> R {
        let executor::raw::Drive { turn, driver } = self.drive;
        map(self.target, turn, driver)
    }
}

const _: () = {
    assert!(
        mem::size_of::<Activate<'static, 'static, 'static, 'static>>()
            == mem::size_of::<executor::raw::Drive<'static, 'static, 'static, 'static>>()
                + mem::size_of::<route::Erased<'static, kind::Any>>()
    );
    assert!(
        mem::align_of::<Activate<'static, 'static, 'static, 'static>>() == mem::align_of::<usize>()
    );
};