Allow configuring each Immix space to be non moving

qinsoon · qinsoon · commit 836cac59d5fd · 2025-04-17T04:27:11.000Z
diff --git a/Cargo.toml b/Cargo.toml
@@ -152,11 +152,6 @@ object_pinning = []
 # Disable any object copying in Immix. This makes Immix a non-moving policy.
 immix_non_moving = []
 
-# Disable any object copying in nursery GC for Sticky Immix while allowing other kinds of copying.
-# `immix_non_moving` disables all kinds of copying in Immix, so this feature is not needed
-# if `immix_non_moving` is in use.
-sticky_immix_non_moving_nursery = []
-
 # Turn on stress copying for Immix. This is a debug feature to test copying for Immix plans.
 immix_stress_copying = []
 # Reduce block size for ImmixSpace.  This mitigates fragmentation when defrag is disabled.
diff --git a/src/plan/generational/immix/global.rs b/src/plan/generational/immix/global.rs
@@ -87,9 +87,9 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
 
     fn last_collection_was_exhaustive(&self) -> bool {
         self.last_gc_was_full_heap.load(Ordering::Relaxed)
-            && ImmixSpace::<VM>::is_last_gc_exhaustive(
-                self.last_gc_was_defrag.load(Ordering::Relaxed),
-            )
+            && self
+                .immix_space
+                .is_last_gc_exhaustive(self.last_gc_was_defrag.load(Ordering::Relaxed))
     }
 
     fn collection_required(&self, space_full: bool, space: Option<SpaceStats<Self::VM>>) -> bool
@@ -254,6 +254,7 @@ impl<VM: VMBinding> GenImmix<VM> {
                 // In GenImmix, young objects are not allocated in ImmixSpace directly.
                 #[cfg(feature = "vo_bit")]
                 mixed_age: false,
+                never_move_objects: cfg!(feature = "immix_non_moving"),
             },
         );
 
diff --git a/src/plan/immix/global.rs b/src/plan/immix/global.rs
@@ -38,7 +38,7 @@ pub struct Immix<VM: VMBinding> {
 
 /// The plan constraints for the immix plan.
 pub const IMMIX_CONSTRAINTS: PlanConstraints = PlanConstraints {
-    moves_objects: crate::policy::immix::DEFRAG,
+    moves_objects: true,
     // Max immix object size is half of a block.
     max_non_los_default_alloc_bytes: crate::policy::immix::MAX_IMMIX_OBJECT_SIZE,
     needs_prepare_mutator: false,
@@ -51,7 +51,8 @@ impl<VM: VMBinding> Plan for Immix<VM> {
     }
 
     fn last_collection_was_exhaustive(&self) -> bool {
-        ImmixSpace::<VM>::is_last_gc_exhaustive(self.last_gc_was_defrag.load(Ordering::Relaxed))
+        self.immix_space
+            .is_last_gc_exhaustive(self.last_gc_was_defrag.load(Ordering::Relaxed))
     }
 
     fn constraints(&self) -> &'static PlanConstraints {
@@ -139,6 +140,7 @@ impl<VM: VMBinding> Immix<VM> {
                 unlog_object_when_traced: false,
                 #[cfg(feature = "vo_bit")]
                 mixed_age: false,
+                never_move_objects: cfg!(feature = "immix_non_moving"),
             },
         )
     }
diff --git a/src/plan/sticky/immix/global.rs b/src/plan/sticky/immix/global.rs
@@ -7,7 +7,6 @@ use crate::plan::PlanConstraints;
 use crate::policy::gc_work::TraceKind;
 use crate::policy::gc_work::TRACE_KIND_TRANSITIVE_PIN;
 use crate::policy::immix::ImmixSpace;
-use crate::policy::immix::PREFER_COPY_ON_NURSERY_GC;
 use crate::policy::immix::TRACE_KIND_FAST;
 use crate::policy::sft::SFT;
 use crate::policy::space::Space;
@@ -41,7 +40,7 @@ pub struct StickyImmix<VM: VMBinding> {
 
 /// The plan constraints for the sticky immix plan.
 pub const STICKY_IMMIX_CONSTRAINTS: PlanConstraints = PlanConstraints {
-    moves_objects: crate::policy::immix::DEFRAG || crate::policy::immix::PREFER_COPY_ON_NURSERY_GC,
+    moves_objects: true,
     needs_log_bit: true,
     barrier: crate::plan::BarrierSelector::ObjectBarrier,
     // We may trace duplicate edges in sticky immix (or any plan that uses object remembering barrier). See https://github.com/mmtk/mmtk-core/issues/743.
@@ -164,7 +163,7 @@ impl<VM: VMBinding> Plan for StickyImmix<VM> {
 
     fn current_gc_may_move_object(&self) -> bool {
         if self.is_current_gc_nursery() {
-            PREFER_COPY_ON_NURSERY_GC
+            self.get_immix_space().prefer_copy_on_nursery_gc()
         } else {
             self.get_immix_space().in_defrag()
         }
@@ -263,7 +262,7 @@ impl<VM: VMBinding> crate::plan::generational::global::GenerationalPlanExt<VM> f
                     self.immix
                         .immix_space
                         .trace_object_without_moving(queue, object)
-                } else if crate::policy::immix::PREFER_COPY_ON_NURSERY_GC {
+                } else if self.immix.immix_space.is_nursery_copy_enabled() {
                     let ret = self.immix.immix_space.trace_object_with_opportunistic_copy(
                         queue,
                         object,
@@ -330,6 +329,7 @@ impl<VM: VMBinding> StickyImmix<VM> {
                 // In StickyImmix, both young and old objects are allocated in the ImmixSpace.
                 #[cfg(feature = "vo_bit")]
                 mixed_age: true,
+                never_move_objects: cfg!(feature = "immix_non_moving"),
             },
         );
         Self {
diff --git a/src/policy/immix/defrag.rs b/src/policy/immix/defrag.rs
@@ -72,12 +72,11 @@ impl Defrag {
         exhausted_reusable_space: bool,
         full_heap_system_gc: bool,
     ) {
-        let in_defrag = super::DEFRAG
-            && (emergency_collection
-                || (collection_attempts > 1)
-                || !exhausted_reusable_space
-                || super::STRESS_DEFRAG
-                || (collect_whole_heap && user_triggered && full_heap_system_gc));
+        let in_defrag = emergency_collection
+            || (collection_attempts > 1)
+            || !exhausted_reusable_space
+            || super::STRESS_DEFRAG
+            || (collect_whole_heap && user_triggered && full_heap_system_gc);
         info!("Defrag: {}", in_defrag);
         probe!(mmtk, immix_defrag, in_defrag);
         self.in_defrag_collection
@@ -116,9 +115,8 @@ impl Defrag {
     }
 
     /// Prepare work. Should be called in ImmixSpace::prepare.
-    #[allow(clippy::assertions_on_constants)]
     pub fn prepare<VM: VMBinding>(&self, space: &ImmixSpace<VM>, plan_stats: StatsForDefrag) {
-        debug_assert!(super::DEFRAG);
+        debug_assert!(space.is_defrag_enabled());
         self.defrag_space_exhausted.store(false, Ordering::Release);
 
         // Calculate available free space for defragmentation.
@@ -207,9 +205,7 @@ impl Defrag {
     }
 
     /// Reset the in-defrag state.
-    #[allow(clippy::assertions_on_constants)]
     pub fn reset_in_defrag(&self) {
-        debug_assert!(super::DEFRAG);
         self.in_defrag_collection.store(false, Ordering::Release);
     }
 }
diff --git a/src/policy/immix/immixspace.rs b/src/policy/immix/immixspace.rs
@@ -73,6 +73,8 @@ pub struct ImmixSpaceArgs {
     // Currently only used when "vo_bit" is enabled.  Using #[cfg(...)] to eliminate dead code warning.
     #[cfg(feature = "vo_bit")]
     pub mixed_age: bool,
+    /// Disable copying for this Immix space.
+    pub never_move_objects: bool,
 }
 
 unsafe impl<VM: VMBinding> Sync for ImmixSpace<VM> {}
@@ -84,7 +86,7 @@ impl<VM: VMBinding> SFT for ImmixSpace<VM> {
 
     fn get_forwarded_object(&self, object: ObjectReference) -> Option<ObjectReference> {
         // If we never move objects, look no further.
-        if super::NEVER_MOVE_OBJECTS {
+        if !self.is_movable() {
             return None;
         }
 
@@ -102,7 +104,7 @@ impl<VM: VMBinding> SFT for ImmixSpace<VM> {
         }
 
         // If we never move objects, look no further.
-        if super::NEVER_MOVE_OBJECTS {
+        if !self.is_movable() {
             return false;
         }
 
@@ -122,7 +124,7 @@ impl<VM: VMBinding> SFT for ImmixSpace<VM> {
         VM::VMObjectModel::LOCAL_PINNING_BIT_SPEC.is_object_pinned::<VM>(object)
     }
     fn is_movable(&self) -> bool {
-        !super::NEVER_MOVE_OBJECTS
+        !self.is_defrag_enabled() && !self.is_nursery_copy_enabled()
     }
 
     #[cfg(feature = "sanity")]
@@ -278,12 +280,13 @@ impl<VM: VMBinding> ImmixSpace<VM> {
         args: crate::policy::space::PlanCreateSpaceArgs<VM>,
         space_args: ImmixSpaceArgs,
     ) -> Self {
-        #[cfg(feature = "immix_non_moving")]
-        info!(
-            "Creating non-moving ImmixSpace: {}. Block size: 2^{}",
-            args.name,
-            Block::LOG_BYTES
-        );
+        if space_args.never_move_objects {
+            info!(
+                "Creating non-moving ImmixSpace: {}. Block size: 2^{}",
+                args.name,
+                Block::LOG_BYTES
+            );
+        }
 
         if space_args.unlog_object_when_traced {
             assert!(
@@ -292,7 +295,18 @@ impl<VM: VMBinding> ImmixSpace<VM> {
             );
         }
 
-        super::validate_features();
+        // validate features
+        if super::BLOCK_ONLY {
+            assert!(
+                space_args.never_move_objects,
+                "Block-only immix must not move objects"
+            );
+        }
+        assert!(
+            Block::LINES / 2 <= u8::MAX as usize - 2,
+            "Number of lines in a block should not exceed BlockState::MARK_MARKED"
+        );
+
         #[cfg(feature = "vo_bit")]
         vo_bit::helper::validate_config::<VM>();
         let vm_map = args.vm_map;
@@ -355,6 +369,9 @@ impl<VM: VMBinding> ImmixSpace<VM> {
         user_triggered_collection: bool,
         full_heap_system_gc: bool,
     ) -> bool {
+        if !self.is_defrag_enabled() {
+            return false;
+        }
         self.defrag.decide_whether_to_defrag(
             emergency_collection,
             collect_whole_heap,
@@ -390,7 +407,7 @@ impl<VM: VMBinding> ImmixSpace<VM> {
             }
 
             // Prepare defrag info
-            if super::DEFRAG {
+            if self.is_defrag_enabled() {
                 self.defrag.prepare(self, plan_stats);
             }
 
@@ -483,7 +500,7 @@ impl<VM: VMBinding> ImmixSpace<VM> {
     /// Return whether this GC was a defrag GC, as a plan may want to know this.
     pub fn end_of_gc(&mut self) -> bool {
         let did_defrag = self.defrag.in_defrag();
-        if super::DEFRAG {
+        if self.is_defrag_enabled() {
             self.defrag.reset_in_defrag();
         }
         did_defrag
@@ -806,8 +823,8 @@ impl<VM: VMBinding> ImmixSpace<VM> {
         Some((start, end))
     }
 
-    pub fn is_last_gc_exhaustive(did_defrag_for_last_gc: bool) -> bool {
-        if super::DEFRAG {
+    pub fn is_last_gc_exhaustive(&self, did_defrag_for_last_gc: bool) -> bool {
+        if self.is_defrag_enabled() {
             did_defrag_for_last_gc
         } else {
             // If defrag is disabled, every GC is exhaustive.
@@ -833,6 +850,18 @@ impl<VM: VMBinding> ImmixSpace<VM> {
             self.mark_lines(object);
         }
     }
+
+    pub(crate) fn prefer_copy_on_nursery_gc(&self) -> bool {
+        self.is_nursery_copy_enabled()
+    }
+
+    pub(crate) fn is_nursery_copy_enabled(&self) -> bool {
+        !self.space_args.never_move_objects
+    }
+
+    pub(crate) fn is_defrag_enabled(&self) -> bool {
+        !self.space_args.never_move_objects
+    }
 }
 
 /// A work packet to prepare each block for a major GC.
@@ -867,7 +896,7 @@ impl<VM: VMBinding> GCWork<VM> for PrepareBlockState<VM> {
                 continue;
             }
             // Check if this block needs to be defragmented.
-            let is_defrag_source = if !super::DEFRAG {
+            let is_defrag_source = if self.space.space_args.never_move_objects {
                 // Do not set any block as defrag source if defrag is disabled.
                 false
             } else if super::DEFRAG_EVERY_BLOCK {
diff --git a/src/policy/immix/mod.rs b/src/policy/immix/mod.rs
@@ -14,9 +14,6 @@ pub const MAX_IMMIX_OBJECT_SIZE: usize = Block::BYTES >> 1;
 /// Mark/sweep memory for block-level only
 pub const BLOCK_ONLY: bool = false;
 
-/// Do we allow Immix to do defragmentation?
-pub const DEFRAG: bool = !cfg!(feature = "immix_non_moving"); // defrag if we are allowed to move.
-
 // STRESS COPYING: Set the feature 'immix_stress_copying' so that Immix will copy as many objects as possible.
 // Useful for debugging copying GC if you cannot use SemiSpace.
 //
@@ -46,28 +43,6 @@ pub const DEFRAG_HEADROOM_PERCENT: usize = if cfg!(feature = "immix_stress_copyi
     2
 };
 
-/// If Immix is used as a nursery space, do we prefer copy?
-pub const PREFER_COPY_ON_NURSERY_GC: bool =
-    !cfg!(feature = "immix_non_moving") && !cfg!(feature = "sticky_immix_non_moving_nursery"); // copy nursery objects if we are allowed to move.
-
-/// In some cases/settings, Immix may never move objects.
-/// Currently we only have two cases where we move objects: 1. defrag, 2. nursery copy.
-/// If we do neither, we will not move objects.
-/// If we have other reasons to move objects, we need to add them here.
-pub const NEVER_MOVE_OBJECTS: bool = !DEFRAG && !PREFER_COPY_ON_NURSERY_GC;
-
 /// Mark lines when scanning objects.
 /// Otherwise, do it at mark time.
 pub const MARK_LINE_AT_SCAN_TIME: bool = true;
-
-macro_rules! validate {
-    ($x: expr) => { assert!($x, stringify!($x)) };
-    ($x: expr => $y: expr) => { if $x { assert!($y, stringify!($x implies $y)) } };
-}
-
-fn validate_features() {
-    // Block-only immix cannot do defragmentation
-    validate!(DEFRAG => !BLOCK_ONLY);
-    // Number of lines in a block should not exceed BlockState::MARK_MARKED
-    assert!(Block::LINES / 2 <= u8::MAX as usize - 2);
-}

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ pub struct Immix<VM: VMBinding> {`
`38`	`38`
`39`	`39`	`/// The plan constraints for the immix plan.`
`40`	`40`	`pub const IMMIX_CONSTRAINTS: PlanConstraints = PlanConstraints {`
`41`		`- moves_objects: crate::policy::immix::DEFRAG,`
	`41`	`+ moves_objects: true,`
`42`	`42`	`// Max immix object size is half of a block.`
`43`	`43`	`max_non_los_default_alloc_bytes: crate::policy::immix::MAX_IMMIX_OBJECT_SIZE,`
`44`	`44`	`needs_prepare_mutator: false,`
`@@ -51,7 +51,8 @@ impl<VM: VMBinding> Plan for Immix<VM> {`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`fn last_collection_was_exhaustive(&self) -> bool {`
`54`		`- ImmixSpace::<VM>::is_last_gc_exhaustive(self.last_gc_was_defrag.load(Ordering::Relaxed))`
	`54`	`+ self.immix_space`
	`55`	`+ .is_last_gc_exhaustive(self.last_gc_was_defrag.load(Ordering::Relaxed))`
`55`	`56`	`}`
`56`	`57`
`57`	`58`	`fn constraints(&self) -> &'static PlanConstraints {`
`@@ -139,6 +140,7 @@ impl<VM: VMBinding> Immix<VM> {`
`139`	`140`	`unlog_object_when_traced: false,`
`140`	`141`	`#[cfg(feature = "vo_bit")]`
`141`	`142`	`mixed_age: false,`
	`143`	`+ never_move_objects: cfg!(feature = "immix_non_moving"),`
`142`	`144`	`},`
`143`	`145`	`)`
`144`	`146`	`}`