Enum WorkBucketStage

pub enum WorkBucketStage {
    Unconstrained,
    Concurrent,
    Prepare,
    ClearVOBits,
    TPinningClosure,
    PinningRootsTrace,
    Closure,
    SoftRefClosure,
    WeakRefClosure,
    FinalRefClosure,
    PhantomRefClosure,
    VMRefClosure,
    CalculateForwarding,
    SecondRoots,
    RefForwarding,
    FinalizableForwarding,
    VMRefForwarding,
    Compact,
    Release,
    Final,
}

This enum defines all the work bucket types. The scheduler will instantiate a work bucket for each stage defined here.

Variants

Unconstrained

This bucket is always open.

Concurrent

This bucket is intended for concurrent work. Though some concurrent work may be put and executed in the unconstrained bucket, work in the unconstrained bucket will always be consumed during STW. Users can disable this bucket and cache some concurrent work during STW, and only enable this bucket and allow concurrent execution once a STW is done.

Prepare

Preparation work. Plans, spaces, GC workers, mutators, etc. should be prepared for GC at this stage.

ClearVOBits

Clear the VO bit metadata. Mainly used by ImmixSpace.

TPinningClosure

Compute the transtive closure starting from transitively pinning (TP) roots following only strong references. No objects in this closure are allow to move.

PinningRootsTrace

Trace (non-transitively) pinning roots. Objects pointed by those roots must not move, but their children may. To ensure correctness, these must be processed after TPinningClosure

Closure

Compute the transtive closure following only strong references.

SoftRefClosure

Handle Java-style soft references, and potentially expand the transitive closure.

WeakRefClosure

Handle Java-style weak references.

FinalRefClosure

Resurrect Java-style finalizable objects, and potentially expand the transitive closure.

PhantomRefClosure

Handle Java-style phantom references.

VMRefClosure

Let the VM handle VM-specific weak data structures, including weak references, weak collections, table of finalizable objects, ephemerons, etc. Potentially expand the transitive closure.

NOTE: This stage is intended to replace the Java-specific weak reference handling stages above.

CalculateForwarding

Compute the forwarding addresses of objects (mark-compact-only).

SecondRoots

Scan roots again to initiate another transitive closure to update roots and reference after computing the forwarding addresses (mark-compact-only).

RefForwarding

Update Java-style weak references after computing forwarding addresses (mark-compact-only).

NOTE: This stage should be updated to adapt to the VM-side reference handling. It shall be kept after removing {Soft,Weak,Final,Phantom}RefClosure.

FinalizableForwarding

Update the list of Java-style finalization cadidates and finalizable objects after computing forwarding addresses (mark-compact-only).

VMRefForwarding

Let the VM handle the forwarding of reference fields in any VM-specific weak data structures, including weak references, weak collections, table of finalizable objects, ephemerons, etc., after computing forwarding addresses (mark-compact-only).

NOTE: This stage is intended to replace Java-specific forwarding phases above.

Compact

Compact objects (mark-compact-only).

Release

Work packets that should be done just before GC shall go here. This includes releasing resources and setting states in plans, spaces, GC workers, mutators, etc.

Final

Resume mutators and end GC.

Implementations

impl WorkBucketStage

pub const FIRST_STW_STAGE: Self = WorkBucketStage::Prepare

The first stop-the-world stage. This stage has no open condition, and will be opened manually once all the mutators threads are stopped.

pub const fn is_first_stw_stage(&self) -> bool

Is this the first stop-the-world stage? See Self::FIRST_STW_STAGE.

pub const fn is_always_open(&self) -> bool

Is this stage always open?

pub const fn is_open_by_default(&self) -> bool

Is this stage open by default?

pub const fn is_enabled_by_default(&self) -> bool

Is this stage enabled by default?

pub const fn is_sequentially_opened(&self) -> bool

Is this stage sequentially opened? All the stop-the-world stages, except the first one, are sequentially opened.

pub const fn is_stw(&self) -> bool

Is this stage a stop-the-world stage?

pub const fn is_concurrent(&self) -> bool

Is this stage concurrent (which may be executed during mutator time)?

Trait Implementations

impl Clone for WorkBucketStage

fn clone(&self) -> WorkBucketStage

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WorkBucketStage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Enum for WorkBucketStage

const LENGTH: usize = 20usize

Length of the enum.

fn from_usize(value: usize) -> Self

Takes an usize, and returns an element matching into_usize function.

fn into_usize(self) -> usize

Returns an unique identifier for a value within range of 0..Array::LENGTH.

impl<V> EnumArray<V> for WorkBucketStage

type Array = [V; 20]

Representation of an enum map for type V.

impl PartialEq for WorkBucketStage

fn eq(&self, other: &WorkBucketStage) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for WorkBucketStage

impl Eq for WorkBucketStage

impl StructuralPartialEq for WorkBucketStage