Struct TwoLevelMmapper

pub struct TwoLevelMmapper {
    transition_lock: Mutex<()>,
    slabs: Vec<OnceOptionBox<[Atomic<MapState>; 8192]>>,
}

A two-level implementation of Mmapper.

It is essentially a lazily initialized array of [Atomic<MapState>]. Because it is designed to govern a large address range, and the array is sparse, we use a two-level design. The higher level holds a vector of slabs, and each slab holds an array of [Atomic<MapState>]. Each slab governs an aligned region of MMAP_CHUNKS_PER_SLAB chunks. Slabs are lazily created when the user intends to write into one of its MapState.

Fields

transition_lock: Mutex<()>

Lock for transitioning map states.

FIXME: We only need this lock when transitioning map states. The TwoLevelMmapper itself is completely lock-free even when allocating new slabs. We should move the lock one leve above, to MapState.

slabs: Vec<OnceOptionBox<[Atomic<MapState>; 8192]>>

Slabs

Implementations

impl TwoLevelMmapper

pub fn new() -> Self

fn new_slab() -> [Atomic<MapState>; 8192]

fn slab_table(&self, addr: Address) -> Option<&[Atomic<MapState>; 8192]>

fn get_or_allocate_slab_table(&self, addr: Address) -> &[Atomic<MapState>; 8192]

fn chunk_index_to_address(base: Address, chunk: usize) -> Address

fn slab_align_down(addr: Address) -> Address

Align addr down to slab size.

fn slab_limit(addr: Address) -> Address

Get the base address of the next slab after the slab that contains addr.

fn chunk_index(slab: Address, addr: Address) -> usize

Return the index of the chunk that contains addr within the slab starting at slab. If addr is beyond the end of the slab, the result could be beyond the end of the slab.

Trait Implementations

impl Debug for TwoLevelMmapper

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

Formats the value using the given formatter.

impl Default for TwoLevelMmapper

fn default() -> Self

Returns the “default value” for a type.

impl Mmapper for TwoLevelMmapper

fn is_mapped_address(&self, addr: Address) -> bool

Return {@code true} if the given address has been mmapped

@param addr The address in question. @return {@code true} if the given address has been mmapped

fn eagerly_mmap_all_spaces(&self, _space_map: &[Address])

Given an address array describing the regions of virtual memory to be used by MMTk, demand zero map all of them if they are not already mapped.

fn mark_as_mapped(&self, start: Address, bytes: usize)

Mark a number of pages as mapped, without making any request to the operating system. Used to mark pages that the VM has already mapped.

fn quarantine_address_range( &self, start: Address, pages: usize, strategy: MmapStrategy, anno: &MmapAnnotation<'_>, ) -> Result<()>

Quarantine/reserve address range. We mmap from the OS with no reserve and with PROT_NONE, which should be little overhead. This ensures that we can reserve certain address range that we can use if needed. Quarantined memory needs to be mapped before it can be used.

fn ensure_mapped( &self, start: Address, pages: usize, strategy: MmapStrategy, anno: &MmapAnnotation<'_>, ) -> Result<()>

Ensure that a range of pages is mmapped (or equivalent). If the pages are not yet mapped, demand-zero map them. Note that mapping occurs at chunk granularity, not page granularity.

fn protect(&self, start: Address, pages: usize)

Mark a number of pages as inaccessible.

impl Send for TwoLevelMmapper

impl Sync for TwoLevelMmapper