Struct RegionPageResource

pub struct RegionPageResource<VM: VMBinding, R: Region> {
    mpr: MonotonePageResource<VM>,
    sync: RwLock<Sync<R>>,
}

A PageResource which allocates pages from a region-structured heap. We assume that allocations are much smaller than regions, as we scan linearly over all regions to allocate, and do not revisit regions before a garbage collection cycle.

Fields

mpr: MonotonePageResource<VM>

sync: RwLock<Sync<R>>

Implementations

impl<VM: VMBinding, R: Region + 'static> RegionPageResource<VM, R>

const REGION_PAGES: usize = _

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

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

fn new(mpr: MonotonePageResource<VM>) -> Self

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

fn allocate_from_region( &self, alloc: &mut AllocatedRegion<R>, bytes: usize, ) -> Option<Address>

pub fn reset_cursor(&self, alloc: &AllocatedRegion<R>, address: Address)

Reset the allocation cursor for one region.

pub fn reset_allocator(&self)

Reset the allocator state after a collection, so that the allocator will revisit regions which the garbage collector has compacted.

pub fn enumerate(&self, enumerator: &mut dyn ObjectEnumerator)

pub fn with_regions<T>( &self, f: &mut impl FnMut(&Vec<AllocatedRegion<R>>) -> T, ) -> T

pub fn enumerate_regions( &self, enumerator: &mut impl FnMut(&AllocatedRegion<R>), )

Trait Implementations

impl<VM: VMBinding, R: Region + 'static> PageResource<VM> for RegionPageResource<VM, R>

fn common(&self) -> &CommonPageResource

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

fn update_discontiguous_start(&mut self, start: Address)

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

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 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 reserve_pages(&self, pages: usize) -> usize

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