Struct mmtk::plan::immix::global::Immix

pub struct Immix<VM: VMBinding> {
    pub immix_space: ImmixSpace<VM>,
    pub common: CommonPlan<VM>,
    last_gc_was_defrag: AtomicBool,
}

Fields

immix_space: ImmixSpace<VM>

common: CommonPlan<VM>

last_gc_was_defrag: AtomicBool

Implementations

impl<VM: VMBinding> Immix<VM>

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

pub fn new_with_args( plan_args: CreateSpecificPlanArgs<'_, VM>, space_args: ImmixSpaceArgs ) -> Self

pub(crate) fn schedule_immix_full_heap_collection<PlanType: Plan<VM = VM>, FastContext: GCWorkContext<VM = VM, PlanType = PlanType>, DefragContext: GCWorkContext<VM = VM, PlanType = PlanType>>( plan: &'static DefragContext::PlanType, immix_space: &ImmixSpace<VM>, scheduler: &GCWorkScheduler<VM> )

Schedule a full heap immix collection. This method is used by immix/genimmix/stickyimmix to schedule a full heap collection. A plan must call set_collection_kind and set_gc_status before this method.

pub(in plan) fn set_last_gc_was_defrag( &self, defrag: bool, order: Ordering )

Trait Implementations

impl<VM: VMBinding> HasSpaces for Immix<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> Plan for Immix<VM>

fn collection_required( &self, space_full: bool, _space: Option<SpaceStats<'_, Self::VM>> ) -> bool

Ask the plan if they would trigger a GC. If MMTk is in charge of triggering GCs, this method is called periodically during allocation. However, MMTk may delegate the GC triggering decision to the runtime, in which case, this method may not be called. This method returns true to trigger a collection.

fn last_collection_was_exhaustive(&self) -> bool

Return whether last GC was an exhaustive attempt to collect the heap. For example, for generational GCs, minor collection is not an exhaustive collection. For example, for Immix, fast collection (no defragmentation) is not an exhaustive collection.

fn constraints(&self) -> &'static PlanConstraints

Get the plan constraints for the plan. This returns a non-constant value. A constant value can be found in each plan’s module if needed.

fn create_copy_config(&'static self) -> CopyConfig<Self::VM>

Create a copy config for this plan. A copying GC plan MUST override this method, and provide a valid config.

fn schedule_collection(&'static self, scheduler: &GCWorkScheduler<VM>)

Schedule work for the upcoming GC.

fn get_allocator_mapping( &self ) -> &'static EnumMap<AllocationSemantics, AllocatorSelector>

Get the allocator mapping between crate::AllocationSemantics and crate::util::alloc::AllocatorSelector. This defines what space this plan will allocate objects into for different semantics.

fn prepare(&mut self, tls: VMWorkerThread)

Prepare the plan before a GC. This is invoked in an initial step in the GC. This is invoked once per GC by one worker thread. tls is the worker thread that executes this method.

fn release(&mut self, tls: VMWorkerThread)

Release the plan after transitive closure. A plan can implement this method to call each policy’s release, or create any work packet that should be done in release. This is invoked once per GC by one worker thread. tls is the worker thread that executes this method.

fn end_of_gc(&mut self, _tls: VMWorkerThread)

Inform the plan about the end of a GC. It is guaranteed that there is no further work for this GC. This is invoked once per GC by one worker thread. tls is the worker thread that executes this method.

fn current_gc_may_move_object(&self) -> bool

Return whether the current GC may move any object. The VM binding can make use of this information and choose to or not to update some data structures that record the addresses of objects.

fn get_collection_reserved_pages(&self) -> usize

Get the number of pages that are reserved for collection. By default, we return 0. For copying plans, they need to override this and calculate required pages to complete a copying GC.

fn get_used_pages(&self) -> usize

Get the number of pages that are used.

fn base(&self) -> &BasePlan<VM>

Get a immutable reference to the base plan. BasePlan is included by all the MMTk GC plans.

fn base_mut(&mut self) -> &mut BasePlan<Self::VM>

Get a mutable reference to the base plan. BasePlan is included by all the MMTk GC plans.

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

Get the common plan. CommonPlan is included by most of MMTk GC plans.

fn generational(&self) -> Option<&dyn GenerationalPlan<VM = Self::VM>>

Return a reference to GenerationalPlan to allow access methods specific to generational plans if the plan is a generational plan.

fn options(&self) -> &Options

Get the current run time options.

fn prepare_worker(&self, _worker: &mut GCWorker<Self::VM>)

Prepare a worker for a GC. Each worker has its own prepare method. This hook is for plan-specific per-worker preparation. This method is invoked once per worker by the worker thread passed as the argument.

fn notify_emergency_collection(&self)

Notify the plan that an emergency collection will happen. The plan should try to free as much memory as possible. The default implementation will force a full heap collection for generational plans.

fn get_reserved_pages(&self) -> usize

Get the number of pages that are reserved, including pages used by MMTk spaces, pages that will be used (e.g. for copying), and live pages allocated outside MMTk spaces as reported by the VM binding.

fn get_total_pages(&self) -> usize

Get the total number of pages for the heap.

fn get_available_pages(&self) -> usize

Get the number of pages that are still available for use. The available pages should always be positive or 0.

fn get_free_pages(&self) -> usize

Get the number of pages that are NOT used. This is clearly different from available pages. Free pages are unused, but some of them may have been reserved for some reason.

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

An object is firstly reached by a sanity GC. So the object is reachable in the current GC, and all the GC work has been done for the object (such as tracing and releasing). A plan can implement this to use plan specific semantics to check if the object is sane. Return true if the object is considered valid by the plan.

fn verify_side_metadata_sanity(&self)

Call space.verify_side_metadata_sanity for all spaces in this plan.

impl<VM: VMBinding> PlanTraceObject<VM> for Immix<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.