Rename initialize_header to initialize_object_metadata (#316)

Author: qinsoon

src/plan/mutator_context.rs

@@ -77,7 +77,7 @@ impl<VM: VMBinding> MutatorContext<VM> for Mutator<VM> {
                 .get_allocator_mut(self.config.allocator_mapping[allocator])
         }
         .get_space()
-        .initialize_header(refer, true)
+        .initialize_object_metadata(refer, true)
     }
 
     fn get_tls(&self) -> VMMutatorThread {

src/policy/copyspace.rs

@@ -37,7 +37,7 @@ impl<VM: VMBinding> SFT for CopySpace<VM> {
     fn is_sane(&self) -> bool {
         !self.from_space()
     }
-    fn initialize_header(&self, _object: ObjectReference, _alloc: bool) {}
+    fn initialize_object_metadata(&self, _object: ObjectReference, _alloc: bool) {}
 }
 
 impl<VM: VMBinding> Space<VM> for CopySpace<VM> {

src/policy/immortalspace.rs

@@ -45,7 +45,7 @@ impl<VM: VMBinding> SFT for ImmortalSpace<VM> {
     fn is_sane(&self) -> bool {
         true
     }
-    fn initialize_header(&self, object: ObjectReference, _alloc: bool) {
+    fn initialize_object_metadata(&self, object: ObjectReference, _alloc: bool) {
         let old_value = gc_byte::read_gc_byte::<VM>(object);
         let mut new_value = (old_value & GC_MARK_BIT_MASK) | self.mark_state;
         if self.header_byte.needs_unlogged_bit {

src/policy/largeobjectspace.rs

@@ -50,7 +50,7 @@ impl<VM: VMBinding> SFT for LargeObjectSpace<VM> {
     fn is_sane(&self) -> bool {
         true
     }
-    fn initialize_header(&self, object: ObjectReference, alloc: bool) {
+    fn initialize_object_metadata(&self, object: ObjectReference, alloc: bool) {
         let old_value = gc_byte::read_gc_byte::<VM>(object);
         let mut new_value = (old_value & (!LOS_BIT_MASK)) | self.mark_state;
         if alloc {

src/policy/lockfreeimmortalspace.rs

@@ -54,7 +54,7 @@ impl<VM: VMBinding> SFT for LockFreeImmortalSpace<VM> {
     fn is_sane(&self) -> bool {
         unimplemented!()
     }
-    fn initialize_header(&self, _object: ObjectReference, _alloc: bool) {
+    fn initialize_object_metadata(&self, _object: ObjectReference, _alloc: bool) {
         unimplemented!()
     }
 }

src/policy/mallocspace/global.rs

@@ -52,8 +52,8 @@ impl<VM: VMBinding> SFT for MallocSpace<VM> {
     fn is_sane(&self) -> bool {
         true
     }
-    fn initialize_header(&self, object: ObjectReference, _alloc: bool) {
-        trace!("initialize_header for object {}", object);
+    fn initialize_object_metadata(&self, object: ObjectReference, _alloc: bool) {
+        trace!("initialize_object_metadata for object {}", object);
         set_alloc_bit(object);
     }
 }

src/policy/space.rs

@@ -28,33 +28,38 @@ use std::marker::PhantomData;
 
 use downcast_rs::Downcast;
 
-/**
- * Space Function Table (SFT).
- *
- * This trait captures functions that reflect _space-specific per-object
- * semantics_.   These functions are implemented for each object via a special
- * space-based dynamic dispatch mechanism where the semantics are _not_
- * determined by the object's _type_, but rather, are determined by the _space_
- * that the object is in.
- *
- * The underlying mechanism exploits the fact that spaces use the address space
- * at an MMTk chunk granularity with the consequence that each chunk maps to
- * exactluy one space, so knowing the chunk for an object reveals its space.
- * The dispatch then works by performing simple address arithmetic on the object
- * reference to find a chunk index which is used to index a table which returns
- * the space.   The relevant function is then dispatched against that space
- * object.
- *
- * We use the SFT trait to simplify typing for Rust, so our table is a
- * table of SFT rather than Space.
- */
+/// Space Function Table (SFT).
+///
+/// This trait captures functions that reflect _space-specific per-object
+/// semantics_.   These functions are implemented for each object via a special
+/// space-based dynamic dispatch mechanism where the semantics are _not_
+/// determined by the object's _type_, but rather, are determined by the _space_
+/// that the object is in.
+///
+/// The underlying mechanism exploits the fact that spaces use the address space
+/// at an MMTk chunk granularity with the consequence that each chunk maps to
+/// exactluy one space, so knowing the chunk for an object reveals its space.
+/// The dispatch then works by performing simple address arithmetic on the object
+/// reference to find a chunk index which is used to index a table which returns
+/// the space.   The relevant function is then dispatched against that space
+/// object.
+///
+/// We use the SFT trait to simplify typing for Rust, so our table is a
+/// table of SFT rather than Space.
 pub trait SFT {
+    /// The space name
     fn name(&self) -> &str;
+    /// Is the object live, determined by the policy?
     fn is_live(&self, object: ObjectReference) -> bool;
+    /// Is the object movable, determined by the policy? E.g. the policy is non-moving,
+    /// or the object is pinned.
     fn is_movable(&self) -> bool;
+    /// Is the object sane? A policy should return false if there is any abnormality about
+    /// object - the sanity checker will fail if an object is not sane.
     #[cfg(feature = "sanity")]
     fn is_sane(&self) -> bool;
-    fn initialize_header(&self, object: ObjectReference, alloc: bool);
+    /// Initialize object metadata (in the header, or in the side metadata).
+    fn initialize_object_metadata(&self, object: ObjectReference, alloc: bool);
 }
 
 /// Print debug info for SFT. Should be false when committed.
@@ -91,9 +96,9 @@ impl SFT for EmptySpaceSFT {
         false
     }
 
-    fn initialize_header(&self, object: ObjectReference, _alloc: bool) {
+    fn initialize_object_metadata(&self, object: ObjectReference, _alloc: bool) {
         panic!(
-            "Called initialize_header() on {:x}, which maps to an empty space",
+            "Called initialize_object_metadata() on {:x}, which maps to an empty space",
             object
         )
     }