Clear side forwarding bits properly

src/policy/copyspace.rs

@@ -168,32 +168,26 @@ impl<VM: VMBinding> CopySpace<VM> {
 
     pub fn prepare(&self, from_space: bool) {
         self.from_space.store(from_space, Ordering::SeqCst);
-        // Clear the metadata if we are using side forwarding status table. Otherwise
-        // objects may inherit forwarding status from the previous GC.
-        // TODO: Fix performance.
-        if let MetadataSpec::OnSide(side_forwarding_status_table) =
-            *<VM::VMObjectModel as ObjectModel<VM>>::LOCAL_FORWARDING_BITS_SPEC
-        {
-            side_forwarding_status_table
-                .bzero_metadata(self.common.start, self.pr.cursor() - self.common.start);
-        }
     }
 
     pub fn release(&self) {
-        unsafe {
+        for (start, size) in self.pr.iterate_allocated_regions() {
+            // Clear the forwarding bits if it is on the side.
+            if let MetadataSpec::OnSide(side_forwarding_status_table) =
+                *<VM::VMObjectModel as ObjectModel<VM>>::LOCAL_FORWARDING_BITS_SPEC
+            {
+                side_forwarding_status_table.bzero_metadata(start, size);
+            }
+
+            // Clear VO bits because all objects in the space are dead.
             #[cfg(feature = "vo_bit")]
-            self.reset_vo_bit();
-            self.pr.reset();
+            crate::util::metadata::vo_bit::bzero_vo_bit(start, size);
         }
-        self.common.metadata.reset();
-        self.from_space.store(false, Ordering::SeqCst);
-    }
 
-    #[cfg(feature = "vo_bit")]
-    unsafe fn reset_vo_bit(&self) {
-        for (start, size) in self.pr.iterate_allocated_regions() {
-            crate::util::metadata::vo_bit::bzero_vo_bit(start, size);
+        unsafe {
+            self.pr.reset();
         }
+        self.from_space.store(false, Ordering::SeqCst);
     }
 
     fn is_from_space(&self) -> bool {

src/policy/immix/immixspace.rs

@@ -841,10 +841,6 @@ impl<VM: VMBinding> PrepareBlockState<VM> {
                 unimplemented!("We cannot bulk zero unlogged bit.")
             }
         }
-        // If the forwarding bits are on the side, we need to clear them, too.
-        if let MetadataSpec::OnSide(side) = *VM::VMObjectModel::LOCAL_FORWARDING_BITS_SPEC {
-            side.bzero_metadata(self.chunk.start(), Chunk::BYTES);
-        }
     }
 }
 
@@ -891,14 +887,17 @@ struct SweepChunk<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> GCWork<VM> for SweepChunk<VM> {
-    fn do_work(&mut self, _worker: &mut GCWorker<VM>, _mmtk: &'static MMTK<VM>) {
+    fn do_work(&mut self, _worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
         let mut histogram = self.space.defrag.new_histogram();
         if self.space.chunk_map.get(self.chunk) == ChunkState::Allocated {
             let line_mark_state = if super::BLOCK_ONLY {
                 None
             } else {
                 Some(self.space.line_mark_state.load(Ordering::Acquire))
             };
+            // Hints for clearing side forwarding bits.
+            let is_moving_gc = mmtk.get_plan().current_gc_may_move_object();
+            let is_defrag_gc = self.space.defrag.in_defrag();
             // number of allocated blocks.
             let mut allocated_blocks = 0;
             // Iterate over all allocated blocks in this chunk.
@@ -911,6 +910,17 @@ impl<VM: VMBinding> GCWork<VM> for SweepChunk<VM> {
                     // Block is live. Increment the allocated block count.
                     allocated_blocks += 1;
                 }
+
+                // Clear side forwarding bits.
+                // In the beginning of the next GC, no side forwarding bits shall be set.
+                if let MetadataSpec::OnSide(side) = *VM::VMObjectModel::LOCAL_FORWARDING_BITS_SPEC {
+                    if is_moving_gc {
+                        let objects_may_move = !is_defrag_gc || block.is_defrag_source();
+                        if objects_may_move {
+                            side.bzero_metadata(block.start(), Block::BYTES);
+                        }
+                    }
+                }
             }
             // Set this chunk as free if there is not live blocks.
             if allocated_blocks == 0 {

src/util/metadata/side_metadata/global.rs

@@ -1080,8 +1080,6 @@ impl SideMetadataContext {
         total
     }
 
-    pub fn reset(&self) {}
-
     // ** NOTE: **
     //  Regardless of the number of bits in a metadata unit, we always represent its content as a word.