use ::core::ops::Deref;
use ::core::ptr::NonNull;
use ::core::alloc::Layout;
use std::alloc::{self, dealloc};
use std::sync::Arc;
use iceoryx2_bb_memory::heap_allocator::HeapAllocator;
use crate::containers::Vector;
use crate::prelude::FoundationAtomicU8;
use crate::types::CommonErrors;
pub trait ReusableObjectTrait {
fn reusable_clear(&mut self);
}
pub struct ReusableObjects<T: ReusableObjectTrait> {
storage: Box<[NonNull<T>]>,
states: Box<[Arc<ObjectState>]>, position: usize, size: usize, }
unsafe impl<T: ReusableObjectTrait + Send> Send for ReusableObjects<T> {}
impl<T: ReusableObjectTrait> ReusableObjects<T> {
pub fn new<U: Fn(usize) -> T>(cnt: usize, init: U) -> Self {
assert!(cnt != 0, "Pool cannot be 0 sized!");
let storage = Self::create_arr_storage(cnt, |i| unsafe {
let input_layout = Layout::new::<T>();
let memory = alloc::alloc(input_layout);
let typed = memory as *mut T;
typed.write(init(i));
NonNull::new(typed).unwrap()
});
let states = Self::create_arr_storage(cnt, |_| Arc::new(ObjectState::new()));
Self {
storage,
states,
position: 0,
size: cnt,
}
}
pub fn next_object(&mut self) -> Result<ReusableObject<T>, CommonErrors> {
let index = self.position % self.size;
let atomic_ref = &self.states[index].0;
match atomic_ref.compare_exchange(
OBJECT_FREE,
OBJECT_TAKEN,
::core::sync::atomic::Ordering::AcqRel,
::core::sync::atomic::Ordering::Acquire,
) {
Ok(_) => {}
Err(_) => return Err(CommonErrors::NoData), }
self.position += 1;
Ok(ReusableObject {
storage: self.storage[index],
state: self.states[index].clone(),
})
}
fn create_arr_storage<Type, U: Fn(usize) -> Type>(size: usize, init: U) -> Box<[Type]> {
let layout = Layout::array::<Type>(size).unwrap();
let ptr = unsafe { alloc::alloc(layout) as *mut Type };
for i in 0..size {
unsafe {
ptr.add(i).write(init(i)); }
}
unsafe { Box::from_raw(::core::ptr::slice_from_raw_parts_mut(ptr, size)) }
}
}
pub struct ReusableObject<T: ReusableObjectTrait> {
storage: NonNull<T>,
state: Arc<ObjectState>, }
unsafe impl<T: ReusableObjectTrait + Send> Send for ReusableObject<T> {}
impl<T: ReusableObjectTrait> ReusableObject<T> {
pub unsafe fn as_inner_mut(&mut self) -> &mut T {
self.storage.as_mut()
}
}
impl<T: ReusableObjectTrait> Drop for ReusableObjects<T> {
fn drop(&mut self) {
for index in 0..self.size {
let object = &self.storage[index];
match self.states[index].0.compare_exchange(
OBJECT_TAKEN,
OBJECT_POOL_GONE,
::core::sync::atomic::Ordering::AcqRel,
::core::sync::atomic::Ordering::Acquire,
) {
Ok(_) => {}
Err(actual) => unsafe {
assert_eq!(actual, OBJECT_FREE);
::core::sync::atomic::fence(::core::sync::atomic::Ordering::SeqCst); object.drop_in_place();
dealloc(object.as_ptr() as *mut u8, Layout::new::<T>());
},
}
}
}
}
impl<T: ReusableObjectTrait> Drop for ReusableObject<T> {
fn drop(&mut self) {
struct DropGuard<'a, T: ReusableObjectTrait> {
this: &'a mut ReusableObject<T>,
}
impl<T: ReusableObjectTrait> DropGuard<'_, T> {
fn reusable_clear(&mut self) {
unsafe {
self.this.storage.as_mut().reusable_clear();
}
}
}
impl<T: ReusableObjectTrait> Drop for DropGuard<'_, T> {
fn drop(&mut self) {
match self.this.state.0.compare_exchange(
OBJECT_TAKEN,
OBJECT_FREE,
::core::sync::atomic::Ordering::AcqRel,
::core::sync::atomic::Ordering::Acquire,
) {
Ok(_) => {}
Err(val) => {
assert_eq!(val, OBJECT_POOL_GONE);
unsafe {
self.this.storage.drop_in_place();
dealloc(self.this.storage.as_ptr() as *mut u8, Layout::new::<T>());
}
}
}
}
}
let mut guard = DropGuard { this: self }; guard.reusable_clear();
}
}
impl<T: ReusableObjectTrait> Deref for ReusableObject<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
unsafe { self.storage.as_ref() }
}
}
const OBJECT_TAKEN: u8 = 1; const OBJECT_FREE: u8 = 0; const OBJECT_POOL_GONE: u8 = 0xFF;
struct ObjectState(FoundationAtomicU8);
impl ObjectState {
fn new() -> Self {
Self(FoundationAtomicU8::new(OBJECT_FREE))
}
}
macro_rules! impl_reusable_for_primitive {
($($t:ty),*) => {
$(
impl ReusableObjectTrait for $t {
#[inline]
fn reusable_clear(&mut self) {
*self = Default::default();
}
}
)*
};
}
impl_reusable_for_primitive!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64, bool, char);
impl<T> ReusableObjectTrait for crate::containers::PolymorphicVec<'_, T, HeapAllocator> {
fn reusable_clear(&mut self) {
self.clear();
}
}
#[cfg(test)]
#[cfg(not(loom))]
mod tests {
use crate::prelude::FoundationAtomicUsize;
use super::*;
use std::sync::Arc;
pub struct TestObject {
id: usize,
value: i32,
clear_count: Arc<FoundationAtomicUsize>,
}
impl ReusableObjectTrait for TestObject {
fn reusable_clear(&mut self) {
self.value = 0;
self.clear_count.fetch_add(1, ::core::sync::atomic::Ordering::Relaxed);
}
}
#[test]
fn test_create_and_access() {
let clear_count = Arc::new(FoundationAtomicUsize::new(0));
let cc = clear_count.clone();
let mut pool = ReusableObjects::new(5, |i| TestObject {
id: i,
value: 10,
clear_count: cc.clone(),
});
let obj1 = pool.next_object().expect("Should get first object");
assert_eq!(obj1.id, 0);
assert_eq!(obj1.value, 10);
let obj2 = pool.next_object().expect("Should get second object");
assert_eq!(obj2.id, 1);
assert_eq!(obj2.value, 10);
}
#[test]
fn test_round_robin() {
let clear_count = Arc::new(FoundationAtomicUsize::new(0));
let cc = clear_count.clone();
let mut pool = ReusableObjects::new(3, |i| TestObject {
id: i,
value: 10,
clear_count: cc.clone(),
});
let obj1 = pool.next_object().expect("Should get first object");
let obj2 = pool.next_object().expect("Should get second object");
let obj3 = pool.next_object().expect("Should get third object");
assert_eq!(obj1.id, 0);
assert_eq!(obj2.id, 1);
assert_eq!(obj3.id, 2);
assert!(pool.next_object().is_err());
drop(obj1);
let obj4 = pool.next_object().expect("Should get an object after dropping one");
assert_eq!(obj4.id, 0); }
#[test]
fn test_reusable_clear() {
let clear_count = Arc::new(FoundationAtomicUsize::new(0));
let cc = clear_count.clone();
let mut pool = ReusableObjects::new(1, |i| TestObject {
id: i,
value: 10,
clear_count: cc.clone(),
});
{
let obj = pool.next_object().expect("Should get object");
assert_eq!(obj.value, 10);
}
assert_eq!(clear_count.load(::core::sync::atomic::Ordering::Relaxed), 1);
let obj = pool.next_object().expect("Should get object again");
assert_eq!(obj.value, 0);
}
#[test]
fn test_exhaustion_recovery() {
let clear_count = Arc::new(FoundationAtomicUsize::new(0));
let cc = clear_count.clone();
let mut pool = ReusableObjects::new(2, |i| TestObject {
id: i,
value: 10,
clear_count: cc.clone(),
});
let obj1 = pool.next_object().expect("Should get first object");
let obj2 = pool.next_object().expect("Should get second object");
assert!(pool.next_object().is_err());
drop(obj1);
drop(obj2);
let obj1 = pool.next_object().expect("Should get object again");
let obj2 = pool.next_object().expect("Should get object again");
assert_eq!(obj1.id, 0);
assert_eq!(obj2.id, 1);
}
#[test]
fn test_drop_while_objects_in_use() {
let clear_count = Arc::new(FoundationAtomicUsize::new(0));
let cc = clear_count.clone();
let object_holder = {
let mut pool = ReusableObjects::new(1, |i| TestObject {
id: i,
value: 10,
clear_count: cc.clone(),
});
pool.next_object().expect("Should get object")
};
assert_eq!(object_holder.id, 0);
assert_eq!(object_holder.value, 10);
drop(object_holder);
assert_eq!(clear_count.load(::core::sync::atomic::Ordering::Relaxed), 1);
}
#[test]
fn test_multiple_drops_and_acquires() {
let clear_count = Arc::new(FoundationAtomicUsize::new(0));
let cc = clear_count.clone();
let mut pool = ReusableObjects::new(3, |i| TestObject {
id: i,
value: 10,
clear_count: cc.clone(),
});
let obj1 = pool.next_object().expect("Should get object");
let obj2 = pool.next_object().expect("Should get object");
drop(obj1);
let obj3 = pool.next_object().expect("Should get object");
drop(obj2);
drop(obj3);
let obj1 = pool.next_object().expect("Should get object");
let obj2 = pool.next_object().expect("Should get object");
let obj3 = pool.next_object().expect("Should get object");
drop(obj2);
drop(obj1);
drop(obj3);
assert_eq!(clear_count.load(::core::sync::atomic::Ordering::Relaxed), 6);
}
#[test]
#[should_panic]
fn test_zero_sized_pool() {
let clear_count = Arc::new(FoundationAtomicUsize::new(0));
let cc = clear_count.clone();
let _pool = ReusableObjects::new(0, |i| TestObject {
id: i,
value: 10,
clear_count: cc.clone(),
});
}
}
#[cfg(test)]
#[cfg(loom)]
mod tests {
use crate::prelude::FoundationAtomicUsize;
use super::*;
use ::core::sync::atomic::Ordering;
use loom::model::Builder;
pub struct TestObject {
id: usize,
value: i32,
clear_count: Arc<FoundationAtomicUsize>,
}
impl ReusableObjectTrait for TestObject {
fn reusable_clear(&mut self) {
self.value = 0;
self.clear_count.fetch_add(1, Ordering::Relaxed);
}
}
#[test]
fn test_thread_safety() {
use loom::model::Builder;
let builder = Builder::new();
builder.check(|| {
let clear_count = Arc::new(FoundationAtomicUsize::new(0));
let cc = clear_count.clone();
let mut pool = ReusableObjects::new(1, |i| TestObject {
id: i,
value: 10,
clear_count: cc.clone(),
});
let obj = pool.next_object().expect("Should get object");
let handle = loom::thread::spawn(move || {
assert_eq!(obj.id, 0);
assert_eq!(obj.value, 10);
});
let _ = handle.join().unwrap();
let obj = pool.next_object().expect("Should get object back after thread completes");
assert_eq!(obj.id, 0);
assert_eq!(obj.value, 0); });
}
#[test]
fn test_reusable_object() {
let builder = Builder::new();
builder.check(|| {
let mut pool = ReusableObjects::new(2, |_| 0);
let obj1 = pool.next_object().unwrap();
let obj2 = pool.next_object().unwrap();
let handle = loom::thread::spawn(move || {
let x = obj2.deref() + 1;
x
});
assert!(pool.next_object().is_err());
drop(obj1);
let _ = handle.join();
{
let _obj1 = pool.next_object().unwrap();
let _obj2 = pool.next_object().unwrap();
}
});
}
#[test]
fn test_reusable_object_with_values() {
let builder = Builder::new();
builder.check(|| {
let mut pool = ReusableObjects::new(2, |i| i);
let obj1 = pool.next_object().unwrap();
let obj2 = pool.next_object().unwrap();
assert_eq!(*obj1, 0);
assert_eq!(*obj2, 1);
let handle = loom::thread::spawn(move || {
drop(obj1);
});
let res = pool.next_object();
match res {
Ok(v) => assert_eq!(0, *v),
Err(_) => {}
}
let _ = handle.join();
});
}
}