Consider regions that lead to very small back paddings as unsuitable

If the resulting back padding is too small to be stored as a hole, we treat the hole as unsuitable for the allocation. This way, we avoid unrecoverable leaks of that back padding, which can add up over time and fragment the heap.

Author: phil-opp

src/hole.rs

@@ -120,31 +120,31 @@ impl Cursor {
             alloc_ptr = aligned_addr;
             alloc_size = required_size;
 
-            // Okay, time to move onto the back padding. Here, we are opportunistic -
-            // if it fits, we sits. Otherwise we just skip adding the back padding, and
-            // sort of assume that the allocation is actually a bit larger than it
-            // actually needs to be.
-            //
-            // NOTE: Because we always use `HoleList::align_layout`, the size of
-            // the new allocation is always "rounded up" to cover any partial gaps that
-            // would have occurred. For this reason, we DON'T need to "round up"
-            // to account for an unaligned hole spot.
-            let hole_layout = Layout::new::<Hole>();
-            let back_padding_start = align_up(allocation_end, hole_layout.align());
-            let back_padding_end = back_padding_start.wrapping_add(hole_layout.size());
-
-            // Will the proposed new back padding actually fit in the old hole slot?
-            back_padding = if back_padding_end <= hole_end {
-                // Yes, it does! Place a back padding node
-                Some(HoleInfo {
-                    addr: back_padding_start,
-                    size: (hole_end as usize) - (back_padding_start as usize),
-                })
-            } else {
-                // No, it does not. We are now pretending the allocation now
-                // holds the extra 0..size_of::<Hole>() bytes that are not
-                // big enough to hold what SHOULD be back_padding
+            // Okay, time to move onto the back padding.
+            let back_padding_size = hole_end as usize - allocation_end as usize;
+            back_padding = if back_padding_size == 0 {
                 None
+            } else {
+                // NOTE: Because we always use `HoleList::align_layout`, the size of
+                // the new allocation is always "rounded up" to cover any partial gaps that
+                // would have occurred. For this reason, we DON'T need to "round up"
+                // to account for an unaligned hole spot.
+                let hole_layout = Layout::new::<Hole>();
+                let back_padding_start = align_up(allocation_end, hole_layout.align());
+                let back_padding_end = back_padding_start.wrapping_add(hole_layout.size());
+
+                // Will the proposed new back padding actually fit in the old hole slot?
+                if back_padding_end <= hole_end {
+                    // Yes, it does! Place a back padding node
+                    Some(HoleInfo {
+                        addr: back_padding_start,
+                        size: back_padding_size,
+                    })
+                } else {
+                    // No, it does not. We don't want to leak any heap bytes, so we
+                    // consider this hole unsuitable for the requested allocation.
+                    return Err(self);
+                }
             };
         }