palloc 0.1.3

portable linked-list allocator for baremetal systems
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

extern crate std;

use crate::{Palloc, PallocError};
use core::ptr::{slice_from_raw_parts_mut, NonNull};

fn empty_allocator(heap: &mut [u8]) -> Palloc {
    let mut palloc = Palloc::empty();
    unsafe { palloc.init_from_slice(heap) };
    palloc
}

fn memtest_allocation(start: NonNull<u8>, size: usize) -> bool {
    let memory = unsafe { &mut *slice_from_raw_parts_mut(start.as_ptr(), size) };
    !memory
        .iter_mut()
        .enumerate()
        .map(|(index, addr)| (index as u8, addr))
        .any(|(index, addr)| {
            *addr = index;
            *addr != index
        })
}

#[test]
fn test_single_alloc() -> Result<(), PallocError> {
    let mut heap = [0u8; 50];
    let mut palloc = empty_allocator(&mut heap);

    let ptr = unsafe { palloc.alloc(30)? };
    assert!(memtest_allocation(ptr, 30), "should pass memtest");

    Ok(())
}

#[test]
fn test_realloc() -> Result<(), PallocError> {
    let mut heap = [0u8; 100];
    let mut palloc = empty_allocator(&mut heap);

    let allocation = unsafe { palloc.alloc(50)? };
    unsafe { palloc.free(allocation)? };

    let new_allocation = unsafe { palloc.alloc(20)? };
    assert_eq!(allocation, new_allocation);

    Ok(())
}

#[test]
fn test_merge() -> Result<(), PallocError> {
    let mut heap = [0; 100];
    let mut palloc = empty_allocator(&mut heap);

    let first = unsafe { palloc.alloc(20)? };
    let second = unsafe { palloc.alloc(20)? };

    unsafe {
        palloc.free(first)?;
        palloc.free(second)?;
    }

    let realloc = unsafe { palloc.alloc(40)? };

    assert_eq!(first, realloc);
    Ok(())
}

#[test]
fn test_segment() -> Result<(), PallocError> {
    let mut heap = [0; 100];
    let mut palloc = empty_allocator(&mut heap);

    let alloc = unsafe { palloc.alloc(50)? };
    unsafe { palloc.free(alloc)? };

    let new_alloc = unsafe { palloc.alloc(5)? };

    assert!((new_alloc.as_ptr() as usize) < alloc.as_ptr() as usize + 50);
    Ok(())
}

#[test]
fn test_oom() {
    let mut heap = [0; 30];
    let mut palloc = empty_allocator(&mut heap);

    assert_eq!(
        unsafe { palloc.alloc(15) }.unwrap_err(),
        PallocError::OutOfMemory
    );
}