[#996] Refactor Bumpallocator

Use NonNull<u8> for the pointer to the memory on construction and add a
size parameter. Removed the atomic primitives.

Author: dkroenke

iceoryx2-bb/elementary/src/bump_allocator.rs

@@ -10,23 +10,26 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
+use core::ptr::NonNull;
+use iceoryx2_bb_concurrency::cell::RefCell;
+
 use crate::math::align;
-use iceoryx2_bb_concurrency::atomic::AtomicUsize;
-use iceoryx2_bb_concurrency::atomic::Ordering;
 use iceoryx2_bb_elementary_traits::allocator::{AllocationError, BaseAllocator};
 
 /// A minimalistic [`BumpAllocator`].
 pub struct BumpAllocator {
-    start: *mut u8,
-    pos: AtomicUsize,
+    start: NonNull<u8>,
+    next_free_memory: RefCell<u64>,
+    start_size: usize,
 }
 
 impl BumpAllocator {
     /// Creates a new [`BumpAllocator`] that manages the memory starting at `start`.
-    pub fn new(start: *mut u8) -> Self {
+    pub fn new(start: NonNull<u8>, size: usize) -> Self {
         Self {
             start,
-            pos: AtomicUsize::new(start as usize),
+            next_free_memory: RefCell::<u64>::new(start.as_ptr().cast::<u64>() as u64),
+            start_size: size,
         }
     }
 }
@@ -36,20 +39,29 @@ impl BaseAllocator for BumpAllocator {
         &self,
         layout: core::alloc::Layout,
     ) -> Result<core::ptr::NonNull<[u8]>, AllocationError> {
-        let mem = align(self.pos.load(Ordering::Relaxed), layout.align());
-        self.pos.store(mem + layout.size(), Ordering::Relaxed);
+        let mem = align(*self.next_free_memory.borrow() as usize, layout.align()) as u64;
+        let allocated_memory_size =
+            *self.next_free_memory.borrow() as usize - self.start.as_ptr() as usize;
+
+        if allocated_memory_size + layout.size() > self.start_size {
+            return Err(AllocationError::SizeTooLarge);
+        }
+
+        self.next_free_memory.replace(mem + layout.size() as u64);
 
         unsafe {
             Ok(core::ptr::NonNull::new_unchecked(
                 core::ptr::slice_from_raw_parts_mut(
-                    self.start.add(mem - self.start as usize),
+                    self.start
+                        .add(mem as usize - self.start.as_ptr() as usize)
+                        .as_ptr(),
                     layout.size(),
                 ),
             ))
         }
     }
 
     unsafe fn deallocate(&self, _ptr: core::ptr::NonNull<u8>, _layout: core::alloc::Layout) {
-        self.pos.store(self.start as usize, Ordering::Relaxed);
+        self.next_free_memory.replace(self.start.as_ptr() as u64);
     }
 }

iceoryx2-bb/elementary/tests/bump_allocator_tests.rs

@@ -15,45 +15,59 @@ use core::{alloc::Layout, ptr::NonNull};
 use iceoryx2_bb_elementary::{bump_allocator::*, math::align};
 use iceoryx2_bb_elementary_traits::allocator::BaseAllocator;
 use iceoryx2_bb_testing::assert_that;
+use std::ptr;
 
 #[test]
 fn start_position_is_correctly_used() {
     let mut memory = [0u8; 8192];
-    let start_position: *mut u8 = memory.as_mut_ptr();
+    let start_position: Option<core::ptr::NonNull<u8>> =
+        core::ptr::NonNull::<u8>::new(memory.as_mut_ptr());
     const MEM_SIZE: usize = 91;
     const MEM_ALIGN: usize = 1;
-    let sut = BumpAllocator::new(start_position);
+    let sut = BumpAllocator::new(start_position.unwrap(), core::mem::size_of_val(&memory));
 
     let memory = sut
         .allocate(Layout::from_size_align(MEM_SIZE, MEM_ALIGN).unwrap())
         .unwrap();
 
-    assert_that!(unsafe { memory.as_ref() }.as_ptr() as usize, eq start_position as usize);
+    assert_that!(unsafe { memory.as_ref() }.as_ptr() as usize, eq start_position.unwrap().as_ptr() as usize);
     assert_that!(unsafe { memory.as_ref() }.len(), eq MEM_SIZE);
 }
 
+#[test]
+#[should_panic]
+fn start_position_is_null() {
+    let null_ptr: *const u8 = ptr::null();
+    let start_position: core::ptr::NonNull<u8> =
+        core::ptr::NonNull::<u8>::new(null_ptr.cast_mut()).unwrap();
+
+    let _sut = BumpAllocator::new(start_position, 0);
+}
+
 #[test]
 fn allocated_memory_is_correctly_aligned() {
-    let mut memory = [0u8; 8192];
-    let start_position: *mut u8 = unsafe { memory.as_mut_ptr().add(1) };
+    let memory = [0u8; 8192];
+    let start_position: core::ptr::NonNull<u8> =
+        unsafe { core::ptr::NonNull::<u8>::new(memory.as_ptr().cast_mut().add(1)).unwrap() };
     const MEM_SIZE: usize = 128;
     const MEM_ALIGN: usize = 64;
-    let sut = BumpAllocator::new(start_position);
+    let sut = BumpAllocator::new(start_position, core::mem::size_of_val(&memory));
 
     let memory = sut
         .allocate(Layout::from_size_align(MEM_SIZE, MEM_ALIGN).unwrap())
         .unwrap();
 
-    assert_that!(unsafe { memory.as_ref() }.as_ptr() as usize, eq align(start_position as usize, MEM_ALIGN));
+    assert_that!(unsafe { memory.as_ref() }.as_ptr() as usize, eq align(start_position.as_ptr() as usize, MEM_ALIGN));
     assert_that!(unsafe { memory.as_ref() }.len(), eq MEM_SIZE);
 }
 
 #[test]
 fn allocating_many_aligned_chunks_work() {
-    let mut memory = [0u8; 8192];
-    let start_position: *mut u8 = unsafe { memory.as_mut_ptr().add(1) };
+    let memory = [0u8; 8192];
+    let start_position: core::ptr::NonNull<u8> =
+        unsafe { core::ptr::NonNull::<u8>::new(memory.as_ptr().cast_mut().add(1)).unwrap() };
     const ITERATIONS: u32 = 5;
-    let sut = BumpAllocator::new(start_position);
+    let sut = BumpAllocator::new(start_position, core::mem::size_of_val(&memory));
 
     let mut last_size = 0;
     let mut last_position = 0;
@@ -76,11 +90,12 @@ fn allocating_many_aligned_chunks_work() {
 
 #[test]
 fn deallocating_releases_everything() {
-    let mut memory = [0u8; 8192];
-    let start_position: *mut u8 = unsafe { memory.as_mut_ptr().add(3) };
+    let memory = [0u8; 8192];
+    let start_position: core::ptr::NonNull<u8> =
+        unsafe { core::ptr::NonNull::<u8>::new(memory.as_ptr().cast_mut().add(3)).unwrap() };
     const MEM_SIZE: usize = 128;
     const MEM_ALIGN: usize = 1;
-    let sut = BumpAllocator::new(start_position);
+    let sut = BumpAllocator::new(start_position, core::mem::size_of_val(&memory));
 
     let layout = Layout::from_size_align(MEM_SIZE, MEM_ALIGN).unwrap();
     let mut memory = sut.allocate(layout).unwrap();
@@ -96,6 +111,6 @@ fn deallocating_releases_everything() {
         .allocate(Layout::from_size_align(MEM_SIZE, MEM_ALIGN).unwrap())
         .unwrap();
 
-    assert_that!(unsafe { memory.as_ref() }.as_ptr() as usize, eq start_position as usize);
+    assert_that!(unsafe { memory.as_ref() }.as_ptr() as usize, eq start_position.as_ptr() as usize);
     assert_that!(unsafe { memory.as_ref() }.len(), eq MEM_SIZE);
 }