PageProtect GC (#345)

* Add a paging GC: Each object is allocated to a separate page, where free pages are protected
* Panic for failed prorect/unprotect. Add a warning to PageProtect.gc_init()
* Expose PageProtect constraints, same as other plans
* expose .._VM_BASE_ADDRESS instead of .._BASE_ADDRESS to expose the base address available to Bindings

Co-authored-by: Javad Amiri <javad.amiri@anu.edu.au>
Co-authored-by: Yi Lin <qinsoon@gmail.com>

Author: 3 people

src/plan/global.rs

@@ -126,6 +126,9 @@ pub fn create_mutator<VM: VMBinding>(
         PlanSelector::MarkSweep => {
             crate::plan::marksweep::mutator::create_ms_mutator(tls, &*mmtk.plan)
         }
+        PlanSelector::PageProtect => {
+            crate::plan::pageprotect::mutator::create_pp_mutator(tls, &*mmtk.plan)
+        }
     })
 }
 
@@ -146,6 +149,9 @@ pub fn create_plan<VM: VMBinding>(
         PlanSelector::MarkSweep => Box::new(crate::plan::marksweep::MarkSweep::new(
             vm_map, mmapper, options,
         )),
+        PlanSelector::PageProtect => Box::new(crate::plan::pageprotect::PageProtect::new(
+            vm_map, mmapper, options,
+        )),
     }
 }
 
@@ -733,6 +739,7 @@ impl<VM: VMBinding> CommonPlan<VM> {
                 mmapper,
                 &mut heap,
                 constraints,
+                false,
             ),
             base: BasePlan::new(
                 vm_map,

src/plan/mod.rs

@@ -43,6 +43,7 @@ pub use transitive_closure::TransitiveClosure;
 mod gencopy;
 mod marksweep;
 mod nogc;
+mod pageprotect;
 mod semispace;
 
 // Expose plan constraints as public. Though a binding can get them from plan.constraints(),
@@ -51,4 +52,5 @@ mod semispace;
 pub use gencopy::GENCOPY_CONSTRAINTS;
 pub use marksweep::MS_CONSTRAINTS;
 pub use nogc::NOGC_CONSTRAINTS;
+pub use pageprotect::PP_CONSTRAINTS;
 pub use semispace::SS_CONSTRAINTS;

src/plan/pageprotect/gc_work.rs

@@ -0,0 +1,58 @@
+use super::global::PageProtect;
+use crate::plan::global::NoCopy;
+use crate::policy::space::Space;
+use crate::scheduler::gc_work::*;
+use crate::util::{Address, ObjectReference};
+use crate::vm::VMBinding;
+use crate::MMTK;
+use std::ops::{Deref, DerefMut};
+
+/// Edge scanning work packet.
+pub struct PPProcessEdges<VM: VMBinding> {
+    /// Use a static ref to the specific plan to avoid overhead from dynamic dispatch or
+    /// downcast for each traced object.
+    plan: &'static PageProtect<VM>,
+    base: ProcessEdgesBase<PPProcessEdges<VM>>,
+}
+
+impl<VM: VMBinding> ProcessEdgesWork for PPProcessEdges<VM> {
+    const OVERWRITE_REFERENCE: bool = false;
+    type VM = VM;
+    fn new(edges: Vec<Address>, _roots: bool, mmtk: &'static MMTK<VM>) -> Self {
+        let base = ProcessEdgesBase::new(edges, mmtk);
+        let plan = base.plan().downcast_ref::<PageProtect<VM>>().unwrap();
+        Self { plan, base }
+    }
+    #[inline]
+    fn trace_object(&mut self, object: ObjectReference) -> ObjectReference {
+        let object = unsafe {
+            let untagged_word = object.to_address().as_usize() & !0b11usize;
+            Address::from_usize(untagged_word).to_object_reference()
+        };
+        if object.is_null() {
+            return object;
+        }
+        if self.plan.space.in_space(object) {
+            self.plan.space.trace_object::<Self>(self, object)
+        } else {
+            self.plan
+                .common
+                .trace_object::<Self, NoCopy<VM>>(self, object)
+        }
+    }
+}
+
+impl<VM: VMBinding> Deref for PPProcessEdges<VM> {
+    type Target = ProcessEdgesBase<Self>;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
+
+impl<VM: VMBinding> DerefMut for PPProcessEdges<VM> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.base
+    }
+}

src/plan/pageprotect/global.rs

@@ -0,0 +1,171 @@
+use super::gc_work::PPProcessEdges;
+use super::mutator::ALLOCATOR_MAPPING;
+use crate::mmtk::MMTK;
+use crate::plan::global::GcStatus;
+use crate::plan::AllocationSemantics;
+use crate::plan::Plan;
+use crate::plan::PlanConstraints;
+use crate::policy::space::Space;
+use crate::scheduler::gc_work::*;
+use crate::scheduler::*;
+use crate::util::alloc::allocators::AllocatorSelector;
+#[cfg(feature = "analysis")]
+use crate::util::analysis::GcHookWork;
+use crate::util::heap::layout::heap_layout::Mmapper;
+use crate::util::heap::layout::heap_layout::VMMap;
+use crate::util::heap::layout::vm_layout_constants::{HEAP_END, HEAP_START};
+use crate::util::heap::HeapMeta;
+use crate::util::heap::VMRequest;
+use crate::util::metadata::side_metadata::SideMetadataContext;
+use crate::util::options::UnsafeOptionsWrapper;
+#[cfg(feature = "sanity")]
+use crate::util::sanity::sanity_checker::*;
+use crate::{plan::global::BasePlan, vm::VMBinding};
+use crate::{
+    plan::global::{CommonPlan, NoCopy},
+    policy::largeobjectspace::LargeObjectSpace,
+    util::opaque_pointer::VMWorkerThread,
+};
+use enum_map::EnumMap;
+use std::sync::Arc;
+
+pub struct PageProtect<VM: VMBinding> {
+    pub space: LargeObjectSpace<VM>,
+    pub common: CommonPlan<VM>,
+}
+
+pub const CONSTRAINTS: PlanConstraints = PlanConstraints {
+    moves_objects: false,
+    ..PlanConstraints::default()
+};
+
+impl<VM: VMBinding> Plan for PageProtect<VM> {
+    type VM = VM;
+
+    fn constraints(&self) -> &'static PlanConstraints {
+        &CONSTRAINTS
+    }
+
+    fn create_worker_local(
+        &self,
+        tls: VMWorkerThread,
+        mmtk: &'static MMTK<Self::VM>,
+    ) -> GCWorkerLocalPtr {
+        let mut c = NoCopy::new(mmtk);
+        c.init(tls);
+        GCWorkerLocalPtr::new(c)
+    }
+
+    fn gc_init(
+        &mut self,
+        heap_size: usize,
+        vm_map: &'static VMMap,
+        scheduler: &Arc<MMTkScheduler<VM>>,
+    ) {
+        // Warn users that the plan may fail due to maximum mapping allowed.
+        warn!(
+            "PageProtect uses a high volume of memory mappings. \
+            If you encounter failures in memory protect/unprotect in this plan,\
+            consider increase the maximum mapping allowed by the OS{}.",
+            if cfg!(target_os = "linux") {
+                " (e.g. sudo sysctl -w vm.max_map_count=655300)"
+            } else {
+                ""
+            }
+        );
+        self.common.gc_init(heap_size, vm_map, scheduler);
+        self.space.init(&vm_map);
+    }
+
+    fn schedule_collection(&'static self, scheduler: &MMTkScheduler<VM>) {
+        self.base().set_collection_kind();
+        self.base().set_gc_status(GcStatus::GcPrepare);
+        self.common()
+            .schedule_common::<PPProcessEdges<VM>>(&CONSTRAINTS, scheduler);
+        // Stop & scan mutators (mutator scanning can happen before STW)
+        scheduler.work_buckets[WorkBucketStage::Unconstrained]
+            .add(StopMutators::<PPProcessEdges<VM>>::new());
+        // Prepare global/collectors/mutators
+        scheduler.work_buckets[WorkBucketStage::Prepare]
+            .add(Prepare::<Self, NoCopy<VM>>::new(self));
+        // Release global/collectors/mutators
+        scheduler.work_buckets[WorkBucketStage::Release]
+            .add(Release::<Self, NoCopy<VM>>::new(self));
+        // Scheduling all the gc hooks of analysis routines. It is generally recommended
+        // to take advantage of the scheduling system we have in place for more performance
+        #[cfg(feature = "analysis")]
+        scheduler.work_buckets[WorkBucketStage::Unconstrained].add(GcHookWork);
+        // Resume mutators
+        #[cfg(feature = "sanity")]
+        scheduler.work_buckets[WorkBucketStage::Final]
+            .add(ScheduleSanityGC::<Self, NoCopy<VM>>::new(self));
+        scheduler.set_finalizer(Some(EndOfGC));
+    }
+
+    fn get_allocator_mapping(&self) -> &'static EnumMap<AllocationSemantics, AllocatorSelector> {
+        &*ALLOCATOR_MAPPING
+    }
+
+    fn prepare(&mut self, tls: VMWorkerThread) {
+        self.common.prepare(tls, true);
+        self.space.prepare(true);
+    }
+
+    fn release(&mut self, tls: VMWorkerThread) {
+        self.common.release(tls, true);
+        self.space.release(true);
+    }
+
+    fn collection_required(&self, space_full: bool, space: &dyn Space<Self::VM>) -> bool {
+        self.base().collection_required(self, space_full, space)
+    }
+
+    fn get_collection_reserve(&self) -> usize {
+        0
+    }
+
+    fn get_pages_used(&self) -> usize {
+        self.space.reserved_pages() + self.common.get_pages_used()
+    }
+
+    fn base(&self) -> &BasePlan<VM> {
+        &self.common.base
+    }
+
+    fn common(&self) -> &CommonPlan<VM> {
+        &self.common
+    }
+}
+
+impl<VM: VMBinding> PageProtect<VM> {
+    pub fn new(
+        vm_map: &'static VMMap,
+        mmapper: &'static Mmapper,
+        options: Arc<UnsafeOptionsWrapper>,
+    ) -> Self {
+        let mut heap = HeapMeta::new(HEAP_START, HEAP_END);
+        let global_metadata_specs = SideMetadataContext::new_global_specs(&[]);
+
+        PageProtect {
+            space: LargeObjectSpace::new(
+                "los",
+                true,
+                VMRequest::discontiguous(),
+                global_metadata_specs.clone(),
+                vm_map,
+                mmapper,
+                &mut heap,
+                &CONSTRAINTS,
+                true,
+            ),
+            common: CommonPlan::new(
+                vm_map,
+                mmapper,
+                options,
+                heap,
+                &CONSTRAINTS,
+                global_metadata_specs,
+            ),
+        }
+    }
+}

src/plan/pageprotect/mod.rs

@@ -0,0 +1,11 @@
+//! Plan: pageprotect
+//!
+//! Allocate each object on a separate page and protect the memory on release.
+//! This GC is commonly used for debugging purposes.
+
+pub(super) mod gc_work;
+pub(super) mod global;
+pub(super) mod mutator;
+
+pub use self::global::PageProtect;
+pub use self::global::CONSTRAINTS as PP_CONSTRAINTS;

src/plan/pageprotect/mutator.rs

@@ -0,0 +1,56 @@
+use super::PageProtect;
+use crate::plan::mutator_context::Mutator;
+use crate::plan::mutator_context::MutatorConfig;
+use crate::plan::AllocationSemantics as AllocationType;
+use crate::plan::Plan;
+use crate::util::alloc::allocators::{AllocatorSelector, Allocators};
+use crate::vm::VMBinding;
+use crate::{
+    plan::barriers::NoBarrier,
+    util::opaque_pointer::{VMMutatorThread, VMWorkerThread},
+};
+use enum_map::enum_map;
+use enum_map::EnumMap;
+
+/// Prepare mutator. Do nothing.
+fn pp_mutator_prepare<VM: VMBinding>(_mutator: &mut Mutator<VM>, _tls: VMWorkerThread) {}
+
+/// Release mutator. Do nothing.
+fn pp_mutator_release<VM: VMBinding>(_mutator: &mut Mutator<VM>, _tls: VMWorkerThread) {}
+
+lazy_static! {
+    pub static ref ALLOCATOR_MAPPING: EnumMap<AllocationType, AllocatorSelector> = enum_map! {
+        AllocationType::Default | AllocationType::Los => AllocatorSelector::LargeObject(0),
+        // Temporarily put code and readonly objects to immortal space, for v8 support.
+        AllocationType::Immortal | AllocationType::Code | AllocationType::ReadOnly => AllocatorSelector::BumpPointer(0),
+    };
+}
+
+/// Create a mutator instance.
+/// Every object is allocated to LOS.
+pub fn create_pp_mutator<VM: VMBinding>(
+    mutator_tls: VMMutatorThread,
+    plan: &'static dyn Plan<VM = VM>,
+) -> Mutator<VM> {
+    let page = plan.downcast_ref::<PageProtect<VM>>().unwrap();
+    let config = MutatorConfig {
+        allocator_mapping: &*ALLOCATOR_MAPPING,
+        space_mapping: box vec![
+            (
+                AllocatorSelector::BumpPointer(0),
+                page.common.get_immortal(),
+            ),
+            (AllocatorSelector::LargeObject(0), &page.space),
+        ],
+        prepare_func: &pp_mutator_prepare,
+        release_func: &pp_mutator_release,
+    };
+
+    Mutator {
+        allocators: Allocators::<VM>::new(mutator_tls, plan, &config.space_mapping),
+        barrier: box NoBarrier,
+        mutator_tls,
+        config,
+        plan,
+    }
+}