polymorph-allocator 0.1.0-beta.1

A minimal memory manager for no_std
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

#[cfg(not(any(test, rustdoc)))]
use alloc::prelude::v1::*;
#[cfg(any(test, rustdoc))]
use std::prelude::v1::*;

use core::mem::size_of;
use alloc::alloc::Layout;
use super::{Allocator, Region};

#[test]
fn add_region_single() {
    const HEAP_SIZE: usize = 1024;
    let heap = Box::into_raw(Box::new([0u8; HEAP_SIZE])) as *mut u8;

    let mut allocator = Allocator::empty();
    unsafe {
        // Add region
        allocator.add_region(heap as usize, HEAP_SIZE);

        // Check the data pointer is where we want it to be
        let region = allocator.get_region_first().unwrap();
        assert_eq!(region.data_ptr(), heap.offset(size_of::<Region>() as isize));
    }

    // Destroy heap box
    core::mem::drop(allocator);
    core::mem::drop(unsafe { Box::from_raw(heap) });
}

#[test]
fn add_region_multiple() {
    const HEAP_SIZE: usize = 1024;
    let heap_one = Box::into_raw(Box::new([0u8; HEAP_SIZE])) as *mut u8;
    let heap_two = Box::into_raw(Box::new([0u8; HEAP_SIZE])) as *mut u8;

    let mut allocator = Allocator::empty();
    unsafe {
        allocator.add_region(heap_one as usize, HEAP_SIZE);
        allocator.add_region(heap_two as usize, HEAP_SIZE);

        let region_two = allocator.get_region_first().unwrap();
        assert_eq!(region_two.data_ptr(), heap_two.offset(size_of::<Region>() as isize));

        let region_one = region_two.next().unwrap();
        assert_eq!(region_one.data_ptr(), heap_one.offset(size_of::<Region>() as isize));
    }
}

#[test]
fn allocation_single() {
    const HEAP_SIZE: usize = 1024;
    let heap = Box::into_raw(Box::new([0u8; HEAP_SIZE])) as *mut u8;

    // Set up allocator
    let mut allocator = Allocator::empty();
    unsafe {
        allocator.add_region(heap as usize, HEAP_SIZE);
    }

    // Do an allocation
    let layout = Layout::from_size_align(size_of::<usize>() * 4, 1).unwrap();
    allocator.allocate(layout).expect("failed to allocate");

    // Check first region is used, and is now the size of 4x usize
    let region = allocator.get_region_first().expect("failed to get region");
    assert_eq!(region.get_used(), true);
    assert_eq!(region.size(), size_of::<usize>() * 4);

    // Check that the next region is free
    let next = region.next().expect("failed to get next region");
    assert_eq!(next.get_used(), false);
}

#[test]
fn allocation_and_deallocation_multiple() {
    const HEAP_SIZE: usize = 4096;
    let heap = Box::into_raw(Box::new([0u8; HEAP_SIZE])) as *mut u8;

    // Set up allocator
    let mut allocator = Allocator::empty();
    unsafe {
        allocator.add_region(heap as usize, HEAP_SIZE);
    }

    // Do allocations
    for _ in 0..100 {
        let layout = Layout::from_size_align(size_of::<usize>() * 4, 1).unwrap();
        let ptr = allocator.allocate(layout).expect("failed to allocate");
        allocator.deallocate(ptr, layout);
    }
}

#[test]
fn allocation_and_deallocation_single() {
    const HEAP_SIZE: usize = 1024;
    let heap = Box::into_raw(Box::new([0u8; HEAP_SIZE])) as *mut u8;

    // Set up allocator
    let mut allocator = Allocator::empty();
    unsafe {
        allocator.add_region(heap as usize, HEAP_SIZE);
    }

    // Do an allocation
    let layout = Layout::from_size_align(size_of::<usize>() * 4, 1).unwrap();
    let ptr = allocator.allocate(layout).expect("failed to allocate");

    // Check first region is used, and is now the size of 4x usize
    let region = allocator.get_region_first().expect("failed to get region");
    assert_eq!(region.get_used(), true);
    assert_eq!(region.size(), size_of::<usize>() * 4);
    core::mem::drop(region);

    // Deallocate
    allocator.deallocate(ptr, layout);

    // Check region is now set as free
    let region = allocator.get_region_first().expect("failed to get region");
    assert_eq!(region.get_used(), false);
}