Struct MmapBacked 

pub struct MmapBacked { /* private fields */ }

OS-mapped anonymous region.

len is rounded up to a multiple of the page size at construction. The Allocator impl serves requests bump-style from the mapping.

Thread safety

Send: yes — the mapping is identified by (ptr, len), both Send-safe values; we restore Send via an unsafe impl since NonNull<u8> is !Send by default. Sync: NO. The cursor uses UnsafeCell for &self allocation; concurrent &self allocators would race. UnsafeCell is !Sync, which gives us the right behavior without any extra marker field. Cross-thread allocation belongs to higher layers (SharedBumpArena, SlabRemote).

Implementations

impl MmapBacked

pub fn new(size: usize) -> Result<Self, AllocError>

Allocate an anonymous OS-mapped region of at least size bytes (rounded up to the page size).

pub fn with_huge_pages(size: usize) -> Result<Self, AllocError>

Allocate with huge-pages requested. This layer ignores the hint; HugePageAligned enforces 2 MiB / 32 MiB alignment.

pub fn new_lazy(size: usize) -> Result<Self, AllocError>

Reserve an anonymous OS-mapped region of at least size bytes without committing it up front (see MmapFlags::lazy_commit).

Windows-only effect. On Windows the region is MEM_RESERVE-only and consumes no commit charge until FixedRange::commit commits pages on demand; on Unix this is identical to new because mmap is already demand-paged.

Safety / usage contract

The returned region hands back reserved-but-uncommitted pages on Windows. It is safe under BumpArena / StackAlloc (true demand-commit), under any pass-through FixedRange wrapper over those, and under Slab / SizeClassed / direct Allocator::allocate (safe, but committed eagerly). It faults under SharedBumpArena and GuardPage. See MmapFlags::lazy_commit for the full contract.

pub fn with_flags(size: usize, flags: MmapFlags) -> Result<Self, AllocError>

Allocate with the supplied MmapFlags.

pub fn allocated(&self) -> usize

Bytes already allocated from this backing.

pub const fn capacity(&self) -> usize

Total size of the OS-mapped region (page-aligned).

pub fn remaining(&self) -> usize

Bytes remaining for allocation.

Trait Implementations

impl Allocator for MmapBacked

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 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.

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 corruption_events(&self) -> u64

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

impl Deallocator for MmapBacked

unsafe fn deallocate(&self, _ptr: NonNull<u8>, _layout: NonZeroLayout)

Release a previously allocated block.

impl Drop for MmapBacked

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 FixedRange for 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 commit(&self, offset: usize, len: usize) -> Result<(), AllocError>

Ensure the bytes [offset, offset + len) (relative to base) are backed by committed, writable memory before a consumer writes through them.

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

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

impl OsBacked for MmapBacked

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

Caveat (shared with commit)

On Windows this reads the committed high-water mark through &self under the !Sync single-writer contract. Do NOT call release_pages on a &MmapBacked that is shared while an allocator (or commit) advances the watermark — that races the UnsafeCell, exactly as commit’s own caveat warns.

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.

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

Change memory protection flags on [ptr, ptr + size).

impl Send for MmapBacked