* Introduced CommonPlan

* Introduced HeapMeta
* Introduced SpaceDescriptor
* Sanity code is conditionally compiled.

Cargo.toml

@@ -16,6 +16,7 @@ lazy_static = "1.1"
 log = {version = "0.4", features = ["max_level_trace", "release_max_level_off"] }
 crossbeam-deque = "0.6"
 num_cpus = "1.8"
+derivative = "1.0.3"
 
 [features]
 default = ["nogc", "openjdk"]

src/lib.rs

@@ -17,6 +17,8 @@ extern crate lazy_static;
 extern crate log;
 extern crate crossbeam_deque;
 extern crate num_cpus;
+#[macro_use]
+extern crate derivative;
 
 #[macro_use]
 pub mod util;

src/mm/memory_manager.rs

@@ -3,7 +3,7 @@ use libc::c_void;
 use libc::c_char;
 
 use std::ffi::CStr;
-use std::str;
+use std::{str, thread};
 
 use std::sync::atomic::Ordering;
 
@@ -12,7 +12,6 @@ use ::plan::MutatorContext;
 use ::plan::TraceLocal;
 use ::plan::CollectorContext;
 use ::plan::ParallelCollectorGroup;
-use ::plan::plan::CONTROL_COLLECTOR_CONTEXT;
 
 use ::vm::{Collection, VMCollection};
 
@@ -31,7 +30,6 @@ use ::plan::Allocator;
 use util::constants::LOG_BYTES_IN_PAGE;
 use util::heap::layout::vm_layout_constants::HEAP_START;
 use util::heap::layout::vm_layout_constants::HEAP_END;
-use ::util::sanity::sanity_checker::{INSIDE_SANITY, SanityChecker};
 use util::OpaquePointer;
 use crate::mmtk::SINGLETON;
 
@@ -77,7 +75,7 @@ pub unsafe extern fn openjdk_gc_init(calls: *const OpenJDK_Upcalls, heap_size: u
 #[no_mangle]
 #[cfg(any(feature = "jikesrvm", feature = "openjdk"))]
 pub extern fn start_control_collector(tls: OpaquePointer) {
- CONTROL_COLLECTOR_CONTEXT.run(tls);
+ SINGLETON.plan.common().control_collector_context.run(tls);
 }
 
 #[no_mangle]
@@ -96,7 +94,10 @@ pub unsafe extern fn gc_init(heap_size: usize) {
  }
  ::util::logger::init().unwrap();
  SINGLETON.plan.gc_init(heap_size, &SINGLETON.vm_map);
- ::plan::plan::INITIALIZED.store(true, Ordering::SeqCst);
+ SINGLETON.plan.common().initialized.store(true, Ordering::SeqCst);
+ thread::spawn(|| {
+ SINGLETON.plan.common().control_collector_context.run(OpaquePointer::UNINITIALIZED)
+ });
 }
 
 #[no_mangle]
@@ -145,48 +146,72 @@ pub unsafe extern fn is_valid_ref(val: ObjectReference) -> bool {
 }
 
 #[no_mangle]
+#[cfg(feature = "sanity")]
 pub unsafe extern fn report_delayed_root_edge(trace_local: *mut c_void, addr: *mut c_void) {
- trace!("JikesRVM called report_delayed_root_edge with trace_local={:?}", trace_local);
- if cfg!(feature = "sanity") && INSIDE_SANITY.load(Ordering::Relaxed) {
- let local = &mut *(trace_local as *mut SanityChecker);
- local.report_delayed_root_edge(Address::from_usize(addr as usize));
+ use ::util::sanity::sanity_checker::SanityChecker;
+ if SINGLETON.plan.common().is_in_sanity() {
+ report_delayed_root_edge_inner::<SanityChecker>(trace_local, addr)
  } else {
- let local = &mut *(trace_local as *mut <SelectedPlan as Plan>::TraceLocalT);
- local.report_delayed_root_edge(Address::from_usize(addr as usize));
+ report_delayed_root_edge_inner::<<SelectedPlan as Plan>::TraceLocalT>(trace_local, addr)
  }
+}
+#[no_mangle]
+#[cfg(not(feature = "sanity"))]
+pub unsafe extern fn report_delayed_root_edge(trace_local: *mut c_void, addr: *mut c_void) {
+ report_delayed_root_edge_inner::<<SelectedPlan as Plan>::TraceLocalT>(trace_local, addr)
+}
+unsafe fn report_delayed_root_edge_inner<T: TraceLocal>(trace_local: *mut c_void, addr: *mut c_void) {
+ trace!("report_delayed_root_edge with trace_local={:?}", trace_local);
+ let local = &mut *(trace_local as *mut T);
+ local.report_delayed_root_edge(Address::from_usize(addr as usize));
  trace!("report_delayed_root_edge returned with trace_local={:?}", trace_local);
 }
 
 #[no_mangle]
+#[cfg(feature = "sanity")]
 pub unsafe extern fn will_not_move_in_current_collection(trace_local: *mut c_void, obj: *mut c_void) -> bool {
- trace!("will_not_move_in_current_collection({:?}, {:?})", trace_local, obj);
- if cfg!(feature = "sanity") && INSIDE_SANITY.load(Ordering::Relaxed) {
- let local = &mut *(trace_local as *mut SanityChecker);
- let ret = local.will_not_move_in_current_collection(Address::from_usize(obj as usize).to_object_reference());
- trace!("will_not_move_in_current_collection returned with trace_local={:?}", trace_local);
- ret
+ use ::util::sanity::sanity_checker::SanityChecker;
+ if SINGLETON.plan.common().is_in_sanity() {
+ will_not_move_in_current_collection_inner::<SanityChecker>(trace_local, obj)
  } else {
- let local = &mut *(trace_local as *mut <SelectedPlan as Plan>::TraceLocalT);
- let ret = local.will_not_move_in_current_collection(Address::from_usize(obj as usize).to_object_reference());
- trace!("will_not_move_in_current_collection returned with trace_local={:?}", trace_local);
- ret
+ will_not_move_in_current_collection_inner::<<SelectedPlan as Plan>::TraceLocalT>(trace_local, obj)
  }
 }
+#[no_mangle]
+#[cfg(not(feature = "sanity"))]
+pub unsafe extern fn will_not_move_in_current_collection(trace_local: *mut c_void, obj: *mut c_void) -> bool {
+ will_not_move_in_current_collection_inner::<<SelectedPlan as Plan>::TraceLocalT>(trace_local, obj)
+}
+unsafe fn will_not_move_in_current_collection_inner<T: TraceLocal>(trace_local: *mut c_void, obj: *mut c_void) -> bool {
+ trace!("will_not_move_in_current_collection({:?}, {:?})", trace_local, obj);
+ let local = &mut *(trace_local as *mut T);
+ let ret = local.will_not_move_in_current_collection(Address::from_usize(obj as usize).to_object_reference());
+ trace!("will_not_move_in_current_collection returned with trace_local={:?}", trace_local);
+ ret
+}
 
 #[no_mangle]
+#[cfg(feature = "sanity")]
 pub unsafe extern fn process_interior_edge(trace_local: *mut c_void, target: *mut c_void, slot: *mut c_void, root: bool) {
- trace!("JikesRVM called process_interior_edge with trace_local={:?}", trace_local);
- if cfg!(feature = "sanity") && INSIDE_SANITY.load(Ordering::Relaxed) {
- let local = &mut *(trace_local as *mut SanityChecker);
- local.process_interior_edge(Address::from_usize(target as usize).to_object_reference(),
- Address::from_usize(slot as usize), root);
+ use ::util::sanity::sanity_checker::SanityChecker;
+ if SINGLETON.plan.common().is_in_sanity() {
+ process_interior_edge_inner::<SanityChecker>(trace_local, target, slot, root)
  } else {
- let local = &mut *(trace_local as *mut <SelectedPlan as Plan>::TraceLocalT);
- local.process_interior_edge(Address::from_usize(target as usize).to_object_reference(),
- Address::from_usize(slot as usize), root);
+ process_interior_edge_inner::<<SelectedPlan as Plan>::TraceLocalT>(trace_local, target, slot, root)
  }
  trace!("process_interior_root_edge returned with trace_local={:?}", trace_local);
-
+}
+#[no_mangle]
+#[cfg(not(feature = "sanity"))]
+pub unsafe extern fn process_interior_edge(trace_local: *mut c_void, target: *mut c_void, slot: *mut c_void, root: bool) {
+ process_interior_edge_inner::<<SelectedPlan as Plan>::TraceLocalT>(trace_local, target, slot, root)
+}
+unsafe fn process_interior_edge_inner<T: TraceLocal>(trace_local: *mut c_void, target: *mut c_void, slot: *mut c_void, root: bool) {
+ trace!("process_interior_edge with trace_local={:?}", trace_local);
+ let local = &mut *(trace_local as *mut T);
+ local.process_interior_edge(Address::from_usize(target as usize).to_object_reference(),
+ Address::from_usize(slot as usize), root);
+ trace!("process_interior_root_edge returned with trace_local={:?}", trace_local);
 }
 
 #[no_mangle]
@@ -199,9 +224,9 @@ pub unsafe extern fn start_worker(tls: OpaquePointer, worker: *mut c_void) {
 #[no_mangle]
 #[cfg(feature = "jikesrvm")]
 pub unsafe extern fn enable_collection(tls: OpaquePointer) {
- (&mut *CONTROL_COLLECTOR_CONTEXT.workers.get()).init_group(&SINGLETON, tls);
+ (&mut *SINGLETON.plan.common().control_collector_context.workers.get()).init_group(&SINGLETON, tls);
  VMCollection::spawn_worker_thread::<<SelectedPlan as Plan>::CollectorT>(tls, null_mut()); // spawn controller thread
- ::plan::plan::INITIALIZED.store(true, Ordering::SeqCst);
+ SINGLETON.plan.common().initialized.store(true, Ordering::SeqCst);
 }
 
 #[no_mangle]
@@ -279,6 +304,7 @@ pub extern fn executable() -> bool {
 }
 
 #[no_mangle]
+#[cfg(feature = "sanity")]
 pub unsafe extern fn scan_region(){
  ::util::sanity::memory_scan::scan_region(&SINGLETON.plan);
 }

src/plan/controller_collector_context.rs

@@ -60,7 +60,9 @@ impl ControllerCollectorContext {
  VMCollection::stop_all_mutators(tls);
 
  // For heap growth logic
- let user_triggered_collection: bool = SelectedPlan::is_user_triggered_collection();
+ // FIXME: This is not used. However, we probably want to set a 'user_triggered' flag
+ // when GC is requested.
+ // let user_triggered_collection: bool = SelectedPlan::is_user_triggered_collection();
 
  self.clear_request();
 

src/plan/nogc/nogc.rs

@@ -19,17 +19,20 @@ use super::NoGCTraceLocal;
 use super::NoGCMutator;
 use super::NoGCCollector;
 use util::conversions::bytes_to_pages;
-use plan::plan::create_vm_space;
+use plan::plan::{create_vm_space, CommonPlan};
 use util::heap::layout::heap_layout::VMMap;
 use util::heap::layout::heap_layout::Mmapper;
 use util::options::{Options, UnsafeOptionsWrapper};
 use std::sync::Arc;
+use util::heap::HeapMeta;
+use util::heap::layout::vm_layout_constants::{HEAP_START, HEAP_END};
+use std::sync::atomic::Ordering;
 
 pub type SelectedPlan = NoGC;
 
 pub struct NoGC {
- pub control_collector_context: ControllerCollectorContext,
  pub unsync: UnsafeCell<NoGCUnsync>,
+ pub common: CommonPlan,
 }
 
 unsafe impl Sync for NoGC {}
@@ -38,9 +41,6 @@ pub struct NoGCUnsync {
  vm_space: ImmortalSpace,
  pub space: ImmortalSpace,
  pub los: LargeObjectSpace,
- pub mmapper: &'static Mmapper,
- pub options: Arc<UnsafeOptionsWrapper>,
- pub total_pages: usize,
 }
 
 impl Plan for NoGC {
@@ -49,53 +49,36 @@ impl Plan for NoGC {
  type CollectorT = NoGCCollector;
 
  fn new(vm_map: &'static VMMap, mmapper: &'static Mmapper, options: Arc<UnsafeOptionsWrapper>) -> Self {
+ let mut heap = HeapMeta::new(HEAP_START, HEAP_END);
+
  NoGC {
- control_collector_context: ControllerCollectorContext::new(),
  unsync: UnsafeCell::new(NoGCUnsync {
- vm_space: create_vm_space(vm_map, mmapper),
+ vm_space: create_vm_space(vm_map, mmapper, &mut heap),
  space: ImmortalSpace::new("nogc_space", true,
- VMRequest::discontiguous(), vm_map, mmapper),
- los: LargeObjectSpace::new("los", true, VMRequest::discontiguous(), vm_map, mmapper),
- mmapper,
- options,
- total_pages: 0,
- }
- ),
+ VMRequest::discontiguous(), vm_map, mmapper, &mut heap),
+ los: LargeObjectSpace::new("los", true, VMRequest::discontiguous(), vm_map, mmapper, &mut heap),
+ }),
+ common: CommonPlan::new(vm_map, mmapper, options, heap),
  }
  }
 
  unsafe fn gc_init(&self, heap_size: usize, vm_map: &'static VMMap) {
- vm_map.finalize_static_space_map();
+ vm_map.finalize_static_space_map(self.common.heap.get_discontig_start(), self.common.heap.get_discontig_end());
+
  let unsync = &mut *self.unsync.get();
- unsync.total_pages = bytes_to_pages(heap_size);
+ self.common.heap.total_pages.store(bytes_to_pages(heap_size), Ordering::Relaxed);
  // FIXME correctly initialize spaces based on options
  unsync.vm_space.init(vm_map);
  unsync.space.init(vm_map);
  unsync.los.init(vm_map);
-
- // These VMs require that the controller thread is started by the VM itself.
- // (Usually because it calls into VM code that accesses the TLS.)
- if !(cfg!(feature = "jikesrvm") || cfg!(feature = "openjdk")) {
- thread::spawn(|| {
- ::plan::plan::CONTROL_COLLECTOR_CONTEXT.run(OpaquePointer::UNINITIALIZED )
- });
- }
- }
-
- fn mmapper(&self) -> &'static Mmapper {
- let unsync = unsafe { &*self.unsync.get() };
- unsync.mmapper
  }
 
- fn options(&self) -> &Options {
- let unsync = unsafe { &*self.unsync.get() };
- &unsync.options
+ fn common(&self) -> &CommonPlan {
+ &self.common
  }
 
- fn bind_mutator(&self, tls: OpaquePointer) -> *mut c_void {
- let unsync = unsafe { &*self.unsync.get() };
- Box::into_raw(Box::new(NoGCMutator::new(
- tls, &unsync.space, &unsync.los))) as *mut c_void
+ fn bind_mutator(&'static self, tls: OpaquePointer) -> *mut c_void {
+ Box::into_raw(Box::new(NoGCMutator::new(tls, self))) as *mut c_void
  }
 
  fn will_never_move(&self, object: ObjectReference) -> bool {
@@ -104,11 +87,6 @@ impl Plan for NoGC {
 
  unsafe fn collection_phase(&self, tls: OpaquePointer, phase: &Phase) {}
 
- fn get_total_pages(&self) -> usize {
- let unsync = unsafe { &*self.unsync.get() };
- unsync.total_pages
- }
-
  fn get_pages_used(&self) -> usize {
  let unsync = unsafe { &*self.unsync.get() };
  unsync.space.reserved_pages() + unsync.los.reserved_pages()
@@ -139,7 +117,7 @@ impl Plan for NoGC {
  unsync.vm_space.in_space(address.to_object_reference()) ||
  unsync.los.in_space(address.to_object_reference())
  } {
- return unsync.mmapper.address_is_mapped(address);
+ return self.common.mmapper.address_is_mapped(address);
  } else {
  return false;
  }
@@ -158,4 +136,16 @@ impl Plan for NoGC {
  }
  return true;
  }
+}
+
+impl NoGC {
+ pub fn get_immortal_space(&self) -> &'static ImmortalSpace {
+ let unsync = unsafe { &*self.unsync.get() };
+ &unsync.space
+ }
+
+ pub fn get_los(&self) -> &'static LargeObjectSpace {
+ let unsync = unsafe { &*self.unsync.get() };
+ &unsync.los
+ }
 }

src/plan/nogc/nogcmutator.rs

@@ -10,12 +10,13 @@ use ::util::heap::MonotonePageResource;
 use ::mmtk::SINGLETON;
 use ::util::OpaquePointer;
 use libc::c_void;
+use plan::nogc::NoGC;
 
 #[repr(C)]
 pub struct NoGCMutator {
  // ImmortalLocal
  nogc: BumpAllocator<MonotonePageResource<ImmortalSpace>>,
- los: LargeObjectAllocator
+ los: LargeObjectAllocator,
 }
 
 impl MutatorContext for NoGCMutator {
@@ -56,10 +57,10 @@ impl MutatorContext for NoGCMutator {
 }
 
 impl NoGCMutator {
- pub fn new(tls: OpaquePointer, space: &'static ImmortalSpace, los: &'static LargeObjectSpace) -> Self {
+ pub fn new(tls: OpaquePointer, plan: &'static NoGC) -> Self {
  NoGCMutator {
- nogc: BumpAllocator::new(tls, Some(space)),
- los: LargeObjectAllocator::new(tls, Some(los))
+ nogc: BumpAllocator::new(tls, Some(plan.get_immortal_space()), plan),
+ los: LargeObjectAllocator::new(tls, Some(plan.get_los()), plan),
  }
  }
 }

src/plan/phase.rs

@@ -144,7 +144,7 @@ impl PhaseManager {
  let order = collector.rendezvous();
  let primary = order == 0;
  if primary && resume {
- plan::plan::set_gc_status(plan::plan::GcStatus::GcProper);
+ plan.common().set_gc_status(plan::plan::GcStatus::GcProper);
  }
  let mut is_even_phase = true;
  if primary {