dope-core 0.2.3

Thin io_uring adaptor with "Manifolds"
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use crate::driver::BackendToken;

#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TokenSlot(u16);

impl TokenSlot {
    #[inline(always)]
    pub fn from_index(index: usize) -> Self {
        Self(u16::try_from(index).expect("dope: token slot index exceeds u16 range"))
    }

    #[inline(always)]
    pub const fn from_raw(raw: u16) -> Self {
        Self(raw)
    }

    #[inline(always)]
    pub const fn as_usize(self) -> usize {
        self.0 as usize
    }

    #[inline(always)]
    pub const fn raw(self) -> u16 {
        self.0
    }
}

#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TokenEpoch(u32);

impl TokenEpoch {
    pub const MAX: u32 = (1 << 24) - 1;

    #[inline(always)]
    pub const fn from_raw(raw: u32) -> Self {
        assert!(
            raw <= Self::MAX,
            "dope: token epoch exceeds 24-bit user_data budget",
        );
        Self(raw)
    }

    #[inline(always)]
    pub const fn raw(self) -> u32 {
        self.0
    }

    #[inline(always)]
    pub fn next(seq: &mut u32) -> Self {
        *seq = seq.wrapping_add(1) & Self::MAX;
        Self::from_raw(*seq)
    }
}

pub trait WirePad: Copy + 'static {
    const ZERO: Self;
}

impl WirePad for () {
    const ZERO: () = ();
}
impl WirePad for u8 {
    const ZERO: u8 = 0;
}

#[repr(C, packed)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Token<P: WirePad> {
    slot: TokenSlot,
    epoch: TokenEpoch,
    _pad: P,
}

impl<P: WirePad> Token<P> {
    #[inline(always)]
    pub const fn new(slot: TokenSlot, epoch: TokenEpoch) -> Self {
        Self {
            slot,
            epoch,
            _pad: P::ZERO,
        }
    }

    #[inline(always)]
    pub fn from_index(index: usize, epoch: TokenEpoch) -> Self {
        Self::new(TokenSlot::from_index(index), epoch)
    }

    #[inline(always)]
    pub fn from_index_raw(index: usize, epoch: u32) -> Self {
        Self::from_index(index, TokenEpoch::from_raw(epoch))
    }

    #[inline(always)]
    pub fn next_for_slot(index: usize, seq: &mut u32) -> Self {
        Self::from_index(index, TokenEpoch::next(seq))
    }

    #[inline(always)]
    pub const fn parts(self) -> (usize, u32) {
        (self.slot.as_usize(), self.epoch.raw())
    }

    #[inline(always)]
    pub fn slot_raw(self) -> u16 {
        self.slot.raw()
    }

    #[inline(always)]
    pub fn epoch_raw(self) -> u32 {
        self.epoch.raw()
    }
}

impl<P: WirePad> BackendToken for Token<P> {
    #[inline(always)]
    fn parts(self) -> (usize, u32) {
        Self::parts(self)
    }

    #[inline(always)]
    fn next_for_slot(index: usize, seq: &mut u32) -> Self {
        Self::next_for_slot(index, seq)
    }

    #[inline(always)]
    fn from_index_raw(index: usize, epoch: u32) -> Self {
        Self::from_index_raw(index, epoch)
    }
}