Struct mmtk::util::heap::monotonepageresource::MonotonePageResource

pub struct MonotonePageResource<VM: VMBinding> {
    common: CommonPageResource,
    sync: Mutex<MonotonePageResourceSync>,
    _p: PhantomData<VM>,
}

Fields

common: CommonPageResource

sync: Mutex<MonotonePageResourceSync>

_p: PhantomData<VM>

Implementations

impl<VM: VMBinding> MonotonePageResource<VM>

pub fn new_contiguous( start: Address, bytes: usize, vm_map: &'static dyn VMMap ) -> Self

pub fn new_discontiguous(vm_map: &'static dyn VMMap) -> Self

pub fn cursor(&self) -> Address

Get highwater mark of current monotone space.

fn log_chunk_fields(&self, space_descriptor: SpaceDescriptor, site: &str)

fn get_region_start(addr: Address) -> Address

pub unsafe fn reset(&self)

Safety

TODO: I am not sure why this is unsafe.

pub unsafe fn get_current_chunk(&self) -> Address

pub fn reset_cursor(&self, top: Address)

unsafe fn release_pages( &self, guard: &mut MutexGuard<'_, MonotonePageResourceSync> )

pub fn iterate_allocated_regions( &self ) -> impl Iterator<Item = (Address, usize)> + '_

Iterate over all contiguous memory regions in this space. For contiguous space, this iterator should yield only once, and returning a contiguous memory region covering the whole space.

fn release_pages_extent(&self, _first: Address, bytes: usize)

fn move_to_next_chunk( &self, guard: &mut MutexGuard<'_, MonotonePageResourceSync> ) -> bool

Trait Implementations

impl<VM: VMBinding> PageResource<VM> for MonotonePageResource<VM>

fn common(&self) -> &CommonPageResource

fn common_mut(&mut self) -> &mut CommonPageResource

fn reserve_pages(&self, pages: usize) -> usize

fn get_available_physical_pages(&self) -> usize

Return the number of available physical pages by this resource. This includes all pages currently unused by this resource. If the resource is using a discontiguous space, it also includes the currently unassigned discontiguous space.

fn alloc_pages( &self, space_descriptor: SpaceDescriptor, reserved_pages: usize, required_pages: usize, tls: VMThread ) -> Result<PRAllocResult, PRAllocFail>

fn get_new_pages( &self, space_descriptor: SpaceDescriptor, reserved_pages: usize, required_pages: usize, tls: VMThread ) -> Result<PRAllocResult, PRAllocFail>

Allocate pages from this resource. Simply bump the cursor, and fail if we hit the sentinel. Return The start of the first page if successful, zero on failure.

fn clear_request(&self, reserved_pages: usize)

fn update_zeroing_approach(&self, _nontemporal: bool, concurrent: bool)

fn skip_concurrent_zeroing(&self)

fn trigger_concurrent_zeroing(&self)

fn concurrent_zeroing(&self)

fn commit_pages( &self, reserved_pages: usize, actual_pages: usize, tls: VMThread )

Commit pages to the page budget. This is called after successfully determining that the request can be satisfied by both the page budget and virtual memory. This simply accounts for the discrepancy between committed and reserved while the request was pending.

fn reserved_pages(&self) -> usize

fn committed_pages(&self) -> usize

fn vm_map(&self) -> &'static dyn VMMap

fn update_discontiguous_start(&mut self, _start: Address)