Struct PoolStats 

pub struct PoolStats {

    pub inserts: u64,
    pub frees: u64,
    pub writes_elided: u64,
    pub evictions_compress: u64,
    pub evictions_cheap: u64,
    pub extent_bytes_written: u64,
    pub spill_scheduled: u64,
    pub spill_cancelled: u64,
    pub spill_in_flight: u64,
    pub slot_exhausted_fallbacks: u64,
    pub oversize_payloads: u64,
    pub live_chunks: u64,
    pub resident_bytes: u64,
    pub oversize_bytes: u64,
    pub warm_bytes: u64,
    pub warm_reuses: u64,
    pub eager_backs: u64,
    pub admissions_budget: u64,
    pub admissions_steal: u64,
    pub admissions_denied: u64,
    pub extent_resident_bytes: u64,
    pub extent_unreclaimable_bytes: u64,
    pub extent_pageouts: u64,
    pub extent_pageout_incomplete: u64,
    pub extent_arena_fallbacks: u64,
}

Available on Unix and crate feature pool only.

Snapshot of pool counters.

Fields

inserts: u64

Chunks inserted.

frees: u64

Chunks freed (handle dropped).

writes_elided: u64

Backing writes elided: chunks dead before their compression completed, so no extent write happened. Covers chunks freed while UnbackedResident and chunks freed while queued for a spill thread that had not yet compressed them.

evictions_compress: u64

Evictions that compressed the chunk into a new extent.

evictions_cheap: u64

Evictions of BackedResident chunks: pure page release, no I/O.

extent_bytes_written: u64

Compressed bytes written into extents.

spill_scheduled: u64

Evictions handed to spill threads.

spill_cancelled: u64

Compressions cancelled because the chunk was freed while queued or in flight, whatever scheduled them. Eager-backing work counts here but never in spill_scheduled, so this can exceed that counter.

spill_in_flight: u64

Entries currently queued for or being processed by spill threads.

slot_exhausted_fallbacks: u64

Inserts that fell back to the heap because their size class had no free slot (the live set outgrew the class reservation). Heap-backed chunks behave like oversize ones: always resident, never paged.

oversize_payloads: u64

Inserts whose payload exceeded the largest size class and therefore went straight to a heap-backed oversize chunk.

live_chunks: u64

Live size-classed chunks across all classes, whatever their residency. For backlog-shaped consumers this tracks the un-drained backlog in chunks. (Slots are scoped to residency, so the quantity that exhausts a class reservation is the resident subset, bounded by the budget.)

resident_bytes: u64

Uncompressed bytes of currently resident chunks (including oversize).

oversize_bytes: u64

Uncompressed bytes of live oversize chunks.

warm_bytes: u64

Class bytes of free slots currently kept warm (pages resident for fault-free reuse). Bounded by a fraction of the budget; RSS exceeds resident_bytes by up to this amount.

warm_reuses: u64

Slot allocations served from the warm list: reuses that faulted no pages and skipped the kernel’s page zeroing.

eager_backs: u64

Chunks eagerly compressed to BackedResident by idle spill threads (write-behind): still readable in their slots, with eviction pre-paid.

admissions_budget: u64

Evicted chunks re-admitted to BackedResident by an admitting read out of free budget headroom.

admissions_steal: u64

Evicted chunks re-admitted to BackedResident by an admitting read stealing the slot of a clean backed victim of the same size class. The victim becomes Evicted with zero I/O and its extent intact.

admissions_denied: u64

Admitting reads of evicted chunks served as a plain decompress instead: no budget headroom (or an exhausted size class), and no clean victim whose growth the budget could absorb.

extent_resident_bytes: u64

Allocation bytes of compressed extents currently resident — the compressed-but-resident middle tier. Bounded by the RSS target; exceeding it pages the oldest extents out to the swap device.

extent_unreclaimable_bytes: u64

Allocation bytes of resident extents the RSS target cannot push out: retry-capped arena extents (the kernel declined the reclaim advice until the retry budget ran out) and heap-fallback extents. The compressed tier settles above its capacity by this amount. Climbing steadily means pages cannot reach the swap device (no swap, or a cgroup that cannot reclaim).

extent_pageouts: u64

Extents pushed to the swap device by RSS-target enforcement, with the whole range observed nonresident afterwards.

extent_pageout_incomplete: u64

Pageout passes whose observation found some of the extent’s pages still mapped: MADV_PAGEOUT may decline pages and still succeed, so the page table decides. The extent keeps its full resident accounting and is retried until its per-extent retry cap. Climbing steadily on a loaded pool means pages cannot actually be unmapped to the swap device (no swap, or a cgroup that cannot reclaim).

extent_arena_fallbacks: u64

Extent writes that fell back to the heap because their extent-arena class had no free slot. Heap-backed extents stay readable but are never paged out, so their compressed bytes hold RAM until freed.

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 Default for PoolStats

fn default() -> PoolStats

Returns the “default value” for a type.

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 Eq for PoolStats

impl StructuralPartialEq for PoolStats