o3 0.31.0

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

use std::mem;

use crate::depot::queue::round;

/// One resident and destination admitted against the same allocation.
#[derive(Debug)]
pub struct Place;

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

    /// Preserves existing membership in this destination.
    /// Returns true when inserted and false when already present.
    pub fn set(&self) -> bool {
        let lane = self.slot().linked_lane();
        if lane == Some(self.position.lane) {
            return false;
        }
        let round::Lanes { block, groups } = self.owner;
        // SAFETY: this snapshot admits both indices to these same-owner fields;
        // membership was just resolved without an intervening callback.
        unsafe { round::lanes::push_from(block, groups, self.position, lane) };
        true
    }

    /// Moves this resident to its destination's tail.
    pub fn push(&self) {
        let lane = self.slot().linked_lane();
        let round::Lanes { block, groups } = self.owner;
        // SAFETY: this snapshot admits both indices to these same-owner fields;
        // membership was just resolved without an intervening callback.
        unsafe { round::lanes::push_from(block, groups, self.position, lane) };
    }
}

const _: () = {
    assert!(
        mem::size_of::<round::Snapshot<&'static round::Lanes<(), 1>, Place>>()
            == 2 * mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<Option<round::Snapshot<&'static round::Lanes<(), 1>, Place>>>()
            == 2 * mem::size_of::<usize>()
    );
};