Reset in-defrag state in end-of-gc

Author: wks

src/plan/generational/immix/global.rs

@@ -137,10 +137,7 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
         let full_heap = !self.gen.is_current_gc_nursery();
         self.gen.release(tls);
         if full_heap {
-            let did_defrag = self.immix_space.release(full_heap);
-            self.last_gc_was_defrag.store(did_defrag, Ordering::Relaxed);
-        } else {
-            self.last_gc_was_defrag.store(false, Ordering::Relaxed);
+            self.immix_space.release(full_heap);
         }
         self.last_gc_was_full_heap
             .store(full_heap, Ordering::Relaxed);
@@ -149,6 +146,9 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
     fn end_of_gc(&mut self, _tls: VMWorkerThread) {
         self.gen
             .set_next_gc_full_heap(CommonGenPlan::should_next_gc_be_full_heap(self));
+
+        let did_defrag = self.immix_space.end_of_gc();
+        self.last_gc_was_defrag.store(did_defrag, Ordering::Relaxed);
     }
 
     fn current_gc_may_move_object(&self) -> bool {

src/plan/global.rs

@@ -302,6 +302,10 @@ pub trait Plan: 'static + HasSpaces + Sync + Downcast {
     /// Return whether the current GC may move any object.  The VM binding can make use of this
     /// information and choose to or not to update some data structures that record the addresses
     /// of objects.
+    ///
+    /// This function is callable during a GC.  From the VM binding's point of view, the information
+    /// of whether the current GC is a defrag GC is available since `Collection::stop_mutators` is
+    /// called, and remains available until `resume_mutators`.
     fn current_gc_may_move_object(&self) -> bool;
 
     /// An object is firstly reached by a sanity GC. So the object is reachable

src/plan/immix/global.rs

@@ -93,8 +93,12 @@ impl<VM: VMBinding> Plan for Immix<VM> {
     fn release(&mut self, tls: VMWorkerThread) {
         self.common.release(tls, true);
         // release the collected region
+        self.immix_space.release(true);
+    }
+
+    fn end_of_gc(&mut self, _tls: VMWorkerThread) {
         self.last_gc_was_defrag
-            .store(self.immix_space.release(true), Ordering::Relaxed);
+            .store(self.immix_space.end_of_gc(), Ordering::Relaxed);
     }
 
     fn current_gc_may_move_object(&self) -> bool {

src/plan/sticky/immix/global.rs

@@ -126,9 +126,6 @@ impl<VM: VMBinding> Plan for StickyImmix<VM> {
 
     fn release(&mut self, tls: crate::util::VMWorkerThread) {
         if self.is_current_gc_nursery() {
-            let was_defrag = self.immix.immix_space.release(false);
-            self.immix
-                .set_last_gc_was_defrag(was_defrag, Ordering::Relaxed);
             self.immix.common.los.release(false);
         } else {
             self.immix.release(tls);
@@ -140,6 +137,10 @@ impl<VM: VMBinding> Plan for StickyImmix<VM> {
             crate::plan::generational::global::CommonGenPlan::should_next_gc_be_full_heap(self);
         self.next_gc_full_heap
             .store(next_gc_full_heap, Ordering::Relaxed);
+
+        let was_defrag = self.immix.immix_space.end_of_gc();
+        self.immix
+            .set_last_gc_was_defrag(was_defrag, Ordering::Relaxed);
     }
 
     fn collection_required(&self, space_full: bool, space: Option<SpaceStats<Self::VM>>) -> bool {

src/policy/immix/defrag.rs

@@ -205,9 +205,9 @@ impl Defrag {
             .store(threshold, Ordering::Release);
     }
 
-    /// Release work. Should be called in ImmixSpace::release.
+    /// Reset the in-defrag state.
     #[allow(clippy::assertions_on_constants)]
-    pub fn release<VM: VMBinding>(&self, _space: &ImmixSpace<VM>) {
+    pub fn reset_in_defrag(&self) {
         debug_assert!(super::DEFRAG);
         self.in_defrag_collection.store(false, Ordering::Release);
     }

src/policy/immix/immixspace.rs

@@ -440,12 +440,10 @@ impl<VM: VMBinding> ImmixSpace<VM> {
         }
     }
 
-    /// Release for the immix space. This is called when a GC finished.
-    /// Return whether this GC was a defrag GC, as a plan may want to know this.
-    pub fn release(&mut self, major_gc: bool) -> bool {
-        let did_defrag = self.defrag.in_defrag();
+    /// Release for the immix space.
+    pub fn release(&mut self, major_gc: bool) {
         if major_gc {
-            // Update line_unavail_state for hole searching afte this GC.
+            // Update line_unavail_state for hole searching after this GC.
             if !super::BLOCK_ONLY {
                 self.line_unavail_state.store(
                     self.line_mark_state.load(Ordering::Acquire),
@@ -460,12 +458,17 @@ impl<VM: VMBinding> ImmixSpace<VM> {
         // Sweep chunks and blocks
         let work_packets = self.generate_sweep_tasks();
         self.scheduler().work_buckets[WorkBucketStage::Release].bulk_add(work_packets);
-        if super::DEFRAG {
-            self.defrag.release(self);
-        }
 
         self.lines_consumed.store(0, Ordering::Relaxed);
+    }
 
+    /// This is called when a GC finished.
+    /// 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 {
+            self.defrag.reset_in_defrag();
+        }
         did_defrag
     }