Trait GCTriggerPolicy 

pub trait GCTriggerPolicy<VM: VMBinding>: Sync + Send {
    // Required methods
    fn is_gc_required(
        &self,
        space_full: bool,
        space: Option<SpaceStats<'_, VM>>,
        plan: &dyn Plan<VM = VM>,
    ) -> bool;
    fn is_heap_full(&self, plan: &dyn Plan<VM = VM>) -> bool;
    fn get_current_heap_size_in_pages(&self) -> usize;
    fn get_max_heap_size_in_pages(&self) -> usize;
    fn can_heap_size_grow(&self) -> bool;

    // Provided methods
    fn on_pending_allocation(&self, _pages: usize) { ... }
    fn on_gc_start(&self, _mmtk: &'static MMTK<VM>) { ... }
    fn on_gc_end(&self, _mmtk: &'static MMTK<VM>) { ... }
    fn on_pause_start(&self, _mmtk: &'static MMTK<VM>) { ... }
    fn on_pause_end(&self, _mmtk: &'static MMTK<VM>) { ... }
    fn on_gc_release(&self, _mmtk: &'static MMTK<VM>) { ... }
}

This trait describes a GC trigger policy. A triggering policy have hooks to be informed about GC start/end so they can collect some statistics about GC and allocation. The policy needs to decide the (current) heap limit and decide whether a GC should be performed.

Required Methods

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

Is a GC required now? The GC trigger may implement its own heuristics to decide when a GC should be performed. However, we recommend the implementation to do its own checks first, and always call plan.collection_required(space_full, space) at the end as a fallback to see if the plan needs to do a GC.

Arguments:

• space_full: Is any space full?
• space: The space that is full. The GC trigger may access some stats of the space.
• plan: The reference to the plan in use.

fn is_heap_full(&self, plan: &dyn Plan<VM = VM>) -> bool

Is current heap full?

fn get_current_heap_size_in_pages(&self) -> usize

Return the current heap size (in pages)

fn get_max_heap_size_in_pages(&self) -> usize

Return the upper bound of heap size

fn can_heap_size_grow(&self) -> bool

Can the heap size grow?

Provided Methods

fn on_pending_allocation(&self, _pages: usize)

Inform the triggering policy that we have pending allocation. Any GC trigger policy with dynamic heap size should take this into account when calculating a new heap size. Failing to do so may result in unnecessay GCs, or result in an infinite loop if the new heap size can never accomodate the pending allocation.

fn on_gc_start(&self, _mmtk: &'static MMTK<VM>)

Inform the triggering policy that a GC cycle starts. A GC cycle consists of one or more GC pauses (see Self::on_pause_start) plus any concurrent work in between the pauses. For a stop-the-world GC, a GC cycle is just a single pause, and this is called at the same time as Self::on_pause_start. For a concurrent GC that splits a cycle into multiple pauses (e.g. an initial mark pause and a final mark pause with concurrent marking in between), this is only called once per cycle, for the first pause in the cycle.

fn on_gc_end(&self, _mmtk: &'static MMTK<VM>)

Inform the triggering policy that a GC cycle ends. See Self::on_gc_start for what a GC cycle is. This is only called once per GC cycle, for the last pause in the cycle.

fn on_pause_start(&self, _mmtk: &'static MMTK<VM>)

Inform the triggering policy that a pause starts. For a concurrent GC, this is called once for every STW pause in a GC cycle, not just once per cycle. See Self::on_gc_start for the hook that is only called once per GC cycle.

fn on_pause_end(&self, _mmtk: &'static MMTK<VM>)

Inform the triggering policy that a pause ends. For a concurrent GC, this is called once for every STW pause in a GC cycle, not just once per cycle. See Self::on_gc_end for the hook that is only called once per GC cycle.

fn on_gc_release(&self, _mmtk: &'static MMTK<VM>)

Inform the triggering policy that a GC is about to start the release work. This is called in the global Release work packet. This means we assume a plan do not schedule any work that reclaims memory before the global Release work. The current plans satisfy this assumption: they schedule other release work in plan.release().

Implementors

impl<VM: VMBinding> GCTriggerPolicy<VM> for FixedHeapSizeTrigger

impl<VM: VMBinding> GCTriggerPolicy<VM> for MemBalancerTrigger