Add choice of Two-Level Segregate Fit and Linked List First Fit

Author: trueb2

Cargo.toml

@@ -23,12 +23,20 @@ license = "MIT OR Apache-2.0"
 name = "embedded-alloc"
 version = "0.5.0"
 
+[features]
+# Choose exactly 1 allocator
+default = []
+
+# Use the Two-Level Segregated Fit allocator
+tlsf = ["rlsf", "const-default"]
+# Use the LinkedList first-fit allocator
+llff = ["linked_list_allocator"]
+
 [dependencies]
 critical-section = "1.0"
-
-[dependencies.linked_list_allocator]
-default-features = false
-version = "0.10.5"
+linked_list_allocator = { version = "0.10.5", default-features = false, optional = true }
+rlsf = { version = "0.2.1", default-features = false, optional = true }
+const-default = { version = "1.0.0", default-features = false, optional = true }
 
 [dev-dependencies]
 cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }

src/lib.rs

@@ -5,11 +5,27 @@ use core::alloc::{GlobalAlloc, Layout};
 use core::cell::RefCell;
 use core::ptr::{self, NonNull};
 
+#[cfg(feature = "tlsf")]
+use const_default::ConstDefault;
 use critical_section::Mutex;
+
+// Exactly one of these features must be enabled: "llff" or "tlsf"
+#[cfg(all(feature = "tlsf", feature = "llff"))]
+compile_error!("You can't enable both 'tlsf' and 'llff' features simultaneously. Choose one allocator.");
+
+#[cfg(feature = "llff")]
 use linked_list_allocator::Heap as LLHeap;
+#[cfg(feature = "tlsf")]
+use rlsf::Tlsf;
+
+#[cfg(feature = "tlsf")]
+type TlsfHeap = Tlsf<'static, usize, usize, { usize::BITS as usize }, { usize::BITS as usize }>;
 
 pub struct Heap {
+    #[cfg(feature = "llff")]
     heap: Mutex<RefCell<LLHeap>>,
+    #[cfg(feature = "tlsf")]
+    heap: Mutex<RefCell<TlsfHeap>>,
 }
 
 impl Heap {
@@ -19,7 +35,10 @@ impl Heap {
     /// [`init`](Self::init) method before using the allocator.
     pub const fn empty() -> Heap {
         Heap {
+            #[cfg(feature = "llff")]
             heap: Mutex::new(RefCell::new(LLHeap::empty())),
+            #[cfg(feature = "tlsf")]
+            heap: Mutex::new(RefCell::new(ConstDefault::DEFAULT)),
         }
     }
 
@@ -49,19 +68,32 @@ impl Heap {
     /// - `size > 0`
     pub unsafe fn init(&self, start_addr: usize, size: usize) {
         critical_section::with(|cs| {
-            self.heap
-                .borrow(cs)
-                .borrow_mut()
-                .init(start_addr as *mut u8, size);
+            #[cfg(feature = "llff")]
+            {
+                self.heap
+                    .borrow(cs)
+                    .borrow_mut()
+                    .init(start_addr as *mut u8, size);
+            }
+            #[cfg(feature = "tlsf")]
+            {
+                let block: &[u8] = core::slice::from_raw_parts(start_addr as *const u8, size);
+                self.heap
+                    .borrow(cs)
+                    .borrow_mut()
+                    .insert_free_block_ptr(block.into());
+            }
         });
     }
 
     /// Returns an estimate of the amount of bytes in use.
+    #[cfg(feature = "llff")]
     pub fn used(&self) -> usize {
         critical_section::with(|cs| self.heap.borrow(cs).borrow_mut().used())
     }
 
     /// Returns an estimate of the amount of bytes available.
+    #[cfg(feature = "llff")]
     pub fn free(&self) -> usize {
         critical_section::with(|cs| self.heap.borrow(cs).borrow_mut().free())
     }
@@ -70,21 +102,42 @@ impl Heap {
 unsafe impl GlobalAlloc for Heap {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         critical_section::with(|cs| {
-            self.heap
-                .borrow(cs)
-                .borrow_mut()
-                .allocate_first_fit(layout)
-                .ok()
-                .map_or(ptr::null_mut(), |allocation| allocation.as_ptr())
+            #[cfg(feature = "llff")]
+            {
+                self.heap
+                    .borrow(cs)
+                    .borrow_mut()
+                    .allocate_first_fit(layout)
+                    .ok()
+                    .map_or(ptr::null_mut(), |allocation| allocation.as_ptr())
+            }
+            #[cfg(feature = "tlsf")]
+            {
+                self.heap
+                    .borrow(cs)
+                    .borrow_mut()
+                    .allocate(layout)
+                    .map_or(ptr::null_mut(), |allocation| allocation.as_ptr())
+            }
         })
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
         critical_section::with(|cs| {
-            self.heap
-                .borrow(cs)
-                .borrow_mut()
-                .deallocate(NonNull::new_unchecked(ptr), layout)
+            #[cfg(feature = "llff")]
+            {
+                self.heap
+                    .borrow(cs)
+                    .borrow_mut()
+                    .deallocate(NonNull::new_unchecked(ptr), layout)
+            }
+            #[cfg(feature = "tlsf")]
+            {
+                self.heap
+                    .borrow(cs)
+                    .borrow_mut()
+                    .deallocate(NonNull::new_unchecked(ptr), layout.align())
+            }
         });
     }
 }