Merge branch 'master' of https://github.com/rust-embedded/embedded-alloc into before-conflicts

Author: trueb2

.cargo/config.toml

@@ -0,0 +1,4 @@
+[target.thumbv7m-none-eabi]
+# used to run the qemu_test.rs example with QEMU
+runner = "qemu-system-arm -cpu cortex-m3 -machine lm3s6965evb -nographic -semihosting-config enable=on,target=native -kernel"
+rustflags = ["-C", "link-arg=-Tlink.x"]

.github/workflows/ci.yml

@@ -24,10 +24,25 @@ jobs:
         with:
           targets: ${{ matrix.target }}
           toolchain: ${{ matrix.toolchain }}
-      - run: cargo check --target=${{ matrix.target }} --examples
+      - run: cargo check --target=${{ matrix.target }} --example global_alloc
       - if: ${{ matrix.toolchain == 'nightly' }}
         run: cargo check --target=${{ matrix.target }} --examples --all-features
 
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          targets: thumbv7m-none-eabi
+          toolchain: nightly
+      - name: Install QEMU
+        run: |
+          sudo apt update
+          sudo apt install qemu-system-arm
+      - run: qemu-system-arm --version
+      - run: cargo run --target thumbv7m-none-eabi --example integration_test --all-features
+
   clippy:
     name: Clippy
     runs-on: ubuntu-latest

Cargo.toml

@@ -24,7 +24,7 @@ name = "embedded-alloc"
 version = "0.5.0"
 
 [features]
-default = ["llff"]
+default = ["llff", "tlsf"]
 allocator_api = []
 
 # Use the Two-Level Segregated Fit allocator
@@ -42,3 +42,5 @@ const-default = { version = "1.0.0", default-features = false, optional = true }
 [dev-dependencies]
 cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7"
+cortex-m-semihosting = "0.5"
+panic-semihosting = { version = "0.6", features = ["exit"] }

examples/allocator_api.rs

@@ -0,0 +1,35 @@
+#![feature(allocator_api)]
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use core::mem::MaybeUninit;
+use core::panic::PanicInfo;
+use cortex_m_rt::entry;
+use embedded_alloc::Heap;
+
+// This is not used, but as of 2023-10-29 allocator_api cannot be used without
+// a global heap
+#[global_allocator]
+static HEAP: Heap = Heap::empty();
+
+#[entry]
+fn main() -> ! {
+    const HEAP_SIZE: usize = 16;
+    static mut HEAP_MEM: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
+    let heap: Heap = Heap::empty();
+    unsafe { heap.init(HEAP_MEM.as_ptr() as usize, HEAP_SIZE) }
+
+    let mut xs = Vec::new_in(heap);
+    xs.push(1);
+
+    #[allow(clippy::empty_loop)]
+    loop { /* .. */ }
+}
+
+#[panic_handler]
+fn panic(_: &PanicInfo) -> ! {
+    loop {}
+}

examples/integration_test.rs

@@ -0,0 +1,88 @@
+//! This is a very basic smoke test that runs in QEMU
+//! Reference the QEMU section of the [Embedded Rust Book] for more information
+//!
+//! This only tests integration of the allocator on an embedded target.
+//! Comprehensive allocator tests are located in the allocator dependency.
+//!
+//! After toolchain installation this test can be run with:
+//!
+//! ```bash
+//! cargo +nightly run --target thumbv7m-none-eabi --example integration_test --all-features
+//! ```
+//!
+//! [Embedded Rust Book]: https://docs.rust-embedded.org/book/intro/index.html
+
+#![feature(allocator_api)]
+#![no_main]
+#![no_std]
+
+extern crate alloc;
+extern crate panic_semihosting;
+
+use alloc::vec::Vec;
+use core::mem::{size_of, MaybeUninit};
+use cortex_m_rt::entry;
+use cortex_m_semihosting::{debug, hprintln};
+use embedded_alloc::Heap;
+
+#[global_allocator]
+static HEAP: Heap = Heap::empty();
+
+fn test_global_heap() {
+    assert_eq!(HEAP.used(), 0);
+
+    let mut xs: Vec<i32> = alloc::vec![1];
+    xs.push(2);
+    xs.extend(&[3, 4]);
+
+    // do not optimize xs
+    core::hint::black_box(&mut xs);
+
+    assert_eq!(xs.as_slice(), &[1, 2, 3, 4]);
+    assert_eq!(HEAP.used(), size_of::<i32>() * xs.len());
+}
+
+fn test_allocator_api() {
+    // small local heap
+    const HEAP_SIZE: usize = 16;
+    let heap_mem: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
+    let local_heap: Heap = Heap::empty();
+    unsafe { local_heap.init(heap_mem.as_ptr() as usize, HEAP_SIZE) }
+
+    assert_eq!(local_heap.used(), 0);
+
+    let mut v: Vec<u16, Heap> = Vec::new_in(local_heap);
+    v.push(0xCAFE);
+    v.extend(&[0xDEAD, 0xFEED]);
+
+    // do not optimize v
+    core::hint::black_box(&mut v);
+
+    assert_eq!(v.as_slice(), &[0xCAFE, 0xDEAD, 0xFEED]);
+}
+
+#[entry]
+fn main() -> ! {
+    {
+        const HEAP_SIZE: usize = 1024;
+        static mut HEAP_MEM: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
+        unsafe { HEAP.init(HEAP_MEM.as_ptr() as usize, HEAP_SIZE) }
+    }
+
+    #[allow(clippy::type_complexity)]
+    let tests: &[(fn() -> (), &'static str)] = &[
+        (test_global_heap, "test_global_heap"),
+        (test_allocator_api, "test_allocator_api"),
+    ];
+
+    for (test_fn, test_name) in tests {
+        hprintln!("{}: start", test_name);
+        test_fn();
+        hprintln!("{}: pass", test_name);
+    }
+
+    // exit QEMU with a success status
+    debug::exit(debug::EXIT_SUCCESS);
+    #[allow(clippy::empty_loop)]
+    loop {}
+}

memory.x

@@ -0,0 +1,6 @@
+MEMORY
+{
+  /* These values correspond to the LM3S6965, one of the few devices QEMU can emulate */
+  FLASH : ORIGIN = 0x00000000, LENGTH = 256K
+  RAM : ORIGIN = 0x20000000, LENGTH = 64K
+}

src/lib.rs

@@ -75,17 +75,14 @@ mod llff {
         pub fn free(&self) -> usize {
             critical_section::with(|cs| self.heap.borrow(cs).borrow_mut().free())
         }
-    }
 
-    unsafe impl GlobalAlloc for Heap {
-        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        unsafe fn alloc(&self, layout: Layout) -> Option<NonNull<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())
             })
         }
 
@@ -99,6 +96,17 @@ mod llff {
         }
     }
 
+    unsafe impl GlobalAlloc for Heap {
+        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+            self.alloc(layout)
+                .map_or(ptr::null_mut(), |allocation| allocation.as_ptr())
+        }
+
+        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+            self.dealloc(ptr, layout);
+        }
+    }
+
     #[cfg(feature = "allocator_api")]
     mod allocator_api {
         use super::*;
@@ -192,17 +200,9 @@ mod tlsf {
                     .insert_free_block_ptr(block.into());
             });
         }
-    }
 
-    unsafe impl GlobalAlloc for Heap {
-        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-            critical_section::with(|cs| {
-                self.heap
-                    .borrow(cs)
-                    .borrow_mut()
-                    .allocate(layout)
-                    .map_or(ptr::null_mut(), |allocation| allocation.as_ptr())
-            })
+        unsafe fn alloc(&self, layout: Layout) -> Option<NonNull<u8>> {
+            critical_section::with(|cs| self.heap.borrow(cs).borrow_mut().allocate(layout))
         }
 
         unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
@@ -211,7 +211,18 @@ mod tlsf {
                     .borrow(cs)
                     .borrow_mut()
                     .deallocate(NonNull::new_unchecked(ptr), layout.align())
-            });
+            })
+        }
+    }
+
+    unsafe impl GlobalAlloc for Heap {
+        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+            self.alloc(layout)
+                .map_or(ptr::null_mut(), |allocation| allocation.as_ptr())
+        }
+
+        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+            self.dealloc(ptr, layout)
         }
     }