stele 0.3.5

An atomic Vec-like structure with no copying on allocation
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
138
139
140
141
142
143
144
145
146
147

#[cfg(feature = "allocator_api")]
pub(crate) use allocator::{alloc_inner, dealloc_inner};
use core::{cell::UnsafeCell, mem::MaybeUninit};
#[cfg(not(feature = "allocator_api"))]
pub(crate) use without_allocator::{alloc_inner, dealloc_inner};

#[derive(Debug)]
pub(crate) struct Inner<T> {
    raw: MaybeUninit<UnsafeCell<T>>,
}

impl<T> Inner<T> {
    pub(crate) fn new(val: T) -> Self {
        Self {
            raw: MaybeUninit::new(UnsafeCell::new(val)),
        }
    }

    /// SAFETY: The Inner must have been written to before reading
    pub(crate) unsafe fn read(&self) -> &T {
        unsafe {
            (*self.raw.as_ptr())
                .get()
                .as_ref()
                .expect("Pointer is non null")
        }
    }
}

impl<T> Inner<T>
where
    T: Copy,
{
    pub(crate) unsafe fn get(&self) -> T {
        unsafe { *(*self.raw.as_ptr()).get() }
    }
}

#[cfg(not(feature = "allocator_api"))]
mod without_allocator {
    use alloc::alloc::{alloc, dealloc};
    use core::alloc::Layout;
    /// # Safety
    /// `alloc_inner` must be called with `len` such that `len` * [`size_of::<T>()`](core::mem::size_of()),
    /// when aligned to [`align_of::<T>()`](core::mem::align_of()), is no more than [`usize::max`]
    pub(crate) unsafe fn alloc_inner<T>(len: usize) -> *mut crate::Inner<T> {
        debug_assert!(core::mem::size_of::<T>().checked_mul(len).is_some());
        if core::mem::size_of::<T>() == 0 {
            core::ptr::NonNull::dangling().as_ptr()
        } else {
            let layout = Layout::array::<T>(len)
                .expect("Len is constrained by the safety contract of alloc_inner()!");
            unsafe { alloc(layout).cast() }
        }
    }

    /// # Safety
    /// The following two points must hold:
    ///
    /// - `dealloc_inner` must be called with the correct `len` for `ptr`
    ///
    /// - `ptr` must have been allocated by `alloc_inner` and therefore must not be null
    pub(crate) unsafe fn dealloc_inner<T>(ptr: *mut crate::Inner<T>, len: usize) {
        debug_assert!(core::mem::size_of::<T>().checked_mul(len).is_some());
        debug_assert!(!ptr.is_null());
        if core::mem::size_of::<T>() != 0 {
            let layout = Layout::array::<T>(len)
                .expect("Len is constrained by the safety contract of dealloc_inner()!");
            // SAFETY: By the safety contract of `dealloc_inner` and (in debug) the asserts above, we know
            // that ptr can not be null as `alloc_inner` does not hand out null pointers
            unsafe {
                dealloc(ptr.cast(), layout);
            }
        }
    }

    #[cfg(test)]
    #[test]
    fn allocation() {
        unsafe {
            let ptr = alloc_inner::<u8>(1);
            assert!(!core::ptr::eq(ptr, core::ptr::null()));
            dealloc_inner(ptr, 1);
        }
    }
}

#[cfg(feature = "allocator_api")]
mod allocator {
    use alloc::alloc::{handle_alloc_error, Allocator, Layout};
    use core::ptr::NonNull;
    /// # Safety
    /// `alloc_inner` must be called with `len` such that `len` * [`size_of::<T>()`](core::mem::size_of()),
    /// when aligned to [`align_of::<T>()`](core::mem::align_of()), is no more than [`usize::max`]
    pub(crate) unsafe fn alloc_inner<T, A: Allocator>(
        allocator: &A,
        len: usize,
    ) -> *mut crate::Inner<T> {
        debug_assert!(core::mem::size_of::<T>().checked_mul(len).is_some());
        if core::mem::size_of::<T>() == 0 {
            NonNull::dangling().as_ptr()
        } else {
            let layout = Layout::array::<T>(len)
                .expect("Len is constrained by the safety contract of alloc_inner()!");
            let ptr = match allocator.allocate(layout) {
                Ok(p) => p,
                Err(_) => handle_alloc_error(layout),
            };
            ptr.as_ptr().cast()
        }
    }

    /// # Safety
    /// The following two points must hold:
    ///
    /// - `dealloc_inner` must be called with the correct `len` for `ptr`
    ///
    /// - `ptr` must have been allocated by `alloc_inner` and therefore must not be null
    pub(crate) unsafe fn dealloc_inner<T, A: Allocator>(
        allocator: &A,
        ptr: *mut crate::Inner<T>,
        len: usize,
    ) {
        debug_assert!(core::mem::size_of::<T>().checked_mul(len).is_some());
        debug_assert!(!ptr.is_null());
        if core::mem::size_of::<T>() != 0 {
            let layout = Layout::array::<T>(len)
                .expect("Len is constrained by the safety contract of dealloc_inner()!");
            // SAFETY: By the safety contract of `dealloc_inner` and (in debug) the asserts above, we know
            // that ptr can not be null as `alloc_inner` does not hand out null pointers
            unsafe { allocator.deallocate(NonNull::new_unchecked(ptr.cast()), layout) }
        }
    }

    #[cfg(test)]
    #[test]
    fn allocation() {
        use alloc::alloc::Global;

        let allocator = &Global;
        unsafe {
            let ptr = alloc_inner::<u8, _>(allocator, 1);
            assert!(!core::ptr::eq(ptr, core::ptr::null()));
            dealloc_inner(allocator, ptr, 1);
        }
    }
}