Struct HugePageAligned 

pub struct HugePageAligned<I: OsBacked> { /* private fields */ }

HugePageAligned wrapper.

huge_page_size defaults to a platform-appropriate value (default_huge_page_size); pass an explicit size to override (useful for hugetlbfs setups with 1 GiB pages, or testing).

Implementations

impl<I: OsBacked> HugePageAligned<I>

pub fn new(inner: I) -> Option<Self>

Wrap with the platform-default huge page size.

On Linux/Windows with x86_64 or aarch64 (non-Apple) this is 2 MiB. On macOS aarch64 (Apple Silicon, 16 KiB native granule) it is 32 MiB. Returns None if the platform-default would not satisfy Self::with_huge_page_size’s invariants (impossible on supported targets).

pub fn with_huge_page_size(inner: I, huge_page_size: usize) -> Option<Self>

Wrap with an explicit huge page size. Must be a power of two and at least 4 KiB (any smaller would not be a “huge” page on any real architecture).

pub fn huge_page_size(&self) -> usize

Configured huge page size in bytes.

pub fn min_purge_size(&self) -> usize

Minimum purge granularity. Equal to huge_page_size. Calls to release_pages below this size are dropped.

pub fn inner(&self) -> &I

Borrow the inner allocator.

Trait Implementations

impl<I: OsBacked> Allocator for HugePageAligned<I>

fn allocate(&self, layout: NonZeroLayout) -> Result<NonNull<[u8]>, AllocError>

Allocate a block satisfying layout. The returned slice’s length is at least layout.size() but may be larger.

fn capacity_bytes(&self) -> Option<usize>

Total bytes this allocator can issue, if bounded. None for unbounded allocators like System. Used by Watermark to compute thresholds.

fn corruption_events(&self) -> u64

Detected freelist / metadata corruption events observed by this allocator since construction.

unsafe fn usable_size( &self, ptr: NonNull<u8>, layout: NonZeroLayout, ) -> Option<usize>

Usable size of an existing allocation, if the allocator can report it. Defaults to None — implementors that track usable size override.

fn allocate_zeroed( &self, layout: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Allocate a zero-initialized block.

unsafe fn grow( &self, ptr: NonNull<u8>, old: NonZeroLayout, new: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Grow an allocation in place if possible, otherwise allocate-copy-free.

unsafe fn shrink( &self, ptr: NonNull<u8>, old: NonZeroLayout, new: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Shrink an allocation in place if possible, otherwise allocate-copy-free.

fn reset(&mut self) -> Result<(), AllocError>

Reclaim everything previously allocated. Default impl returns AllocError — only arena-style allocators implement a meaningful reset.

impl<I: OsBacked> Deallocator for HugePageAligned<I>

unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: NonZeroLayout)

Release a previously allocated block.

impl<I: OsBacked + FixedRange> FixedRange for HugePageAligned<I>

fn commit(&self, offset: usize, len: usize) -> Result<(), AllocError>

Pass-through forward so a commit-aware consumer reaches the inner backing when this wrapper sits over a lazy_commit MmapBacked.

fn base(&self) -> NonNull<u8>

First byte of the owned address range.

fn size(&self) -> usize

Length in bytes of the owned address range.

fn contains(&self, ptr: NonNull<u8>) -> bool

Whether ptr lies within [base, base + size).

impl<I: OsBacked> OsBacked for HugePageAligned<I>

unsafe fn release_pages(&self, ptr: NonNull<u8>, size: usize)

Round the requested range inward to whole huge pages. If nothing remains after rounding, the call is dropped — this is the “refuse to fragment a huge page” guarantee. Partial purges that would force the kernel to demote a promoted huge page back to 4 KiB are silently elided.

unsafe fn protect(&self, ptr: NonNull<u8>, size: usize, flags: ProtectFlags)

Forwarded unchanged. Protection changes don’t fragment a huge page the way a purge does, and a caller using PROT_NONE for a guard page explicitly wants the page split.

fn base_ptr(&self) -> NonNull<u8>

First byte of the OS-managed region.

fn region_size(&self) -> usize

Length in bytes of the OS-managed region.