Struct mmtk::plan::generational::immix::global::GenImmix

pub struct GenImmix<VM: VMBinding> {
    pub gen: CommonGenPlan<VM>,
    pub immix_space: ImmixSpace<VM>,
    pub last_gc_was_defrag: AtomicBool,
    pub last_gc_was_full_heap: AtomicBool,
}

Generational immix. This implements the functionality of a two-generation copying collector where the higher generation is an immix space. See the PLDI’08 paper by Blackburn and McKinley for a description of the algorithm: http://doi.acm.org/10.1145/1375581.1375586.

Fields

gen: CommonGenPlan<VM>

Generational plan, which includes a nursery space and operations related with nursery.

immix_space: ImmixSpace<VM>

An immix space as the mature space.

last_gc_was_defrag: AtomicBool

Whether the last GC was a defrag GC for the immix space.

last_gc_was_full_heap: AtomicBool

Whether the last GC was a full heap GC

Implementations

impl<VM: VMBinding> GenImmix<VM>

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

fn requires_full_heap_collection(&self) -> bool

Trait Implementations

impl<VM: VMBinding> GenerationalPlan for GenImmix<VM>

fn is_current_gc_nursery(&self) -> bool

Is the current GC a nursery GC? If a GC is not a nursery GC, it will be a full heap GC. This should only be called during GC.

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

Is the object in the nursery?

fn is_address_in_nursery(&self, addr: Address) -> bool

Is the address in the nursery? As we only know addresses rather than object references, the implementation cannot access per-object metadata. If the plan does not have knowledge whether the address is in nursery or not (e.g. mature/nursery objects share the same space and are only differentiated by object metadata), the implementation should return false as a more conservative result.

fn get_mature_physical_pages_available(&self) -> usize

Return the number of pages available for allocation into the mature space.

fn get_mature_reserved_pages(&self) -> usize

Return the number of used pages in the mature space.

fn force_full_heap_collection(&self)

Force the next collection to be full heap.

fn last_collection_full_heap(&self) -> bool

Return whether last GC is a full GC.

impl<VM: VMBinding> GenerationalPlanExt<VM> for GenImmix<VM>

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

Trace an object in nursery collection. If the object is in nursery, we should call trace_object on the space. Otherwise, we can just return the object.

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

fn get_available_pages(&self) -> usize

Return the number of pages available for allocation. Assuming all future allocations goes to nursery.

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 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 collection_required( &self, space_full: bool, space: Option<SpaceStats<'_, Self::VM>> ) -> bool

where Self: Sized,

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 schedule_collection(&'static self, scheduler: &GCWorkScheduler<Self::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 = 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_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 GenImmix<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.