Struct mmtk::util::heap::gc_trigger::MemBalancerTrigger

pub struct MemBalancerTrigger {
    min_heap_pages: usize,
    max_heap_pages: usize,
    current_heap_pages: AtomicUsize,
    pending_pages: AtomicUsize,
    stats: AtomicRefCell<MemBalancerStats>,
}

An implementation of MemBalancer (Optimal heap limits for reducing browser memory use, https://dl.acm.org/doi/10.1145/3563323) We use MemBalancer to decide a heap limit between the min heap and the max heap. The current implementation is a simplified version of mem balancer and it does not take collection/allocation speed into account, and uses a fixed constant instead.

Fields

min_heap_pages: usize

The min heap size

max_heap_pages: usize

The max heap size

current_heap_pages: AtomicUsize

The current heap size

pending_pages: AtomicUsize

The number of pending allocation pages. The allocation requests for them have failed, and a GC is triggered. We will need to take them into consideration so that the new heap size can accomodate those allocations.

stats: AtomicRefCell<MemBalancerStats>

Statistics

Implementations

impl MemBalancerTrigger

fn new(min_heap_pages: usize, max_heap_pages: usize) -> Self

fn access_stats<F>(&self, f: F)

where F: FnMut(&mut MemBalancerStats),

fn compute_new_heap_limit( &self, live: usize, extra_reserve: usize, stats: &mut MemBalancerStats )

Trait Implementations

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

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.

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 starts.

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().

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

Inform the triggering policy that a GC ends.

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?