Struct mmtk::util::heap::freelistpageresource::FreeListPageResource

pub struct FreeListPageResource<VM: VMBinding> {
    common: CommonPageResource,
    sync: Mutex<FreeListPageResourceSync>,
    _p: PhantomData<VM>,
    pub(crate) protect_memory_on_release: Option<MmapProtection>,
}

Fields

common: CommonPageResource

sync: Mutex<FreeListPageResourceSync>

_p: PhantomData<VM>

protect_memory_on_release: Option<MmapProtection>

Protect memory on release, and unprotect on re-allocate.

Implementations

impl<VM: VMBinding> FreeListPageResource<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

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

Protect the memory

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

Unprotect the memory

pub(crate) fn allocate_one_chunk_no_commit( &self, space_descriptor: SpaceDescriptor ) -> Result<PRAllocResult, PRAllocFail>

unsafe fn allocate_contiguous_chunks( &self, space_descriptor: SpaceDescriptor, pages: usize, sync: &mut MutexGuard<'_, FreeListPageResourceSync> ) -> i32

unsafe fn free_contiguous_chunk( &self, chunk: Address, sync: &mut FreeListPageResourceSync )

pub fn release_pages(&self, first: Address)

Release pages previously allocated by alloc_pages.

Warning: This method acquires the mutex self.sync. If multiple threads release pages concurrently, the lock contention will become a performance bottleneck. This is especially problematic for plans that sweep objects in bulk in the Release stage. Spaces except the large object space are recommended to use BlockPageResource whenever possible.

fn release_free_chunks( &self, freed_page: Address, pages_freed: usize, sync: &mut FreeListPageResourceSync )

Trait Implementations

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

fn common(&self) -> &CommonPageResource

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

fn update_discontiguous_start(&mut self, start: Address)

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

impl<VM: VMBinding> Send for FreeListPageResource<VM>

impl<VM: VMBinding> Sync for FreeListPageResource<VM>