Struct mmtk::plan::global::BasePlan

pub struct BasePlan<VM: VMBinding> {
    pub(crate) global_state: Arc<GlobalState>,
    pub options: Arc<Options>,
    pub gc_trigger: Arc<GCTrigger<VM>>,
    pub code_space: ImmortalSpace<VM>,
    pub code_lo_space: ImmortalSpace<VM>,
    pub ro_space: ImmortalSpace<VM>,
    pub vm_space: VMSpace<VM>,
}

BasePlan should contain all plan-related state and functions that are fundamental to all plans. These include VM-specific (but not plan-specific) features such as a code space or vm space, which are fundamental to all plans for a given VM. Features that are common to many (but not intrinsically all) plans should instead be included in CommonPlan.

Fields

global_state: Arc<GlobalState>

options: Arc<Options>

gc_trigger: Arc<GCTrigger<VM>>

code_space: ImmortalSpace<VM>

code_lo_space: ImmortalSpace<VM>

ro_space: ImmortalSpace<VM>

vm_space: VMSpace<VM>

A VM space is a space allocated and populated by the VM. Currently it is used by JikesRVM for boot image.

If VM space is present, it has some special interaction with the memory_manager::is_mmtk_object and the memory_manager::is_in_mmtk_spaces functions.

• The functions is_mmtk_object and find_object_from_internal_pointer require the valid object (VO) bit side metadata to identify objects. If the binding maintains the VO bit for objects in VM spaces, those functions will work accordingly. Otherwise, calling them is undefined behavior.

• The is_in_mmtk_spaces currently returns true if the given object reference is in the VM space.

Implementations

impl<VM: VMBinding> BasePlan<VM>

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

pub fn get_used_pages(&self) -> usize

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

pub fn prepare(&mut self, _tls: VMWorkerThread, _full_heap: bool)

pub fn release(&mut self, _tls: VMWorkerThread, _full_heap: bool)

pub(crate) fn collection_required<P: Plan>( &self, plan: &P, space_full: bool ) -> bool

Trait Implementations

impl<VM: VMBinding> HasSpaces for BasePlan<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 BasePlan<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.