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

use std::{cell::Cell, marker, num::NonZero};

use crate::{
    alloc,
    base::cell::region,
    depot::{capacity, queue::pool::fair, raw::QueueBlock},
};

pub struct Lanes<'d, T, S = ()> {
    pub(super) inner: QueueBlock<T, fair::State<S>, NonZero<u32>>,
    domain: marker::PhantomData<*mut &'d region::Token<region::Identity<'d>>>,
}

impl<'d, T, S> Lanes<'d, T, S> {
    pub fn try_new(
        plan: fair::Plan,
        region::Token { .. }: &region::Token<region::Identity<'d>>,
    ) -> Result<Self, alloc::Error>
    where
        S: Default,
    {
        let inner = QueueBlock::try_with(plan.slots, plan.lanes, |index| fair::State {
            index: capacity::Count::new(index.raw()),
            value: S::default(),
            held: Cell::new(capacity::Count::EMPTY),
        })?;
        inner
            .store
            .available
            .set(plan.slots.raw() - plan.lanes.get());
        Ok(Self {
            inner,
            domain: marker::PhantomData,
        })
    }

    /// The admitted nonzero extent of this owner's immutable lane domain.
    pub const fn capacity(&self) -> NonZero<u32> {
        self.inner.count()
    }

    pub fn bind(&self, lane: usize) -> Option<fair::Binding<'_, 'd, T, S>> {
        if lane >= self.capacity().get() as usize {
            return None;
        }
        // SAFETY: admission bounds this lane in its exact immutable owner.
        Some(fair::Binding::from_source(unsafe {
            crate::depot::raw::Proof::new((self, lane))
        }))
    }
}

const _: () =
    assert!(std::mem::size_of::<Lanes<'static, u64>>() == 5 * std::mem::size_of::<usize>());