Struct mmtk::util::heap::layout::fragmented_mapper::FragmentedMapper

pub struct FragmentedMapper {
    lock: Mutex<()>,
    inner: UnsafeCell<InnerFragmentedMapper>,
}

Fields

lock: Mutex<()>

inner: UnsafeCell<InnerFragmentedMapper>

Implementations

impl FragmentedMapper

pub fn new() -> Self

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

fn hash(addr: Address) -> usize

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

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

fn inner(&self) -> &InnerFragmentedMapper

fn inner_mut(&self) -> &mut InnerFragmentedMapper

fn get_or_optionally_allocate_slab_table( &self, addr: Address, allocate: bool ) -> Option<&[Atomic<MapState>; 2048]>

fn slab_table_for( &self, _addr: Address, index: usize ) -> Option<&[Atomic<MapState>; 2048]>

unsafe fn commit_free_slab(&self, index: usize)

Take a free slab of chunks from the freeSlabs array, and insert it at the correct index in the slabTable. @param index slab table index

Safety

Caller must ensure that only one thread is calling this function at a time.

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

fn slab_align_down(addr: Address) -> Address

@param addr an address @return the base address of the enclosing slab

fn slab_limit(addr: Address) -> Address

@param addr an address @return the base address of the next slab

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

@param slab Address of the slab @param addr Address within a chunk (could be in the next slab) @return The index of the chunk within the slab (could be beyond the end of the slab)

Trait Implementations

impl Debug for FragmentedMapper

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

Formats the value using the given formatter.

impl Default for FragmentedMapper

fn default() -> Self

Returns the “default value” for a type.

impl Mmapper for FragmentedMapper

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 ) -> 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 ) -> 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 FragmentedMapper

impl Sync for FragmentedMapper