dope-core 0.13.0

The manifold runtime
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
133
134
135

use std::cell::Cell;
use std::io::{self, Error, ErrorKind};

use crate::driver::control::ContextControl;

use super::token::ROUTE_FRAMEWORK;
use super::{DriverContext, DriverRef};

pub(crate) struct Routes {
    live: [u64; 4],
    poisoned: [u64; 4],
}

impl Routes {
    pub(crate) const fn new() -> Self {
        Self {
            live: [0; 4],
            poisoned: [0; 4],
        }
    }

    pub(crate) fn reserve(&mut self, id: u8) -> bool {
        let word = id as usize / 64;
        let mask = 1u64 << (id % 64);
        if self.live[word] & mask != 0 || self.poisoned[word] & mask != 0 {
            return false;
        }
        self.live[word] |= mask;
        true
    }

    pub(crate) fn release(&mut self, id: u8) {
        self.live[id as usize / 64] &= !(1u64 << (id % 64));
    }

    pub(crate) fn poison(&mut self, id: u8) {
        debug_assert!(!self.is_poisoned(id));
        let word = id as usize / 64;
        let mask = 1u64 << (id % 64);
        self.live[word] &= !mask;
        self.poisoned[word] |= mask;
    }

    pub(crate) fn is_poisoned(&self, id: u8) -> bool {
        self.poisoned[id as usize / 64] & (1u64 << (id % 64)) != 0
    }
}

pub struct Route<'d, const ID: u8> {
    driver: DriverRef<'d>,
    live: Cell<bool>,
}

#[doc(hidden)]
pub struct RouteReservation<'a, 'c, 'd, const ID: u8> {
    route: Option<Route<'d, ID>>,
    driver: &'a mut DriverContext<'c, 'd>,
}

impl<'d, const ID: u8> Route<'d, ID> {
    pub fn reserve(driver: &mut DriverContext<'_, 'd>) -> io::Result<Self> {
        if ID == ROUTE_FRAMEWORK {
            return Err(Error::new(ErrorKind::InvalidInput, "dope: reserved route"));
        }
        if !driver.reserve_route(ID) {
            return Err(Error::new(
                ErrorKind::AlreadyExists,
                "dope: route already used",
            ));
        }
        Ok(Self {
            driver: driver.driver_ref(),
            live: Cell::new(true),
        })
    }

    #[doc(hidden)]
    pub fn reserve_transaction<'a, 'c>(
        driver: &'a mut DriverContext<'c, 'd>,
    ) -> io::Result<RouteReservation<'a, 'c, 'd, ID>> {
        let route = Self::reserve(driver)?;
        Ok(RouteReservation {
            route: Some(route),
            driver,
        })
    }

    pub fn poison(&self, driver: &mut DriverContext<'_, 'd>) {
        if self.live.replace(false) {
            driver.poison_route(ID);
        }
    }

    pub fn driver(&self) -> DriverRef<'d> {
        self.driver
    }

    pub fn release(self, driver: &mut DriverContext<'_, 'd>) {
        if self.live.replace(false) {
            driver.release_route(ID);
        }
    }

    pub fn finish(&self, driver: &mut DriverContext<'_, 'd>, poison: bool) {
        if !self.live.replace(false) {
            return;
        }
        if poison {
            driver.poison_route(ID);
        } else {
            driver.release_route(ID);
        }
    }
}

impl<'c, 'd, const ID: u8> RouteReservation<'_, 'c, 'd, ID> {
    pub fn driver(&mut self) -> &mut DriverContext<'c, 'd> {
        self.driver
    }

    pub fn commit(mut self) -> Route<'d, ID> {
        let Some(route) = self.route.take() else {
            unreachable!("dope: route reservation committed twice")
        };
        route
    }
}

impl<const ID: u8> Drop for RouteReservation<'_, '_, '_, ID> {
    fn drop(&mut self) {
        if let Some(route) = self.route.take() {
            route.release(self.driver);
        }
    }
}