Removed Heap wrapper

Author: thejpster

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-authors = ["Jorge Aparicio <[email protected]>"]
+authors = ["Jorge Aparicio <[email protected]>", "Jonathan Pallant <[email protected]>"]
 description = "A heap allocator for Cortex-M processors"
 documentation = "https://docs.rs/alloc-cortex-m"
 keywords = ["arm", "cortex-m", "allocator"]

src/lib.rs

@@ -31,6 +31,7 @@ extern crate linked_list_allocator;
 
 use core::{ptr, cmp};
 
+use linked_list_allocator::Heap;
 use cortex_m::interrupt::Mutex;
 
 /// A global UNINITIALIZED heap allocator
@@ -39,35 +40,25 @@ use cortex_m::interrupt::Mutex;
 /// [`init`](struct.Heap.html#method.init) method before using the allocator.
 pub static HEAP: Mutex<Heap> = Mutex::new(Heap::empty());
 
-/// A heap allocator
-// NOTE newtype to hide all the other Heap methods
-pub struct Heap {
-    inner: linked_list_allocator::Heap,
-}
-
-impl Heap {
-    const fn empty() -> Self {
-        Heap { inner: linked_list_allocator::Heap::empty() }
-    }
-
-    /// Initializes the heap
-    ///
-    /// This method must be called before you run any code that makes use of the
-    /// allocator.
-    ///
-    /// This method must be called exactly ONCE.
-    ///
-    /// `heap_bottom` is the address where the heap will be located. Note that
-    /// heap grows "upwards", towards larger addresses.
-    ///
-    /// `heap_size` is the size of the heap in bytes
-    pub unsafe fn init(&mut self, heap_bottom: usize, heap_size: usize) {
-        self.inner.init(heap_bottom, heap_size);
-    }
-}
-
-/// Init function
-pub unsafe fn alloc_init(start_addr: *mut usize, end_addr: *mut usize) {
+/// Initializes the heap
+///
+/// This method must be called before you run any code that makes use of the
+/// allocator.
+///
+/// This method must be called exactly ONCE.
+///
+/// `start_addr` is the address where the heap will be located. Note that
+/// heap grows "upwards", towards larger addresses.
+///
+/// `end_addr` is the address just part the end of the heap.
+///
+/// In your linker script, you might have something like:
+///
+/// ```
+///    _heap_start = .;
+///    _heap_end = ORIGIN(SRAM) + LENGTH(SRAM) - _stack_size;
+/// ```
+pub unsafe fn init(start_addr: *mut usize, end_addr: *mut usize) {
     let start = start_addr as usize;
     let end = end_addr as usize;
     let size = (end - start) - 1;
@@ -80,16 +71,14 @@ pub unsafe fn alloc_init(start_addr: *mut usize, end_addr: *mut usize) {
 #[no_mangle]
 /// Rust allocation function (c.f. malloc)
 pub extern "C" fn __rust_allocate(size: usize, align: usize) -> *mut u8 {
-    HEAP.lock(|heap| {
-        heap.inner.allocate_first_fit(size, align).expect("out of memory")
-    })
+    HEAP.lock(|heap| heap.allocate_first_fit(size, align).expect("out of memory"))
 }
 
 /// Rust de-allocation function (c.f. free)
 #[doc(hidden)]
 #[no_mangle]
 pub extern "C" fn __rust_deallocate(ptr: *mut u8, size: usize, align: usize) {
-    HEAP.lock(|heap| unsafe { heap.inner.deallocate(ptr, size, align) });
+    HEAP.lock(|heap| unsafe { heap.deallocate(ptr, size, align) });
 }
 
 /// Rust re-allocation function (c.f. realloc)