WIP: Fix errors after rebase onto PR#146 -- nogc/semispace working

Author: wenyuzhao

src/mm/memory_manager.rs

@@ -59,20 +59,20 @@ pub fn gc_init<VM: VMBinding>(mmtk: &MMTK<VM>, heap_size: usize) {
 pub fn bind_mutator<VM: VMBinding>(
     mmtk: &'static MMTK<VM>,
     tls: OpaquePointer,
-) -> Box<Mutator<VM, SelectedPlan<VM>>> {
+) -> Box<Mutator<SelectedPlan<VM>>> {
     SelectedPlan::bind_mutator(&mmtk.plan, tls)
 }
 
-pub fn destroy_mutator<VM: VMBinding>(mutator: Box<Mutator<VM, SelectedPlan<VM>>>) {
+pub fn destroy_mutator<VM: VMBinding>(mutator: Box<Mutator<SelectedPlan<VM>>>) {
     drop(mutator);
 }
 
-pub fn flush_mutator<VM: VMBinding>(mutator: &mut SelectedMutator<VM>) {
+pub fn flush_mutator<VM: VMBinding>(mutator: &mut Mutator<SelectedPlan<VM>>) {
     mutator.flush()
 }
 
 pub fn alloc<VM: VMBinding>(
-    mutator: &mut Mutator<VM, SelectedPlan<VM>>,
+    mutator: &mut Mutator<SelectedPlan<VM>>,
     size: usize,
     align: usize,
     offset: isize,
@@ -82,7 +82,7 @@ pub fn alloc<VM: VMBinding>(
 }
 
 pub fn post_alloc<VM: VMBinding>(
-    mutator: &mut Mutator<VM, SelectedPlan<VM>>,
+    mutator: &mut Mutator<SelectedPlan<VM>>,
     refer: ObjectReference,
     type_refer: ObjectReference,
     bytes: usize,

src/plan/mutator_context.rs

@@ -13,31 +13,34 @@ use enum_map::EnumMap;
 // This struct is part of the Mutator struct.
 // We are trying to make it fixed-sized so that VM bindings can easily define a Mutator type to have the exact same layout as our Mutator struct.
 #[repr(C)]
-pub struct MutatorConfig<VM: VMBinding, P: Plan<VM> + 'static> {
+pub struct MutatorConfig<P: Plan> {
     // Mapping between allocation semantics and allocator selector
     pub allocator_mapping: &'static EnumMap<AllocationType, AllocatorSelector>,
     // Mapping between allocator selector and spaces. Each pair represents a mapping.
     // Put this behind a box, so it is a pointer-sized field.
     #[allow(clippy::box_vec)]
-    pub space_mapping: Box<Vec<(AllocatorSelector, &'static dyn Space<VM>)>>,
+    pub space_mapping: Box<Vec<(AllocatorSelector, &'static dyn Space<P::VM>)>>,
     // Plan-specific code for mutator prepare/release
-    pub prepare_func: &'static dyn Fn(&mut Mutator<VM, P>, OpaquePointer),
-    pub release_func: &'static dyn Fn(&mut Mutator<VM, P>, OpaquePointer),
+    pub prepare_func: &'static dyn Fn(&mut Mutator<P>, OpaquePointer),
+    pub release_func: &'static dyn Fn(&mut Mutator<P>, OpaquePointer),
 }
 
+unsafe impl <P: Plan> Send for MutatorConfig<P> {}
+unsafe impl <P: Plan> Sync for MutatorConfig<P> {}
+
 // We are trying to make this struct fixed-sized so that VM bindings can easily define a type to have the exact same layout as this struct.
 // Currently Mutator is fixed sized, and we should try keep this invariant:
 // - Allocators are fixed-length arrays of allocators.
 // - MutatorConfig has 3 pointers/refs (including one fat pointer), and is fixed sized.
 #[repr(C)]
-pub struct Mutator<VM: VMBinding, P: Plan<VM> + 'static> {
-    pub allocators: Allocators<VM>,
+pub struct Mutator<P: Plan> {
+    pub allocators: Allocators<P::VM>,
     pub mutator_tls: OpaquePointer,
     pub plan: &'static P,
-    pub config: MutatorConfig<VM, P>,
+    pub config: MutatorConfig<P>,
 }
 
-impl<VM: VMBinding, P: Plan<VM>> MutatorContext<VM> for Mutator<VM, P> {
+impl <P: Plan<Mutator=Self>> MutatorContext<P::VM> for Mutator<P> {
     fn prepare(&mut self, tls: OpaquePointer) {
         (*self.config.prepare_func)(self, tls)
     }

src/plan/nogc/global.rs

@@ -36,7 +36,7 @@ unsafe impl<VM: VMBinding> Sync for NoGC<VM> {}
 
 impl<VM: VMBinding> Plan for NoGC<VM> {
     type VM = VM;
-    type Mutator = Mutator<VM, Self>;
+    type Mutator = Mutator<Self>;
     type CopyContext = NoCopy<VM>;
 
     fn new(
@@ -80,7 +80,7 @@ impl<VM: VMBinding> Plan for NoGC<VM> {
         &self.base
     }
 
-    fn bind_mutator(&'static self, tls: OpaquePointer) -> Box<Mutator<VM, Self>> {
+    fn bind_mutator(&'static self, tls: OpaquePointer) -> Box<Mutator<Self>> {
         Box::new(create_nogc_mutator(tls, self))
     }
 

src/plan/nogc/mutator.rs

@@ -16,17 +16,17 @@ lazy_static! {
     };
 }
 
-pub fn nogc_mutator_noop<VM: VMBinding>(_mutator: &mut Mutator<VM, SemiSpace<VM>>, _tls: OpaquePointer) {
-
+pub fn nogc_mutator_noop<VM: VMBinding>(_mutator: &mut Mutator<NoGC<VM>>, _tls: OpaquePointer) {
+    unreachable!();
 }
 
 pub fn create_nogc_mutator<VM: VMBinding>(
     mutator_tls: OpaquePointer,
     plan: &'static NoGC<VM>,
-) -> Mutator<VM, NoGC<VM>> {
+) -> Mutator<NoGC<VM>> {
     let config = MutatorConfig {
         allocator_mapping: &*ALLOCATOR_MAPPING,
-        space_mapping: box vec![(AllocatorSelector::BumpPointer(0), plan.get_immortal_space())],
+        space_mapping: box vec![(AllocatorSelector::BumpPointer(0), &plan.nogc_space)],
         prepare_func: &nogc_mutator_noop,
         release_func: &nogc_mutator_noop,
     };

src/plan/semispace/global.rs

@@ -46,7 +46,7 @@ unsafe impl<VM: VMBinding> Sync for SemiSpace<VM> {}
 
 impl<VM: VMBinding> Plan for SemiSpace<VM> {
     type VM = VM;
-    type Mutator = Mutator<VM, Self>;
+    type Mutator = Mutator<Self>;
     type CopyContext = SSCopyContext<VM>;
 
     fn new(
@@ -101,7 +101,7 @@ impl<VM: VMBinding> Plan for SemiSpace<VM> {
         scheduler.set_finalizer(Some(EndOfGC));
     }
 
-    fn bind_mutator(&'static self, tls: OpaquePointer) -> Box<Mutator<VM, Self>> {
+    fn bind_mutator(&'static self, tls: OpaquePointer) -> Box<Mutator<Self>> {
         Box::new(create_ss_mutator(tls, self))
     }
 

src/plan/semispace/mutator.rs

@@ -15,11 +15,11 @@ use crate::vm::VMBinding;
 use enum_map::enum_map;
 use enum_map::EnumMap;
 
-pub fn ss_mutator_prepare<VM: VMBinding>(mutator: &mut Mutator<VM, SemiSpace<VM>>, _tls: OpaquePointer) {
+pub fn ss_mutator_prepare<VM: VMBinding>(mutator: &mut Mutator<SemiSpace<VM>>, _tls: OpaquePointer) {
     // Do nothing
 }
 
-pub fn ss_mutator_release<VM: VMBinding>(mutator: &mut Mutator<VM, SemiSpace<VM>>, _tls: OpaquePointer) {
+pub fn ss_mutator_release<VM: VMBinding>(mutator: &mut Mutator<SemiSpace<VM>>, _tls: OpaquePointer) {
     // rebind the allocation bump pointer to the appropriate semispace
     let bump_allocator = unsafe {
         mutator
@@ -42,7 +42,7 @@ lazy_static! {
 pub fn create_ss_mutator<VM: VMBinding>(
     mutator_tls: OpaquePointer,
     plan: &'static SemiSpace<VM>,
-) -> Mutator<VM, SemiSpace<VM>> {
+) -> Mutator<SemiSpace<VM>> {
     let config = MutatorConfig {
         allocator_mapping: &*ALLOCATOR_MAPPING,
         space_mapping: box vec![

src/scheduler/gc_works.rs

@@ -217,7 +217,7 @@ impl <E: ProcessEdgesWork> GCWork<E::VM> for ScanStackRoots<E> {
     }
 }
 
-pub struct ScanStackRoot<Edges: ProcessEdgesWork>(pub &'static mut SelectedMutator<Edges::VM>);
+pub struct ScanStackRoot<Edges: ProcessEdgesWork>(pub &'static mut Mutator<SelectedPlan<Edges::VM>>);
 
 impl <E: ProcessEdgesWork> GCWork<E::VM> for ScanStackRoot<E> {
     fn do_work(&mut self, worker: &mut GCWorker<E::VM>, mmtk: &'static MMTK<E::VM>) {

src/util/heap/monotonepageresource.rs

@@ -17,6 +17,7 @@ use super::PageResource;
 
 use crate::util::heap::layout::heap_layout::VMMap;
 use crate::vm::VMBinding;
+use std::sync::atomic::Ordering;
 use libc::{c_void, memset};
 
 pub struct MonotonePageResource<VM: VMBinding> {

src/util/heap/pageresource.rs

@@ -108,7 +108,7 @@ pub trait PageResource<VM: VMBinding>: 'static {
 }
 
 pub struct CommonPageResource<VM: VMBinding> {
-    reserved: AtomicUsize,
+    pub reserved: AtomicUsize,
     committed: AtomicUsize,
 
     pub contiguous: bool,

src/vm/scanning.rs

@@ -1,9 +1,8 @@
-use crate::plan::{TraceLocal, TransitiveClosure};
+use crate::plan::{TraceLocal, TransitiveClosure, Mutator, SelectedPlan};
 use crate::util::ObjectReference;
 use crate::util::OpaquePointer;
 use crate::vm::VMBinding;
 use crate::scheduler::gc_works::ProcessEdgesWork;
-use crate::SelectedMutator;
 
 pub trait Scanning<VM: VMBinding> {
     /// Scan stack roots after all mutators are paused
@@ -26,7 +25,7 @@ pub trait Scanning<VM: VMBinding> {
     /// Scan all the mutators for roots
     fn scan_thread_roots<W: ProcessEdgesWork<VM=VM>>();
     /// Scan one mutator for roots
-    fn scan_thread_root<W: ProcessEdgesWork<VM=VM>>(mutator: &'static mut SelectedMutator<VM>);
+    fn scan_thread_root<W: ProcessEdgesWork<VM=VM>>(mutator: &'static mut Mutator<SelectedPlan<VM>>);
     /// The creation of all root scan tasks (except thread scanning) goes here
     fn scan_vm_specific_roots<W: ProcessEdgesWork<VM=VM>>();
     fn compute_static_roots<T: TraceLocal>(trace: &mut T, tls: OpaquePointer);