bun_alloc 0.1.1

A Rust-native programmable browser runtime built on Servo and SpiderMonkey
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

//! An allocator that attempts to allocate from a provided buffer first,
//! falling back to another allocator when the buffer is exhausted.
//! Unlike `std.heap.StackFallbackAllocator`, this does not own the buffer.

use core::ffi::c_void;

use crate::{Alignment, AllocatorVTable, FixedBufferAllocator, StdAllocator};

pub struct BufferFallbackAllocator<'a> {
    fallback: StdAllocator,
    fixed: FixedBufferAllocator<'a>,
}

impl<'a> BufferFallbackAllocator<'a> {
    pub fn init(buffer: &'a mut [u8], fallback: StdAllocator) -> BufferFallbackAllocator<'a> {
        BufferFallbackAllocator {
            fallback,
            fixed: FixedBufferAllocator::init(buffer),
        }
    }

    pub fn allocator(&mut self) -> StdAllocator {
        StdAllocator {
            ptr: std::ptr::from_mut::<Self>(self).cast::<c_void>(),
            vtable: &VTABLE,
        }
    }

    pub fn reset(&mut self) {
        self.fixed.reset();
    }
}

static VTABLE: AllocatorVTable = AllocatorVTable {
    alloc,
    resize,
    remap,
    free,
};

unsafe fn alloc(ctx: *mut c_void, len: usize, alignment: Alignment, ra: usize) -> *mut u8 {
    // SAFETY: ctx was set to `&mut BufferFallbackAllocator` in `allocator()`.
    let self_: &mut BufferFallbackAllocator =
        unsafe { &mut *ctx.cast::<BufferFallbackAllocator>() };
    FixedBufferAllocator::alloc(&mut self_.fixed, len, alignment, ra)
        .or_else(|| self_.fallback.raw_alloc(len, alignment, ra))
        .unwrap_or(core::ptr::null_mut())
}

unsafe fn resize(
    ctx: *mut c_void,
    buf: &mut [u8],
    alignment: Alignment,
    new_len: usize,
    ra: usize,
) -> bool {
    // SAFETY: ctx was set to `&mut BufferFallbackAllocator` in `allocator()`.
    let self_: &mut BufferFallbackAllocator =
        unsafe { &mut *ctx.cast::<BufferFallbackAllocator>() };
    if self_.fixed.owns_ptr(buf.as_ptr()) {
        return FixedBufferAllocator::resize(&mut self_.fixed, buf, alignment, new_len, ra);
    }
    self_.fallback.raw_resize(buf, alignment, new_len, ra)
}

unsafe fn remap(
    ctx: *mut c_void,
    memory: &mut [u8],
    alignment: Alignment,
    new_len: usize,
    ra: usize,
) -> *mut u8 {
    // SAFETY: ctx was set to `&mut BufferFallbackAllocator` in `allocator()`.
    let self_: &mut BufferFallbackAllocator =
        unsafe { &mut *ctx.cast::<BufferFallbackAllocator>() };
    if self_.fixed.owns_ptr(memory.as_ptr()) {
        return FixedBufferAllocator::remap(&mut self_.fixed, memory, alignment, new_len, ra)
            .unwrap_or(core::ptr::null_mut());
    }
    self_
        .fallback
        .raw_remap(memory, alignment, new_len, ra)
        .unwrap_or(core::ptr::null_mut())
}

unsafe fn free(ctx: *mut c_void, buf: &mut [u8], alignment: Alignment, ra: usize) {
    // SAFETY: ctx was set to `&mut BufferFallbackAllocator` in `allocator()`.
    let self_: &mut BufferFallbackAllocator =
        unsafe { &mut *ctx.cast::<BufferFallbackAllocator>() };
    if self_.fixed.owns_ptr(buf.as_ptr()) {
        return FixedBufferAllocator::free(&mut self_.fixed, buf, alignment, ra);
    }
    self_.fallback.raw_free(buf, alignment, ra)
}

// ported from: src/bun_alloc/BufferFallbackAllocator.zig