melinoe 0.10.0

Zero-sized, branded, multi-token phantom capabilities for compile-time data-access and thread-synchronization proofs (a generalized evolution of GhostCell) for the Mnemosyne memory ecosystem.
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

//! Integer read-modify-write operations on [`BrandedAtomic`].

use core::sync::atomic::Ordering;

use super::BrandedAtomic;
use crate::atomic::order::{AtomicOrder, OrderingSource};
use crate::atomic::traits::AtomicInt;
use crate::token::ReadPermit;

impl<'brand, A: AtomicInt> BrandedAtomic<'brand, A> {
    order_pair! {
        /// Atomic fetch-add. Requires a [`ReadPermit`] for `'brand` (the shared phase).
        fn fetch_add;
        /// Atomic fetch-add using a compile-time ZST ordering policy.
        fn fetch_add_with;
        before: (value: A::Value);
        after: ();
        generics: ();
        bounds: ();
        order: order;
        ret: A::Value;
        body: inner.atomic_fetch_add(value, order.rmw_order())
    }

    order_pair! {
        /// Atomic fetch-sub. Requires a [`ReadPermit`] for `'brand`.
        fn fetch_sub;
        /// Atomic fetch-sub using a compile-time ZST ordering policy.
        fn fetch_sub_with;
        before: (value: A::Value);
        after: ();
        generics: ();
        bounds: ();
        order: order;
        ret: A::Value;
        body: inner.atomic_fetch_sub(value, order.rmw_order())
    }

    order_pair! {
        /// Atomic fetch-and. Requires a [`ReadPermit`] for `'brand`.
        fn fetch_and;
        /// Atomic fetch-and using a compile-time ZST ordering policy.
        fn fetch_and_with;
        before: (value: A::Value);
        after: ();
        generics: ();
        bounds: ();
        order: order;
        ret: A::Value;
        body: inner.atomic_fetch_and(value, order.rmw_order())
    }

    order_pair! {
        /// Atomic fetch-or. Requires a [`ReadPermit`] for `'brand`.
        fn fetch_or;
        /// Atomic fetch-or using a compile-time ZST ordering policy.
        fn fetch_or_with;
        before: (value: A::Value);
        after: ();
        generics: ();
        bounds: ();
        order: order;
        ret: A::Value;
        body: inner.atomic_fetch_or(value, order.rmw_order())
    }

    order_pair! {
        /// Atomic fetch-xor. Requires a [`ReadPermit`] for `'brand`.
        fn fetch_xor;
        /// Atomic fetch-xor using a compile-time ZST ordering policy.
        fn fetch_xor_with;
        before: (value: A::Value);
        after: ();
        generics: ();
        bounds: ();
        order: order;
        ret: A::Value;
        body: inner.atomic_fetch_xor(value, order.rmw_order())
    }

    order_pair! {
        /// Atomic fetch-nand. Requires a [`ReadPermit`] for `'brand`.
        fn fetch_nand;
        /// Atomic fetch-nand using a compile-time ZST ordering policy.
        fn fetch_nand_with;
        before: (value: A::Value);
        after: ();
        generics: ();
        bounds: ();
        order: order;
        ret: A::Value;
        body: inner.atomic_fetch_nand(value, order.rmw_order())
    }

    order_pair! {
        /// Atomic fetch-max. Requires a [`ReadPermit`] for `'brand`.
        fn fetch_max;
        /// Atomic fetch-max using a compile-time ZST ordering policy.
        fn fetch_max_with;
        before: (value: A::Value);
        after: ();
        generics: ();
        bounds: ();
        order: order;
        ret: A::Value;
        body: inner.atomic_fetch_max(value, order.rmw_order())
    }

    order_pair! {
        /// Atomic fetch-min. Requires a [`ReadPermit`] for `'brand`.
        fn fetch_min;
        /// Atomic fetch-min using a compile-time ZST ordering policy.
        fn fetch_min_with;
        before: (value: A::Value);
        after: ();
        generics: ();
        bounds: ();
        order: order;
        ret: A::Value;
        body: inner.atomic_fetch_min(value, order.rmw_order())
    }
}