Struct BufferPool

pub struct BufferPool<T: Buffer> {
    pub mode: PoolMode,
    /* private fields */
}

A pool of reusable memory buffers to optimize memory allocation for Sv2 message frames.

Manages memory slices across three pool modes: back (default), front, and system memory. It reuses preallocated memory slices, minimizing the need for frequent memory allocation. The pool is thread-safe, using atomic state tracking.

Type T implements the Buffer trait, which defines how memory is handled in the buffer pool. BufferFromSystemMemory is used as the default system memory allocator.

Fields

mode: PoolMode

Tracks the current mode of memory allocation (back, front, or system).

Implementations

impl BufferPool<BufferFromSystemMemory>

pub fn new(capacity: usize) -> Self

Creates a new BufferPool with the specified memory capacity, in bytes.

Initializes the buffer pool with pre-allocated memory (inner_memory) and sets the pool mode to the back. The buffer pool uses BufferFromSystemMemory as a fallback when the buffer sections are full.

impl<T: Buffer> BufferPool<T>

pub fn is_front_mode(&self) -> bool

Checks if the buffer pool is operating in the front mode.

This mode indicates that the back of the buffer pool has been filled and the system is now using the front section for memory allocation. Returns true if the pool is in front mode, otherwise false.

pub fn is_back_mode(&self) -> bool

Checks if the buffer pool is operating in the back mode.

The back mode is the default state, where the buffer pool first tries to allocate memory. Returns true if the pool is in back mode, otherwise false.

pub fn is_alloc_mode(&self) -> bool

Checks if the buffer pool is operating in the system memory allocation mode.

This mode is used when both the back and front sections of the buffer pool are full, leading the system to allocate memory from the heap, which has performance trade-offs. Returns true if the pool is in alloc mode, otherwise false.

impl<T: Buffer> BufferPool<T>

pub fn droppable(&self) -> bool

Determines if the BufferPool can be safely dropped.

Returns true if all memory slices managed by the buffer pool have been released (i.e., the shared_state is zero), indicating that all the slices are dropped. This check helps prevent dropping the buffer pool while it’s still in use.

Trait Implementations

impl<T: Buffer> AsMut<[u8]> for BufferPool<T>

fn as_mut(&mut self) -> &mut [u8]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: Buffer> AsRef<[u8]> for BufferPool<T>

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Buffer> Buffer for BufferPool<T>

type Slice = Slice

The type of slice that the buffer uses.

fn get_writable(&mut self, len: usize) -> &mut [u8]

Borrows a mutable slice of the buffer, allowing the caller to write data into it. The caller specifies the length of the data they need to write.

fn get_data_owned(&mut self) -> Self::Slice

Provides ownership of a slice in the buffer pool to the caller and updates the buffer pool’s state by modifying the position in shared_state that the slice occupies. The pool now points to the next set of uninitialized space.

fn get_data_by_ref(&mut self, len: usize) -> &mut [u8]

Provides a mutable reference to the written portion of the buffer, up to the specified length, without transferring ownership of the buffer. This allows the caller to modify the buffer’s contents directly without taking ownership.

fn get_data_by_ref_(&self, len: usize) -> &[u8]

Provides an immutable reference to the written portion of the buffer, up to the specified length, without transferring ownership of the buffer. This allows the caller to inspect the buffer’s contents without modifying or taking ownership.

fn len(&self) -> usize

Returns the size of the written portion of the buffer. This is useful for tracking how much of the buffer has been filled with data. The number of bytes currently written in the buffer is returned.

fn danger_set_start(&mut self, index: usize)

Modifies the starting point of the buffer, effectively discarding data up to the given index. This can be useful for performance optimizations in situations where older data is no longer needed, but its use can be unsafe unless you understand its implications.

fn is_droppable(&self) -> bool

Determines if the buffer is safe to drop. This typically checks if the buffer contains essential data that still needs to be processed.

fn is_empty(&self) -> bool

Returns true if the buffer is empty, false otherwise.

impl<T: Buffer + AeadBuffer> Buffer for BufferPool<T>

fn extend_from_slice(&mut self, other: &[u8]) -> Result<()>

Extend this buffer from the given slice

fn truncate(&mut self, len: usize)

Truncate this buffer to the given size

fn len(&self) -> usize

Get the length of the buffer

fn is_empty(&self) -> bool

Is the buffer empty?

impl<T: Debug + Buffer> Debug for BufferPool<T>

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

Formats the value using the given formatter.

impl<T: Buffer> Drop for BufferPool<T>

fn drop(&mut self)

Executes the destructor for this type.