Implement mem balancer

src/plan/generational/copying/global.rs

@@ -151,6 +151,10 @@ impl<VM: VMBinding> Plan for GenCopy<VM> {
         self.tospace().available_physical_pages()
     }
 
+    fn get_mature_reserved_pages(&self) -> usize {
+        self.tospace().reserved_pages()
+    }
+
     fn base(&self) -> &BasePlan<VM> {
         &self.gen.common.base
     }
@@ -159,8 +163,8 @@ impl<VM: VMBinding> Plan for GenCopy<VM> {
         &self.gen.common
     }
 
-    fn generational(&self) -> &Gen<VM> {
-        &self.gen
+    fn generational(&self) -> Option<&Gen<VM>> {
+        Some(&self.gen)
     }
 
     fn is_current_gc_nursery(&self) -> bool {

src/plan/generational/gc_work.rs

@@ -24,7 +24,7 @@ impl<VM: VMBinding> ProcessEdgesWork for GenNurseryProcessEdges<VM> {
 
     fn new(edges: Vec<EdgeOf<Self>>, roots: bool, mmtk: &'static MMTK<VM>) -> Self {
         let base = ProcessEdgesBase::new(edges, roots, mmtk);
-        let gen = base.plan().generational();
+        let gen = base.plan().generational().unwrap();
         Self { gen, base }
     }
     #[inline]

src/plan/generational/global.rs

@@ -5,7 +5,6 @@ use crate::plan::Plan;
 use crate::policy::copyspace::CopySpace;
 use crate::policy::space::Space;
 use crate::scheduler::*;
-use crate::util::conversions;
 use crate::util::copy::CopySemantics;
 use crate::util::heap::VMRequest;
 use crate::util::metadata::side_metadata::SideMetadataSanity;
@@ -42,7 +41,7 @@ impl<VM: VMBinding> Gen<VM> {
             args.get_space_args(
                 "nursery",
                 true,
-                VMRequest::fixed_extent(args.global_args.options.get_max_nursery(), false),
+                VMRequest::fixed_extent(args.global_args.options.get_max_nursery_bytes(), false),
             ),
             true,
         );
@@ -111,8 +110,15 @@ impl<VM: VMBinding> Gen<VM> {
         space_full: bool,
         space: Option<&dyn Space<VM>>,
     ) -> bool {
-        let nursery_full = self.nursery.reserved_pages()
-            >= (conversions::bytes_to_pages_up(self.common.base.options.get_max_nursery()));
+        let cur_nursery = self.nursery.reserved_pages();
+        let max_nursery = self.common.base.options.get_max_nursery_pages();
+        let nursery_full = cur_nursery >= max_nursery;
+        trace!(
+            "nursery_full = {:?} (nursery = {}, max_nursery = {})",
+            nursery_full,
+            cur_nursery,
+            max_nursery,
+        );
 
         if nursery_full {
             return true;
@@ -151,6 +157,7 @@ impl<VM: VMBinding> Gen<VM> {
         // The conditions are complex, and it is easier to read if we put them to separate if blocks.
         #[allow(clippy::if_same_then_else, clippy::needless_bool)]
         let is_full_heap = if crate::plan::generational::FULL_NURSERY_GC {
+            trace!("full heap: forced full heap");
             // For barrier overhead measurements, we always do full gc in nursery collections.
             true
         } else if self
@@ -160,6 +167,7 @@ impl<VM: VMBinding> Gen<VM> {
             .load(Ordering::SeqCst)
             && *self.common.base.options.full_heap_system_gc
         {
+            trace!("full heap: user triggered");
             // User triggered collection, and we force full heap for user triggered collection
             true
         } else if self.next_gc_full_heap.load(Ordering::SeqCst)
@@ -170,9 +178,18 @@ impl<VM: VMBinding> Gen<VM> {
                 .load(Ordering::SeqCst)
                 > 1
         {
+            trace!(
+                "full heap: next_gc_full_heap = {}, cur_collection_attempts = {}",
+                self.next_gc_full_heap.load(Ordering::SeqCst),
+                self.common
+                    .base
+                    .cur_collection_attempts
+                    .load(Ordering::SeqCst)
+            );
             // Forces full heap collection
             true
         } else if self.virtual_memory_exhausted(plan) {
+            trace!("full heap: virtual memory exhausted");
             true
         } else {
             // We use an Appel-style nursery. The default GC (even for a "heap-full" collection)
@@ -250,8 +267,16 @@ impl<VM: VMBinding> Gen<VM> {
     /// [`get_available_pages`](crate::plan::Plan::get_available_pages)
     /// whose value depends on which spaces have been released.
     pub fn should_next_gc_be_full_heap(plan: &dyn Plan<VM = VM>) -> bool {
-        plan.get_available_pages()
-            < conversions::bytes_to_pages_up(plan.base().options.get_min_nursery())
+        let available = plan.get_available_pages();
+        let min_nursery = plan.base().options.get_min_nursery_pages();
+        let next_gc_full_heap = available < min_nursery;
+        trace!(
+            "next gc will be full heap? {}, availabe pages = {}, min nursery = {}",
+            next_gc_full_heap,
+            available,
+            min_nursery
+        );
+        next_gc_full_heap
     }
 
     /// Set next_gc_full_heap to the given value.

src/plan/generational/immix/global.rs

@@ -193,6 +193,10 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
         self.immix.available_physical_pages()
     }
 
+    fn get_mature_reserved_pages(&self) -> usize {
+        self.immix.reserved_pages()
+    }
+
     fn base(&self) -> &BasePlan<VM> {
         &self.gen.common.base
     }
@@ -201,8 +205,8 @@ impl<VM: VMBinding> Plan for GenImmix<VM> {
         &self.gen.common
     }
 
-    fn generational(&self) -> &Gen<VM> {
-        &self.gen
+    fn generational(&self) -> Option<&Gen<VM>> {
+        Some(&self.gen)
     }
 
     fn is_current_gc_nursery(&self) -> bool {

src/plan/global.rs

@@ -175,8 +175,8 @@ pub trait Plan: 'static + Sync + Downcast {
     fn common(&self) -> &CommonPlan<Self::VM> {
         panic!("Common Plan not handled!")
     }
-    fn generational(&self) -> &Gen<Self::VM> {
-        panic!("This is not a generational plan.")
+    fn generational(&self) -> Option<&Gen<Self::VM>> {
+        None
     }
     fn mmapper(&self) -> &'static Mmapper {
         self.base().mmapper
@@ -282,6 +282,12 @@ pub trait Plan: 'static + Sync + Downcast {
         panic!("This is not a generational plan.")
     }
 
+    /// Return the number of used pages in the mature space. Only
+    /// generational plans have to implement this function.
+    fn get_mature_reserved_pages(&self) -> usize {
+        panic!("This is not a generational plan.")
+    }
+
     /// Get the number of pages that are reserved for collection. By default, we return 0.
     /// For copying plans, they need to override this and calculate required pages to complete
     /// a copying GC.

src/scheduler/gc_work.rs

@@ -108,6 +108,8 @@ impl<C: GCWorkContext> Release<C> {
 impl<C: GCWorkContext + 'static> GCWork<C::VM> for Release<C> {
     fn do_work(&mut self, worker: &mut GCWorker<C::VM>, mmtk: &'static MMTK<C::VM>) {
         trace!("Release Global");
+        self.plan.base().gc_trigger.policy.on_gc_release(mmtk);
+
         <C::VM as VMBinding>::VMCollection::vm_release();
         // We assume this is the only running work packet that accesses plan at the point of execution
         #[allow(clippy::cast_ref_to_mut)]