[#996] Use NonNull<u8> in elementary/BumpAllocator

doc/release-notes/iceoryx2-unreleased.md

@@ -48,6 +48,10 @@
     NOTE: Add new entries sorted by issue number to minimize the possibility of
     conflicts when merging.
 -->
+
+- Use 'NonNull' in 'elementary/BumpAllocator'
+  [#996](https://github.com/eclipse-iceoryx/iceoryx2/issues/996)
+
 * Remove support for Bazel Workspaces
   [#1263](https://github.com/eclipse-iceoryx/iceoryx2/issues/1263)
 * Adjust test names to naming convention
@@ -108,3 +112,20 @@
    set_log_level(LogLevel::Info);
    info!("some log message")
    ```
+
+1. Creating a BumpAllocator expects a `NonNull<u8>` instead of a mutable raw pointer.
+
+   ```rust
+   // old
+    let mut memory = [0u8; 8192];
+    let allocator = BumpAllocator::new(memory.as_mut_ptr());
+
+   // new
+   let mut memory = [0u8; 8192];
+   let allocator = BumpAllocator::new(
+       core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast()).expect(
+           "Precondition failed: Memory pointer is null"),
+            core::mem::size_of_val(&memory)
+   )
+   .unwrap();
+   ```

iceoryx2-bb/concurrency/src/cell.rs

@@ -66,6 +66,10 @@ impl<T> RefCell<T> {
     pub fn borrow_mut(&self) -> RefMut<'_, T> {
         self.0.borrow_mut()
     }
+
+    pub fn replace(&self, t: T) -> T {
+        self.0.replace(t)
+    }
 }
 
 impl<T: Default> PlacementDefault for RefCell<T> {

iceoryx2-bb/container/src/flatmap.rs

@@ -676,7 +676,16 @@ impl<K: Eq, V: Clone, const CAPACITY: usize> PlacementDefault for FixedSizeFlatM
     unsafe fn placement_default(ptr: *mut Self) {
         let map_ptr = core::ptr::addr_of_mut!((*ptr).map);
         map_ptr.write(unsafe { RelocatableFlatMap::new_uninit(CAPACITY) });
-        let allocator = BumpAllocator::new((*ptr)._idx_to_data.as_mut_ptr().cast());
+
+        // SAFETY: Creating a pointer to an existing member is always not null
+        let data_ptr = unsafe {
+            core::ptr::NonNull::<u8>::new_unchecked((*ptr)._idx_to_data.as_mut_ptr().cast())
+        };
+
+        let allocator = BumpAllocator::new(
+            data_ptr,
+            size_of::<Self>() - core::mem::offset_of!(Self, _idx_to_data),
+        );
         (*ptr)
             .map
             .init(&allocator)
@@ -715,7 +724,16 @@ impl<K: Eq, V: Clone, const CAPACITY: usize> FixedSizeFlatMap<K, V, CAPACITY> {
             _data: MaybeUninit::uninit(),
             _data_next_free_index: MaybeUninit::uninit(),
         };
-        let allocator = BumpAllocator::new(new_self._idx_to_data.as_mut_ptr().cast());
+
+        // SAFETY: Creating a pointer to an existing member is always not null
+        let data_ptr = unsafe {
+            core::ptr::NonNull::<u8>::new_unchecked(new_self._idx_to_data.as_mut_ptr().cast())
+        };
+
+        let allocator = BumpAllocator::new(
+            data_ptr,
+            size_of::<Self>() - core::mem::offset_of!(Self, _idx_to_data),
+        );
         unsafe {
             new_self
                 .map

iceoryx2-bb/container/src/queue.rs

@@ -80,7 +80,12 @@
 //!             queue_memory: [const { MaybeUninit::uninit() }; QUEUE_CAPACITY] ,
 //!         };
 //!
-//!         let allocator = BumpAllocator::new(new_self.queue_memory.as_mut_ptr().cast());
+//!         let allocator = BumpAllocator::new(
+//!         core::ptr::NonNull::<u8>::new(new_self.queue_memory.as_mut_ptr().cast())
+//!         .expect("Precondition failed: Pointer to memory is null"),
+//!         core::mem::size_of_val(&new_self.queue_memory)
+//!         );
+//!
 //!         unsafe {
 //!             new_self.queue.init(&allocator).expect("Enough memory provided.")
 //!         };
@@ -103,7 +108,11 @@
 //! const MEM_SIZE: usize = RelocatableQueue::<u128>::const_memory_size(QUEUE_CAPACITY);
 //! let mut memory = [0u8; MEM_SIZE];
 //!
-//! let bump_allocator = BumpAllocator::new(memory.as_mut_ptr());
+//! let bump_allocator = BumpAllocator::new(
+//!     core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+//!     .expect("Precondition failed: Pointer to memory is null"),
+//!     core::mem::size_of_val(&memory)
+//!     );
 //!
 //! let mut queue = unsafe { RelocatableQueue::<u128>::new_uninit(QUEUE_CAPACITY) };
 //! unsafe { queue.init(&bump_allocator).expect("queue init failed") };
@@ -472,7 +481,11 @@ impl<T, const CAPACITY: usize> PlacementDefault for FixedSizeQueue<T, CAPACITY>
         let state_ptr = core::ptr::addr_of_mut!((*ptr).state);
         state_ptr.write(RelocatableQueue::new_uninit(CAPACITY));
 
-        let allocator = BumpAllocator::new((*ptr)._data.as_mut_ptr().cast());
+        // SAFETY: Creating a pointer to an existing member is always not null
+        let data_ptr =
+            unsafe { core::ptr::NonNull::<u8>::new_unchecked((*ptr)._data.as_mut_ptr().cast()) };
+
+        let allocator = BumpAllocator::new(data_ptr, core::mem::size_of_val((*ptr)._data.as_ref()));
         (*ptr)
             .state
             .init(&allocator)
@@ -487,7 +500,12 @@ impl<T, const CAPACITY: usize> Default for FixedSizeQueue<T, CAPACITY> {
             _data: unsafe { MaybeUninit::uninit().assume_init() },
         };
 
-        let allocator = BumpAllocator::new(new_self._data.as_mut_ptr().cast());
+        // SAFETY: Creating a pointer to an existing member is always not null
+        let data_ptr =
+            unsafe { core::ptr::NonNull::<u8>::new_unchecked(new_self._data.as_mut_ptr().cast()) };
+
+        let allocator =
+            BumpAllocator::new(data_ptr, core::mem::size_of_val(new_self._data.as_ref()));
         unsafe {
             new_self
                 .state

iceoryx2-bb/container/src/slotmap.rs

@@ -603,7 +603,16 @@ impl<T, const CAPACITY: usize> PlacementDefault for FixedSizeSlotMap<T, CAPACITY
     unsafe fn placement_default(ptr: *mut Self) {
         let state_ptr = core::ptr::addr_of_mut!((*ptr).state);
         state_ptr.write(unsafe { RelocatableSlotMap::new_uninit(CAPACITY) });
-        let allocator = BumpAllocator::new((*ptr)._idx_to_data.as_mut_ptr().cast());
+
+        // SAFETY: Creating a pointer to an existing member is always not null
+        let data_ptr = unsafe {
+            core::ptr::NonNull::<u8>::new_unchecked((*ptr)._idx_to_data.as_mut_ptr().cast())
+        };
+
+        let allocator = BumpAllocator::new(
+            data_ptr,
+            size_of::<Self>() - core::mem::offset_of!(Self, _idx_to_data),
+        );
         (*ptr)
             .state
             .init(&allocator)
@@ -621,7 +630,16 @@ impl<T, const CAPACITY: usize> Default for FixedSizeSlotMap<T, CAPACITY> {
             state: unsafe { RelocatableSlotMap::new_uninit(CAPACITY) },
         };
 
-        let allocator = BumpAllocator::new(new_self._idx_to_data.as_mut_ptr().cast());
+        // SAFETY: Creating a pointer to an existing member is always not null
+        let data_ptr = unsafe {
+            core::ptr::NonNull::<u8>::new_unchecked(new_self._idx_to_data.as_mut_ptr().cast())
+        };
+
+        let allocator = BumpAllocator::new(
+            data_ptr,
+            size_of::<Self>() - core::mem::offset_of!(Self, _idx_to_data),
+        );
+
         unsafe {
             new_self
                 .state

iceoryx2-bb/container/src/string/relocatable_string.rs

@@ -38,7 +38,12 @@
 //!             str_memory: [const { MaybeUninit::uninit() }; STRING_CAPACITY + 1] ,
 //!         };
 //!
-//!         let allocator = BumpAllocator::new(new_self.str_memory.as_mut_ptr().cast());
+//!         let allocator = BumpAllocator::new(
+//!         core::ptr::NonNull::<u8>::new(new_self.str_memory.as_mut_ptr().cast())
+//!         .expect("Precondition failed: Pointer to memory is null"),
+//!         core::mem::size_of_val(&new_self.str_memory)
+//!         );
+//!
 //!         unsafe {
 //!             new_self.my_str.init(&allocator).expect("Enough memory provided.")
 //!         };
@@ -60,7 +65,11 @@
 //! const MEM_SIZE: usize = RelocatableString::const_memory_size(STRING_CAPACITY);
 //! let mut memory = [0u8; MEM_SIZE];
 //!
-//! let bump_allocator = BumpAllocator::new(memory.as_mut_ptr());
+//! let bump_allocator = BumpAllocator::new(
+//!     core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+//!     .expect("Precondition failed: Pointer to memory is null"),
+//!     core::mem::size_of_val(&memory)
+//!     );
 //!
 //! let mut my_str = unsafe { RelocatableString::new_uninit(STRING_CAPACITY) };
 //! unsafe { my_str.init(&bump_allocator).expect("string init failed") };

iceoryx2-bb/container/src/vector/relocatable_vec.rs

@@ -36,7 +36,11 @@
 //!             vec_memory: [const { MaybeUninit::uninit() }; VEC_CAPACITY] ,
 //!         };
 //!
-//!         let allocator = BumpAllocator::new(new_self.vec_memory.as_mut_ptr().cast());
+//!         let allocator = BumpAllocator::new(
+//!         core::ptr::NonNull::<u8>::new(new_self.vec_memory.as_mut_ptr().cast())
+//!         .expect("Precondition failed: Pointer to memory is null"),
+//!         core::mem::size_of_val(&new_self.vec_memory)
+//!         );
 //!         unsafe {
 //!             new_self.vec.init(&allocator).expect("Enough memory provided.")
 //!         };
@@ -57,7 +61,11 @@
 //! const MEM_SIZE: usize = RelocatableVec::<u128>::const_memory_size(VEC_CAPACITY);
 //! let mut memory = [0u8; MEM_SIZE];
 //!
-//! let bump_allocator = BumpAllocator::new(memory.as_mut_ptr());
+//! let bump_allocator = BumpAllocator::new(
+//!     core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+//!     .expect("Precondition failed: Pointer to memory is null"),
+//!     core::mem::size_of_val(&memory)
+//! );
 //!
 //! let mut vec = unsafe { RelocatableVec::<u128>::new_uninit(VEC_CAPACITY) };
 //! unsafe { vec.init(&bump_allocator).expect("vec init failed") };

iceoryx2-bb/container/tests/flatmap_tests.rs

@@ -216,7 +216,11 @@ mod flat_map {
     fn double_init_call_causes_panic() {
         const MEM_SIZE: usize = RelocatableFlatMap::<u8, u8>::const_memory_size(CAPACITY);
         let mut memory = [0u8; MEM_SIZE];
-        let bump_allocator = BumpAllocator::new(memory.as_mut_ptr());
+        let bump_allocator = BumpAllocator::new(
+            core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+                .expect("Precondition failed: Pointer to memory is null"),
+            core::mem::size_of_val(&memory),
+        );
 
         let mut sut = unsafe { RelocatableFlatMap::<u8, u8>::new_uninit(CAPACITY) };
         unsafe { sut.init(&bump_allocator).expect("sut init failed") };

iceoryx2-bb/container/tests/polymorphic_string_tests.rs

@@ -39,7 +39,9 @@ impl Test {
         unsafe {
             if (*self.allocator.get()).is_none() {
                 *self.allocator.get() = Some(Box::new(BumpAllocator::new(
-                    (*self.raw_memory.get()).as_mut_ptr(),
+                    core::ptr::NonNull::<u8>::new((*self.raw_memory.get()).as_mut_ptr().cast())
+                        .expect("Precondition failed: Pointer to memory is null"),
+                    core::mem::size_of_val((*self.raw_memory.get()).as_ref()),
                 )))
             }
         };

iceoryx2-bb/container/tests/polymorphic_vec_tests.rs

@@ -39,7 +39,9 @@ impl Test {
         unsafe {
             if (*self.allocator.get()).is_none() {
                 *self.allocator.get() = Some(Box::new(BumpAllocator::new(
-                    (*self.raw_memory.get()).as_mut_ptr(),
+                    core::ptr::NonNull::<u8>::new((*self.raw_memory.get()).as_mut_ptr().cast())
+                        .expect("Precondition failed: Pointer to memory is null"),
+                    core::mem::size_of_val((*self.raw_memory.get()).as_ref()),
                 )))
             }
         };

iceoryx2-bb/container/tests/queue_tests.rs

@@ -24,7 +24,11 @@ mod queue {
     #[test]
     fn relocatable_push_pop_works_with_uninitialized_memory() {
         let mut memory = [0u8; 1024];
-        let allocator = BumpAllocator::new(memory.as_mut_ptr());
+        let allocator = BumpAllocator::new(
+            core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+                .expect("Precondition failed: Pointer to memory is null"),
+            core::mem::size_of_val(&memory),
+        );
 
         let mut sut = unsafe { RelocatableQueue::<usize>::new_uninit(SUT_CAPACITY) };
         unsafe { assert_that!(sut.init(&allocator), is_ok) };
@@ -53,7 +57,11 @@ mod queue {
     #[test]
     fn relocatable_clear_empties_queue() {
         let mut memory = [0u8; 1024];
-        let allocator = BumpAllocator::new(memory.as_mut_ptr());
+        let allocator = BumpAllocator::new(
+            core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+                .expect("Precondition failed: Pointer to memory is null"),
+            core::mem::size_of_val(&memory),
+        );
 
         let mut sut = unsafe { RelocatableQueue::<usize>::new_uninit(SUT_CAPACITY) };
         unsafe { assert_that!(sut.init(&allocator), is_ok) };
@@ -332,7 +340,11 @@ mod queue {
     fn double_init_call_causes_panic() {
         const MEM_SIZE: usize = RelocatableQueue::<usize>::const_memory_size(SUT_CAPACITY);
         let mut memory = [0u8; MEM_SIZE];
-        let bump_allocator = BumpAllocator::new(memory.as_mut_ptr());
+        let bump_allocator = BumpAllocator::new(
+            core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+                .expect("Precondition failed: Pointer to memory is null"),
+            core::mem::size_of_val(&memory),
+        );
 
         let mut sut = unsafe { RelocatableQueue::<usize>::new_uninit(SUT_CAPACITY) };
         unsafe { sut.init(&bump_allocator).expect("sut init failed") };

iceoryx2-bb/container/tests/relocatable_vec_tests.rs

@@ -22,7 +22,11 @@ fn double_init_call_causes_panic() {
     const CAPACITY: usize = 12;
     const MEM_SIZE: usize = RelocatableVec::<u128>::const_memory_size(CAPACITY);
     let mut memory = [0u8; MEM_SIZE];
-    let bump_allocator = BumpAllocator::new(memory.as_mut_ptr());
+    let bump_allocator = BumpAllocator::new(
+        core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+            .expect("Precondition failed: Pointer to data in memory is null"),
+        core::mem::size_of_val(&memory),
+    );
     let mut sut = unsafe { RelocatableVec::<u128>::new_uninit(CAPACITY) };
     unsafe { sut.init(&bump_allocator).expect("sut init failed") };
 
@@ -44,8 +48,16 @@ fn two_vectors_with_same_content_are_equal() {
     const MEM_SIZE: usize = RelocatableVec::<usize>::const_memory_size(SUT_CAPACITY);
     let mut memory_1 = [0u8; MEM_SIZE];
     let mut memory_2 = [0u8; MEM_SIZE];
-    let bump_allocator_1 = BumpAllocator::new(memory_1.as_mut_ptr());
-    let bump_allocator_2 = BumpAllocator::new(memory_2.as_mut_ptr());
+    let bump_allocator_1 = BumpAllocator::new(
+        core::ptr::NonNull::<u8>::new(memory_1.as_mut_ptr().cast())
+            .expect("Precondition failed: Pointer to data in memory is null"),
+        core::mem::size_of_val(&memory_1),
+    );
+    let bump_allocator_2 = BumpAllocator::new(
+        core::ptr::NonNull::<u8>::new(memory_2.as_mut_ptr().cast())
+            .expect("Precondition failed: Pointer to data in memory is null"),
+        core::mem::size_of_val(&memory_2),
+    );
     let mut sut_1 = unsafe { RelocatableVec::<usize>::new_uninit(SUT_CAPACITY) };
     unsafe { sut_1.init(&bump_allocator_1).unwrap() };
     let mut sut_2 = unsafe { RelocatableVec::<usize>::new_uninit(SUT_CAPACITY) };
@@ -65,8 +77,16 @@ fn two_vectors_with_different_content_are_not_equal() {
     const MEM_SIZE: usize = RelocatableVec::<usize>::const_memory_size(SUT_CAPACITY);
     let mut memory_1 = [0u8; MEM_SIZE];
     let mut memory_2 = [0u8; MEM_SIZE];
-    let bump_allocator_1 = BumpAllocator::new(memory_1.as_mut_ptr());
-    let bump_allocator_2 = BumpAllocator::new(memory_2.as_mut_ptr());
+    let bump_allocator_1 = BumpAllocator::new(
+        core::ptr::NonNull::<u8>::new(memory_1.as_mut_ptr().cast())
+            .expect("Precondition failed: Pointer to data in memory is null"),
+        core::mem::size_of_val(&memory_1),
+    );
+    let bump_allocator_2 = BumpAllocator::new(
+        core::ptr::NonNull::<u8>::new(memory_2.as_mut_ptr().cast())
+            .expect("Precondition failed: Pointer to data in memory is null"),
+        core::mem::size_of_val(&memory_2),
+    );
     let mut sut_1 = unsafe { RelocatableVec::<usize>::new_uninit(SUT_CAPACITY) };
     unsafe { sut_1.init(&bump_allocator_1).unwrap() };
     let mut sut_2 = unsafe { RelocatableVec::<usize>::new_uninit(SUT_CAPACITY) };
@@ -88,8 +108,16 @@ fn two_vectors_with_different_len_are_not_equal() {
     const MEM_SIZE: usize = RelocatableVec::<usize>::const_memory_size(SUT_CAPACITY);
     let mut memory_1 = [0u8; MEM_SIZE];
     let mut memory_2 = [0u8; MEM_SIZE];
-    let bump_allocator_1 = BumpAllocator::new(memory_1.as_mut_ptr());
-    let bump_allocator_2 = BumpAllocator::new(memory_2.as_mut_ptr());
+    let bump_allocator_1 = BumpAllocator::new(
+        core::ptr::NonNull::<u8>::new(memory_1.as_mut_ptr().cast())
+            .expect("Precondition failed: Pointer to data in memory is null"),
+        core::mem::size_of_val(&memory_1),
+    );
+    let bump_allocator_2 = BumpAllocator::new(
+        core::ptr::NonNull::<u8>::new(memory_2.as_mut_ptr().cast())
+            .expect("Precondition failed: Pointer to data in memory is null"),
+        core::mem::size_of_val(&memory_2),
+    );
     let mut sut_1 = unsafe { RelocatableVec::<usize>::new_uninit(SUT_CAPACITY) };
     unsafe { sut_1.init(&bump_allocator_1).unwrap() };
     let mut sut_2 = unsafe { RelocatableVec::<usize>::new_uninit(SUT_CAPACITY) };

iceoryx2-bb/container/tests/slotmap_tests.rs

@@ -243,7 +243,11 @@ mod slot_map {
     fn double_init_call_causes_panic() {
         const MEM_SIZE: usize = RelocatableSlotMap::<usize>::const_memory_size(SUT_CAPACITY);
         let mut memory = [0u8; MEM_SIZE];
-        let bump_allocator = BumpAllocator::new(memory.as_mut_ptr());
+        let bump_allocator = BumpAllocator::new(
+            core::ptr::NonNull::<u8>::new(memory.as_mut_ptr().cast())
+                .expect("Precondition failed: Pointer to memory is null"),
+            core::mem::size_of_val(&memory),
+        );
 
         let mut sut = unsafe { RelocatableSlotMap::<usize>::new_uninit(SUT_CAPACITY) };
         unsafe { sut.init(&bump_allocator).expect("sut init failed") };