dumpalo 0.1.0

A minimalistic global bump allocator
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

//! Usage:
//! ```rust
//! #[global_allocator]
//! static DUMP: dumpalo::DumpAlloc = dumpalo::DumpAlloc;
//! ```
use std::{
    alloc::{GlobalAlloc, Layout},
    cell::UnsafeCell,
    cmp::max,
    ptr::null_mut,
};

const AREA_SIZE: usize = 64 * 1024 * 1024 - 4096;
const MAX_ALLOC_SIZE: usize = AREA_SIZE / 4;

thread_local! {
    static DUMP: UnsafeCell<Dump> = UnsafeCell::new(Dump {
        next: null_mut(),
        end: null_mut(),
    });
}

struct Dump {
    next: *mut u8,
    end: *mut u8,
}

pub struct DumpAlloc;

unsafe impl GlobalAlloc for DumpAlloc {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        if MAX_ALLOC_SIZE <= layout.size() {
            return new_area(layout.size());
        }
        DUMP.with(|dump| alloc_local(layout, dump.get().as_mut().unwrap()))
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        if cfg!(feature = "zero-on-dealloc") {
            // Maybe zram will have an easier time as your machine inevitably descends into swap-induced slugishness
            for o in 0..layout.size() {
                ptr.add(o).write_unaligned(0);
            }
        }
    }
}

unsafe fn alloc_local(layout: Layout, dump: &mut Dump) -> *mut u8 {
    let require = layout.size() + layout.align();
    if require > dump.end as usize - dump.next as usize {
        let a = new_area(max(AREA_SIZE, require));
        if a.is_null() {
            return null_mut();
        }
        dump.next = a;
        dump.end = a.add(AREA_SIZE);
    }
    let at = dump.next.add(dump.next.align_offset(layout.align()));
    dump.next = at.add(layout.size());
    at
}

unsafe fn new_area(size: usize) -> *mut u8 {
    libc::malloc(size) as *mut u8
}