Introduce VMSpace, and allow VMSpace to be set lazily

docs/tutorial/code/mygc_semispace/global.rs

@@ -154,6 +154,10 @@ impl<VM: VMBinding> Plan for MyGC<VM> {
  fn base(&self) -> &BasePlan<VM> {
  &self.common.base
  }
+
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.common.base
+ }
  // ANCHOR_END: plan_base
 
  // Add

src/memory_manager.rs

@@ -85,6 +85,11 @@ pub fn mmtk_init<VM: VMBinding>(builder: &MMTKBuilder) -> Box<MMTK<VM>> {
  Box::new(mmtk)
 }
 
+#[cfg(feature = "vm_space")]
+pub fn lazy_init_vm_space<VM: VMBinding>(mmtk: &'static mut MMTK<VM>, start: Address, size: usize) {
+ mmtk.plan.base_mut().vm_space.lazy_initialize(start, size);
+}
+
 /// Request MMTk to create a mutator for the given thread. The ownership
 /// of returned boxed mutator is transferred to the binding, and the binding needs to take care of its
 /// lifetime. For performance reasons, A VM should store the returned mutator in a thread local storage

src/plan/generational/copying/global.rs

@@ -148,6 +148,10 @@ impl<VM: VMBinding> Plan for GenCopy<VM> {
  &self.gen.common.base
  }
 
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.gen.common.base
+ }
+
  fn common(&self) -> &CommonPlan<VM> {
  &self.gen.common
  }

src/plan/generational/immix/global.rs

@@ -178,6 +178,10 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
  &self.gen.common.base
  }
 
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.gen.common.base
+ }
+
  fn common(&self) -> &CommonPlan<VM> {
  &self.gen.common
  }

src/plan/global.rs

@@ -8,6 +8,8 @@ use crate::plan::Mutator;
 use crate::policy::immortalspace::ImmortalSpace;
 use crate::policy::largeobjectspace::LargeObjectSpace;
 use crate::policy::space::{PlanCreateSpaceArgs, Space};
+#[cfg(feature = "vm_space")]
+use crate::policy::vmspace::VMSpace;
 use crate::scheduler::*;
 use crate::util::alloc::allocators::AllocatorSelector;
 #[cfg(feature = "analysis")]
@@ -176,6 +178,7 @@ pub trait Plan: 'static + Sync + Downcast {
  }
 
  fn base(&self) -> &BasePlan<Self::VM>;
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM>;
  fn schedule_collection(&'static self, _scheduler: &GCWorkScheduler<Self::VM>);
  fn common(&self) -> &CommonPlan<Self::VM> {
  panic!("Common Plan not handled!")
@@ -423,29 +426,7 @@ pub struct BasePlan<VM: VMBinding> {
  /// the VM space.
  #[cfg(feature = "vm_space")]
  #[trace]
- pub vm_space: ImmortalSpace<VM>,
-}
-
-#[cfg(feature = "vm_space")]
-pub fn create_vm_space<VM: VMBinding>(args: &mut CreateSpecificPlanArgs<VM>) -> ImmortalSpace<VM> {
- use crate::util::constants::LOG_BYTES_IN_MBYTE;
- let boot_segment_bytes = *args.global_args.options.vm_space_size;
- debug_assert!(boot_segment_bytes > 0);
-
- use crate::util::conversions::raw_align_up;
- use crate::util::heap::layout::vm_layout_constants::BYTES_IN_CHUNK;
- let boot_segment_mb = raw_align_up(boot_segment_bytes, BYTES_IN_CHUNK) >> LOG_BYTES_IN_MBYTE;
-
- let space = ImmortalSpace::new_vm_space(args.get_space_args(
- "boot",
- false,
- VMRequest::fixed_size(boot_segment_mb),
- ));
-
- // The space is mapped externally by the VM. We need to update our mmapper to mark the range as mapped.
- space.ensure_mapped();
-
- space
+ pub vm_space: VMSpace<VM>,
 }
 
 /// Args needed for creating any plan. This includes a set of contexts from MMTK or global. This
@@ -520,7 +501,7 @@ impl<VM: VMBinding> BasePlan<VM> {
  VMRequest::discontiguous(),
  )),
  #[cfg(feature = "vm_space")]
- vm_space: create_vm_space(&mut args),
+ vm_space: VMSpace::new(&mut args),
 
  initialized: AtomicBool::new(false),
  trigger_gc_when_heap_is_full: AtomicBool::new(true),

src/plan/immix/global.rs

@@ -117,6 +117,10 @@ impl<VM: VMBinding> Plan for Immix<VM> {
  &self.common.base
  }
 
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.common.base
+ }
+
  fn common(&self) -> &CommonPlan<VM> {
  &self.common
  }

src/plan/markcompact/global.rs

@@ -61,6 +61,10 @@ impl<VM: VMBinding> Plan for MarkCompact<VM> {
  &self.common.base
  }
 
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.common.base
+ }
+
  fn common(&self) -> &CommonPlan<VM> {
  &self.common
  }

src/plan/marksweep/global.rs

@@ -87,6 +87,10 @@ impl<VM: VMBinding> Plan for MarkSweep<VM> {
  &self.common.base
  }
 
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.common.base
+ }
+
  fn common(&self) -> &CommonPlan<VM> {
  &self.common
  }

src/plan/mod.rs

@@ -26,6 +26,8 @@ pub use global::AllocationSemantics;
 pub(crate) use global::GcStatus;
 pub use global::Plan;
 pub(crate) use global::PlanTraceObject;
+#[cfg(feature = "vm_space")] // This is used for creating VM space
+pub(crate) use global::{CreateGeneralPlanArgs, CreateSpecificPlanArgs};
 
 mod mutator_context;
 pub use mutator_context::Mutator;

src/plan/nogc/global.rs

@@ -53,6 +53,10 @@ impl<VM: VMBinding> Plan for NoGC<VM> {
  &self.base
  }
 
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.base
+ }
+
  fn prepare(&mut self, _tls: VMWorkerThread) {
  unreachable!()
  }

src/plan/pageprotect/global.rs

@@ -77,6 +77,10 @@ impl<VM: VMBinding> Plan for PageProtect<VM> {
  &self.common.base
  }
 
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.common.base
+ }
+
  fn common(&self) -> &CommonPlan<VM> {
  &self.common
  }

src/plan/semispace/global.rs

@@ -129,6 +129,10 @@ impl<VM: VMBinding> Plan for SemiSpace<VM> {
  &self.common.base
  }
 
+ fn base_mut(&mut self) -> &mut BasePlan<Self::VM> {
+ &mut self.common.base
+ }
+
  fn common(&self) -> &CommonPlan<VM> {
  &self.common
  }

src/plan/sticky/immix/global.rs

@@ -67,6 +67,10 @@ impl<VM: VMBinding> Plan for StickyImmix<VM> {
  self.immix.base()
  }
 
+ fn base_mut(&mut self) -> &mut crate::plan::global::BasePlan<Self::VM> {
+ self.immix.base_mut()
+ }
+
  fn generational(
  &self,
  ) -> Option<&dyn crate::plan::generational::global::GenerationalPlan<VM = Self::VM>> {

src/policy/immortalspace.rs

@@ -120,15 +120,6 @@ impl<VM: VMBinding> crate::policy::gc_work::PolicyTraceObject<VM> for ImmortalSp
 
 impl<VM: VMBinding> ImmortalSpace<VM> {
  pub fn new(args: crate::policy::space::PlanCreateSpaceArgs<VM>) -> Self {
- Self::new_inner(args, false)
- }
-
- #[cfg(feature = "vm_space")]
- pub fn new_vm_space(args: crate::policy::space::PlanCreateSpaceArgs<VM>) -> Self {
- Self::new_inner(args, true)
- }
-
- pub fn new_inner(args: crate::policy::space::PlanCreateSpaceArgs<VM>, vm_space: bool) -> Self {
  let vm_map = args.vm_map;
  let is_discontiguous = args.vmrequest.is_discontiguous();
  let common = CommonSpace::new(args.into_policy_args(
@@ -144,7 +135,26 @@ impl<VM: VMBinding> ImmortalSpace<VM> {
  MonotonePageResource::new_contiguous(common.start, common.extent, vm_map)
  },
  common,
- vm_space,
+ vm_space: false,
+ }
+ }
+
+ #[cfg(feature = "vm_space")]
+ pub fn new_vm_space(
+ args: crate::policy::space::PlanCreateSpaceArgs<VM>,
+ start: Address,
+ size: usize,
+ ) -> Self {
+ assert!(!args.vmrequest.is_discontiguous());
+ ImmortalSpace {
+ mark_state: MarkState::new(),
+ pr: MonotonePageResource::new_contiguous(start, size, args.vm_map),
+ common: CommonSpace::new(args.into_policy_args(
+ false,
+ true,
+ metadata::extract_side_metadata(&[*VM::VMObjectModel::LOCAL_MARK_BIT_SPEC]),
+ )),
+ vm_space: true,
  }
  }
 

src/policy/mod.rs

@@ -27,3 +27,5 @@ pub mod largeobjectspace;
 pub mod lockfreeimmortalspace;
 pub mod markcompactspace;
 pub mod marksweepspace;
+#[cfg(feature = "vm_space")]
+pub mod vmspace;

src/policy/sft_map.rs

@@ -120,8 +120,13 @@ mod space_map {
  assert!(old.name() == EMPTY_SFT_NAME || old.name() == space.name());
  // Make sure the range is in the space
  let space_start = Self::index_to_space_start(index);
- assert!(start >= space_start);
- assert!(start + bytes <= space_start + MAX_SPACE_EXTENT);
+ // FIXME: Curerntly skip the check for the last space. The following works fine for MMTk internal spaces,
+ // but the VM space is an exception. Any address after the last space is considered as the last space,
+ // based on our indexing function. In that case, we cannot assume the end of the region is within the last space (with MAX_SPACE_EXTENT).
+ if index != Self::TABLE_SIZE - 1 {
+ assert!(start >= space_start);
+ assert!(start + bytes <= space_start + MAX_SPACE_EXTENT);
+ }
  }
  *mut_self.sft.get_unchecked_mut(index) = space;
  }
@@ -512,8 +517,9 @@ mod sparse_chunk_map {
  // in which case, we still set SFT map again.
  debug_assert!(
  old == EMPTY_SFT_NAME || new == EMPTY_SFT_NAME || old == new,
- "attempt to overwrite a non-empty chunk {} in SFT map (from {} to {})",
+ "attempt to overwrite a non-empty chunk {} ({}) in SFT map (from {} to {})",
  chunk,
+ crate::util::conversions::chunk_index_to_address(chunk),
  old,
  new
  );

src/policy/space.rs

@@ -490,10 +490,8 @@ impl<VM: VMBinding> CommonSpace<VM> {
  top: _top,
  } => (_extent, _top),
  VMRequest::Fixed {
- extent: _extent,
- top: _top,
- ..
- } => (_extent, _top),
+ extent: _extent, ..
+ } => (_extent, false),
  _ => unreachable!(),
  };
 
@@ -524,7 +522,32 @@ impl<VM: VMBinding> CommonSpace<VM> {
  // FIXME
  rtn.descriptor = SpaceDescriptor::create_descriptor_from_heap_range(start, start + extent);
  // VM.memory.setHeapRange(index, start, start.plus(extent));
- args.plan_args.vm_map.insert(start, extent, rtn.descriptor);
+
+ // We only initialize our vm map if the range of the space is in our available heap range. For normally spaces,
+ // they are definitely in our heap range. But for VM space, a runtime could give us an arbitrary range. We only
+ // insert into our vm map if the range overlaps with our heap.
+ {
+ use crate::util::heap::layout;
+ if layout::range_overlaps_available_range(start, extent) {
+ // Crop the range to our available heap range. We only need to set VM map for the range that is in our heap
+ let start_in_range = if start > layout::vm_layout_constants::AVAILABLE_START {
+ start
+ } else {
+ layout::vm_layout_constants::AVAILABLE_START
+ };
+ let end_in_range = if start + extent < layout::vm_layout_constants::AVAILABLE_END {
+ start + extent
+ } else {
+ layout::vm_layout_constants::AVAILABLE_END
+ };
+
+ args.plan_args.vm_map.insert(
+ start_in_range,
+ end_in_range - start_in_range,
+ rtn.descriptor,
+ );
+ }
+ }
 
  // For contiguous space, we know its address range so we reserve metadata memory for its range.
  if rtn