Simplified LXR GC

.gitignore

@@ -31,5 +31,7 @@ Cargo.lock
 # Generated for testing tutorial code build
 /src/plan/mygc
 
+/*.log
+/_*
 # Python script cache
 __pycache__

Cargo.toml

@@ -2,7 +2,7 @@
 name = "mmtk"
 version = "0.32.0"
 authors = ["The MMTk Developers <>"]
-edition = "2021" # TODO: Switch to 2024 after bumping MSRV to 1.85
+edition = "2021"                                                                                                        # TODO: Switch to 2024 after bumping MSRV to 1.85
 license = "MIT OR Apache-2.0"
 description = "MMTk is a framework for the design and implementation of high-performance and portable memory managers."
 homepage = "https://www.mmtk.io"
@@ -31,13 +31,16 @@ doctest = false
 
 [dependencies]
 # MMTk macros - we have to specify a version here in order to publish the crate, even though we use the dependency from a local path.
-mmtk-macros = { version="0.32.0", path = "macros/" }
+mmtk-macros = { version = "0.32.0", path = "macros/" }
 
 # Third party dependencies
 atomic = "0.6.0"
 atomic_refcell = "0.1.7"
 atomic-traits = "0.4.0"
-bytemuck = { version = "1.14.0", features = ["derive", "zeroable_maybe_uninit"] }
+bytemuck = { version = "1.14.0", features = [
+    "derive",
+    "zeroable_maybe_uninit",
+] }
 cfg-if = "1.0"
 crossbeam = "0.8.1"
 delegate = "0.13.2"
@@ -46,7 +49,9 @@ enum-map = "2.7.3"
 env_logger = { version = "0.11.3", optional = true }
 is-terminal = "0.4.7"
 itertools = "0.14.0"
-jemalloc-sys = { version = "0.5.3", features = ["disable_initial_exec_tls"], optional = true }
+jemalloc-sys = { version = "0.5.3", features = [
+    "disable_initial_exec_tls",
+], optional = true }
 lazy_static = "1.1"
 libc = "0.2"
 log = { version = "0.4", features = ["max_level_trace"] }
@@ -106,6 +111,14 @@ builtin_env_logger = ["dep:env_logger"]
 # Enable this feature if you want to use nightly features and compiler
 nightly = []
 
+# LXR Features
+lxr_no_cm = []
+lxr_no_lazy = []
+lxr_stw = ["lxr_no_cm", "lxr_no_lazy"]
+lxr_no_nursery_evac = []
+lxr_no_mature_evac = []
+lxr_no_evac = ["lxr_no_nursery_evac", "lxr_no_mature_evac"]
+
 # This feature is only supported on x86-64 for now
 # It's manually added to CI scripts
 perf_counter = ["dep:pfm"]
@@ -141,7 +154,7 @@ set_unlog_bits_vm_space = []
 # TODO: This is not properly implemented yet. We currently use an immortal space instead, and do not guarantee read-only semantics.
 ro_space = []
 # A code space with execution permission.
-code_space  = []
+code_space = []
 
 # By default, we only allow execution permission for code spaces. With this feature, all the spaces have execution permission.
 # Use with care.

README.md

@@ -122,7 +122,7 @@ MMTk uses a pinned Rust version in the repository (recorded in the `rust-toolcha
 our tests and benchmarks using the pinned Rust version. We recommend using the pinned Rust version
 for development. We update the pinned Rust version between releases of mmtk-core to keep it close to
 the latest Rust stable release. The release cycle of mmtk-core is six weeks, roughly the same as
-Rust itself. 
+Rust itself.
 
 Our minimum support Rust version (MSRV) policy is "N-1" (note that N is *NOT* the current stable Rust release).  That means we also ensure mmtk-core works
 properly with the Rust toolchain that is one minor version before the version specified in

docs/dummyvm/include/mmtk.h

@@ -71,8 +71,8 @@ extern bool mmtk_is_in_mmtk_spaces(void* object);
 // Return if the address pointed to by `addr` is in memory that is mapped by MMTk
 extern bool mmtk_is_mapped_address(void* addr);
 
-// Request MMTk to trigger a GC. Note that this may not actually trigger a GC
-extern void mmtk_handle_user_collection_request(void* tls);
+// Request MMTk to trigger a GC. Note that this may not actually trigger a GC unless `force` is true
+extern void mmtk_handle_user_collection_request(void* tls, bool force);
 
 // Add a reference to the list of weak references
 extern void mmtk_add_weak_candidate(void* ref);

docs/dummyvm/src/api.rs

@@ -167,8 +167,8 @@ pub extern "C" fn mmtk_is_mapped_address(address: Address) -> bool {
 }
 
 #[no_mangle]
-pub extern "C" fn mmtk_handle_user_collection_request(tls: VMMutatorThread) {
-    memory_manager::handle_user_collection_request::<DummyVM>(mmtk(), tls);
+pub extern "C" fn mmtk_handle_user_collection_request(tls: VMMutatorThread, force: bool) {
+    memory_manager::handle_user_collection_request::<DummyVM>(mmtk(), tls, force);
 }
 
 #[no_mangle]

docs/dummyvm/src/object_model.rs

@@ -19,6 +19,8 @@ impl ObjectModel<DummyVM> for VMObjectModel {
     // Global metadata
 
     const GLOBAL_LOG_BIT_SPEC: VMGlobalLogBitSpec = VMGlobalLogBitSpec::side_first();
+    const GLOBAL_FIELD_UNLOG_BIT_SPEC: VMGlobalFieldUnlogBitSpec =
+        VMGlobalFieldUnlogBitSpec::side_after(Self::GLOBAL_LOG_BIT_SPEC.as_spec());
 
     // Local metadata
 

docs/dummyvm/src/scanning.rs

@@ -21,10 +21,10 @@ impl Scanning<DummyVM> for VMScanning {
     fn scan_vm_specific_roots(_tls: VMWorkerThread, _factory: impl RootsWorkFactory<DummyVMSlot>) {
         unimplemented!()
     }
-    fn scan_object<SV: SlotVisitor<DummyVMSlot>>(
+    fn scan_object(
         _tls: VMWorkerThread,
         _object: ObjectReference,
-        _slot_visitor: &mut SV,
+        _slot_visitor: &mut impl SlotVisitor<DummyVMSlot>,
     ) {
         unimplemented!()
     }

src/lib.rs

@@ -1,3 +1,4 @@
+#![allow(static_mut_refs)]
 // Use the `{likely, unlikely}` provided by compiler when using nightly
 #![cfg_attr(feature = "nightly", feature(core_intrinsics))]
 
@@ -39,6 +40,7 @@ pub use mmtk::MMTK;
 mod global_state;
 pub use crate::global_state::{GcStatus, LiveBytesStats};
 
+#[macro_use]
 mod policy;
 
 pub mod build_info;

src/memory_manager.rs

@@ -28,6 +28,17 @@ use crate::vm::slot::MemorySlice;
 use crate::vm::ReferenceGlue;
 use crate::vm::VMBinding;
 
+/// Notify MMTk that a GC has started, so that MMTk can update its internal statistics (e.g. GC counts
+/// and timers) to reflect this. A binding does not normally need to call this directly, as MMTk calls it
+/// itself when it triggers a GC; it is only needed if the binding drives GC start/stop outside of MMTk's
+/// own scheduling.
+///
+/// Arguments:
+/// * `mmtk`: A reference to an MMTk instance.
+pub fn report_gc_start<VM: VMBinding>(mmtk: &MMTK<VM>) {
+    mmtk.stats.start_gc();
+}
+
 use std::collections::HashMap;
 
 /// Initialize an MMTk instance. A VM should call this method after creating an [`crate::MMTK`]
@@ -677,8 +688,9 @@ pub fn total_bytes<VM: VMBinding>(mmtk: &MMTK<VM>) -> usize {
 pub fn handle_user_collection_request<VM: VMBinding>(
     mmtk: &MMTK<VM>,
     tls: VMMutatorThread,
+    force: bool,
 ) -> bool {
-    mmtk.handle_user_collection_request(tls, false, false)
+    mmtk.handle_user_collection_request(tls, force, false)
 }
 
 /// Is the object alive?

src/mmtk.rs

@@ -112,13 +112,15 @@ impl Default for MMTKBuilder {
 /// An MMTk instance. MMTk allows multiple instances to run independently, and each instance gives users a separate heap.
 /// *Note that multi-instances is not fully supported yet*
 pub struct MMTK<VM: VMBinding> {
-    pub(crate) options: Arc<Options>,
+    /// The command line options for this MMTk instance, shared with the VM binding.
+    pub options: Arc<Options>,
     pub(crate) state: Arc<GlobalState>,
     pub(crate) plan: UnsafeCell<Box<dyn Plan<VM = VM>>>,
     pub(crate) reference_processors: ReferenceProcessors,
     pub(crate) finalizable_processor:
         Mutex<FinalizableProcessor<<VM::VMReferenceGlue as ReferenceGlue<VM>>::FinalizableType>>,
-    pub(crate) scheduler: Arc<GCWorkScheduler<VM>>,
+    /// The GC work scheduler that schedules and executes GC work packets on GC worker threads.
+    pub scheduler: Arc<GCWorkScheduler<VM>>,
     #[cfg(feature = "sanity")]
     pub(crate) sanity_checker: Mutex<SanityChecker<VM::VMSlot>>,
     #[cfg(feature = "extreme_assertions")]
@@ -152,7 +154,11 @@ impl<VM: VMBinding> MMTK<VM> {
             *options.threads
         };
 
-        let scheduler = GCWorkScheduler::new(num_workers, (*options.thread_affinity).clone());
+        let scheduler = GCWorkScheduler::new(
+            num_workers,
+            usize::min(num_workers, *options.conc_threads),
+            (*options.thread_affinity).clone(),
+        );
 
         let state = Arc::new(GlobalState::default());
 
@@ -343,6 +349,10 @@ impl<VM: VMBinding> MMTK<VM> {
     pub fn harness_begin(&self, tls: VMMutatorThread) {
         probe!(mmtk, harness_begin);
         self.handle_user_collection_request(tls, true, true);
+        if tls.0 .0.is_null() {
+            use crate::vm::Collection;
+            VM::VMCollection::block_for_gc(tls);
+        }
         self.state.inside_harness.store(true, Ordering::SeqCst);
         self.stats.start_all();
         self.scheduler.enable_stat();
@@ -450,7 +460,9 @@ impl<VM: VMBinding> MMTK<VM> {
             .handle_user_collection_request(force, exhaustive)
         {
             use crate::vm::Collection;
-            VM::VMCollection::block_for_gc(tls);
+            if !tls.0 .0.is_null() {
+                VM::VMCollection::block_for_gc(tls);
+            }
             true
         } else {
             false

src/plan/barriers.rs

@@ -21,6 +21,8 @@ pub enum BarrierSelector {
     NoBarrier,
     /// Object remembering post-write barrier is used.
     ObjectBarrier,
+    /// Field remembering post-write barrier is used, using a per-field (rather than per-object) unlogged bit.
+    FieldBarrier,
     /// Object remembering pre-write barrier with weak reference loading barrier.
     // TODO: We might be able to generalize this to object remembering pre-write barrier.
     SATBBarrier,
@@ -149,8 +151,11 @@ impl<VM: VMBinding> Barrier<VM> for NoBarrier {}
 /// A barrier is a combination of fast-path behaviour + slow-path semantics.
 /// The fast-path code will decide whether to call the slow-path calls.
 pub trait BarrierSemantics: 'static + Send {
+    /// The VM binding type that this barrier semantics is specialized for.
     type VM: VMBinding;
 
+    /// The metadata spec used to store the unlogged bit that this barrier's fast-path checks and
+    /// slow-path clears/sets.
     const UNLOG_BIT_SPEC: MetadataSpec =
         *<Self::VM as VMBinding>::VMObjectModel::GLOBAL_LOG_BIT_SPEC.as_spec();
 
@@ -271,6 +276,84 @@ impl<S: BarrierSemantics> Barrier<S::VM> for ObjectBarrier<S> {
     }
 }
 
+/// Generic object barrier with a type argument defining it's slow-path behaviour.
+pub struct FieldBarrier<S: BarrierSemantics> {
+    semantics: S,
+}
+
+impl<S: BarrierSemantics> FieldBarrier<S> {
+    /// Create a new FieldBarrier with the given semantics.
+    pub fn new(semantics: S) -> Self {
+        Self { semantics }
+    }
+}
+
+impl<S: BarrierSemantics> Barrier<S::VM> for FieldBarrier<S> {
+    fn flush(&mut self) {
+        self.semantics.flush();
+    }
+
+    fn load_weak_reference(&mut self, o: ObjectReference) {
+        self.semantics.load_weak_reference(o)
+    }
+
+    fn object_probable_write(&mut self, obj: ObjectReference) {
+        self.semantics.object_probable_write_slow(obj);
+    }
+
+    fn object_reference_write_pre(
+        &mut self,
+        src: ObjectReference,
+        slot: <S::VM as VMBinding>::VMSlot,
+        target: Option<ObjectReference>,
+    ) {
+        self.semantics
+            .object_reference_write_slow(src, slot, target);
+    }
+
+    fn object_reference_write_post(
+        &mut self,
+        _src: ObjectReference,
+        _slot: <S::VM as VMBinding>::VMSlot,
+        _target: Option<ObjectReference>,
+    ) {
+        unimplemented!()
+    }
+
+    fn object_reference_write_slow(
+        &mut self,
+        src: ObjectReference,
+        slot: <S::VM as VMBinding>::VMSlot,
+        target: Option<ObjectReference>,
+    ) {
+        self.semantics
+            .object_reference_write_slow(src, slot, target);
+    }
+
+    fn memory_region_copy_pre(
+        &mut self,
+        src: <S::VM as VMBinding>::VMMemorySlice,
+        dst: <S::VM as VMBinding>::VMMemorySlice,
+    ) {
+        self.semantics.memory_region_copy_slow(src, dst);
+    }
+
+    fn memory_region_copy_post(
+        &mut self,
+        _src: <S::VM as VMBinding>::VMMemorySlice,
+        _dst: <S::VM as VMBinding>::VMMemorySlice,
+    ) {
+        unimplemented!()
+    }
+}
+
+/// The value stored in the log bit/byte indicating that the object or field is unlogged, i.e. it
+/// has not yet been recorded in the remembered set and the write barrier should still take its slow path.
+pub const UNLOGGED_VALUE: u8 = 0b1;
+/// The value stored in the log bit/byte indicating that the object or field is logged, i.e. it
+/// has already been recorded in the remembered set and the write barrier can skip its slow path.
+pub const LOGGED_VALUE: u8 = 0b0;
+
 /// A SATB (Snapshot-At-The-Beginning) barrier implementation.
 /// This barrier is basically a pre-write object barrier with a weak reference loading barrier.
 pub struct SATBBarrier<S: BarrierSemantics> {

src/plan/concurrent/barrier.rs

@@ -15,6 +15,10 @@ use crate::{
     MMTK,
 };
 
+/// A snapshot-at-the-beginning (SATB) barrier, used by concurrent plans (e.g. concurrent Immix)
+/// to preserve the objects that were reachable at the start of concurrent marking. Old values
+/// overwritten by mutators, and referents loaded from weak references, are buffered and later
+/// enqueued as roots for concurrent marking, so they are not incorrectly reclaimed as garbage.
 pub struct SATBBarrierSemantics<
     VM: VMBinding,
     P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>,
@@ -30,6 +34,7 @@ pub struct SATBBarrierSemantics<
 impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND: TraceKind>
     SATBBarrierSemantics<VM, P, KIND>
 {
+    /// Create a new SATB barrier for the given mutator, with empty SATB/weak-reference buffers.
     pub fn new(mmtk: &'static MMTK<VM>, tls: VMMutatorThread) -> Self {
         Self {
             mmtk,

src/plan/concurrent/concurrent_marking_work.rs

@@ -3,7 +3,7 @@ use crate::plan::concurrent::Pause;
 use crate::plan::tracing::{PlanTrace, Trace};
 use crate::plan::PlanTraceObject;
 use crate::policy::gc_work::TraceKind;
-use crate::scheduler::{GCWork, GCWorker, WorkBucketStage};
+use crate::scheduler::{gc_work::RootKind, GCWork, GCWorker, WorkBucketStage};
 use crate::util::{scanning_helper, ObjectReference};
 use crate::vm::slot::Slot;
 use crate::vm::{RootsKind, RootsWorkFactory, VMBinding};
@@ -202,7 +202,7 @@ impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND
 impl<VM: VMBinding, P: ConcurrentPlan<VM = VM> + PlanTraceObject<VM>, const KIND: TraceKind>
     RootsWorkFactory<VM::VMSlot> for ConcurrentMarkingRootsWorkFactory<VM, P, KIND>
 {
-    fn create_process_roots_work(&mut self, slots: Vec<VM::VMSlot>) {
+    fn create_process_roots_work(&mut self, slots: Vec<VM::VMSlot>, _kind: RootKind) {
         probe!(mmtk, roots, RootsKind::NORMAL, slots.len());
 
         self.debug_assert_initial_mark();