dope-core 0.29.1

Owned native I/O and completion driver 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
95

use std::cell;

#[derive(Clone, Copy, Eq, PartialEq)]
#[repr(u8)]
pub(in crate::driver::schedule::ready) enum Side {
    A,
    B,
}

#[derive(Clone, Copy, Eq, PartialEq)]
pub(in crate::driver::schedule::ready::arena::set) enum Phase {
    Idle,
    Draining,
    Paused(Side),
}

#[derive(Clone, Copy, Eq, PartialEq)]
#[repr(u8)]
enum Mode {
    IdleA,
    IdleB,
    DrainingA,
    DrainingB,
    PausedA,
    PausedB,
}

pub(in crate::driver::schedule::ready::arena::set) struct State {
    mode: cell::Cell<Mode>,
}

impl Side {
    pub(in crate::driver::schedule::ready::arena::set) const fn index(self) -> usize {
        match self {
            Self::A => 0,
            Self::B => 1,
        }
    }

    pub(in crate::driver::schedule::ready::arena::set) const fn other(self) -> Self {
        match self {
            Self::A => Self::B,
            Self::B => Self::A,
        }
    }
}

impl State {
    pub(in crate::driver::schedule::ready::arena::set) const fn new() -> Self {
        Self {
            mode: cell::Cell::new(Mode::IdleA),
        }
    }

    pub(in crate::driver::schedule::ready::arena::set) fn active(&self) -> Side {
        match self.mode.get() {
            Mode::IdleA => Side::A,
            Mode::IdleB => Side::B,
            Mode::DrainingA | Mode::PausedA => Side::B,
            Mode::DrainingB | Mode::PausedB => Side::A,
        }
    }

    pub(in crate::driver::schedule::ready::arena::set) fn phase(&self) -> Phase {
        match self.mode.get() {
            Mode::IdleA | Mode::IdleB => Phase::Idle,
            Mode::DrainingA | Mode::DrainingB => Phase::Draining,
            Mode::PausedA => Phase::Paused(Side::A),
            Mode::PausedB => Phase::Paused(Side::B),
        }
    }

    pub(in crate::driver::schedule::ready::arena::set) fn idle(&self, active: Side) {
        self.mode.set(match active {
            Side::A => Mode::IdleA,
            Side::B => Mode::IdleB,
        });
    }

    pub(in crate::driver::schedule::ready::arena::set) fn draining(&self, side: Side) {
        self.mode.set(match side {
            Side::A => Mode::DrainingA,
            Side::B => Mode::DrainingB,
        });
    }

    pub(in crate::driver::schedule::ready::arena::set) fn paused(&self, side: Side) {
        self.mode.set(match side {
            Side::A => Mode::PausedA,
            Side::B => Mode::PausedB,
        });
    }
}

const _: () = assert!(std::mem::size_of::<State>() == 1);