Struct BufferPoolConfig 

pub struct BufferPoolConfig {
    pub pool_min_size: usize,
    pub min_size: NonZeroUsize,
    pub max_size: NonZeroUsize,
    pub max_per_class: NonZeroUsize,
    pub prefill: bool,
    pub alignment: NonZeroUsize,
    /* private fields */
}

Configuration for a buffer pool.

Fields

pool_min_size: usize

Minimum request size that should use pooled allocation.

Requests smaller than this bypass the pool and use direct aligned allocation instead. A value of 0 means all eligible requests use the pool.

min_size: NonZeroUsize

Minimum buffer size. Must be >= alignment and a power of two.

max_size: NonZeroUsize

Maximum buffer size. Must be a power of two and >= min_size.

max_per_class: NonZeroUsize

Maximum number of buffers per size class.

prefill: bool

Whether to pre-allocate all buffers on pool creation.

alignment: NonZeroUsize

Buffer alignment. Must be a power of two. Use page_size() for storage I/O and cache_line_size() for network I/O.

Implementations

impl BufferPoolConfig

pub const fn for_network() -> Self

Network I/O preset: cache-line aligned, 1KB to 64KB buffers, 4096 per class, not prefilled.

Network operations typically need multiple concurrent buffers per connection (message, encoding, encryption) so we allow 4096 buffers per size class. Cache-line alignment is used because network buffers don’t require page alignment for DMA, and smaller alignment reduces internal fragmentation.

pub fn for_storage() -> Self

Storage I/O preset: page-aligned, page_size to 8MB buffers, 32 per class, not prefilled.

Page alignment is required for direct I/O and efficient DMA transfers.

pub const fn with_pool_min_size(self, pool_min_size: usize) -> Self

Returns a copy of this config with a new minimum request size that uses pooling.

pub const fn with_min_size(self, min_size: NonZeroUsize) -> Self

Returns a copy of this config with a new minimum buffer size.

pub const fn with_max_size(self, max_size: NonZeroUsize) -> Self

Returns a copy of this config with a new maximum buffer size.

pub const fn with_max_per_class(self, max_per_class: NonZeroUsize) -> Self

Returns a copy of this config with a new maximum number of buffers per size class.

pub const fn with_thread_cache_capacity( self, thread_cache_capacity: NonZeroUsize, ) -> Self

Returns a copy of this config with an explicit per-thread cache size.

pub const fn with_thread_cache_for_parallelism( self, parallelism: NonZeroUsize, ) -> Self

Returns a copy of this config with thread-cache capacity derived from a parallelism hint.

The final per-thread cache size is resolved when the pool is created, using the final max_per_class value. The derived size reserves half the class budget for the shared freelist and clamps the local cache to [1, 8].

pub const fn with_thread_cache_disabled(self) -> Self

Returns a copy of this config with thread-local caching disabled.

pub const fn with_prefill(self, prefill: bool) -> Self

Returns a copy of this config with a new prefill setting.

pub const fn with_alignment(self, alignment: NonZeroUsize) -> Self

Returns a copy of this config with a new alignment.

pub fn with_budget_bytes(self, budget_bytes: NonZeroUsize) -> Self

Returns a copy of this config sized for an approximate tracked-memory budget.

This computes max_per_class as:

ceil(budget_bytes / sum(size_class_bytes))

where size_class_bytes includes every class from min_size to max_size. This always rounds up to at least one buffer per size class, so the resulting estimated capacity may exceed budget_bytes.

Trait Implementations

impl Clone for BufferPoolConfig

fn clone(&self) -> BufferPoolConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BufferPoolConfig

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

Formats the value using the given formatter.