cao-lang 0.1.92

The back-end of cao-lang, a node based visual scripting language
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

use super::{AllocError, Allocator};
use std::{
    alloc::{alloc, dealloc, Layout},
    cell::UnsafeCell,
    ops::Deref,
    ptr::NonNull,
    rc::Rc,
};

/// Shared BumpAllocator.
///
/// # Safety
///
/// Note that BumpAllocator is NOT thread-safe!
#[derive(Debug, Clone)]
pub struct BumpProxy {
    inner: Rc<UnsafeCell<BumpAllocator>>,
}

impl From<BumpAllocator> for BumpProxy {
    fn from(inner: BumpAllocator) -> Self {
        Self {
            inner: Rc::new(UnsafeCell::new(inner)),
        }
    }
}

impl Deref for BumpProxy {
    type Target = BumpAllocator;

    fn deref(&self) -> &Self::Target {
        unsafe { &*self.inner.get() }
    }
}

impl BumpProxy {
    pub unsafe fn get_inner(&mut self) -> &mut BumpAllocator {
        &mut *self.inner.get()
    }
}

#[derive(Debug)]
pub struct BumpAllocator {
    data: NonNull<u8>,
    capacity: usize,
    head: UnsafeCell<usize>,
}

impl Drop for BumpAllocator {
    fn drop(&mut self) {
        unsafe {
            dealloc(
                self.data.as_ptr(),
                Layout::from_size_align(self.capacity, 8).expect("Failed to produce alignment"),
            );
        }
    }
}

impl BumpAllocator {
    pub fn new(capacity: usize) -> Self {
        unsafe {
            Self {
                data: NonNull::new(alloc(
                    Layout::from_size_align(capacity, 8).expect("Failed to produce alignment"),
                ))
                .expect("Failed to allocate memory"),
                capacity,
                head: UnsafeCell::new(0),
            }
        }
    }

    ///# Safety
    ///
    ///Invalidates all outstanding pointers
    pub unsafe fn reset(&mut self, capacity: usize) {
        dealloc(
            self.data.as_ptr(),
            Layout::from_size_align(self.capacity, 8).expect("Failed to produce alignment"),
        );

        self.data = NonNull::new(alloc(
            Layout::from_size_align(capacity, 8).expect("Failed to produce alignment"),
        ))
        .expect("Failed to allocate memory");
        self.capacity = capacity;
        *self.head.get_mut() = 0;
    }

    ///# Safety
    ///
    ///Invalidates all outstanding pointers
    pub unsafe fn clear(&mut self) {
        *self.head.get_mut() = 0;
    }

    /// # Safety
    /// `alloc` is not thread safe. It is on the caller to ensure that only a single thread uses
    /// the allocator at a time
    pub unsafe fn alloc(&self, l: Layout) -> Result<NonNull<u8>, AllocError> {
        let s = l.size() + l.align();
        if *self.head.get() + s >= self.capacity {
            return Err(AllocError::OutOfMemory);
        }
        let ptr = self.data.as_ptr().add(*self.head.get());
        *self.head.get() += s;
        let ptr = ptr.add(ptr.align_offset(l.align()));
        Ok(NonNull::new_unchecked(ptr))
    }

    /// # Safety
    ///
    /// Only pointers allocated by this instance are safe to free
    pub unsafe fn dealloc(&self, _p: NonNull<u8>, _l: Layout) {
        // noop
    }
}

impl Allocator for BumpAllocator {
    unsafe fn alloc(&self, l: Layout) -> Result<NonNull<u8>, AllocError> {
        BumpAllocator::alloc(self, l)
    }

    unsafe fn dealloc(&self, p: NonNull<u8>, l: Layout) {
        BumpAllocator::dealloc(self, p, l)
    }
}
impl Allocator for BumpProxy {
    unsafe fn alloc(&self, l: Layout) -> Result<NonNull<u8>, AllocError> {
        (*self.inner.get()).alloc(l)
    }

    unsafe fn dealloc(&self, p: NonNull<u8>, l: Layout) {
        (*self.inner.get()).dealloc(p, l)
    }
}