per-thread-object 0.6.1

Efficient per-object thread-local storage implementation
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

use std::{ ops, mem, alloc, slice };
use std::marker::PhantomData;
use std::ptr::{ self, NonNull };


pub struct BoxTail<T, S>(NonNull<Inner<T, S>>);

struct Inner<T, S> {
    value: T,
    arr_len: usize,
    _arr: IncompleteArrayField<S>
}

// Guaranteed alignment
struct IncompleteArrayField<T>(PhantomData<T>, [T; 0]);

impl<T, S> BoxTail<T, S> {
    pub fn new(
        value: T,
        arr_len: usize,
        arr_init: fn(*mut S)
    ) -> Self {
        // dont handle drop, because we do not need
        assert!(!mem::needs_drop::<S>());

        let layout = alloc::Layout::new::<Inner<T, S>>();
        let array_layout = alloc::Layout::array::<S>(arr_len).unwrap();
        let (layout, _offset) = layout.extend(array_layout).unwrap();

        unsafe {
            let ptr = NonNull::new(alloc::alloc(layout).cast::<Inner<T, S>>()).unwrap();

            ptr.as_ptr().write(Inner {
                value, arr_len,
                _arr: IncompleteArrayField(PhantomData, [])
            });

            // dont use `IncompleteArrayField` to take pointer because miri is not happy
            let arr_ptr = ptr.as_ptr().add(1).cast::<S>();

            for idx in 0..arr_len {
                let elem = arr_ptr.add(idx);
                arr_init(elem);
            }

            BoxTail(ptr)
        }
    }

    #[inline]
    pub fn array_len(&self) -> usize {
        unsafe {
            self.0.as_ref().arr_len
        }
    }

    #[inline]
    pub fn array(&self) -> &[S] {
        unsafe {
            let arr_len = self.0.as_ref().arr_len;
            slice::from_raw_parts(self.0.as_ptr().add(1).cast::<S>(), arr_len)
        }
    }
}

impl<T, S> ops::Deref for BoxTail<T, S> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe {
            &self.0.as_ref().value
        }
    }
}

impl<T, S> ops::DerefMut for BoxTail<T, S> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe {
            &mut self.0.as_mut().value
        }
    }
}

impl<T, S> Drop for BoxTail<T, S> {
    fn drop(&mut self) {
        unsafe {
            if mem::needs_drop::<T>() {
                ptr::drop_in_place(self.0.as_ptr());
            }

            let arr_len = self.0.as_ref().arr_len;
            let layout = alloc::Layout::new::<Inner<T, S>>();
            let array_layout = alloc::Layout::array::<S>(arr_len).unwrap();
            let (layout, _offset) = layout.extend(array_layout).unwrap();
            alloc::dealloc(self.0.as_ptr().cast(), layout);
        }
    }
}