Struct Region 

pub(crate) struct Region {
    base: *mut u8,
    capacity: usize,
    align: usize,
    class_size: usize,
    slots: Mutex<SlotAllocator>,
}

Available on Unix and crate feature pool only.

One anonymous virtual-memory reservation serving fixed-size slots of a single size class.

Fields

base: *mut u8

capacity: usize

align: usize

Alignment of base, needed to return the mapping to sys::unmap.

class_size: usize

slots: Mutex<SlotAllocator>

Implementations

impl Region

pub(crate) fn new(class_size: usize, capacity_bytes: usize) -> Result<Region>

Reserves a region of capacity_bytes (rounded down to a whole number of slots) for slots of class_size bytes.

On Linux, regions whose class is at least HUGE_PAGE are aligned to the huge page and advised MADV_HUGEPAGE: their slots tile huge-page boundaries exactly, so populating a slot is one huge-page fault rather than one fault per 4 KiB, and a whole-slot dontneed frees whole huge pages without splitting any. Regions whose class is below the huge page are advised MADV_NOHUGEPAGE instead, so reclaim over a single slot stays page-exact.

pub(crate) fn new_nohuge( class_size: usize, capacity_bytes: usize, ) -> Result<Region>

As Region::new, but the region opts out of transparent huge pages regardless of class size. For regions whose slots are reclaimed with MADV_PAGEOUT under observed residency: reclaiming a range a large folio covers only partially needs a folio split, and a failed split silently leaves pages resident.

fn with_huge_pages( class_size: usize, capacity_bytes: usize, huge: bool, ) -> Result<Region>

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

Size in bytes of every slot in this region.

pub(crate) fn alloc(&self) -> Option<(u32, bool)>

Allocates a slot index, or None if every slot of the class is in use; the flag reports whether the slot came from the warm list (its pages are resident; writing it faults nothing).

Slots are scoped to residency (eviction frees them), so demand scales with the resident set — bounded by the pool budget plus in-flight slack — and exhaustion means residency outgrew the class reservation; callers degrade rather than fail.

pub(crate) fn free(&self, slot: u32, warm: bool)

Returns a slot to the warm or cold free list. The caller must be freeing the chunk that owned the slot, must have released the slot’s physical pages iff warm is false, and owns the warm-bytes accounting that bounds the warm side.

pub(crate) fn cool_warm_slots(&self, want_bytes: usize) -> usize

Moves warm free slots to the cold list, releasing their physical pages, until at least want_bytes have been cooled or no warm slot remains. Returns the bytes cooled. The caller owns the warm-bytes accounting that bounds the warm side.

pub(crate) fn slot_ptr(&self, slot: u32) -> *mut u8

The base address of a slot, fixed while its owning chunk is resident.

Trait Implementations

impl Debug for Region

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

Formats the value using the given formatter.

impl Drop for Region

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 Region

impl Sync for Region