o3 0.36.2

shared-nothing primitives
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

use std::{marker, mem, ops};

use crate::depot::queue::round::{self, Idle, Linked, phase};

pub(super) mod idle;
pub(super) mod linked;

/// A position retaining its exact owner and admitted membership phase.
#[derive(Clone, Copy, Debug)]
pub struct Location<O, P = ()> {
    pub(in crate::depot::queue::round) owner: O,
    pub(in crate::depot::queue::round) position: round::Position,
    phase: marker::PhantomData<P>,
}

impl<O, P> Location<O, P> {
    pub(in crate::depot::queue::round) fn new(owner: O, position: round::Position) -> Self {
        Self {
            owner,
            position,
            phase: marker::PhantomData,
        }
    }
    pub(in crate::depot::queue::round) fn phase<Q>(self) -> Location<O, Q> {
        Location::new(self.owner, self.position)
    }
    pub fn index(&self) -> usize {
        self.position.index.get()
    }
    pub const fn lane(&self) -> usize {
        self.position.lane.get()
    }
}

impl<'a, T, const G: usize, const N: usize, P> Location<&'a round::Lanes<T, G, N>, P> {
    pub fn get(&self) -> &'a T {
        round::Slot {
            owner: self.owner,
            index: self.position.index,
        }
        .get()
    }
}

impl<T, const G: usize, const N: usize, P> Location<&mut round::Lanes<T, G, N>, P> {
    /// Borrows the admitted resident independently of its membership phase.
    pub fn get(&self) -> &T {
        round::Slot {
            owner: &*self.owner,
            index: self.position.index,
        }
        .get()
    }
}

impl<T, const G: usize, const N: usize, O: ops::Deref<Target = round::Lanes<T, G, N>>>
    Location<O, Idle>
{
    pub fn push_back(self) -> Location<O, Linked> {
        let owner = &*self.owner;
        // SAFETY: this location retains its admitted lane and exact detached resident.
        round::Join::insert(unsafe {
            crate::depot::raw::Proof::new((owner.join(self.position.lane), self.position.index))
        });
        self.phase()
    }
}

impl<T, const G: usize, const N: usize, O: ops::Deref<Target = round::Lanes<T, G, N>>>
    Location<O, Linked>
{
    pub fn remove(self) -> Location<O, Idle> {
        let owner = &*self.owner;
        // SAFETY: this location retains its admitted lane and exact linked membership.
        round::Join::remove(unsafe {
            crate::depot::raw::Proof::new((owner.join(self.position.lane), self.position.index))
        })
        .idle();
        self.phase()
    }
}

impl<T, const G: usize, const N: usize, O: ops::Deref<Target = round::Lanes<T, G, N>>>
    Location<O, phase::Head>
{
    pub(in crate::depot::queue::round) fn remove<const ROTATE: bool>(self) -> Location<O, Idle> {
        let owner = &*self.owner;
        // SAFETY: Head retains this owner's admitted lane and exact FIFO front.
        let source = unsafe {
            crate::depot::raw::Proof::new((owner.join(self.position.lane), self.position.index))
        };
        round::Join::head::<ROTATE>(source).idle();
        self.phase()
    }
}

impl<'a, T, const G: usize, const N: usize> Location<&'a round::Lanes<T, G, N>, phase::Head> {
    pub fn pop(self) -> &'a T {
        self.remove::<false>().get()
    }

    /// Advances this nonempty lane while retaining its unchanged topology authority.
    pub fn rotate(mut self) -> Self {
        // SAFETY: Head retains this lane's admission to the unchanged owner.
        let lane = unsafe { self.owner.join(self.position.lane) };
        let entries = lane.entries;
        // SAFETY: Head retains this exact FIFO front without an intervening callback.
        let vacant = round::Join::head::<true>(unsafe {
            crate::depot::raw::Proof::new((round::Join { ..lane }, self.position.index))
        });
        // SAFETY: this consuming transfer retains the same detached hook and admitted lane.
        round::Join::push(unsafe { crate::depot::raw::Proof::new((lane, vacant)) });
        // SAFETY: reinsertion leaves this exact lane nonempty.
        self.position.index = unsafe { entries.front_key() };
        self
    }

    pub(in crate::depot::queue::round) fn take_active(
        source: crate::depot::raw::Proof<Self, phase::Active>,
    ) -> &'a T {
        let entry = source.into_inner();
        // SAFETY: the source retains this exact active-ring front and its
        // admitted nonempty FIFO without callbacks between admission and removal.
        round::Join::active::<true>(unsafe {
            crate::depot::raw::Proof::new(entry.owner.join(entry.position.lane))
        })
        .idle();
        entry.get()
    }
}

const _: () = {
    let word = mem::size_of::<usize>();
    assert!(mem::size_of::<Location<&'static mut round::Lanes<(), 1>>>() == 2 * word);
    assert!(mem::size_of::<Location<&'static mut round::Lanes<(), 1>, Linked>>() == 2 * word);
    assert!(mem::size_of::<Option<Location<&'static mut round::Lanes<(), 1>, Idle>>>() == 2 * word);
};