Struct mmtk::plan::generational::global::CommonGenPlan

pub struct CommonGenPlan<VM: VMBinding> {
    pub nursery: CopySpace<VM>,
    pub common: CommonPlan<VM>,
    pub gc_full_heap: AtomicBool,
    pub next_gc_full_heap: AtomicBool,
    pub full_heap_gc_count: Arc<Mutex<EventCounter>>,
}

Common implementation for generational plans. Each generational plan should include this type, and forward calls to it where possible.

Fields

nursery: CopySpace<VM>

The nursery space.

common: CommonPlan<VM>

The common plan.

gc_full_heap: AtomicBool

Is this GC full heap?

next_gc_full_heap: AtomicBool

Is next GC full heap?

full_heap_gc_count: Arc<Mutex<EventCounter>>

Implementations

impl<VM: VMBinding> CommonGenPlan<VM>

pub fn new(args: CreateSpecificPlanArgs<'_, VM>) -> Self

pub fn prepare(&mut self, tls: VMWorkerThread)

Prepare Gen. This should be called by a single thread in GC prepare work.

pub fn release(&mut self, tls: VMWorkerThread)

Release Gen. This should be called by a single thread in GC release work.

fn virtual_memory_exhausted(plan: &dyn GenerationalPlan<VM = VM>) -> bool

Independent of how many pages remain in the page budget (a function of heap size), we must ensure we never exhaust virtual memory. Therefore we must never let the nursery grow to the extent that it can’t be copied into the mature space.

Returns true if the nursery has grown to the extent that it may not be able to be copied into the mature space.

pub fn collection_required<P: Plan<VM = VM>>( &self, plan: &P, space_full: bool, space: Option<SpaceStats<'_, VM>> ) -> bool

Check if we need a GC based on the nursery space usage. This method may mark the following GC as a full heap GC.

pub fn force_full_heap_collection(&self)

pub fn last_collection_full_heap(&self) -> bool

pub fn requires_full_heap_collection<P: Plan<VM = VM>>(&self, plan: &P) -> bool

Check if we should do a full heap GC. It returns true if we should have a full heap GC. It also sets gc_full_heap based on the result.

pub fn trace_object_full_heap<Q: ObjectQueue>( &self, queue: &mut Q, object: ObjectReference, worker: &mut GCWorker<VM> ) -> ObjectReference

Trace objects for spaces in generational and common plans for a full heap GC.

pub fn trace_object_nursery<Q: ObjectQueue, const KIND: u8>( &self, queue: &mut Q, object: ObjectReference, worker: &mut GCWorker<VM> ) -> ObjectReference

Trace objects for spaces in generational and common plans for a nursery GC.

pub fn is_current_gc_nursery(&self) -> bool

Is the current GC a nursery GC?

pub fn should_next_gc_be_full_heap(plan: &dyn Plan<VM = VM>) -> bool

Check a plan to see if the next GC should be a full heap GC.

Note that this function should be called after all spaces have been released. This is required as we may get incorrect values since this function uses get_available_pages whose value depends on which spaces have been released.

pub fn set_next_gc_full_heap(&self, next_gc_full_heap: bool)

Set next_gc_full_heap to the given value.

pub fn get_collection_reserved_pages(&self) -> usize

Get pages reserved for the collection by a generational plan. A generational plan should add their own reservation with the value returned by this method.

pub fn get_used_pages(&self) -> usize

Get pages used by a generational plan. A generational plan should add their own used pages with the value returned by this method.

Trait Implementations

impl<VM: VMBinding> HasSpaces for CommonGenPlan<VM>

type VM = VM

fn for_each_space(&self, __func: &mut dyn FnMut(&dyn Space<VM>))

Visit each space field immutably.

fn for_each_space_mut(&mut self, __func: &mut dyn FnMut(&mut dyn Space<VM>))

Visit each space field mutably.

impl<VM: VMBinding> PlanTraceObject<VM> for CommonGenPlan<VM>

fn trace_object<Q: ObjectQueue, const KIND: u8>( &self, __mmtk_queue: &mut Q, __mmtk_objref: ObjectReference, __mmtk_worker: &mut GCWorker<VM> ) -> ObjectReference

Trace objects in the plan. Generally one needs to figure out which space an object resides in, and invokes the corresponding policy trace object method.

fn post_scan_object(&self, __mmtk_objref: ObjectReference)

Post-scan objects in the plan. Each object is scanned by VM::VMScanning::scan_object(), and this function will be called after the VM::VMScanning::scan_object() as a hook to invoke possible policy post scan method. If a plan does not have any policy that needs post scan, this method can be implemented as empty. If a plan has a policy that has some policy specific behaviors for scanning (e.g. mark lines in Immix), this method should also invoke those policy specific methods for objects in that space.

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

Whether objects in this plan may move. If any of the spaces used by the plan may move objects, this should return true.