Struct LargeObjectSpace 

pub struct LargeObjectSpace<VM: VMBinding> {
    common: CommonSpace<VM>,
    pr: FreeListPageResource<VM>,
    mark_state: u8,
    in_nursery_gc: bool,
    treadmill: TreadMill,
    clear_log_bit_on_sweep: bool,
    pub num_pages_released_lazy: AtomicUsize,
    pub rc_enabled: bool,
    pub(crate) rc: RefCountHelper<VM>,
    pub is_end_of_satb_or_full_gc: bool,
    pub(crate) bump_page_reuse_count: AtomicBool,
}

This type implements a policy for large objects. Each instance corresponds to one Treadmill space.

Fields

common: CommonSpace<VM>

pr: FreeListPageResource<VM>

mark_state: u8

in_nursery_gc: bool

treadmill: TreadMill

clear_log_bit_on_sweep: bool

num_pages_released_lazy: AtomicUsize

rc_enabled: bool

rc: RefCountHelper<VM>

is_end_of_satb_or_full_gc: bool

bump_page_reuse_count: AtomicBool

Whether newly allocated LOS objects should bump LOS_PAGE_REUSE_COUNT on their pages, so remembered-set entries recorded against a page’s previous occupant are invalidated. Only needed while concurrent marking can be validating a remembered set; set/cleared by the owning plan (currently only LXR) as concurrent marking starts/ends.

Implementations

impl<VM: VMBinding> LargeObjectSpace<VM>

pub fn new( args: PlanCreateSpaceArgs<'_, VM>, protect_memory_on_release: bool, clear_log_bit_on_sweep: bool, ) -> Self

fn release_object(&self, object: ObjectReference) -> usize

pub fn release_rc_nursery_objects(&self)

pub fn prepare(&mut self, full_heap: bool)

pub fn release(&mut self, full_heap: bool)

pub fn trace_object<Q: ObjectQueue>( &self, queue: &mut Q, object: ObjectReference, ) -> ObjectReference

fn sweep_large_pages(&mut self, sweep_nursery: bool)

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

Enumerate objects in the to-space. It is a workaround for OVC which currently needs to enumerate reachable objects for during reference forwarding.

pub fn allocate_pages( &self, tls: VMThread, pages: usize, alloc_options: AllocationOptions, ) -> Address

Allocate an object

pub fn attempt_mark(&self, object: ObjectReference) -> bool

pub fn rc_free(&self, o: ObjectReference)

fn test_and_mark(&self, object: ObjectReference, value: u8) -> bool

Test if the object’s mark bit is the same as the given value. If it is not the same, the method will attemp to mark the object and clear its nursery bit. If the attempt succeeds, the method will return true, meaning the object is marked by this invocation. Otherwise, it returns false.

fn test_mark_bit(&self, object: ObjectReference, value: u8) -> bool

fn is_in_nursery(&self, object: ObjectReference) -> bool

Check if a given object is in nursery

pub fn sweep_rc_mature_objects_after_satb( &self, is_live: &impl Fn(ObjectReference) -> bool, )

pub fn is_marked(&self, object: ObjectReference) -> bool

Trait Implementations

impl<VM: VMBinding> PolicyTraceObject<VM> for LargeObjectSpace<VM>

fn trace_object<Q: ObjectQueue, const KIND: u8>( &self, queue: &mut Q, object: ObjectReference, _copy: Option<CopySemantics>, _worker: &mut GCWorker<VM>, ) -> ObjectReference

Trace object in the policy. If the policy copies objects, we should expect copy to be a Some value.

fn may_move_objects<const KIND: u8>() -> bool

Return whether the policy moves objects.

fn post_scan_object(&self, _object: ObjectReference)

Policy-specific post-scan-object hook. It is called after scanning each object in this space.

impl<VM: VMBinding> SFT for LargeObjectSpace<VM>

fn name(&self) -> &'static str

The space name

fn is_live(&self, object: ObjectReference) -> bool

Is the object live, determined by the policy?

fn is_reachable(&self, object: ObjectReference) -> bool

Is the object reachable, determined by the policy? Note: Objects in ImmortalSpace may have is_live = true but are actually unreachable.

fn pin_object(&self, _object: ObjectReference) -> bool

Pin a given object. Return if this call pinned the given object.

fn unpin_object(&self, _object: ObjectReference) -> bool

Unpin a given object. Return if this call unpinned the given object.

fn is_object_pinned(&self, _object: ObjectReference) -> bool

Return if the given object is pinned.

fn is_movable(&self) -> bool

Is the object movable, determined by the policy? E.g. the policy is non-moving, or the object is pinned.

fn is_sane(&self) -> bool

Is the object sane? A policy should return false if there is any abnormality about object - the sanity checker will fail if an object is not sane.

fn initialize_object_metadata(&self, object: ObjectReference, bytes: usize)

Initialize object metadata (in the header, or in the side metadata).

fn is_mmtk_object(&self, addr: Address) -> Option<ObjectReference>

Is addr a valid object reference to an object allocated in this space? This default implementation works for all spaces that use MMTk’s mapper to allocate memory. Some spaces, like MallocSpace, use third-party libraries to allocate memory. Such spaces needs to override this method.

fn find_object_from_internal_pointer( &self, ptr: Address, max_search_bytes: usize, ) -> Option<ObjectReference>

fn sft_trace_object( &self, queue: &mut Option<ObjectReference>, object: ObjectReference, _worker: GCWorkerMutRef<'_>, ) -> ObjectReference

Trace objects through SFT. This along with crate::plan::tracing::SFTTrace provides an easy way for most plans to trace objects without the need to implement any plan-specific code. However, tracing objects for some policies are more complicated, and they do not provide an implementation of this method. For example, mark compact space requires trace twice in each GC. Immix has defrag trace and fast trace.

fn debug_print_object_info(&self, object: ObjectReference)

Print debug info for the object. The implementer should print one line at a time so in case of an unexpected error, we still print something.

fn get_forwarded_object( &self, _object: ObjectReference, ) -> Option<ObjectReference>

Get forwarding pointer if the object is forwarded.

fn is_in_space(&self, _object: ObjectReference) -> bool

Is the object managed by MMTk? For most cases, if we find the sft for an object, that means the object is in the space and managed by MMTk. However, for some spaces, like MallocSpace, we mark the entire chunk in the SFT table as a malloc space, but only some of the addresses in the space contain actual MMTk objects. So they need a further check.

impl<VM: VMBinding> Space<VM> for LargeObjectSpace<VM>

fn as_space(&self) -> &dyn Space<VM>

fn as_sft(&self) -> &(dyn SFT + Sync + 'static)

fn get_page_resource(&self) -> &dyn PageResource<VM>

fn maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>>

Get a mutable reference to the underlying page resource, or None if the space does not have a page resource.

fn initialize_sft(&self, sft_map: &mut dyn SFTMap)

Initialize entires in SFT map for the space. This is called when the Space object has a non-moving address, as we will use the address to set sft. Currently after we create a boxed plan, spaces in the plan have a non-moving address.

fn common(&self) -> &CommonSpace<VM>

fn release_multiple_pages(&mut self, start: Address)

fn enumerate_objects(&self, enumerator: &mut dyn ObjectEnumerator)

Enumerate objects in the current space.

fn clear_side_log_bits(&self)

Clear the side log bits for allocated regions in this space. This method is only called if the plan knows the log bits are side metadata.

fn set_side_log_bits(&self)

Set the side log bits for allocated regions in this space. This method is only called if the plan knows the log bits are side metadata.

fn initialize_side_metadata(&self)

Initialize side metadata for the space. This is called after spaces and the plan are contructued and the side metadata has been initialized. If a space needs to access side metadata during its construction, it can override this method to initialize side metadata here. By default, this method does nothing.

fn acquire( &self, tls: VMThread, pages: usize, alloc_options: AllocationOptions, ) -> Address

fn get_new_pages_and_initialize( &self, tls: VMThread, pages: usize, pr: &dyn PageResource<VM>, pages_reserved: usize, ) -> Option<Address>

Get new pages from the page resource, and do necessary initialization, including mmapping and zeroing the memory.

fn not_acquiring( &self, tls: VMThread, alloc_options: AllocationOptions, pr: &dyn PageResource<VM>, pages_reserved: usize, attempted_allocation_and_failed: bool, )

Handle the case where Space::acquire will not or can not acquire pages from the page resource. This may happen when

fn address_in_space(&self, start: Address) -> bool

fn in_space(&self, object: ObjectReference) -> bool

fn grow_space(&self, start: Address, bytes: usize, new_chunk: bool)

This is called after we get result from page resources. The space may tap into the hook to monitor heap growth. The call is made from within the page resources’ critical region, immediately before yielding the lock.

fn estimate_side_meta_pages(&self, data_pages: usize) -> usize

Estimate the amount of side metadata memory needed for a give data memory size in pages. The result will over-estimate the amount of metadata pages needed, with at least one page per side metadata. This relatively accurately describes the number of side metadata pages the space actually consumes.

fn reserved_pages(&self) -> usize

fn available_physical_pages(&self) -> usize

Return the number of physical pages available.

fn get_name(&self) -> &'static str

fn get_descriptor(&self) -> SpaceDescriptor

fn get_gc_trigger(&self) -> &GCTrigger<VM>

fn set_copy_for_sft_trace(&mut self, _semantics: Option<CopySemantics>)

What copy semantic we should use for this space if we copy objects from this space. This is only needed for plans that use crate::plan::tracing::SFTTrace.

fn verify_side_metadata_sanity( &self, side_metadata_sanity_checker: &mut SideMetadataSanity, )

Ensure that the current space’s metadata context does not have any issues. Panics with a suitable message if any issue is detected. It also initialises the sanity maps which will then be used if the extreme_assertions feature is active. Internally this calls verify_metadata_context() from util::metadata::sanity

fn set_allocate_as_live(&self, live: bool)

fn should_allocate_as_live(&self) -> bool