Struct WorkerMonitor 

pub(crate) struct WorkerMonitor {
    worker_count: usize,
    sync: Mutex<WorkerMonitorSync>,
    active_workers: AtomicUsize,
    workers_have_anything_to_do: Condvar,
    active_worker_number_changed: Condvar,
}

A data structure for synchronizing workers with each other and with mutators.

Unlike GCWorkerShared, there is only one instance of WorkerMonitor.

• It allows workers to park and unpark.
• It allows mutators to notify workers to schedule a GC.

Fields

worker_count: usize

The total number of workers.

sync: Mutex<WorkerMonitorSync>

The synchronized part.

active_workers: AtomicUsize

The number of workers that are allowed to execute work after being notified.

workers_have_anything_to_do: Condvar

Active workers wait on this when idle. A parked active worker is notified if workers have things to do. That includes:

• any work packets available, and
• any field in sync.goals.requests set to true.

active_worker_number_changed: Condvar

Inactive workers wait on this instead. They are notified whenever the number of active workers changes, which may turn them into active workers.

Implementations

impl WorkerMonitor

pub fn new(worker_count: usize) -> Self

pub(crate) fn active_workers(&self) -> usize

pub(crate) fn is_worker_active(&self, ordinal: usize) -> bool

pub fn set_active_workers(&self, active_workers: usize)

Set the number of workers that are allowed to execute work after being notified.

This only updates the count. Whenever this changes, the caller must also call notify_work_available(true) (directly, or indirectly via the on_last_parked call-back while still holding the monitor’s internal lock) so that both active and inactive workers wake up and re-evaluate whether they should be active. We don’t do the notification here because this function may be called while the current thread is the last parked worker executing on_last_parked, in which case the notification has to happen through the already-held lock instead of acquiring it again.

pub fn make_request(&self, goal: WorkerGoal)

Make a request. Can be called by a mutator to request the workers to work towards the given goal.

pub fn notify_work_available(&self, all: bool)

Wake up workers when more work packets are made available for workers, or a mutator has requested the GC workers to schedule a GC.

fn notify_work_available_while_locked(&self, all: bool)

Like notify_work_available, but for use by callers that already hold the monitor’s internal lock (such as park_and_wait below), to avoid trying to lock it again.

pub fn park_and_wait<F>( &self, ordinal: usize, on_last_parked: F, ) -> Result<(), WorkerShouldExit>

where F: FnOnce(&mut WorkerGoals) -> LastParkedResult,

Park a worker and wait on the CondVar workers_have_anything_to_do.

If it is the last worker parked, on_last_parked will be called. The argument of on_last_parked is true if sync.gc_requested is true. The return value of on_last_parked will determine whether this worker and other workers will wake up or block waiting.

This function returns Ok(()) if the current worker should continue working, or Err(WorkerShouldExit) if the current worker should exit now.

pub fn on_all_workers_exited(&self)

Called when all workers have exited.