dope-fiber 0.8.0

The manifold runtime
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

use std::cell::Cell;
use std::mem::MaybeUninit;
use std::ptr::drop_in_place;

use o3::cell::RawCell;

use crate::io::RecvBuffer;

pub(super) struct RecvSlot<'d> {
    value: RawCell<MaybeUninit<RecvBuffer<'d>>>,
    len: Cell<u32>,
    next: Cell<u32>,
}

impl<'d> RecvSlot<'d> {
    pub(super) fn new(next: u32) -> Self {
        Self {
            value: RawCell::new(MaybeUninit::uninit()),
            len: Cell::new(0),
            next: Cell::new(next),
        }
    }

    pub(super) fn is_empty(&self) -> bool {
        self.len.get() == 0
    }

    pub(super) fn len(&self) -> usize {
        self.len.get() as usize
    }

    pub(super) fn next(&self) -> u32 {
        self.next.get()
    }

    pub(super) fn set_next(&self, next: u32) {
        self.next.set(next);
    }

    pub(super) fn insert(&self, value: RecvBuffer<'d>, len: u32) {
        debug_assert!(self.is_empty());
        debug_assert_ne!(len, 0);
        debug_assert_eq!(value.as_slice().len(), len as usize);
        unsafe {
            self.value.with_mut(|slot| {
                slot.write(value);
            })
        };
        self.len.set(len);
    }

    pub(super) fn copy_prefix(&self, dst: &mut [u8]) {
        debug_assert!(!self.is_empty());
        debug_assert!(dst.len() <= self.len());
        unsafe {
            self.value.with(|value| {
                let src = value.assume_init_ref().as_slice();
                dst.copy_from_slice(&src[..dst.len()]);
            })
        };
    }

    pub(super) fn advance(&self, n: usize) {
        let len = self.len();
        assert!(n < len, "fiber: receive slot advance out of bounds");
        unsafe {
            self.value
                .with_mut(|value| value.assume_init_mut().advance(n))
        };
        self.len.set((len - n) as u32);
    }

    pub(super) fn take(&self) -> Option<RecvBuffer<'d>> {
        if self.len.replace(0) == 0 {
            return None;
        }
        Some(unsafe { self.value.with(|value| value.assume_init_read()) })
    }
}

impl Drop for RecvSlot<'_> {
    fn drop(&mut self) {
        if self.len.get() != 0 {
            unsafe { drop_in_place(self.value.get_mut().as_mut_ptr()) };
        }
    }
}