src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp

rev 7994 : [mq]: filter

@@ -3470,34 +3470,54 @@
   size_t _total_humongous;
   size_t _candidate_humongous;
 
   DirtyCardQueue _dcq;
 
+  // We don't nominate objects with many remembered set entries, on
+  // the assumption that such objects are likely still live.
+  bool is_remset_small(HeapRegion* region) const {
+    HeapRegionRemSet* const rset = region->rem_set();
+    return G1EagerReclaimHumongousObjectsWithStaleRefs
+      ? rset->occupancy_less_or_equal_than(G1RSetSparseRegionEntries)
+      : rset->is_empty();
+  }
+
+  bool is_typeArray_region(HeapRegion* region) const {
+    return oop(region->bottom())->is_typeArray();
+  }
+
   bool humongous_region_is_candidate(G1CollectedHeap* heap, HeapRegion* region) const {
     assert(region->is_starts_humongous(), "Must start a humongous object");
-    if (heap->mark_in_progress() &&
-        (region->bottom() < region->next_top_at_mark_start())) {
-      // While concurrent marking is in progress, disallow eager
-      // reclaim of humongous objects that existed at the start of the
-      // marking cycle.  For objects containing references, this
-      // avoids SATB violations; such objects must be scanned.  This
-      // also avoids problems when eagerly reclaiming an object that
-      // has been marked and placed in the mark stack, but has not yet
-      // been scanned.
-      return false;
-    } else if (!oop(region->bottom())->is_typeArray()) {
-      // For now, only permit reclaiming of humongous is_typeArray()
-      // objects.  For objects containing references, there is more
-      // work to be done to deal with remembered sets from the object.
-      return false;
-    } else {
-      HeapRegionRemSet* const rset = region->rem_set();
-      if (G1EagerReclaimHumongousObjectsWithStaleRefs) {
-        return rset->occupancy_less_or_equal_than(G1RSetSparseRegionEntries);
+
+    if (!heap->mark_in_progress()
+        || (region->bottom() >= region->next_top_at_mark_start())) {
+      // In order to maintain SATB invariants, during concurrent mark
+      // we should only nominate an object containing references if it
+      // was allocated after the start of marking, as such an object
+      // doesn't need to have its references scanned.
+      //
+      // Also, we must not reclaim an object that is in the concurrent
+      // mark stack.  Objects allocated since the start of marking are
+      // never added to the mark stack.
+
+      // However, we presently only nominate is_typeArray() objects.
+      // A humongous object containing references induces remembered
+      // set entries on other regions.  In order to reclaim such an
+      // object, those remembered sets would need to be cleaned up.
+      return is_typeArray_region(region) && is_remset_small(region);
+
       } else {
-        return rset->is_empty();
-      }
+      // We may allow nomination of is_typeArray() objects that were
+      // allocated before the start of concurrent marking.  For this
+      // we rely on mark stack insertion to exclude is_typeArray()
+      // objects, preventing reclaiming an object that is in the mark
+      // stack.  Frequent allocation and drop of large binary blobs is
+      // an important use case for eager reclaim, and this special
+      // handling may reduce needed headroom.
+      return G1EagerReclaimHumongousPreSnapshotTypeArrays
+        && is_typeArray_region(region)
+        && is_remset_small(region);
     }
   }
 
  public:
   RegisterHumongousWithInCSetFastTestClosure()