haz-alloc-core 0.4.0

A general-purpose allocator written in Rust, without system symbols
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
148

use super::Arena;
use crate::__internal::UsizeExt;
use crate::backend::Mutex;
use crate::{bitset, Backend};
use core::alloc::Layout;
use core::cmp::Ordering;
use core::{mem, ptr};

#[repr(C)]
struct Page {
    p: super::Page,

    // Includes header size
    real_size: usize,
}

/// # Safety
///
/// Pointer must be valid.
///
/// Lock must be locked.
pub(super) unsafe fn alloc<B: Backend>(arena: &Arena<B>, layout: Layout) -> *mut u8 {
    let total_size =
        (mem::size_of::<Page>().align_up(layout.align()) + layout.size()).align_up(B::pagesize());
    let pages = total_size / B::pagesize();

    let index = if let Some(x) = bitset::find_zero_run(&*arena.commited(), pages) {
        x
    } else {
        return ptr::null_mut();
    };

    let p = (arena as *const Arena<B> as *const u8).add(index * B::pagesize()) as *mut Page;

    if !B::mcommit(p as _, total_size) {
        return ptr::null_mut();
    }

    bitset::set_range(&mut *arena.commited(), index, pages);
    *arena.rc.get() += 1;

    ptr::addr_of_mut!((*p).p.class).write(-1);
    ptr::addr_of_mut!((*p).real_size).write(total_size);

    let p = p.add(1) as *mut u8;
    p.add(p.align_offset(layout.align()))
}

/// # Safety
///
/// Pointers must be valid.
///
/// Lock must be unlocked.
pub(super) unsafe fn realloc_in_place<B: Backend>(
    page: *mut super::Page,
    arena: &Arena<B>,
    layout: Layout,
) -> bool {
    let page = page as *mut Page;
    let total_size =
        (mem::size_of::<Page>().align_up(layout.align()) + layout.size()).align_up(B::pagesize());
    let pages = total_size / B::pagesize();
    let old_pages = (*page).real_size / B::pagesize();

    match pages.cmp(&old_pages) {
        Ordering::Greater => {
            let _ = arena.lock.lock();
            grow_in_place(page, arena, pages, old_pages, total_size)
        }
        Ordering::Equal => true,
        Ordering::Less => {
            let _ = arena.lock.lock();
            shrink_in_place(page, arena, pages, old_pages, total_size)
        }
    }
}

/// Lock must be locked.
unsafe fn grow_in_place<B: Backend>(
    page: *mut Page,
    arena: &Arena<B>,
    pages: usize,
    old_pages: usize,
    total_size: usize,
) -> bool {
    let index =
        (page as usize - arena as *const Arena<B> as usize) / B::pagesize() + old_pages;
    let len = pages - old_pages;

    if !bitset::is_zero_range(&*arena.commited(), index, len) {
        return false;
    }
    if !B::mcommit(
        (page as *mut u8).add((*page).real_size),
        total_size - (*page).real_size,
    ) {
        return false;
    }
    bitset::set_range(&mut *arena.commited(), index, len);
    (*page).real_size = total_size;

    true
}

/// Lock must be locked.
unsafe fn shrink_in_place<B: Backend>(
    page: *mut Page,
    arena: &Arena<B>,
    pages: usize,
    old_pages: usize,
    total_size: usize,
) -> bool {
    let index = (page as usize - arena as *const Arena<B> as usize) / B::pagesize() + pages;
    let len = old_pages - pages;

    bitset::clear_range(&mut *arena.commited(), index, len);
    B::mdecommit(
        (page as *mut u8).add(total_size),
        (*page).real_size - total_size,
    );
    (*page).real_size = total_size;

    true
}

/// # Safety
///
/// Pointers must be valid.
///
/// Lock must be unlocked.
pub(super) unsafe fn dealloc<B: Backend>(page: *mut super::Page, arena: *const Arena<B>) {
    let page = page as *mut Page;

    let index = (page as usize - arena as usize) / B::pagesize();
    let len = (*page).real_size / B::pagesize();

    B::mdecommit(page as _, (*page).real_size);
    let guard = (*arena).lock.lock();
    bitset::clear_range(&mut *(*arena).commited(), index, len);
    Arena::release(arena, guard);
}

/// # Safety
///
/// Pointer must be valid.
pub(super) unsafe fn size(page: *const super::Page, ptr: *mut u8) -> usize {
    (*(page as *const Page)).real_size - (ptr as usize - page as usize)
}