Struct ObjectPool 

pub struct ObjectPool<T, const N: usize> { /* private fields */ }

Fixed-size object pool for frequently allocated types.

Pre-allocates objects at creation, provides O(1) acquire/release. Used in Ring 0 to avoid heap allocation during event processing.

Type Parameters

• T - The type of objects in the pool. Must implement Default.
• N - Maximum capacity of the pool (compile-time constant).

Example

use laminar_core::alloc::ObjectPool;

// Create a pool of 16 buffers
let mut pool: ObjectPool<Vec<u8>, 16> = ObjectPool::with_init(|| Vec::with_capacity(1024));

// Acquire from pool (O(1), no allocation)
let mut buf = pool.acquire().expect("pool not empty");
buf.extend_from_slice(b"hello");

// Return to pool (O(1), no allocation)
buf.clear();
pool.release(buf);

Thread Safety

This pool is NOT thread-safe. Each core in a thread-per-core architecture should have its own pool.

Implementations

impl<T, const N: usize> ObjectPool<T, N>

pub fn new() -> Self

Create a new empty pool.

Objects must be added via release() or use with_init() for pre-population.

pub fn with_init<F>(factory: F) -> Self

where F: Fn() -> T,

Create a pool pre-populated with objects using a factory function.

The factory is called N times to create the initial pool contents. This allocation happens at startup, not on the hot path.

Arguments

• factory - Function to create each object

Example

use laminar_core::alloc::ObjectPool;

let pool: ObjectPool<Vec<u8>, 8> = ObjectPool::with_init(|| Vec::with_capacity(256));
assert_eq!(pool.available(), 8);

pub fn acquire(&mut self) -> Option<T>

Acquire an object from the pool.

Returns None if the pool is exhausted.

Performance

O(1), no allocation.

Example

use laminar_core::alloc::ObjectPool;

let mut pool: ObjectPool<u64, 4> = ObjectPool::with_init(|| 0);
let obj = pool.acquire().unwrap();
assert_eq!(pool.available(), 3);

pub fn release(&mut self, obj: T) -> bool

Release an object back to the pool.

If the pool is full, the object is dropped instead of stored.

Performance

O(1), no allocation.

Returns

true if the object was added to the pool, false if it was dropped.

Example

use laminar_core::alloc::ObjectPool;

let mut pool: ObjectPool<u64, 4> = ObjectPool::new();
assert!(pool.release(42)); // Added to pool
assert_eq!(pool.available(), 1);

pub fn available(&self) -> usize

Get the number of available objects in the pool.

pub fn in_use(&self) -> usize

Get the number of objects currently in use.

pub const fn capacity(&self) -> usize

Get the maximum capacity of the pool.

pub fn is_empty(&self) -> bool

Check if the pool is empty (no objects available).

pub fn is_full(&self) -> bool

Check if the pool is full (no more room for released objects).

pub fn clear(&mut self)

Clear all objects from the pool.

Drops all pooled objects and resets counters.

Trait Implementations

impl<T: Clone, const N: usize> Clone for ObjectPool<T, N>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for ObjectPool<T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, const N: usize> Default for ObjectPool<T, N>

fn default() -> Self

Create a pool pre-populated with N default objects.