Struct mmtk::scheduler::scheduler::GCWorkScheduler

pub struct GCWorkScheduler<VM: VMBinding> {
    pub work_buckets: EnumMap<WorkBucketStage, WorkBucket<VM>>,
    pub(crate) worker_group: Arc<WorkerGroup<VM>>,
    pub(crate) worker_monitor: Arc<WorkerMonitor>,
    affinity: AffinityKind,
}

Fields

work_buckets: EnumMap<WorkBucketStage, WorkBucket<VM>>

Work buckets

worker_group: Arc<WorkerGroup<VM>>

Workers

worker_monitor: Arc<WorkerMonitor>

For synchronized communication between workers and with mutators.

affinity: AffinityKind

How to assign the affinity of each GC thread. Specified by the user.

Implementations

impl<VM: VMBinding> GCWorkScheduler<VM>

pub fn new(num_workers: usize, affinity: AffinityKind) -> Arc<Self>

pub fn num_workers(&self) -> usize

pub fn spawn_gc_threads( self: &Arc<Self>, mmtk: &'static MMTK<VM>, tls: VMThread )

Create GC threads for the first time. It will also create the GCWorker instances.

Currently GC threads only include worker threads, and we currently have only one worker group. We may add more worker groups in the future.

pub fn stop_gc_threads_for_forking(self: &Arc<Self>)

Ask all GC workers to exit for forking.

pub fn surrender_gc_worker(&self, worker: Box<GCWorker<VM>>)

Surrender the GCWorker struct of a GC worker when it exits.

pub fn respawn_gc_threads_after_forking(self: &Arc<Self>, tls: VMThread)

Respawn GC threads after forking. This will reuse the GCWorker instances of stopped workers. tls is the VM thread that requests GC threads to be re-spawn, and will be passed down to crate::vm::Collection::spawn_gc_thread.

pub fn resolve_affinity(&self, thread: usize)

Resolve the affinity of a thread.

pub(crate) fn request_schedule_collection(&self)

Request a GC to be scheduled. Called by mutator via GCRequester.

fn add_schedule_collection_packet(&self)

Add the ScheduleCollection packet. Called by the last parked worker.

pub fn schedule_common_work<C: GCWorkContext<VM = VM>>( &self, plan: &'static C::PlanType )

Schedule all the common work packets

fn are_buckets_drained(&self, buckets: &[WorkBucketStage]) -> bool

pub fn all_buckets_empty(&self) -> bool

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

Schedule “sentinel” work packets for all activated buckets.

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

Open buckets if their conditions are met.

This function should only be called after all the workers are parked. No workers will be waked up by this function. The caller is responsible for that.

Return true if there’re any non-empty buckets updated.

pub fn deactivate_all(&self)

pub fn reset_state(&self)

pub fn debug_assert_all_buckets_deactivated(&self)

pub(crate) fn assert_all_activated_buckets_are_empty(&self)

Check if all the work buckets are empty

fn poll_schedulable_work_once( &self, worker: &GCWorker<VM> ) -> Steal<Box<dyn GCWork<VM>>>

Get a schedulable work packet without retry.

fn poll_schedulable_work( &self, worker: &GCWorker<VM> ) -> Option<Box<dyn GCWork<VM>>>

Get a schedulable work packet.

pub(crate) fn poll( &self, worker: &GCWorker<VM> ) -> Result<Box<dyn GCWork<VM>>, WorkerShouldExit>

Called by workers to get a schedulable work packet. Park the worker if there’re no available packets.

fn poll_slow( &self, worker: &GCWorker<VM> ) -> Result<Box<dyn GCWork<VM>>, WorkerShouldExit>

fn on_last_parked( &self, worker: &GCWorker<VM>, goals: &mut WorkerGoals ) -> LastParkedResult

Called when the last worker parked. goal allows this function to inspect and change the current goal.

fn respond_to_requests( &self, worker: &GCWorker<VM>, goals: &mut WorkerGoals ) -> LastParkedResult

Respond to a worker reqeust.

fn find_more_work_for_workers(&self) -> bool

Find more work for workers to do. Return true if more work is available.

fn on_gc_finished(&self, worker: &GCWorker<VM>)

Called when GC has finished, i.e. when all work packets have been executed.

pub fn enable_stat(&self)

pub fn statistics(&self) -> HashMap<String, String>

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

Trait Implementations

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