haz-alloc-internal 0.0.1

Internal implementation for haz-alloc
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

#![no_std]

#[cfg(test)]
mod tests;

use core::mem;

pub const SMALL_CLASSES: &[usize] = &[
    mem::size_of::<usize>(),
    8,
    // Incremented by 16:
    16,
    16 * 2,
    16 * 3,
    16 * 4,
    16 * 5,
    16 * 6,
    // Incremented by 64:
    64 * 2,
    64 * 3,
    64 * 4,
    64 * 5,
    64 * 6,
    64 * 7,
    64 * 8,
    // Incremented by 256:
    256 * 3,
    256 * 4,
    256 * 5,
    256 * 6,
    256 * 7,
];

pub const SMALL_MAX: usize = 256 * 7;

pub fn small_class_of(size: usize) -> usize {
    if size <= mem::size_of::<usize>() {
        0
    } else if size <= 8 {
        1
    } else if size <= 16 * 6 {
        2 + size.align_up(16) / 16 - 1
    } else if size <= 64 * 8 {
        8 + size.align_up(64) / 64 - 2
    } else {
        15 + size.align_up(256) / 256 - 3
    }
}

pub trait UsizeExt {
    fn align_up(self, multiple: usize) -> Self;
    fn align_down(self, multiple: usize) -> Self;
}

impl UsizeExt for usize {
    #[inline]
    fn align_up(self, multiple: usize) -> Self {
        (self + multiple - 1) / multiple * multiple
    }

    #[inline]
    fn align_down(self, multiple: usize) -> Self {
        self / multiple * multiple
    }
}