o3 0.25.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
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

use std::{cell, marker, mem, num};

use crate::{
    alloc,
    depot::{capacity, queue::links},
};

#[derive(Debug)]
#[repr(C)]
pub(in crate::depot::queue::round) struct Node<T> {
    pub(in crate::depot::queue::round) value: T,
    pub(in crate::depot::queue::round) hook: links::Hook,
}

#[derive(Debug)]
#[repr(C)]
pub(in crate::depot::queue::round) struct Track {
    pub(in crate::depot::queue::round) entries: links::Chain,
    pub(in crate::depot::queue::round) active: links::Hook,
}

impl Track {
    pub(in crate::depot::queue::round) fn new(index: links::Index) -> Self {
        Self {
            entries: links::Chain::new(),
            active: links::Hook::new(index),
        }
    }
}

#[derive(Debug)]
#[repr(C)]
pub(in crate::depot::queue::round) struct Capacity<T> {
    count: capacity::Count,
    lanes: num::NonZero<u32>,
    ownership: marker::PhantomData<(Node<T>, Track, cell::Cell<links::Index>)>,
}

impl<T> Capacity<T> {
    pub(in crate::depot::queue::round) fn new(
        capacity: usize,
        lanes: num::NonZero<usize>,
    ) -> Result<Self, alloc::Overflow> {
        const {
            assert!(mem::align_of::<Node<T>>() >= mem::align_of::<Track>());
            assert!(mem::align_of::<Track>() >= mem::align_of::<cell::Cell<links::Index>>());
        }
        let count = capacity::Count::try_count(capacity, alloc::Overflow)?;
        let lanes = capacity::Count::try_narrow(lanes, alloc::Overflow)?;
        alloc::raw::Bundle::try_layout::<Self>(count.get(), lanes.get() as usize)?;
        Ok(Self {
            count,
            lanes,
            ownership: marker::PhantomData,
        })
    }
}

unsafe impl<T> alloc::raw::Shape for Capacity<T> {
    type Root = Node<T>;
    type Tail = Track;
    type Extra = cell::Cell<links::Index>;
    type Last = ();

    fn len(&self) -> usize {
        self.count.get()
    }

    fn tail_len(&self) -> usize {
        self.lanes.get() as usize
    }
}

unsafe impl<T> crate::depot::raw::Hooks for [Node<T>] {
    unsafe fn hook_raw(&self, index: links::Index) -> &links::Hook {
        unsafe { &self.get_unchecked(index.get()).hook }
    }
}

unsafe impl crate::depot::raw::Hooks for [Track] {
    unsafe fn hook_raw(&self, index: links::Index) -> &links::Hook {
        unsafe { &self.get_unchecked(index.get()).active }
    }
}

const _: () = {
    assert!(mem::size_of::<Track>() == 2 * mem::size_of::<usize>());
    assert!(mem::size_of::<cell::Cell<links::Index>>() == mem::size_of::<u32>());
};