tlsf 1.1.0

An implementation of the Two-Level Segregated Fit (TLSF) allocator with optimized memory footprint
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

use core::ptr::NonNull;

use crate::Tlsf;

impl<'a, const FLL: usize> Tlsf<'a, FLL> {
    /// Returns the block of memory behind `ptr` to the allocator
    ///
    /// # Safety
    ///
    /// - `ptr` MUST denote a block of memory currently allocated via this allocator
    /// - `ptr` MUST no be freed more than once
    /// - `ptr` MUST not be used after it has been freed
    pub unsafe fn free(&mut self, ptr: NonNull<u32>) {
        let Some(anchor) = self.anchor else { return };
        let used = anchor.get_used_block(ptr);
        let free = used.into_free(anchor);
        self.header.coalesce(anchor, free);
    }
}

#[cfg(test)]
mod tests {
    use core::alloc::Layout;
    use core::mem::MaybeUninit;

    use super::*;
    use crate::block::{Anchor, Offset};
    use crate::helpers::Memory;

    #[test]
    fn it_works() {
        let mut tlsf = Tlsf::<1>::empty();
        let mut memory = [MaybeUninit::uninit(); 4];
        tlsf.initialize(&mut memory);

        let layout = Layout::new::<u32>();

        let alloc = tlsf.memalign(layout).unwrap();
        alloc.iter_mut().for_each(|mu| {
            mu.write(!0);
        });

        unsafe { tlsf.free(NonNull::from(alloc).cast()) }
    }

    #[test]
    fn furthest_block() {
        let mut tlsf = Tlsf::<1>::empty();
        let mut memory = Memory::new();
        let anchor = Anchor::new(memory.bytes());
        tlsf.anchor = Some(anchor);

        unsafe {
            let block = anchor.create_free_block(Offset::max(), 4, true, None);
            let alloc = block.into_used(anchor);
            tlsf.free(NonNull::from(alloc).cast());
        }
    }
}