Struct mmtk::MMTK

pub struct MMTK<VM: VMBinding> {

    pub(crate) options: Arc<Options>,
    pub(crate) state: Arc<GlobalState>,
    pub(crate) plan: UnsafeCell<Box<dyn Plan<VM = VM>>>,
    pub(crate) reference_processors: ReferenceProcessors,
    pub(crate) finalizable_processor: Mutex<FinalizableProcessor<<VM::VMReferenceGlue as ReferenceGlue<VM>>::FinalizableType>>,
    pub(crate) scheduler: Arc<GCWorkScheduler<VM>>,
    pub(crate) sanity_checker: Mutex<SanityChecker<VM::VMEdge>>,
    pub(crate) edge_logger: EdgeLogger<VM::VMEdge>,
    pub(crate) gc_trigger: Arc<GCTrigger<VM>>,
    pub(crate) gc_requester: Arc<GCRequester<VM>>,
    pub(crate) stats: Arc<Stats>,
    inside_harness: AtomicBool,
    inside_sanity: AtomicBool,
    pub(crate) analysis_manager: Arc<AnalysisManager<VM>>,
}

An MMTk instance. MMTk allows multiple instances to run independently, and each instance gives users a separate heap. Note that multi-instances is not fully supported yet

Fields

options: Arc<Options>

state: Arc<GlobalState>

plan: UnsafeCell<Box<dyn Plan<VM = VM>>>

reference_processors: ReferenceProcessors

finalizable_processor: Mutex<FinalizableProcessor<<VM::VMReferenceGlue as ReferenceGlue<VM>>::FinalizableType>>

scheduler: Arc<GCWorkScheduler<VM>>

sanity_checker: Mutex<SanityChecker<VM::VMEdge>>

edge_logger: EdgeLogger<VM::VMEdge>

gc_trigger: Arc<GCTrigger<VM>>

gc_requester: Arc<GCRequester<VM>>

stats: Arc<Stats>

inside_harness: AtomicBool

inside_sanity: AtomicBool

analysis_manager: Arc<AnalysisManager<VM>>

Analysis counters. The feature analysis allows us to periodically stop the world and collect some statistics.

Implementations

impl<VM: VMBinding> MMTK<VM>

pub(crate) fn new(options: Arc<Options>) -> Self

Create an MMTK instance. This is not public. Bindings should use MMTKBuilder::build.

pub fn harness_begin(&self, tls: VMMutatorThread)

Generic hook to allow benchmarks to be harnessed. MMTk will trigger a GC to clear any residual garbage and start collecting statistics for the benchmark. This is usually called by the benchmark harness as its last step before the actual benchmark.

pub fn harness_end(&'static self)

Generic hook to allow benchmarks to be harnessed. MMTk will stop collecting statistics, and print out the collected statistics in a defined format. This is usually called by the benchmark harness right after the actual benchmark.

pub(crate) fn sanity_begin(&self)

pub(crate) fn sanity_end(&self)

pub(crate) fn is_in_sanity(&self) -> bool

pub(crate) fn set_gc_status(&self, s: GcStatus)

pub fn gc_in_progress(&self) -> bool

Return true if a collection is in progress.

pub fn gc_in_progress_proper(&self) -> bool

Return true if a collection is in progress and past the preparatory stage.

pub fn is_emergency_collection(&self) -> bool

Return true if the current GC is an emergency GC.

An emergency GC happens when a normal GC cannot reclaim enough memory to satisfy allocation requests. Plans may do full-heap GC, defragmentation, etc. during emergency in order to free up more memory.

VM bindings can call this function during GC to check if the current GC is an emergency GC. If it is, the VM binding is recommended to retain fewer objects than normal GCs, to the extent allowed by the specification of the VM or langauge. For example, the VM binding may choose not to retain objects used for caching. Specifically, for Java virtual machines, that means not retaining referents of SoftReference which is primarily designed for implementing memory-sensitive caches.

pub fn handle_user_collection_request( &self, tls: VMMutatorThread, force: bool, exhaustive: bool )

The application code has requested a collection. This is just a GC hint, and we may ignore it.

Arguments

• tls: The mutator thread that requests the GC
• force: The request cannot be ignored (except for NoGC)
• exhaustive: The requested GC should be exhaustive. This is also a hint.

pub fn trigger_internal_collection_request(&self)

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

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

Get a reference to the plan.

pub unsafe fn get_plan_mut(&self) -> &mut dyn Plan<VM = VM>

Get the plan as mutable reference.

Safety

This is unsafe because the caller must ensure that the plan is not used by other threads.

pub fn get_options(&self) -> &Options

Get the run time options.

Trait Implementations

impl<VM: VMBinding> Send for MMTK<VM>

impl<VM: VMBinding> Sync for MMTK<VM>