Struct mmtk::scheduler::gc_work::PlanProcessEdges

pub struct PlanProcessEdges<VM: VMBinding, P: Plan<VM = VM> + PlanTraceObject<VM>, const KIND: u8> {
    plan: &'static P,
    base: ProcessEdgesBase<VM>,
}

This provides an implementation of crate::scheduler::gc_work::ProcessEdgesWork. A plan that implements PlanTraceObject can use this work packet for tracing objects.

Fields

plan: &'static P

base: ProcessEdgesBase<VM>

Methods from Deref<Target = ProcessEdgesBase<VM>>

pub fn set_worker(&mut self, worker: &mut GCWorker<VM>)

pub fn worker(&self) -> &'static mut GCWorker<VM>

pub fn mmtk(&self) -> &'static MMTK<VM>

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

pub fn pop_nodes(&mut self) -> Vec<ObjectReference>

Pop all nodes from nodes, and clear nodes to an empty vector.

pub fn is_roots(&self) -> bool

Trait Implementations

impl<VM: VMBinding, P: PlanTraceObject<VM> + Plan<VM = VM>, const KIND: u8> DerefMut for PlanProcessEdges<VM, P, KIND>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<VM: VMBinding, P: PlanTraceObject<VM> + Plan<VM = VM>, const KIND: u8> ProcessEdgesWork for PlanProcessEdges<VM, P, KIND>

type VM = VM

The associate type for the VM.

type ScanObjectsWorkType = PlanScanObjects<PlanProcessEdges<VM, P, KIND>, P>

The work packet type for scanning objects when using this ProcessEdgesWork.

fn new( slots: Vec<<<Self as ProcessEdgesWork>::VM as VMBinding>::VMSlot>, roots: bool, mmtk: &'static MMTK<VM>, bucket: WorkBucketStage ) -> Self

Create a ProcessEdgesWork.

fn create_scan_work( &self, nodes: Vec<ObjectReference> ) -> Self::ScanObjectsWorkType

Create an object-scanning work packet to be used for this ProcessEdgesWork.

fn trace_object(&mut self, object: ObjectReference) -> ObjectReference

Trace an MMTk object. The implementation should forward this call to the policy-specific trace_object() methods, depending on which space this object is in. If the object is not in any MMTk space, the implementation should forward the call to ActivePlan::vm_trace_object() to let the binding handle the tracing.

fn process_slot( &mut self, slot: <<Self as ProcessEdgesWork>::VM as VMBinding>::VMSlot )

Process a slot, including loading the object reference from the memory slot, trace the object and store back the new object reference if necessary.

const CAPACITY: usize = 4_096usize

The maximum number of slots that should be put to one of this work packets. The caller who creates a work packet of this trait should be responsible to comply with this capacity. Higher capacity means the packet will take longer to finish, and may lead to bad load balancing. On the other hand, lower capacity would lead to higher cost on scheduling many small work packets. It is important to find a proper capacity.

const OVERWRITE_REFERENCE: bool = true

Do we update object reference? This has to be true for a moving GC.

const SCAN_OBJECTS_IMMEDIATELY: bool = true

If true, we do object scanning in this work packet with the same worker without scheduling overhead. If false, we will add object scanning work packets to the global queue and allow other workers to work on it.

fn cache_roots_for_sanity_gc(&mut self)

If the work includes roots, we will store the roots somewhere so for sanity GC, we can do another transitive closure from the roots.

fn start_or_dispatch_scan_work(&mut self, work_packet: impl GCWork<Self::VM>)

Start the a scan work packet. If SCAN_OBJECTS_IMMEDIATELY, the work packet will be executed immediately, in this method. Otherwise, the work packet will be added the Closure work bucket and will be dispatched later by the scheduler.

fn flush(&mut self)

Flush the nodes in ProcessEdgesBase, and create a ScanObjects work packet for it. If the node set is empty, this method will simply return with no work packet created.

fn process_slots(&mut self)

Process all the slots in the work packet.

impl<VM: VMBinding, P: PlanTraceObject<VM> + Plan<VM = VM>, const KIND: u8> Deref for PlanProcessEdges<VM, P, KIND>

type Target = ProcessEdgesBase<VM>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.