rlalloc 0.1.3

blazingly slow malloc replacement
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

use std::ptr;

use crate::ralloc::PAGE_SIZE;

#[derive(Debug, Clone)]
pub struct Chunk {
    pub size: usize,
    pub next: *mut Chunk,
}

impl Iterator for Chunk {
    type Item = *mut Chunk;

    fn next(&mut self) -> Option<Self::Item> {
        if self.next.is_null() {
            None
        } else {
            Some(self.next)
        }
    }
}

pub struct ChunkIter {
    prev: *mut Chunk,
    curr: *mut Chunk,
}

impl ChunkIter {
    fn mychunknext(&mut self) -> Option<(*mut Chunk, *mut Chunk)> {
        unsafe {
            if self.curr.is_null() {
                None
            } else {
                let res = (self.prev, self.curr);
                if (self.prev as usize / PAGE_SIZE) != (self.curr as usize / PAGE_SIZE) {
                    // new_free crosses page boundary, cannot allocate
                    return None;
                }
                self.prev = self.curr;
                self.curr = self.curr.read().next;
                Some(res)
            }
        }
    }
}

impl Iterator for ChunkIter {
    type Item = (*mut Chunk, *mut Chunk);

    fn next(&mut self) -> Option<Self::Item> {
        self.mychunknext()
    }
}

pub struct ChunkToIter(*mut Chunk);

impl ChunkToIter {
    pub fn new(ptr: *mut Chunk) -> Self {
        Self(ptr)
    }
}

impl IntoIterator for ChunkToIter {
    type Item = (*mut Chunk, *mut Chunk);
    type IntoIter = ChunkIter;

    fn into_iter(self) -> Self::IntoIter {
        ChunkIter {
            prev: ptr::null_mut(),
            curr: self.0,
        }
    }
}