Remove fl_map and refactor FreeListPageResoure

src/mmtk.rs

@@ -162,7 +162,7 @@ impl<VM: VMBinding> MMTK<VM> {
         // So we do not save it in MMTK. This may change in the future.
         let mut heap = HeapMeta::new();
 
-        let plan = crate::plan::create_plan(
+        let mut plan = crate::plan::create_plan(
             *options.plan,
             CreateGeneralPlanArgs {
                 vm_map: VM_MAP.as_ref(),
@@ -188,9 +188,20 @@ 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(heap.get_discontig_start(), heap.get_discontig_end());
+        VM_MAP.finalize_static_space_map(
+            heap.get_discontig_start(),
+            heap.get_discontig_end(),
+            &mut |start_address| {
+                plan.for_each_space_mut(&mut |space| {
+                    // If the `VMMap` has a discontiguous memory range, we notify all discontiguous
+                    // space that the starting address has been determined.
+                    if let Some(pr) = space.maybe_get_page_resource_mut() {
+                        pr.update_discontiguous_start(start_address);
+                    }
+                })
+            },
+        );
 
         if *options.transparent_hugepages {
             MMAPPER.set_mmap_strategy(crate::util::memory::MmapStrategy::TransparentHugePages);

src/policy/copyspace.rs

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

src/policy/immix/immixspace.rs

@@ -162,6 +162,9 @@ impl<VM: VMBinding> Space<VM> for ImmixSpace<VM> {
     fn get_page_resource(&self) -> &dyn PageResource<VM> {
         &self.pr
     }
+    fn maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>> {
+        Some(&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 maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>> {
+        Some(&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 maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>> {
+        Some(&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

@@ -97,6 +97,9 @@ impl<VM: VMBinding> Space<VM> for LockFreeImmortalSpace<VM> {
     fn get_page_resource(&self) -> &dyn PageResource<VM> {
         unimplemented!()
     }
+    fn maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>> {
+        None
+    }
     fn common(&self) -> &CommonSpace<VM> {
         unimplemented!()
     }

src/policy/markcompactspace.rs

@@ -104,6 +104,10 @@ impl<VM: VMBinding> Space<VM> for MarkCompactSpace<VM> {
         &self.pr
     }
 
+    fn maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>> {
+        Some(&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 maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>> {
+        None
+    }
+
     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,
     },
@@ -209,6 +209,10 @@ impl<VM: VMBinding> Space<VM> for MarkSweepSpace<VM> {
         &self.pr
     }
 
+    fn maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>> {
+        Some(&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

@@ -42,6 +42,10 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
     fn as_sft(&self) -> &(dyn SFT + Sync + 'static);
     fn get_page_resource(&self) -> &dyn PageResource<VM>;
 
+    /// Get a mutable reference to the underlying page resource, or `None` if the space does not
+    /// have a page resource.
+    fn maybe_get_page_resource_mut(&mut self) -> Option<&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 maybe_get_page_resource_mut(&mut self) -> Option<&mut dyn PageResource<VM>> {
+        Some(&mut self.pr)
+    }
     fn common(&self) -> &CommonSpace<VM> {
         &self.common
     }

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,