Struct MemoryPool 

pub struct MemoryPool<T> { /* private fields */ }

A memory pool for temporary allocations.

This provides fast allocation for scratch space by reusing previously allocated buffers. Useful for algorithms that repeatedly allocate and free temporary storage of similar sizes.

Thread Safety

This pool is NOT thread-safe. Use one pool per thread or wrap in a mutex.

Example

use oxiblas_core::memory::MemoryPool;

let mut pool = MemoryPool::new();

// Acquire a buffer
let buffer: Vec<f64> = pool.acquire(100);
// ... use buffer ...

// Return buffer to pool for reuse
pool.release(buffer);

// Next acquire may reuse the buffer
let buffer2: Vec<f64> = pool.acquire(50);

Implementations

impl<T> MemoryPool<T>

pub fn new() -> Self

Creates a new memory pool with default limits.

pub fn with_limits(max_cached: usize, max_bytes: usize) -> Self

Creates a new memory pool with custom limits.

Arguments

• max_cached - Maximum number of buffers to cache
• max_bytes - Maximum total bytes to cache

pub fn acquire(&mut self, min_capacity: usize) -> Vec<T>

Acquires a buffer with at least the given capacity.

If a suitable buffer exists in the pool, it is reused. Otherwise, a new buffer is allocated.

pub fn release(&mut self, buffer: Vec<T>)

Returns a buffer to the pool for future reuse.

The buffer is cleared before being stored.

pub fn cached_count(&self) -> usize

Returns the number of cached buffers.

pub fn cached_bytes(&self) -> usize

Returns the total cached bytes.

pub fn clear(&mut self)

Clears all cached buffers.

pub fn shrink_to_limits(&mut self)

Shrinks the pool to fit within the current limits.

Removes the largest buffers first to stay within limits.

Trait Implementations

impl<T> Default for MemoryPool<T>

fn default() -> Self

Returns the “default value” for a type.