Keep pending allocation pages in reserved_pages. Use reserved_pages as

live for mem balancer

src/policy/space.rs

@@ -69,8 +69,8 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
         if should_poll && self.get_gc_trigger().poll(false, Some(self.as_space())) {
             debug!("Collection required");
             assert!(allow_gc, "GC is not allowed here: collection is not initialized (did you call initialize_collection()?).");
-            pr.clear_request(pages_reserved);
             VM::VMCollection::block_for_gc(VMMutatorThread(tls)); // We have checked that this is mutator
+            pr.clear_request(pages_reserved); // clear the pages after GC. We need those reserved pages so we can compute new heap size properly.
             unsafe { Address::zero() }
         } else {
             debug!("Collection not required");
@@ -176,8 +176,8 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
 
                     let gc_performed = self.get_gc_trigger().poll(true, Some(self.as_space()));
                     debug_assert!(gc_performed, "GC not performed when forced.");
-                    pr.clear_request(pages_reserved);
                     VM::VMCollection::block_for_gc(VMMutatorThread(tls)); // We asserted that this is mutator.
+                    pr.clear_request(pages_reserved); // clear the pages after GC. We need those reserved pages so we can compute new heap size properly.
                     unsafe { Address::zero() }
                 }
             }

src/util/heap/gc_trigger.rs

@@ -143,7 +143,13 @@ pub struct MemBalancerTrigger {
 impl<VM: VMBinding> GCTriggerPolicy<VM> for MemBalancerTrigger {
     fn on_gc_end(&self, mmtk: &'static MMTK<VM>) {
         // live memory after a GC
-        let live = mmtk.plan.get_used_pages() as f64;
+        // Use reserved pages here: reserved pages includes the pending allocation requests that haven't been completed. Using
+        // reserved pages makes sure that the new heap size could accomodate those pending allocation.
+        // Otherwise, we may get into a stuck state where our computed heap size does not accomodate the next allocation,
+        // and a GC is triggered. But the GC cannot collect anything, thus live bytes does not change, and the heap size
+        // does not update. And we still cannot accomodate the next allocation. We have to avoid this, and make sure
+        // our computed heap size works for the currently pending allocation.
+        let live = mmtk.plan.get_reserved_pages() as f64;
         // We use a simplified version of mem balancer. Instead of collecting allocation/collection speed and a constant c,
         // we use a fixed constant 4096 instead.
         let optimal_heap = (live + (live * 4096f64).sqrt()) as usize;