Rename all occurrences of (gc) works to work (#233)

Author: qinsoon

src/lib.rs

@@ -24,12 +24,12 @@
 //!   * [Allocators](util/alloc/allocator/trait.Allocator.html): handlers of allocation requests which allocate objects to the bound space.
 //!   * [Policies](policy/space/trait.Space.html): definitions of semantics and behaviors for memory regions.
 //!      Each space is an instance of a policy, and takes up a unique proportion of the heap.
-//!   * [Work packets](scheduler/work/trait.GCWork.html): units of GC works scheduled by the MMTk's scheduler.
+//!   * [Work packets](scheduler/work/trait.GCWork.html): units of GC work scheduled by the MMTk's scheduler.
 //! * [GC plans](plan/global/trait.Plan.html): GC algorithms composed from components.
 //!   *Note that currently the choice of plans is made through Rust features, which is a build-time config, so only one plan is present in the generated binary
 //!   and in this documentation. We plan to make this a run-time config so that users can choose GC plans at boot time.*
 //! * [Heap implementations](util/heap/index.html): the underlying implementations of memory resources that support spaces.
-//! * [Scheduler](scheduler/scheduler/struct.Scheduler.html): the MMTk scheduler to allow flexible and parallel execution of GC works.
+//! * [Scheduler](scheduler/scheduler/struct.Scheduler.html): the MMTk scheduler to allow flexible and parallel execution of GC work.
 //! * Interfaces: bi-directional interfaces between MMTk and language implementations
 //!   i.e. [the memory manager API](memory_manager/index.html) that allows a language's memory manager to use MMTk
 //!   and [the VMBinding trait](vm/trait.VMBinding.html) that allows MMTk to call the language implementation.

src/plan/barriers.rs

@@ -1,5 +1,5 @@
 use crate::policy::space::Space;
-use crate::scheduler::gc_works::*;
+use crate::scheduler::gc_work::*;
 use crate::scheduler::WorkBucketStage;
 use crate::util::*;
 use crate::MMTK;

src/plan/controller_collector_context.rs

@@ -1,4 +1,4 @@
-use crate::scheduler::gc_works::ScheduleCollection;
+use crate::scheduler::gc_work::ScheduleCollection;
 use crate::scheduler::*;
 use crate::util::OpaquePointer;
 use crate::vm::VMBinding;

src/plan/gencopy/gc_works.rs renamed to src/plan/gencopy/gc_work.rs

@@ -2,7 +2,7 @@ use super::global::GenCopy;
 use crate::plan::CopyContext;
 use crate::plan::PlanConstraints;
 use crate::policy::space::Space;
-use crate::scheduler::gc_works::*;
+use crate::scheduler::gc_work::*;
 use crate::scheduler::WorkerLocal;
 use crate::scheduler::{GCWork, GCWorker, WorkBucketStage};
 use crate::util::alloc::{Allocator, BumpAllocator};

src/plan/gencopy/global.rs

@@ -1,4 +1,4 @@
-use super::gc_works::{GenCopyCopyContext, GenCopyMatureProcessEdges, GenCopyNurseryProcessEdges};
+use super::gc_work::{GenCopyCopyContext, GenCopyMatureProcessEdges, GenCopyNurseryProcessEdges};
 use super::mutator::ALLOCATOR_MAPPING;
 use crate::mmtk::MMTK;
 use crate::plan::global::BasePlan;
@@ -9,7 +9,7 @@ use crate::plan::Plan;
 use crate::plan::PlanConstraints;
 use crate::policy::copyspace::CopySpace;
 use crate::policy::space::Space;
-use crate::scheduler::gc_works::*;
+use crate::scheduler::gc_work::*;
 use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;
 use crate::util::constants::LOG_BYTES_IN_PAGE;

src/plan/gencopy/mod.rs

@@ -1,4 +1,4 @@
-pub(super) mod gc_works;
+pub(super) mod gc_work;
 pub(super) mod global;
 pub(super) mod mutator;
 

src/plan/gencopy/mutator.rs

@@ -1,4 +1,4 @@
-use super::gc_works::*;
+use super::gc_work::*;
 use super::GenCopy;
 use crate::plan::barriers::*;
 use crate::plan::mutator_context::Mutator;

src/plan/semispace/gc_works.rs renamed to src/plan/semispace/gc_work.rs

@@ -2,7 +2,7 @@ use super::global::SemiSpace;
 use crate::plan::CopyContext;
 use crate::plan::PlanConstraints;
 use crate::policy::space::Space;
-use crate::scheduler::gc_works::*;
+use crate::scheduler::gc_work::*;
 use crate::scheduler::WorkerLocal;
 use crate::util::alloc::{Allocator, BumpAllocator};
 use crate::util::forwarding_word;

src/plan/semispace/global.rs

@@ -1,4 +1,4 @@
-use super::gc_works::{SSCopyContext, SSProcessEdges};
+use super::gc_work::{SSCopyContext, SSProcessEdges};
 use crate::mmtk::MMTK;
 use crate::plan::global::BasePlan;
 use crate::plan::global::CommonPlan;
@@ -9,7 +9,7 @@ use crate::plan::Plan;
 use crate::plan::PlanConstraints;
 use crate::policy::copyspace::CopySpace;
 use crate::policy::space::Space;
-use crate::scheduler::gc_works::*;
+use crate::scheduler::gc_work::*;
 use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;
 use crate::util::heap::layout::heap_layout::Mmapper;

src/plan/semispace/mod.rs

@@ -1,4 +1,4 @@
-pub(super) mod gc_works;
+pub(super) mod gc_work;
 pub(super) mod global;
 pub(super) mod mutator;
 

src/plan/transitive_closure.rs

@@ -1,4 +1,4 @@
-use crate::scheduler::gc_works::ProcessEdgesWork;
+use crate::scheduler::gc_work::ProcessEdgesWork;
 use crate::util::{Address, ObjectReference};
 
 /// This trait is the fundamental mechanism for performing a

src/scheduler/gc_works.rs renamed to src/scheduler/gc_work.rs

@@ -47,7 +47,7 @@ impl<P: Plan, W: CopyContext + WorkerLocal> GCWork<P::VM> for Prepare<P, W> {
                 .add(PrepareMutator::<P::VM>::new(mutator));
         }
         for w in &mmtk.scheduler.worker_group().workers {
-            w.local_works.add(PrepareCollector::<W>::new());
+            w.local_work_bucket.add(PrepareCollector::<W>::new());
         }
     }
 }
@@ -115,7 +115,7 @@ impl<P: Plan, W: CopyContext + WorkerLocal> GCWork<P::VM> for Release<P, W> {
                 .add(ReleaseMutator::<P::VM>::new(mutator));
         }
         for w in &mmtk.scheduler.worker_group().workers {
-            w.local_works.add(ReleaseCollector::<W>(PhantomData));
+            w.local_work_bucket.add(ReleaseCollector::<W>(PhantomData));
         }
         // TODO: Process weak references properly
         mmtk.reference_processors.clear();
@@ -381,9 +381,9 @@ pub trait ProcessEdgesWork:
         if Self::SCAN_OBJECTS_IMMEDIATELY {
             // We execute this `scan_objects_work` immediately.
             // This is expected to be a useful optimization because,
-            // say for _pmd_ with 200M heap, we're likely to have 50000~60000 `ScanObjects` works
+            // say for _pmd_ with 200M heap, we're likely to have 50000~60000 `ScanObjects` work packets
             // being dispatched (similar amount to `ProcessEdgesWork`).
-            // Executing these works now can remarkably reduce the global synchronization time.
+            // Executing these work packets now can remarkably reduce the global synchronization time.
             self.worker().do_work(scan_objects_work);
         } else {
             self.mmtk.scheduler.work_buckets[WorkBucketStage::Closure].add(scan_objects_work);

src/scheduler/mod.rs

@@ -1,4 +1,4 @@
-//! A general scheduler implementation. MMTk uses it to schedule GC-related works.
+//! A general scheduler implementation. MMTk uses it to schedule GC-related work.
 
 mod context;
 mod mmtk_context;
@@ -16,4 +16,4 @@ pub use work::*;
 pub use work_bucket::WorkBucketStage;
 pub use worker::*;
 
-pub mod gc_works;
+pub mod gc_work;

src/scheduler/scheduler.rs

@@ -20,15 +20,15 @@ pub enum CoordinatorMessage<C: Context> {
 
 pub struct Scheduler<C: Context> {
     pub work_buckets: EnumMap<WorkBucketStage, WorkBucket<C>>,
-    /// Works for the coordinator thread
-    pub coordinator_works: WorkBucket<C>,
+    /// Work for the coordinator thread
+    pub coordinator_work: WorkBucket<C>,
     /// workers
     worker_group: Option<Arc<WorkerGroup<C>>>,
     /// Condition Variable for worker synchronization
     pub worker_monitor: Arc<(Mutex<()>, Condvar)>,
     context: Option<&'static C>,
     coordinator_worker: Option<RwLock<Worker<C>>>,
-    /// A message channel to send new coordinator works and other actions to the coordinator thread
+    /// A message channel to send new coordinator work and other actions to the coordinator thread
     pub channel: (
         Sender<CoordinatorMessage<C>>,
         Receiver<CoordinatorMessage<C>>,
@@ -51,7 +51,7 @@ impl<C: Context> Scheduler<C> {
                 WorkBucketStage::Release => WorkBucket::new(false, worker_monitor.clone()),
                 WorkBucketStage::Final => WorkBucket::new(false, worker_monitor.clone()),
             },
-            coordinator_works: WorkBucket::new(true, worker_monitor.clone()),
+            coordinator_work: WorkBucket::new(true, worker_monitor.clone()),
             worker_group: None,
             worker_monitor,
             context: None,
@@ -142,20 +142,20 @@ impl<C: Context> Scheduler<C> {
             buckets_updated |= bucket.update();
         }
         if buckets_updated {
-            // Notify the workers for new works
+            // Notify the workers for new work
             let _guard = self.worker_monitor.0.lock().unwrap();
             self.worker_monitor.1.notify_all();
         }
     }
 
-    /// Execute coordinator works, in the controller thread
+    /// Execute coordinator work, in the controller thread
     fn process_coordinator_work(&self, mut work: Box<dyn CoordinatorWork<C>>) {
         let mut coordinator_worker = self.coordinator_worker.as_ref().unwrap().write().unwrap();
         let context = self.context.unwrap();
         work.do_work_with_stat(&mut coordinator_worker, context);
     }
 
-    /// Drain the message queue and execute coordinator works
+    /// Drain the message queue and execute coordinator work
     pub fn wait_for_completion(&self) {
         // At the start of a GC, we probably already have received a `ScheduleCollection` work. Run it now.
         if let Some(initializer) = self.startup.lock().unwrap().take() {
@@ -219,8 +219,8 @@ impl<C: Context> Scheduler<C> {
 
     #[inline]
     fn pop_scheduable_work(&self, worker: &Worker<C>) -> Option<(Box<dyn Work<C>>, bool)> {
-        if let Some(work) = worker.local_works.poll() {
-            return Some((work, worker.local_works.is_empty()));
+        if let Some(work) = worker.local_work_bucket.poll() {
+            return Some((work, worker.local_work_bucket.is_empty()));
         }
         for work_bucket in self.work_buckets.values() {
             if let Some(work) = work_bucket.poll() {

src/scheduler/stat.rs

@@ -12,7 +12,7 @@ pub struct SchedulerStat {
 
 impl SchedulerStat {
     /// Extract the work-packet name from the full type name.
-    /// i.e. simplifies `crate::scheduler::gc_works::SomeWorkPacket<Semispace>` to `SomeWorkPacket`.
+    /// i.e. simplifies `crate::scheduler::gc_work::SomeWorkPacket<Semispace>` to `SomeWorkPacket`.
     fn work_name(&self, name: &str) -> String {
         let end_index = name.find('<').unwrap_or_else(|| name.len());
         let name = name[..end_index].to_owned();
@@ -55,11 +55,11 @@ impl SchedulerStat {
             total_count += c;
             let n = self.work_id_name_map[t];
             stat.insert(
-                format!("works.{}.count", self.work_name(n)),
+                format!("work.{}.count", self.work_name(n)),
                 format!("{}", c),
             );
         }
-        stat.insert("total-works.count".to_owned(), format!("{}", total_count));
+        stat.insert("total-work.count".to_owned(), format!("{}", total_count));
         // Work execution times
         let mut total_durations = vec![];
         for (t, durations) in &self.work_durations {
@@ -74,7 +74,7 @@ impl SchedulerStat {
                     .collect::<Vec<_>>(),
             );
             stat.insert(
-                format!("works.{}.time.geomean", self.work_name(n)),
+                format!("work.{}.time.geomean", self.work_name(n)),
                 format!("{:.2}", geomean),
             );
         }
@@ -84,15 +84,15 @@ impl SchedulerStat {
             .collect::<Vec<_>>();
         if !durations.is_empty() {
             stat.insert(
-                "total-works.time.geomean".to_owned(),
+                "total-work.time.geomean".to_owned(),
                 format!("{:.2}", self.geomean(&durations)),
             );
             stat.insert(
-                "total-works.time.min".to_owned(),
+                "total-work.time.min".to_owned(),
                 format!("{:.2}", self.min(&durations)),
             );
             stat.insert(
-                "total-works.time.max".to_owned(),
+                "total-work.time.max".to_owned(),
                 format!("{:.2}", self.max(&durations)),
             );
         }

src/scheduler/work.rs

@@ -19,7 +19,7 @@ pub trait Work<C: Context>: 'static + Send + Sync {
 /// A special kind of work that will execute on the coorddinator (i.e. controller) thread
 ///
 /// The coorddinator thread holds the global monitor lock when executing `CoordinatorWork`s.
-/// So, directly adding new works to any buckets will cause dead lock.
+/// So, directly adding new work to any buckets will cause dead lock.
 /// For this case, use `WorkBucket::add_with_priority_unsync` instead.
 pub trait CoordinatorWork<C: Context>: 'static + Send + Sync + Work<C> {}
 

src/scheduler/work_bucket.rs

@@ -115,10 +115,10 @@ impl<C: Context> WorkBucket<C> {
     pub fn add<W: Work<C>>(&self, work: W) {
         self.add_with_priority(1000, box work);
     }
-    pub fn bulk_add(&self, priority: usize, works: Vec<Box<dyn Work<C>>>) {
+    pub fn bulk_add(&self, priority: usize, work_vec: Vec<Box<dyn Work<C>>>) {
         {
             let mut queue = self.queue.write();
-            for w in works {
+            for w in work_vec {
                 queue.push(PrioritizedWork::new(priority, w));
             }
         }

src/scheduler/worker.rs

@@ -50,7 +50,7 @@ pub struct Worker<C: Context> {
     pub parked: AtomicBool,
     scheduler: Arc<Scheduler<C>>,
     local: WorkerLocalPtr,
-    pub local_works: WorkBucket<C>,
+    pub local_work_bucket: WorkBucket<C>,
     pub sender: Sender<CoordinatorMessage<C>>,
     pub stat: WorkerLocalStat,
     context: Option<&'static C>,
@@ -71,7 +71,7 @@ impl<C: Context> Worker<C> {
             ordinal,
             parked: AtomicBool::new(true),
             local: WorkerLocalPtr::UNINITIALIZED,
-            local_works: WorkBucket::new(true, scheduler.worker_monitor.clone()),
+            local_work_bucket: WorkBucket::new(true, scheduler.worker_monitor.clone()),
             sender: scheduler.channel.0.clone(),
             scheduler,
             stat: Default::default(),

src/util/sanity/sanity_checker.rs

@@ -1,6 +1,6 @@
 use crate::plan::global::CopyContext;
 use crate::plan::Plan;
-use crate::scheduler::gc_works::*;
+use crate::scheduler::gc_work::*;
 use crate::scheduler::*;
 use crate::util::{Address, ObjectReference};
 use crate::vm::*;
@@ -94,7 +94,7 @@ impl<P: Plan, W: CopyContext + WorkerLocal> GCWork<P::VM> for SanityPrepare<P, W
                 .add(PrepareMutator::<P::VM>::new(mutator));
         }
         for w in &mmtk.scheduler.worker_group().workers {
-            w.local_works.add(PrepareCollector::<W>::new());
+            w.local_work_bucket.add(PrepareCollector::<W>::new());
         }
     }
 }
@@ -123,7 +123,7 @@ impl<P: Plan, W: CopyContext + WorkerLocal> GCWork<P::VM> for SanityRelease<P, W
                 .add(ReleaseMutator::<P::VM>::new(mutator));
         }
         for w in &mmtk.scheduler.worker_group().workers {
-            w.local_works.add(ReleaseCollector::<W>::new());
+            w.local_work_bucket.add(ReleaseCollector::<W>::new());
         }
     }
 }

src/vm/collection.rs

@@ -1,5 +1,5 @@
 use crate::plan::MutatorContext;
-use crate::scheduler::gc_works::ProcessEdgesWork;
+use crate::scheduler::gc_work::ProcessEdgesWork;
 use crate::scheduler::*;
 use crate::util::OpaquePointer;
 use crate::vm::VMBinding;

src/vm/scanning.rs

@@ -1,5 +1,5 @@
 use crate::plan::{Mutator, TransitiveClosure};
-use crate::scheduler::gc_works::ProcessEdgesWork;
+use crate::scheduler::gc_work::ProcessEdgesWork;
 use crate::scheduler::GCWorker;
 use crate::util::ObjectReference;
 use crate::util::OpaquePointer;

tests/scheduler.rs

@@ -23,7 +23,7 @@ impl Work<()> for Sort {
 
 /// A work-packet to do array partition
 ///
-/// Recursively generates `Sort` works for partitioned sub-arrays.
+/// Recursively generates `Sort` work for partitioned sub-arrays.
 struct Partition(&'static mut [usize]);
 
 impl Work<()> for Partition {

vmbindings/dummyvm/src/collection.rs

@@ -3,7 +3,7 @@ use mmtk::MutatorContext;
 use mmtk::util::OpaquePointer;
 use mmtk::MMTK;
 use mmtk::scheduler::*;
-use mmtk::scheduler::gc_works::*;
+use mmtk::scheduler::gc_work::*;
 use DummyVM;
 
 pub struct VMCollection {}

vmbindings/dummyvm/src/scanning.rs

@@ -2,7 +2,7 @@ use mmtk::vm::Scanning;
 use mmtk::{TransitiveClosure, Mutator};
 use mmtk::util::ObjectReference;
 use mmtk::util::OpaquePointer;
-use mmtk::scheduler::gc_works::*;
+use mmtk::scheduler::gc_work::*;
 use mmtk::scheduler::GCWorker;
 use crate::DummyVM;