Struct GCTrigger 

pub struct GCTrigger<VM: VMBinding> {
    plan: MaybeUninit<&'static dyn Plan<VM = VM>>,
    pub policy: Box<dyn GCTriggerPolicy<VM>>,
    scheduler: Arc<GCWorkScheduler<VM>>,
    options: Arc<Options>,
    state: Arc<GlobalState>,
}

GCTrigger is responsible for triggering GCs based on the given policy. All the decisions about heap limit and GC triggering should be resolved here. Depending on the actual policy, we may either forward the calls either to the plan or to the binding/runtime.

Fields

plan: MaybeUninit<&'static dyn Plan<VM = VM>>

The current plan. This is uninitialized when we create it, and later initialized once we have a fixed address for the plan.

policy: Box<dyn GCTriggerPolicy<VM>>

The triggering policy.

scheduler: Arc<GCWorkScheduler<VM>>

options: Arc<Options>

state: Arc<GlobalState>

Implementations

impl<VM: VMBinding> GCTrigger<VM>

pub fn new( options: Arc<Options>, scheduler: Arc<GCWorkScheduler<VM>>, state: Arc<GlobalState>, ) -> Self

pub fn set_plan(&mut self, plan: &'static dyn Plan<VM = VM>)

Set the plan. This is called in create_plan() after we created a boxed plan.

fn plan(&self) -> &dyn Plan<VM = VM>

fn request(&self) -> bool

Request a GC. Called by mutators when polling (during allocation) and when handling user GC requests (e.g. System.gc(); in Java). Atomically check that collection is enabled, and if so, request a GC. This makes the enabled-check and the request atomic with respect to GCTrigger::disable_collection and GCTrigger::enable_collection, so a GC is never requested after collection has been disabled. Returns whether a GC was actually requested.

pub fn disable_collection(&self) -> Result<bool, GcStatus>

Disable collection. On success, returns Ok(true) if this call actually switched collection from enabled to disabled, Ok(false) if it only increased the nesting depth of an already-disabled status. If MMTk is unable to disable GC right now (possibly a GC is in progress, or a GC has been requested), returns Err with the status that prevented it; users should invoke runtime safepoints or other mechanisms to prepare for a GC pause, and then call this function again.

This call is nestable. Each call must be paired with a matching call to GCTrigger::enable_collection.

pub fn enable_collection(&self) -> bool

Re-enable collection. If collection is not currently disabled (e.g. there was no prior matching call to GCTrigger::disable_collection), this is a no-op. Returns true if this call actually re-enabled collection (i.e. it was the outermost matching call), false if it only decremented the nesting depth, or if collection was already enabled.

pub fn is_collection_enabled(&self) -> bool

Return whether collection is currently enabled.

pub fn poll(&self, space_full: bool, space: Option<&dyn Space<VM>>) -> bool

This method is called periodically by the allocation subsystem (by default, each time a page is consumed), and provides the collector with an opportunity to collect.

Arguments:

• space_full: Space request failed, must recover pages within ‘space’.
• space: The space that triggered the poll. This could None if the poll is not triggered by a space.

pub fn handle_user_collection_request( &self, force: bool, exhaustive: bool, ) -> bool

This method is called when the user manually requests a collection, such as System.gc() in Java. Returns true if a collection is actually requested.

Arguments

• force: If true, we force a collection regardless of the settings. If false, we only trigger a collection if the settings allow it.
• exhaustive: If true, we try to make the collection exhaustive (e.g. full heap collection). If false, the collection kind is determined internally.

pub fn trigger_internal_collection_request(&self)

MMTK has requested stop-the-world activity (e.g., stw within a concurrent gc).

pub fn should_do_stress_gc(&self) -> bool

pub(crate) fn should_do_stress_gc_inner( state: &GlobalState, options: &Options, ) -> bool

Check if we should do a stress GC now. If GC is initialized and the allocation bytes exceeds the stress factor, we should do a stress GC.

pub fn is_heap_full(&self) -> bool

Check if the heap is full

pub fn get_max_nursery_bytes(&self) -> usize

Return upper bound of the nursery size (in number of bytes)

pub fn get_min_nursery_bytes(&self) -> usize

Return lower bound of the nursery size (in number of bytes)

pub fn get_max_nursery_pages(&self) -> usize

Return upper bound of the nursery size (in number of pages)

pub fn get_min_nursery_pages(&self) -> usize

Return lower bound of the nursery size (in number of pages)

pub fn will_oom_on_alloc(&self, size: usize) -> bool

A check for the obvious out-of-memory case: if the requested size is larger than the heap size, it is definitely an OOM. We would like to identify that, and allows the binding to deal with OOM. Without this check, we will attempt to allocate from the page resource. If the requested size is unrealistically large (such as usize::MAX), it breaks the assumptions of our implementation of page resource, vm map, etc. This check prevents that, and allows us to handle the OOM case. Each allocator that may request an arbitrary size should call this method before acquring memory from the space. For example, bump pointer allocator and large object allocator need to call this method. On the other hand, allocators that only allocate memory in fixed size blocks do not need to call this method. An allocator should call this method before doing any computation on the size to avoid arithmatic overflow. If we have to do computation in the allocation fastpath and overflow happens there, there is nothing we can do about it. Return a boolean to indicate if we will be out of memory, determined by the check.