Improve deallocate function with next_unwrap() and HoleInfo

Author: phil-opp

src/hole.rs

@@ -169,52 +169,60 @@ fn allocate_first_fit(previous: &mut Hole, size: usize, align: usize) -> Option<
             })
 }
 
+/// Frees the allocation given by `(addr, size)`. It starts at the given hole and walks the list to
+/// find the correct place (the list is sorted by address). 
 fn deallocate(hole: &mut Hole, addr: usize, size: usize) {
+    assert!(size >= HoleList::min_size());
+
     let hole_addr = if hole.size == 0 {
-        0   // dummy
+        // It's the dummy hole, which is the head of the HoleList. It's somewhere on the stack,
+        // so it's address is not the address of the hole. We set the addr to 0 as it's always
+        // the first hole.
+        0
     } else {
+        // tt's a real hole in memory and its address is the address of the hole
         hole as *mut _ as usize
     };
-    assert!(addr >= hole_addr + hole.size);
 
+    // Each freed block must be handled by the previous hole in memory. Thus the freed address must
+    // be always behind the current hole.
+    assert!(hole_addr + hole.size <= addr);
 
+    // get information about the next block
+    let next_hole_info = hole.next.as_ref().map(|next| unsafe { next.get().info() });
 
-    match mem::replace(&mut hole.next, None) {
-        Some(ref mut next) if addr == hole_addr + hole.size && addr + size == **next as usize => {
+    match next_hole_info {
+        Some(next) if hole_addr + hole.size == addr && addr + size == next.addr => {
             // block fills the gap between this hole and the next hole
             // before:  ___XXX____YYYYY____    where X is this hole and Y the next hole
             // after:   ___XXXFFFFYYYYY____    where F is the freed block
-            hole.size += size + unsafe { next.get().size };
-            hole.next = unsafe { next.get_mut() }.next.take();
+
+            hole.size += size + next.size; // merge the F and Y blocks to this X block
+            hole.next = hole.next_unwrap().next.take(); // remove the Y block
         }
-        Some(ref next) if addr == hole_addr + hole.size => {
+        Some(_) if hole_addr + hole.size == addr => {
             // block is right behind this hole but there is used memory after it
             // before:  ___XXX______YYYYY____    where X is this hole and Y the next hole
             // after:   ___XXXFFFF__YYYYY____    where F is the freed block
-            hole.size += size;
 
-            // hole.next should stay the same
-            hole.next = Some(unsafe { Unique::new(**next) }); //hack to avoid implementing clone
+            hole.size += size; // merge the F block to this X block
         }
-        Some(ref mut next) if addr + size == **next as usize => {
+        Some(next) if addr + size == next.addr => {
             // block is right before the next hole but there is used memory before it
             // before:  ___XXX______YYYYY____    where X is this hole and Y the next hole
             // after:   ___XXX__FFFFYYYYY____    where F is the freed block
-            let next_hole_next = unsafe { next.get_mut() }.next.take();
-            let next_hole_size = unsafe { next.get() }.size;
-            hole.next = next_hole_next; // delete next block
-            deallocate(hole, addr, size + next_hole_size); // free it again as a big block
+
+            hole.next = hole.next_unwrap().next.take(); // remove the Y block
+            deallocate(hole, addr, size + next.size); // free the merged F/Y block
         }
-        Some(ref mut next) if addr >= **next as usize => {
+        Some(next) if next.addr <= addr => {
             // block is behind the next hole, so we delegate it to the next hole
             // before:  ___XXX__YYYYY________    where X is this hole and Y the next hole
             // after:   ___XXX__YYYYY__FFFF__    where F is the freed block
 
-            // hole.next should stay the same
-            hole.next = Some(unsafe { Unique::new(**next) }); // hack to avoid implementing clone
-            deallocate(unsafe { next.get_mut() }, addr, size);
+            deallocate(hole.next_unwrap(), addr, size);
         }
-        next => {
+        _ => {
             // block is between this and the next hole
             // before:  ___XXX________YYYYY_    where X is this hole and Y the next hole
             // after:   ___XXX__FFFF__YYYYY_    where F is the freed block
@@ -225,10 +233,12 @@ fn deallocate(hole: &mut Hole, addr: usize, size: usize) {
 
             let new_hole = Hole {
                 size: size,
-                next: next,
+                next: hole.next.take(), // the reference to the Y block (if it exists)
             };
+            // write the new hole to the freed memory
             let ptr = addr as *mut Hole;
             mem::forget(mem::replace(unsafe { &mut *ptr }, new_hole));
+            // add the F block as the next block of the X block
             hole.next = Some(unsafe { Unique::new(ptr) });
         }
     }