dope-runtime 0.28.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

use dope_core::driver::{result::poll, schedule};
use drive::{clock, turn};
use schedule::clock::Sample;
use turn::scope;

use crate::executor::{self, drive};

pub(super) fn run<'app, 'd: 'app, D, S, C>(
    mut state: scope::Scope<'_, '_, 'app, 'd, D, S>,
    source: C,
    tick: impl Fn(C) -> Result<Sample, drive::Error>,
    mut shutdown: impl FnMut() -> turn::Status,
) -> Result<(), drive::Error>
where
    D: executor::raw::App<'d>,
    C: clock::Time,
{
    loop {
        let tick = tick(source)?;
        let ready = state.next_app(tick, &mut shutdown)?;
        if ready.is_quiet() && matches!(ready.shutdown(), schedule::Progress::Quiescent) {
            match ready.sync()? {
                poll::Commit::Drained => return Ok(()),
                poll::Commit::Pending => continue,
            }
        }
        let Some(idle) = ready.skip().park().sync()? else {
            continue;
        };
        let progress = idle.shutdown();
        if idle.is_quiet() && matches!(progress, schedule::Progress::Quiescent) {
            match idle.sync()? {
                poll::Commit::Drained => return Ok(()),
                poll::Commit::Pending => continue,
            }
        }
        idle.wait(progress, source)?;
    }
}