Two step space creation

src/mmtk.rs

@@ -12,15 +12,15 @@ use crate::util::analysis::AnalysisManager;
 use crate::util::edge_logger::EdgeLogger;
 use crate::util::finalizable_processor::FinalizableProcessor;
 use crate::util::heap::gc_trigger::GCTrigger;
+use crate::util::heap::heap_meta::HeapMeta;
 use crate::util::heap::layout::vm_layout::VMLayout;
 use crate::util::heap::layout::{self, Mmapper, VMMap};
-use crate::util::heap::HeapMeta;
-use crate::util::opaque_pointer::*;
 use crate::util::options::Options;
 use crate::util::reference_processor::ReferenceProcessors;
 #[cfg(feature = "sanity")]
 use crate::util::sanity::sanity_checker::SanityChecker;
 use crate::util::statistics::stats::Stats;
+use crate::util::{opaque_pointer::*, Address};
 use crate::vm::ReferenceGlue;
 use crate::vm::VMBinding;
 use std::cell::UnsafeCell;
@@ -188,8 +188,14 @@ 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());
+
+        // `Map32` uses `finalize_static_space_map` this to initialize the global freelists, which is reasonable.
+        // `Map64` uses `finalize_static_space_map` this to fix the starting addresses of `RawMemoryFreeList` instances, which is a bug and should be fixed.
+        // Since `Map64` doesn't read the start and end of the discontiguous range in the function at all, we can leave them as zeroes.
+        let discontig_range = heap
+            .get_discontiguous_range()
+            .unwrap_or(Address::ZERO..Address::ZERO);
+        VM_MAP.finalize_static_space_map(discontig_range.start, discontig_range.end);
 
         if *options.transparent_hugepages {
             MMAPPER.set_mmap_strategy(crate::util::memory::MmapStrategy::TransparentHugePages);

src/plan/generational/copying/global.rs

@@ -16,7 +16,7 @@ use crate::policy::space::Space;
 use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;
 use crate::util::copy::*;
-use crate::util::heap::VMRequest;
+use crate::util::heap::heap_meta::SpaceSpec;
 use crate::util::Address;
 use crate::util::ObjectReference;
 use crate::util::VMWorkerThread;
@@ -200,17 +200,29 @@ impl<VM: VMBinding> GenCopy<VM> {
                 crate::plan::generational::new_generational_global_metadata_specs::<VM>(),
         };
 
+        let copyspace0_spec = plan_args
+            .global_args
+            .heap
+            .specify_space(SpaceSpec::DontCare);
+        let copyspace1_spec = plan_args
+            .global_args
+            .heap
+            .specify_space(SpaceSpec::DontCare);
+
+        // Spaces will eventually be placed by `BasePlan`.
+        let gen = CommonGenPlan::new(&mut plan_args);
+
         let copyspace0 = CopySpace::new(
-            plan_args.get_space_args("copyspace0", true, VMRequest::discontiguous()),
+            plan_args.get_space_args("copyspace0", true, copyspace0_spec.unwrap()),
             false,
         );
         let copyspace1 = CopySpace::new(
-            plan_args.get_space_args("copyspace1", true, VMRequest::discontiguous()),
+            plan_args.get_space_args("copyspace1", true, copyspace1_spec.unwrap()),
             true,
         );
 
         let res = GenCopy {
-            gen: CommonGenPlan::new(plan_args),
+            gen,
             hi: AtomicBool::new(false),
             copyspace0,
             copyspace1,

src/plan/generational/global.rs

@@ -6,7 +6,7 @@ use crate::policy::copyspace::CopySpace;
 use crate::policy::space::Space;
 use crate::scheduler::*;
 use crate::util::copy::CopySemantics;
-use crate::util::heap::VMRequest;
+use crate::util::heap::heap_meta::SpaceSpec;
 use crate::util::statistics::counter::EventCounter;
 use crate::util::Address;
 use crate::util::ObjectReference;
@@ -37,20 +37,24 @@ pub struct CommonGenPlan<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> CommonGenPlan<VM> {
-    pub fn new(mut args: CreateSpecificPlanArgs<VM>) -> Self {
+    pub fn new(args: &mut CreateSpecificPlanArgs<VM>) -> Self {
+        let nursery_spec = args.global_args.heap.specify_space(SpaceSpec::Extent {
+            extent: args.global_args.options.get_max_nursery_bytes(),
+            top: false,
+        });
+
+        // Spaces will eventually be placed by `BasePlan`.
+        let common = CommonPlan::new(args);
+
         let nursery = CopySpace::new(
-            args.get_space_args(
-                "nursery",
-                true,
-                VMRequest::fixed_extent(args.global_args.options.get_max_nursery_bytes(), false),
-            ),
+            args.get_space_args("nursery", true, nursery_spec.unwrap()),
             true,
         );
+
         let full_heap_gc_count = args
             .global_args
             .stats
             .new_event_counter("majorGC", true, true);
-        let common = CommonPlan::new(args);
 
         CommonGenPlan {
             nursery,

src/plan/generational/immix/global.rs

@@ -17,7 +17,7 @@ use crate::scheduler::GCWorkScheduler;
 use crate::scheduler::GCWorker;
 use crate::util::alloc::allocators::AllocatorSelector;
 use crate::util::copy::*;
-use crate::util::heap::VMRequest;
+use crate::util::heap::heap_meta::SpaceSpec;
 use crate::util::Address;
 use crate::util::ObjectReference;
 use crate::util::VMWorkerThread;
@@ -231,8 +231,17 @@ impl<VM: VMBinding> GenImmix<VM> {
             global_side_metadata_specs:
                 crate::plan::generational::new_generational_global_metadata_specs::<VM>(),
         };
+
+        let immix_space_spec = plan_args
+            .global_args
+            .heap
+            .specify_space(SpaceSpec::DontCare);
+
+        // Spaces will eventually be placed by `BasePlan`.
+        let gen = CommonGenPlan::new(&mut plan_args);
+
         let immix_space = ImmixSpace::new(
-            plan_args.get_space_args("immix_mature", true, VMRequest::discontiguous()),
+            plan_args.get_space_args("immix_mature", true, immix_space_spec.unwrap()),
             ImmixSpaceArgs {
                 reset_log_bit_in_major_gc: false,
                 // We don't need to unlog objects at tracing. Instead, we unlog objects at copying.
@@ -244,7 +253,7 @@ impl<VM: VMBinding> GenImmix<VM> {
         );
 
         let genimmix = GenImmix {
-            gen: CommonGenPlan::new(plan_args),
+            gen,
             immix_space,
             last_gc_was_defrag: AtomicBool::new(false),
             last_gc_was_full_heap: AtomicBool::new(false),

src/plan/global.rs

@@ -14,10 +14,9 @@ use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;
 use crate::util::copy::{CopyConfig, GCWorkerCopyContext};
 use crate::util::heap::gc_trigger::GCTrigger;
+use crate::util::heap::heap_meta::{HeapMeta, SpaceMeta, SpaceSpec};
 use crate::util::heap::layout::Mmapper;
 use crate::util::heap::layout::VMMap;
-use crate::util::heap::HeapMeta;
-use crate::util::heap::VMRequest;
 use crate::util::metadata::side_metadata::SideMetadataSanity;
 use crate::util::metadata::side_metadata::SideMetadataSpec;
 use crate::util::options::Options;
@@ -366,16 +365,15 @@ impl<'a, VM: VMBinding> CreateSpecificPlanArgs<'a, VM> {
         &mut self,
         name: &'static str,
         zeroed: bool,
-        vmrequest: VMRequest,
+        space_meta: SpaceMeta,
     ) -> PlanCreateSpaceArgs<VM> {
         PlanCreateSpaceArgs {
             name,
             zeroed,
-            vmrequest,
+            space_meta,
             global_side_metadata_specs: self.global_side_metadata_specs.clone(),
             vm_map: self.global_args.vm_map,
             mmapper: self.global_args.mmapper,
-            heap: self.global_args.heap,
             constraints: self.constraints,
             gc_trigger: self.global_args.gc_trigger.clone(),
             scheduler: self.global_args.scheduler.clone(),
@@ -387,36 +385,47 @@ impl<'a, VM: VMBinding> CreateSpecificPlanArgs<'a, VM> {
 
 impl<VM: VMBinding> BasePlan<VM> {
     #[allow(unused_mut)] // 'args' only needs to be mutable for certain features
-    pub fn new(mut args: CreateSpecificPlanArgs<VM>) -> BasePlan<VM> {
+    pub fn new(args: &mut CreateSpecificPlanArgs<VM>) -> BasePlan<VM> {
+        #[cfg(feature = "code_space")]
+        let code_space_spec = args.global_args.heap.specify_space(SpaceSpec::DontCare);
+        #[cfg(feature = "code_space")]
+        let code_lo_space_spec = args.global_args.heap.specify_space(SpaceSpec::DontCare);
+        #[cfg(feature = "ro_space")]
+        let ro_space_spec = args.global_args.heap.specify_space(SpaceSpec::DontCare);
+        // NOTE: We don't specify VM space because it doesn't use SpaceMeta anyway.
+
+        // BasePlan does not have any nested structs with spaces.  We now place spaces.
+        args.global_args.heap.place_spaces();
+
         BasePlan {
             #[cfg(feature = "code_space")]
             code_space: ImmortalSpace::new(args.get_space_args(
                 "code_space",
                 true,
-                VMRequest::discontiguous(),
+                code_space_spec.unwrap(),
             )),
             #[cfg(feature = "code_space")]
             code_lo_space: ImmortalSpace::new(args.get_space_args(
                 "code_lo_space",
                 true,
-                VMRequest::discontiguous(),
+                code_lo_space_spec.unwrap(),
             )),
             #[cfg(feature = "ro_space")]
             ro_space: ImmortalSpace::new(args.get_space_args(
                 "ro_space",
                 true,
-                VMRequest::discontiguous(),
+                ro_space_spec.unwrap(),
             )),
             #[cfg(feature = "vm_space")]
             vm_space: VMSpace::new(args.get_space_args(
                 "vm_space",
                 false,
-                VMRequest::discontiguous(),
+                SpaceMeta::vm_space_dummy(),
             )),
 
             global_state: args.global_args.state.clone(),
-            gc_trigger: args.global_args.gc_trigger,
-            options: args.global_args.options,
+            gc_trigger: args.global_args.gc_trigger.clone(),
+            options: args.global_args.options.clone(),
         }
     }
 
@@ -550,23 +559,26 @@ pub struct CommonPlan<VM: VMBinding> {
 }
 
 impl<VM: VMBinding> CommonPlan<VM> {
-    pub fn new(mut args: CreateSpecificPlanArgs<VM>) -> CommonPlan<VM> {
+    pub fn new(args: &mut CreateSpecificPlanArgs<VM>) -> CommonPlan<VM> {
+        let immortal_spec = args.global_args.heap.specify_space(SpaceSpec::DontCare);
+        let los_spec = args.global_args.heap.specify_space(SpaceSpec::DontCare);
+        let nonmoving_spec = args.global_args.heap.specify_space(SpaceSpec::DontCare);
+
+        let base = BasePlan::new(args);
+
         CommonPlan {
             immortal: ImmortalSpace::new(args.get_space_args(
                 "immortal",
                 true,
-                VMRequest::discontiguous(),
+                immortal_spec.unwrap(),
             )),
-            los: LargeObjectSpace::new(
-                args.get_space_args("los", true, VMRequest::discontiguous()),
-                false,
-            ),
+            los: LargeObjectSpace::new(args.get_space_args("los", true, los_spec.unwrap()), false),
             nonmoving: ImmortalSpace::new(args.get_space_args(
                 "nonmoving",
                 true,
-                VMRequest::discontiguous(),
+                nonmoving_spec.unwrap(),
             )),
-            base: BasePlan::new(args),
+            base,
         }
     }
 

src/plan/immix/global.rs

@@ -13,7 +13,7 @@ use crate::policy::space::Space;
 use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;
 use crate::util::copy::*;
-use crate::util::heap::VMRequest;
+use crate::util::heap::heap_meta::SpaceSpec;
 use crate::util::metadata::side_metadata::SideMetadataContext;
 use crate::vm::VMBinding;
 use crate::{policy::immix::ImmixSpace, util::opaque_pointer::VMWorkerThread};
@@ -140,12 +140,20 @@ impl<VM: VMBinding> Immix<VM> {
         mut plan_args: CreateSpecificPlanArgs<VM>,
         space_args: ImmixSpaceArgs,
     ) -> Self {
+        let immix_space_spec = plan_args
+            .global_args
+            .heap
+            .specify_space(SpaceSpec::DontCare);
+
+        // Spaces will eventually be placed by `BasePlan`.
+        let common = CommonPlan::new(&mut plan_args);
+
         let immix = Immix {
             immix_space: ImmixSpace::new(
-                plan_args.get_space_args("immix", true, VMRequest::discontiguous()),
+                plan_args.get_space_args("immix", true, immix_space_spec.unwrap()),
                 space_args,
             ),
-            common: CommonPlan::new(plan_args),
+            common,
             last_gc_was_defrag: AtomicBool::new(false),
         };
 

src/plan/markcompact/global.rs

@@ -15,7 +15,7 @@ use crate::scheduler::gc_work::*;
 use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;
 use crate::util::copy::CopySemantics;
-use crate::util::heap::VMRequest;
+use crate::util::heap::heap_meta::SpaceSpec;
 use crate::util::metadata::side_metadata::SideMetadataContext;
 #[cfg(not(feature = "vo_bit"))]
 use crate::util::metadata::vo_bit::VO_BIT_SIDE_METADATA_SPEC;
@@ -192,13 +192,18 @@ impl<VM: VMBinding> MarkCompact<VM> {
             global_side_metadata_specs,
         };
 
+        let mc_space_spec = plan_args
+            .global_args
+            .heap
+            .specify_space(SpaceSpec::DontCare);
+
+        // Spaces will eventually be placed by `BasePlan`.
+        let common = CommonPlan::new(&mut plan_args);
+
         let mc_space =
-            MarkCompactSpace::new(plan_args.get_space_args("mc", true, VMRequest::discontiguous()));
+            MarkCompactSpace::new(plan_args.get_space_args("mc", true, mc_space_spec.unwrap()));
 
-        let res = MarkCompact {
-            mc_space,
-            common: CommonPlan::new(plan_args),
-        };
+        let res = MarkCompact { mc_space, common };
 
         res.verify_side_metadata_sanity();
 

src/plan/marksweep/global.rs

@@ -10,7 +10,7 @@ use crate::plan::PlanConstraints;
 use crate::policy::space::Space;
 use crate::scheduler::GCWorkScheduler;
 use crate::util::alloc::allocators::AllocatorSelector;
-use crate::util::heap::VMRequest;
+use crate::util::heap::heap_meta::SpaceSpec;
 use crate::util::metadata::side_metadata::SideMetadataContext;
 use crate::util::VMWorkerThread;
 use crate::vm::VMBinding;
@@ -102,13 +102,17 @@ impl<VM: VMBinding> MarkSweep<VM> {
             global_side_metadata_specs,
         };
 
+        let ms_spec = plan_args
+            .global_args
+            .heap
+            .specify_space(SpaceSpec::DontCare);
+
+        // Spaces will eventually be placed by `BasePlan`.
+        let common = CommonPlan::new(&mut plan_args);
+
         let res = MarkSweep {
-            ms: MarkSweepSpace::new(plan_args.get_space_args(
-                "ms",
-                true,
-                VMRequest::discontiguous(),
-            )),
-            common: CommonPlan::new(plan_args),
+            ms: MarkSweepSpace::new(plan_args.get_space_args("ms", true, ms_spec.unwrap())),
+            common,
         };
 
         res.verify_side_metadata_sanity();