lever 0.1.4

Pillars for Transactional Systems and Data Grids
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
136
137
138
139
140
141
142
143
144

use super::ops::*;

#[cfg(target_arch = "aarch64")]
use std::arch::aarch64::{
    __tcancel, __tcommit, __tstart, __ttest, _TMFAILURE_CNCL, _TMFAILURE_DBG, _TMFAILURE_ERR,
    _TMFAILURE_IMP, _TMFAILURE_INT, _TMFAILURE_MEM, _TMFAILURE_NEST, _TMFAILURE_REASON,
    _TMFAILURE_RTRY, _TMFAILURE_SIZE, _TMFAILURE_TRIVIAL, _TMSTART_SUCCESS,
};

/// Return code from __tstart()
pub struct HwTxBeginCode(u64);

impl HwTxBeginCode {
    #[inline]
    pub fn started(&self) -> bool {
        self.0 == _TMSTART_SUCCESS
    }

    #[inline]
    pub fn abort(&self) -> bool {
        self.0 & _TMFAILURE_CNCL != 0 && !self.started()
    }

    #[inline]
    pub fn retry(&self) -> bool {
        self.0 & _TMFAILURE_RTRY != 0 && !self.started()
    }

    #[inline]
    pub fn conflict(&self) -> bool {
        self.0 & _TMFAILURE_MEM != 0 && !self.started()
    }

    #[inline]
    pub fn capacity(&self) -> bool {
        self.0 & _TMFAILURE_SIZE != 0 && !self.started()
    }

    /// Aarch64 specific
    #[inline]
    pub fn nest_exceeded(&self) -> bool {
        self.0 & _TMFAILURE_NEST != 0 && !self.started()
    }

    /// Aarch64 specific
    #[inline]
    pub fn trivial_exec(&self) -> bool {
        self.0 & _TMFAILURE_TRIVIAL != 0 && !self.started()
    }

    /// Aarch64 specific
    #[inline]
    pub fn non_permissible(&self) -> bool {
        self.0 & _TMFAILURE_ERR != 0 && !self.started()
    }

    /// Aarch64 specific
    #[inline]
    pub fn interrupted(&self) -> bool {
        self.0 & _TMFAILURE_INT != 0 && !self.started()
    }

    /// Aarch64 specific
    #[inline]
    pub fn fallback_failure(&self) -> bool {
        self.0 & _TMFAILURE_IMP != 0 && !self.started()
    }

    #[inline]
    pub fn debug(&self) -> bool {
        self.0 & _TMFAILURE_DBG != 0 && !self.started()
    }
}

/// most significant 8 bits
#[derive(Copy, Clone)]
pub enum HwTxAbortCode {
    Overhaul = 1 << 0,
    UserlandAbort = 1 << 1,
}

impl PartialEq for HwTxAbortCode {
    fn eq(&self, other: &HwTxAbortCode) -> bool {
        *self as u64 == HTM::_tcancel_code(*other as u64, true)
    }
}

/// Return code from __ttest()
pub struct HwTxTestCode(u64);

impl HwTxTestCode {
    #[inline]
    pub fn in_txn(&self) -> bool {
        self.0 != 0
    }

    #[inline]
    fn depth(&self) -> usize {
        self.0 as usize
    }
}

pub struct HTM();

impl HTM {
    const OVERHAUL: u64 = HwTxAbortCode::Overhaul as u64;
    const USERLAND_ABORT: u64 = HwTxAbortCode::UserlandAbort as u64;

    /// Encodes cancellation reason, which is the parameter passed to [`__tcancel`]
    /// Takes cancellation reason flags and retry-ability.
    #[inline]
    pub const fn _tcancel_code(reason: u64, retryable: bool) -> u64 {
        ((retryable as i64) << 15 | (reason & _TMFAILURE_REASON) as i64) as u64
    }
}

impl Ops for HTM {
    fn begin(&self) -> HwTxBeginCode {
        unsafe { HwTxBeginCode(__tstart()) }
    }

    fn abort(&self, reason_code: &HwTxAbortCode) -> ! {
        // TODO: Pass retryable as argument?
        unsafe {
            match reason_code {
                HwTxAbortCode::Overhaul => __tcancel(HTM::_tcancel_code(HTM::OVERHAUL, true)),
                HwTxAbortCode::UserlandAbort => {
                    __tcancel(HTM::_tcancel_code(HTM::USERLAND_ABORT, true))
                }
            }
            std::hint::unreachable_unchecked()
        }
    }

    fn test(&self) -> HwTxTestCode {
        unsafe { HwTxTestCode(__ttest()) }
    }
    fn commit(&self) {
        unsafe { __tcommit() }
    }
    fn cpu_support(&self) -> bool {
        std::is_aarch64_feature_detected!("tme")
    }
}