Make AllocRef implementation optional behind new alloc_ref feature

Author: phil-opp

Cargo.toml

@@ -14,6 +14,7 @@ homepage = "http://os.phil-opp.com/kernel-heap.html#a-better-allocator"
 [features]
 default = ["use_spin"]
 use_spin = ["spinning_top"]
+alloc_ref = []
 
 [dependencies.spinning_top]
 version = "0.1.0"

src/hole.rs

@@ -1,4 +1,4 @@
-use alloc::alloc::{AllocErr, Layout};
+use alloc::alloc::Layout;
 use core::mem::{align_of, size_of};
 use core::ptr::NonNull;
 
@@ -49,7 +49,7 @@ impl HoleList {
     /// block is returned.
     /// This function uses the “first fit” strategy, so it uses the first hole that is big
     /// enough. Thus the runtime is in O(n) but it should be reasonably fast for small allocations.
-    pub fn allocate_first_fit(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {
+    pub fn allocate_first_fit(&mut self, layout: Layout) -> Result<NonNull<u8>, ()> {
         assert!(layout.size() >= Self::min_size());
 
         allocate_first_fit(&mut self.first, layout).map(|allocation| {
@@ -192,7 +192,7 @@ fn split_hole(hole: HoleInfo, required_layout: Layout) -> Option<Allocation> {
 /// care of freeing it again.
 /// This function uses the “first fit” strategy, so it breaks as soon as a big enough hole is
 /// found (and returns it).
-fn allocate_first_fit(mut previous: &mut Hole, layout: Layout) -> Result<Allocation, AllocErr> {
+fn allocate_first_fit(mut previous: &mut Hole, layout: Layout) -> Result<Allocation, ()> {
     loop {
         let allocation: Option<Allocation> = previous
             .next
@@ -210,7 +210,7 @@ fn allocate_first_fit(mut previous: &mut Hole, layout: Layout) -> Result<Allocat
             }
             None => {
                 // this was the last hole, so no hole is big enough -> allocation not possible
-                return Err(AllocErr);
+                return Err(());
             }
         }
     }

src/lib.rs

@@ -1,5 +1,5 @@
 #![feature(const_fn)]
-#![feature(allocator_api)]
+#![cfg_attr(feature = "alloc_ref", feature(allocator_api))]
 #![no_std]
 
 #[cfg(test)]
@@ -11,7 +11,9 @@ extern crate spinning_top;
 
 extern crate alloc;
 
-use alloc::alloc::{AllocErr, AllocRef, Layout};
+use alloc::alloc::Layout;
+#[cfg(feature = "alloc_ref")]
+use alloc::alloc::{AllocErr, AllocRef};
 use core::alloc::GlobalAlloc;
 use core::mem;
 #[cfg(feature = "use_spin")]
@@ -71,7 +73,7 @@ impl Heap {
     /// This function scans the list of free memory blocks and uses the first block that is big
     /// enough. The runtime is in O(n) where n is the number of free blocks, but it should be
     /// reasonably fast for small allocations.
-    pub fn allocate_first_fit(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {
+    pub fn allocate_first_fit(&mut self, layout: Layout) -> Result<NonNull<u8>, ()> {
         let mut size = layout.size();
         if size < HoleList::min_size() {
             size = HoleList::min_size();
@@ -129,9 +131,13 @@ impl Heap {
     }
 }
 
+#[cfg(feature = "alloc_ref")]
 unsafe impl AllocRef for Heap {
     unsafe fn alloc(&mut self, layout: Layout) -> Result<(NonNull<u8>, usize), AllocErr> {
-        Ok((self.allocate_first_fit(layout)?, layout.size()))
+        match self.allocate_first_fit(layout) {
+            Ok(ptr) => Ok((ptr, layout.size())),
+            Err(()) => Err(AllocErr),
+        }
     }
 
     unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {