Struct SwapExtent 

pub(crate) struct SwapExtent {
    ptr: *mut u8,
    alloc_size: usize,
    comp_len: usize,
    resident: bool,
    incomplete_passes: u8,
    backing: Backing,
}

Available on Unix and crate feature pool only.

One chunk’s compressed backing copy.

Fields

ptr: *mut u8

alloc_size: usize

Byte size of the backing allocation (the extent’s class size, or the heap layout on the fallback path): the granule the resident accounting and the pageout operate on.

comp_len: usize

resident: bool

Whether the extent’s pages are (engine-)resident: set at write and by SwapExtent::read_into, cleared by a SwapExtent::pageout whose residency observation found the whole range gone. Drives the pool’s extent_resident_bytes accounting; mutated only under the owning chunk’s state mutex.

incomplete_passes: u8

Consecutive pageout passes whose observation found pages still resident. Reset by SwapExtent::read_into. At PAGEOUT_RETRY_CAP the extent stops being advised out.

backing: Backing

Implementations

impl SwapExtent

pub(crate) fn write( arena: &Arc<ExtentArena>, data: &[u64], codec: &dyn ExtentCodec, scratch: Scratch, ) -> SwapExtent

Encodes data through codec into a fresh extent, preferring an arena slot and degrading to the heap when the payload’s class is exhausted. The pages stay resident; the pool’s RSS-target enforcement decides when SwapExtent::pageout pushes them to the device.

Encoding goes through a reused thread-local scratch buffer so the extent slot can be chosen by the actual stored payload rather than the codec’s worst case. Worst-case sizing costs ~5.6× on compressible data, in swap capacity and in swap write bandwidth per eviction (the whole allocation is paged out), which at hydration eviction rates backs up device writeback and bloats the working set with swap-cache pages. scratch says whether the caller’s thread keeps the grown scratch for its next job.

pub(crate) fn alloc_size(&self) -> usize

The byte size of the extent’s allocation: the granule the resident accounting and the pageout operate on.

pub(crate) fn is_resident(&self) -> bool

Whether the extent’s pages are engine-resident (not pushed to the device since the last write or read).

pub(crate) fn pageout_capped(&self) -> bool

Whether the extent’s pageout retry budget is exhausted: consecutive incomplete passes reached PAGEOUT_RETRY_CAP, so callers stop calling SwapExtent::pageout until a read resets the budget. Heap-fallback extents are permanently capped: they are never advised out and stay counted resident until freed.

pub(crate) fn pageout(&mut self) -> bool

Hints the kernel to push the extent’s pages to the swap device and observes the result: returns true, marking the extent non-resident, only when the observation finds the whole range unmapped (a page whose clean copy lingers in the swap cache counts as reclaimed). An incomplete pass leaves the extent fully resident for accounting and spends one unit of the retry budget: a single pinned page keeps the whole extent counted, which is the safe direction, and the retry budget exists exactly for such transient pins. Cheap: the compression is already paid, the madvise and page-table read are microseconds, and the device write happens on the kernel’s asynchronous writeback path.

Callers must not invoke this on a SwapExtent::pageout_capped extent.

pub(crate) fn comp_len(&self) -> usize

Compressed size in bytes, including the size prefix.

pub(crate) fn prefetch(&self)

Hints the kernel to swap the extent’s pages back in ahead of a read.

pub(crate) fn read_into(&mut self, codec: &dyn ExtentCodec, dst: &mut [u8])

Decodes the extent through codec into dst, which must be exactly the chunk’s body length. Reading faults the pages back in, so the extent is resident again afterwards; the caller owns the accounting for that transition (the pool re-counts and re-enqueues it for the RSS target).

pub(crate) fn read_range_into( &mut self, codec: &dyn ExtentCodec, body_len: usize, offset: usize, dst: &mut [u8], )

Decodes the byte range [offset, offset + dst.len()) of the extent’s body_len-byte body into dst. The range must lie within the body, and body_len must be the body’s exact length (the codec validates it against the stored form). Residency effects are those of SwapExtent::read_into regardless of the range: the stored form is one whole codec block, so any read faults and decodes the entire extent, and a sub-range only narrows the final copy. A backend whose stored form is rangeable (file extents reading with pread, a sub-block-framed codec) can serve the range with proportional I/O behind this same signature.

Trait Implementations

impl Debug for SwapExtent

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

Formats the value using the given formatter.

impl Drop for SwapExtent

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for SwapExtent