Let FreeListPageResource hold FreeList in sync

src/mmtk.rs

@@ -119,7 +119,7 @@ impl<VM: VMBinding> MMTK<VM> {
 
         let scheduler = GCWorkScheduler::new(num_workers, (*options.thread_affinity).clone());
 
-        let plan = crate::plan::create_plan(
+        let mut plan = crate::plan::create_plan(
             *options.plan,
             VM_MAP.as_ref(),
             MMAPPER.as_ref(),
@@ -128,11 +128,13 @@ impl<VM: VMBinding> MMTK<VM> {
         );
 
         // TODO: This probably does not work if we have multiple MMTk instances.
-        VM_MAP.boot();
         // This needs to be called after we create Plan. It needs to use HeapMeta, which is gradually built when we create spaces.
         VM_MAP.finalize_static_space_map(
             plan.base().heap.get_discontig_start(),
             plan.base().heap.get_discontig_end(),
+            &mut |start| {
+                plan.update_discontiguous_page_resources(start);
+            },
         );
 
         if *options.transparent_hugepages {

src/plan/global.rs

@@ -25,7 +25,7 @@ use crate::util::metadata::side_metadata::SideMetadataSpec;
 use crate::util::options::Options;
 use crate::util::options::PlanSelector;
 use crate::util::statistics::stats::Stats;
-use crate::util::{conversions, ObjectReference};
+use crate::util::{conversions, Address, ObjectReference};
 use crate::util::{VMMutatorThread, VMWorkerThread};
 use crate::vm::*;
 use downcast_rs::Downcast;
@@ -371,6 +371,14 @@ pub trait Plan: 'static + HasSpaces + Sync + Downcast {
         true
     }
 
+    fn update_discontiguous_page_resources(&mut self, start: Address) {
+        self.for_each_space_mut(&mut |space: &mut dyn Space<Self::VM>| {
+            space.for_each_page_resource_mut(&mut |pr| {
+                pr.update_discontiguous_start(start);
+            });
+        });
+    }
+
     /// Call `space.verify_side_metadata_sanity` for all spaces in this plan.
     fn verify_side_metadata_sanity(&self) {
         let mut side_metadata_sanity_checker = SideMetadataSanity::new();

src/policy/copyspace.rs

@@ -102,6 +102,10 @@ impl<VM: VMBinding> Space<VM> for CopySpace<VM> {
         &self.pr
     }
 
+    fn for_each_page_resource_mut(&mut self, f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        f(&mut self.pr);
+    }
+
     fn common(&self) -> &CommonSpace<VM> {
         &self.common
     }

src/policy/immix/immixspace.rs

@@ -170,6 +170,9 @@ impl<VM: VMBinding> Space<VM> for ImmixSpace<VM> {
     fn get_page_resource(&self) -> &dyn PageResource<VM> {
         &self.pr
     }
+    fn for_each_page_resource_mut(&mut self, f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        f(&mut self.pr);
+    }
     fn common(&self) -> &CommonSpace<VM> {
         &self.common
     }

src/policy/immortalspace.rs

@@ -87,6 +87,9 @@ impl<VM: VMBinding> Space<VM> for ImmortalSpace<VM> {
     fn get_page_resource(&self) -> &dyn PageResource<VM> {
         &self.pr
     }
+    fn for_each_page_resource_mut(&mut self, f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        f(&mut self.pr);
+    }
     fn common(&self) -> &CommonSpace<VM> {
         &self.common
     }

src/policy/largeobjectspace.rs

@@ -106,6 +106,9 @@ impl<VM: VMBinding> Space<VM> for LargeObjectSpace<VM> {
     fn get_page_resource(&self) -> &dyn PageResource<VM> {
         &self.pr
     }
+    fn for_each_page_resource_mut(&mut self, f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        f(&mut self.pr);
+    }
 
     fn initialize_sft(&self, sft_map: &mut dyn crate::policy::sft_map::SFTMap) {
         self.common().initialize_sft(self.as_sft(), sft_map)

src/policy/lockfreeimmortalspace.rs

@@ -95,6 +95,10 @@ impl<VM: VMBinding> Space<VM> for LockFreeImmortalSpace<VM> {
     fn get_page_resource(&self) -> &dyn PageResource<VM> {
         unimplemented!()
     }
+    fn for_each_page_resource_mut(&mut self, _f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        // We have no page resources!
+    }
+
     fn common(&self) -> &CommonSpace<VM> {
         unimplemented!()
     }

src/policy/markcompactspace.rs

@@ -109,6 +109,10 @@ impl<VM: VMBinding> Space<VM> for MarkCompactSpace<VM> {
         &self.pr
     }
 
+    fn for_each_page_resource_mut(&mut self, f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        f(&mut self.pr);
+    }
+
     fn common(&self) -> &CommonSpace<VM> {
         &self.common
     }

src/policy/marksweepspace/malloc_ms/global.rs

@@ -137,6 +137,10 @@ impl<VM: VMBinding> Space<VM> for MallocSpace<VM> {
         unreachable!()
     }
 
+    fn for_each_page_resource_mut(&mut self, _f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        // We have no page resources!
+    }
+
     fn common(&self) -> &CommonSpace<VM> {
         unreachable!()
     }

src/policy/marksweepspace/native_ms/global.rs

@@ -7,7 +7,7 @@ use crate::{
     scheduler::{GCWorkScheduler, GCWorker},
     util::{
         copy::CopySemantics,
-        heap::FreeListPageResource,
+        heap::{FreeListPageResource, PageResource},
         metadata::{self, side_metadata::SideMetadataSpec, MetadataSpec},
         ObjectReference,
     },
@@ -152,10 +152,14 @@ impl<VM: VMBinding> Space<VM> for MarkSweepSpace<VM> {
         self
     }
 
-    fn get_page_resource(&self) -> &dyn crate::util::heap::PageResource<VM> {
+    fn get_page_resource(&self) -> &dyn PageResource<VM> {
         &self.pr
     }
 
+    fn for_each_page_resource_mut(&mut self, f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        f(&mut self.pr);
+    }
+
     fn initialize_sft(&self, sft_map: &mut dyn crate::policy::sft_map::SFTMap) {
         self.common().initialize_sft(self.as_sft(), sft_map)
     }

src/policy/space.rs

@@ -39,8 +39,13 @@ use downcast_rs::Downcast;
 pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
     fn as_space(&self) -> &dyn Space<VM>;
     fn as_sft(&self) -> &(dyn SFT + Sync + 'static);
+
+    // TODO: Generate this function automatically in mmtk-macros like PlanTraceObject.
     fn get_page_resource(&self) -> &dyn PageResource<VM>;
 
+    // TODO: Generate this function automatically in mmtk-macros like PlanTraceObject.
+    fn for_each_page_resource_mut(&mut self, f: &mut dyn FnMut(&mut dyn PageResource<VM>));
+
     /// Initialize entires in SFT map for the space. This is called when the Space object
     /// has a non-moving address, as we will use the address to set sft.
     /// Currently after we create a boxed plan, spaces in the plan have a non-moving address.

src/policy/vmspace.rs

@@ -87,6 +87,9 @@ impl<VM: VMBinding> Space<VM> for VMSpace<VM> {
     fn get_page_resource(&self) -> &dyn PageResource<VM> {
         &self.pr
     }
+    fn for_each_page_resource_mut(&mut self, f: &mut dyn FnMut(&mut dyn PageResource<VM>)) {
+        f(&mut self.pr)
+    }
     fn common(&self) -> &CommonSpace<VM> {
         &self.common
     }

src/util/freelist.rs

@@ -14,7 +14,12 @@ const MULTI_MASK: i32 = 1 << (TOTAL_BITS - 1);
 const COALESC_MASK: i32 = 1 << (TOTAL_BITS - 2);
 const SIZE_MASK: i32 = (1 << UNIT_BITS) - 1;
 
-pub trait FreeList: Sync + Downcast {
+// TODO: FreeList should not implement Sync.
+// FreeList instances are not thread-safe.
+// They need external synchronisation (e.g. using Mutex).
+// On the other hand, to put FreeList into a Mutex<T>, FreeList must implement Send.
+// There is no problem sending FreeList instances between threads.
+pub trait FreeList: Sync + Send + Downcast {
     fn head(&self) -> i32;
     // fn head_mut(&mut self) -> &mut i32;
     fn heads(&self) -> i32;

src/util/heap/blockpageresource.rs

@@ -36,6 +36,10 @@ impl<VM: VMBinding, B: Region> PageResource<VM> for BlockPageResource<VM, B> {
         self.flpr.common_mut()
     }
 
+    fn update_discontiguous_start(&mut self, start: Address) {
+        self.flpr.update_discontiguous_start(start);
+    }
+
     fn alloc_pages(
         &self,
         space_descriptor: SpaceDescriptor,