Make it possible to extend the size of the heap

Add extend call that will increase the size of the heap by the given
size. This is unsafe call and the caller must ensure that the new area
is valid.

That allows heap to be more memory efficient, consuming more memory only
when necessary, eg. os allocator might map additional virtual memory when
the allocation fails.

Author: rafalmiel

src/hole.rs

@@ -124,7 +124,7 @@ struct Allocation {
     back_padding: Option<HoleInfo>,
 }
 
-/// Splits the given hole into `(front_padding, hole, back_padding)` if it's big enough to allocate
+/// Splits the given hole into `(fprzewaznieront_padding, hole, back_padding)` if it's big enough to allocate
 /// `required_size` bytes with the `required_align`. Else `None` is returned.
 /// Front padding occurs if the required alignment is higher than the hole's alignment. Back
 /// padding occurs if the required size is smaller than the size of the aligned hole. All padding

src/lib.rs

@@ -93,6 +93,23 @@ impl Heap {
     pub fn size(&self) -> usize {
         self.size
     }
+
+    /// Return the top address of the heap
+    pub fn top(&self) -> usize {
+        self.bottom + self.size
+    }
+
+    /// Extends the size of the heap if it won't exceed max_size
+    /// Returns true if the call succeeded
+    ///
+    /// # Unsafety
+    ///
+    /// The new extended area must be valid
+    pub unsafe fn extend(&mut self, by: usize) {
+        let top = self.top();
+        self.holes.deallocate(top as *mut u8, by);
+        self.size += by;
+    }
 }
 
 /// Align downwards. Returns the greatest x with alignment `align`

src/test.rs

@@ -12,6 +12,17 @@ fn new_heap() -> Heap {
     heap
 }
 
+fn new_max_heap() -> Heap {
+    const HEAP_SIZE: usize = 1024;
+    const HEAP_SIZE_MAX: usize = 2048;
+    let heap_space = Box::into_raw(Box::new([0u8; HEAP_SIZE_MAX]));
+
+    let heap = unsafe { Heap::new(heap_space as usize, HEAP_SIZE) };
+    assert!(heap.bottom == heap_space as usize);
+    assert!(heap.size == HEAP_SIZE);
+    heap
+}
+
 #[test]
 fn empty() {
     let mut heap = Heap::empty();
@@ -201,3 +212,51 @@ fn align_from_small_to_big() {
     // try to allocate a 8 byte aligned block
     assert!(heap.allocate_first_fit(8, 8).is_some());
 }
+
+#[test]
+fn extend_empty_heap() {
+    let mut heap = new_max_heap();
+
+    unsafe {
+        heap.extend(1024);
+    }
+
+    // Try to allocate full heap after extend
+    assert!(heap.allocate_first_fit(2048, 1).is_some());
+}
+
+#[test]
+fn extend_full_heap() {
+    let mut heap = new_max_heap();
+
+    // Allocate full heap, extend and allocate again to the max
+    assert!(heap.allocate_first_fit(1024, 1).is_some());
+    unsafe {
+        heap.extend(1024);
+    }
+    assert!(heap.allocate_first_fit(1024, 1).is_some());
+}
+
+#[test]
+fn extend_fragmented_heap() {
+    let mut heap = new_max_heap();
+
+    let alloc1 = heap.allocate_first_fit(512, 1);
+    let alloc2 = heap.allocate_first_fit(512, 1);
+
+    assert!(alloc1.is_some());
+    assert!(alloc2.is_some());
+
+    unsafe {
+        // Create a hole at the beginning of the heap
+        heap.deallocate(alloc1.unwrap(), 512, 1);
+    }
+
+    unsafe {
+        heap.extend(1024);
+    }
+
+    // We got additional 1024 bytes hole at the end of the heap
+    // Try to allocate there
+    assert!(heap.allocate_first_fit(1024, 1).is_some());
+}