Struct PoolStats 

pub struct PoolStats {
    pub capacity: usize,
    pub available: usize,
    pub in_use: usize,
    pub buffer_size: usize,
    pub total_allocations: u64,
    pub failed_allocations: u64,
    pub utilization: f64,
    pub total_buffers: usize,
    pub available_buffers: usize,
    pub in_use_buffers: usize,
}

Statistics about buffer pool usage.

Provides insights into pool performance and utilization patterns. All statistics are captured at a specific point in time and may become stale as the pool state changes.

Examples

use safer_ring::pool::BufferPool;

let pool = BufferPool::new(10, 4096);
let stats = pool.stats();

println!("Pool utilization: {:.1}%", stats.utilization_percent());
println!("Success rate: {:.1}%", stats.success_rate_percent());

Fields

capacity: usize

Total capacity of the pool

available: usize

Number of buffers currently available

in_use: usize

Number of buffers currently in use

buffer_size: usize

Size of each buffer in bytes

total_allocations: u64

Total successful allocations since pool creation

failed_allocations: u64

Total failed allocation attempts since pool creation

utilization: f64

Current utilization as a ratio (0.0 to 1.0)

total_buffers: usize

Total number of buffers in the pool (same as capacity)

available_buffers: usize

Number of buffers currently available (same as available)

in_use_buffers: usize

Number of buffers currently in use (same as in_use)

Implementations

impl PoolStats

pub fn utilization_percent(&self) -> f64

Get utilization as a percentage (0.0 to 100.0).

Examples

let stats = PoolStats {
    capacity: 10,
    available: 3,
    in_use: 7,
    buffer_size: 4096,
    total_allocations: 100,
    failed_allocations: 5,
    utilization: 0.7,
    total_buffers: 10,
    available_buffers: 3,
    in_use_buffers: 7,
};
assert_eq!(stats.utilization_percent(), 70.0);

pub fn success_rate_percent(&self) -> f64

Get the success rate of allocations as a percentage (0.0 to 100.0).

Returns 100.0 if no allocation attempts have been made.

Examples

let stats = PoolStats {
    capacity: 10,
    available: 5,
    in_use: 5,
    buffer_size: 4096,
    total_allocations: 95,
    failed_allocations: 5,
    utilization: 0.5,
    total_buffers: 10,
    available_buffers: 5,
    in_use_buffers: 5,
};
assert_eq!(stats.success_rate_percent(), 95.0);

pub fn total_memory_bytes(&self) -> usize

Get the total memory allocated by the pool in bytes.

Examples

let stats = PoolStats {
    capacity: 10,
    buffer_size: 4096,
    // ... other fields
};
assert_eq!(stats.total_memory_bytes(), 40960); // 10 * 4096

pub fn memory_in_use_bytes(&self) -> usize

Get the memory currently in use in bytes.

pub fn is_under_pressure(&self) -> bool

Check if the pool is under high pressure (utilization > 80%).

This can be used to trigger alerts or scaling decisions.

Examples

let high_pressure = PoolStats {
    utilization: 0.85, // 85% utilization
};
assert!(high_pressure.is_under_pressure());

let normal_pressure = PoolStats {
    utilization: 0.60, // 60% utilization
};
assert!(!normal_pressure.is_under_pressure());

pub fn has_allocation_failures(&self) -> bool

Check if the pool has experienced allocation failures.

Trait Implementations

impl Clone for PoolStats

fn clone(&self) -> PoolStats

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PoolStats

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

Formats the value using the given formatter.

impl PartialEq for PoolStats

fn eq(&self, other: &PoolStats) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for PoolStats

impl StructuralPartialEq for PoolStats