dope-runtime 0.41.0

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

use std::mem;

use o3::base::marker::ThreadBound;

use crate::process::{
    failure::bus::{Event, Fault},
    runtime::bus,
};

/// Single-use proof that one worker still holds its application gate closed.
#[must_use]
#[repr(transparent)]
pub struct Closed<'run> {
    tx: bus::Tx<'run>,
    thread: ThreadBound,
}

/// Single-use proof that one worker has opened its application gate.
#[must_use]
#[repr(transparent)]
pub struct Open<'run> {
    tx: bus::Tx<'run>,
    thread: ThreadBound,
}

impl<'run> Closed<'run> {
    pub(in crate::process) const fn new(tx: bus::Tx<'run>) -> Self {
        Self {
            tx,
            thread: ThreadBound::NEW,
        }
    }

    pub fn open(self) -> Result<Open<'run>, Fault> {
        let tx = self.tx;
        tx.send(Event::Ready)?;
        Ok(Open::new(tx))
    }
}

impl<'run> Open<'run> {
    const fn new(tx: bus::Tx<'run>) -> Self {
        Self {
            tx,
            thread: ThreadBound::NEW,
        }
    }

    pub fn finish(self) -> Result<(), Fault> {
        self.tx.send(Event::Drain)
    }
}

const _: () = {
    assert!(mem::size_of::<Closed<'static>>() == mem::size_of::<bus::Tx<'static>>());
    assert!(mem::align_of::<Closed<'static>>() == mem::align_of::<bus::Tx<'static>>());
    assert!(mem::size_of::<Open<'static>>() == mem::size_of::<bus::Tx<'static>>());
    assert!(mem::align_of::<Open<'static>>() == mem::align_of::<bus::Tx<'static>>());
};