8378293: GenShen: Simplify selection of aged regions

Reviewed-by: kdnilsen, ysr

Author: William Kemper

src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp

@@ -27,6 +27,7 @@
 
 
 #include "gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp"
+#include "gc/shenandoah/shenandoahInPlacePromoter.hpp"
 
 class ShenandoahGeneration;
 class ShenandoahHeap;
@@ -53,7 +54,7 @@ class ShenandoahGenerationalHeuristics : public ShenandoahAdaptiveHeuristics {
 
 private:
   // Compute evacuation budgets prior to choosing collection set.
-  void compute_evacuation_budgets(ShenandoahHeap* const heap);
+  void compute_evacuation_budgets(ShenandoahInPlacePromotionPlanner& in_place_promotions, ShenandoahHeap* const heap);
 
   // Preselect for possible inclusion into the collection set exactly the most
   // garbage-dense regions, including those that satisfy criteria 1 & 2 below,
@@ -70,10 +71,10 @@ class ShenandoahGenerationalHeuristics : public ShenandoahAdaptiveHeuristics {
   // regions, which are marked in the preselected_regions() indicator
   // array of the heap's collection set, which should be initialized
   // to false.
-  size_t select_aged_regions(const size_t old_promotion_reserve);
+  size_t select_aged_regions(ShenandoahInPlacePromotionPlanner& in_place_promotions, const size_t old_promotion_reserve);
 
   // Filter and sort remaining regions before adding to collection set.
-  void filter_regions(ShenandoahCollectionSet* collection_set);
+  void filter_regions(ShenandoahInPlacePromotionPlanner& in_place_promotions, ShenandoahCollectionSet* collection_set);
 
   // Adjust evacuation budgets after choosing collection set.  The argument regions_to_xfer
   // represents regions to be transferred to old based on decisions made in top_off_collection_set()
@@ -84,10 +85,6 @@ class ShenandoahGenerationalHeuristics : public ShenandoahAdaptiveHeuristics {
   ShenandoahGeneration* _generation;
 
   size_t _add_regions_to_old;
-
-  size_t add_preselected_regions_to_collection_set(ShenandoahCollectionSet* cset,
-                                                   const RegionData* data,
-                                                   size_t size) const;
 };
 
 

src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp

@@ -127,7 +127,7 @@ void ShenandoahGlobalHeuristics::choose_global_collection_set(ShenandoahCollecti
   size_t cur_garbage = cur_young_garbage;
   for (size_t idx = 0; idx < size; idx++) {
     ShenandoahHeapRegion* r = data[idx].get_region();
-    assert(!cset->is_preselected(r->index()), "There should be no preselected regions during GLOBAL GC");
+    assert(!cset->is_in(r->index()), "Region (%zu) should not be in the collection set", r->index());
     bool add_region = false;
     size_t region_garbage = r->garbage();
     size_t new_garbage = cur_garbage + region_garbage;

src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp

@@ -122,13 +122,7 @@ void ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collec
       }
     } else if (region->is_humongous_start()) {
       // Reclaim humongous regions here, and count them as the immediate garbage
-#ifdef ASSERT
-      bool reg_live = region->has_live();
-      bool bm_live = heap->global_generation()->complete_marking_context()->is_marked(cast_to_oop(region->bottom()));
-      assert(reg_live == bm_live,
-             "Humongous liveness and marks should agree. Region live: %s; Bitmap live: %s; Region Live Words: %zu",
-             BOOL_TO_STR(reg_live), BOOL_TO_STR(bm_live), region->get_live_data_words());
-#endif
+      DEBUG_ONLY(assert_humongous_mark_consistency(region));
       if (!region->has_live()) {
         heap->trash_humongous_region_at(region);
 
@@ -137,21 +131,19 @@ void ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collec
         immediate_garbage += garbage;
       }
     } else if (region->is_trash()) {
-      // Count in just trashed collection set, during coalesced CM-with-UR
+      // Count in just trashed humongous continuation regions
       immediate_regions++;
       immediate_garbage += garbage;
     }
   }
 
   // Step 2. Look back at garbage statistics, and decide if we want to collect anything,
   // given the amount of immediately reclaimable garbage. If we do, figure out the collection set.
+  assert(immediate_garbage <= total_garbage,
+         "Cannot have more immediate garbage than total garbage: " PROPERFMT " vs " PROPERFMT,
+         PROPERFMTARGS(immediate_garbage), PROPERFMTARGS(total_garbage));
 
-  assert (immediate_garbage <= total_garbage,
-          "Cannot have more immediate garbage than total garbage: %zu%s vs %zu%s",
-          byte_size_in_proper_unit(immediate_garbage), proper_unit_for_byte_size(immediate_garbage),
-          byte_size_in_proper_unit(total_garbage),     proper_unit_for_byte_size(total_garbage));
-
-  size_t immediate_percent = (total_garbage == 0) ? 0 : (immediate_garbage * 100 / total_garbage);
+  const size_t immediate_percent = (total_garbage == 0) ? 0 : (immediate_garbage * 100 / total_garbage);
 
   if (immediate_percent <= ShenandoahImmediateThreshold) {
     choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free);
@@ -303,3 +295,16 @@ double ShenandoahHeuristics::elapsed_degenerated_cycle_time() const {
   double now = os::elapsedTime();
   return now - _precursor_cycle_start;
 }
+
+#ifdef ASSERT
+void ShenandoahHeuristics::assert_humongous_mark_consistency(ShenandoahHeapRegion* region) {
+  assert(region->is_humongous(), "Region %zu must be humongous", region->index());
+  const oop humongous_oop = cast_to_oop(region->bottom());
+  ShenandoahGeneration* generation = ShenandoahHeap::heap()->generation_for(region->affiliation());
+  const bool bm_live = generation->complete_marking_context()->is_marked(humongous_oop);
+  const bool reg_live = region->has_live();
+  assert(reg_live == bm_live,
+         "Humongous liveness and marks should agree. Region live: %s; Bitmap live: %s; Region Live Words: %zu",
+         BOOL_TO_STR(reg_live), BOOL_TO_STR(bm_live), region->get_live_data_words());
+}
+#endif

src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp

@@ -285,6 +285,8 @@ class ShenandoahHeuristics : public CHeapObj<mtGC> {
 
   // Format prefix and emit log message indicating a GC cycle hs been triggered
   void log_trigger(const char* fmt, ...) ATTRIBUTE_PRINTF(2, 3);
+
+  DEBUG_ONLY(static void assert_humongous_mark_consistency(ShenandoahHeapRegion* region));
 };
 
 #endif // SHARE_GC_SHENANDOAH_HEURISTICS_SHENANDOAHHEURISTICS_HPP

src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp

@@ -54,9 +54,7 @@ void ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(Shenandoah
   // Better select garbage-first regions
   QuickSort::sort<RegionData>(data, size, compare_by_garbage);
 
-  size_t cur_young_garbage = add_preselected_regions_to_collection_set(cset, data, size);
-
-  choose_young_collection_set(cset, data, size, actual_free, cur_young_garbage);
+  choose_young_collection_set(cset, data, size, actual_free);
 
   // Especially when young-gen trigger is expedited in order to finish mixed evacuations, there may not be
   // enough consolidated garbage to make effective use of young-gen evacuation reserve.  If there is still
@@ -70,8 +68,7 @@ void ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(Shenandoah
 
 void ShenandoahYoungHeuristics::choose_young_collection_set(ShenandoahCollectionSet* cset,
                                                             const RegionData* data,
-                                                            size_t size, size_t actual_free,
-                                                            size_t cur_young_garbage) const {
+                                                            size_t size, size_t actual_free) const {
 
   const auto heap = ShenandoahGenerationalHeap::heap();
 
@@ -82,23 +79,20 @@ void ShenandoahYoungHeuristics::choose_young_collection_set(ShenandoahCollection
   // This is young-gen collection or a mixed evacuation.
   // If this is mixed evacuation, the old-gen candidate regions have already been added.
   size_t cur_cset = 0;
+  size_t cur_young_garbage = cset->garbage();
   const size_t max_cset = (size_t) (heap->young_generation()->get_evacuation_reserve() / ShenandoahEvacWaste);
   const size_t free_target = (capacity * ShenandoahMinFreeThreshold) / 100 + max_cset;
   const size_t min_garbage = (free_target > actual_free) ? (free_target - actual_free) : 0;
 
-
   log_info(gc, ergo)(
-          "Adaptive CSet Selection for YOUNG. Max Evacuation: %zu%s, Actual Free: %zu%s.",
-          byte_size_in_proper_unit(max_cset), proper_unit_for_byte_size(max_cset),
-          byte_size_in_proper_unit(actual_free), proper_unit_for_byte_size(actual_free));
+          "Adaptive CSet Selection for YOUNG. Max Evacuation: " PROPERFMT ", Actual Free: " PROPERFMT,
+          PROPERFMTARGS(max_cset), PROPERFMTARGS(actual_free));
 
   for (size_t idx = 0; idx < size; idx++) {
     ShenandoahHeapRegion* r = data[idx].get_region();
-    if (cset->is_preselected(r->index())) {
-      continue;
-    }
+    assert(!cset->is_in(r), "Region %zu should not already be in the collection set", idx);
 
-    // Note that we do not add tenurable regions if they were not pre-selected.  They were not preselected
+    // Note that we do not add tenurable regions if they were not pre-selected.  They were not selected
     // because there is insufficient room in old-gen to hold their to-be-promoted live objects or because
     // they are to be promoted in place.
     if (!heap->is_tenurable(r)) {

src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp

@@ -49,8 +49,7 @@ class ShenandoahYoungHeuristics : public ShenandoahGenerationalHeuristics {
 private:
   void choose_young_collection_set(ShenandoahCollectionSet* cset,
                                    const RegionData* data,
-                                   size_t size, size_t actual_free,
-                                   size_t cur_young_garbage) const;
+                                   size_t size, size_t actual_free) const;
 
 };
 

src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp

@@ -49,7 +49,6 @@ ShenandoahCollectionSet::ShenandoahCollectionSet(ShenandoahHeap* heap, ReservedS
   _live(0),
   _region_count(0),
   _old_garbage(0),
-  _preselected_regions(nullptr),
   _young_available_bytes_collected(0),
   _old_available_bytes_collected(0),
   _current_index(0) {

src/hotspot/share/gc/shenandoah/shenandoahCollectionSet.cpp

@@ -36,13 +36,6 @@
 
 class ShenandoahCollectionSet : public CHeapObj<mtGC> {
   friend class ShenandoahHeap;
-  friend class ShenandoahCollectionSetPreselector;
-
-  void establish_preselected(bool *preselected) {
-   assert(_preselected_regions == nullptr, "Over-writing");
-   _preselected_regions = preselected;
-  }
-  void abandon_preselected() { _preselected_regions = nullptr; }
 
 private:
   size_t const          _map_size;
@@ -67,11 +60,6 @@ class ShenandoahCollectionSet : public CHeapObj<mtGC> {
   // How many bytes of old garbage are present in a mixed collection set?
   size_t                _old_garbage;
 
-  // Points to array identifying which tenure-age regions have been preselected
-  // for inclusion in collection set. This field is only valid during brief
-  // spans of time while collection set is being constructed.
-  bool*                 _preselected_regions;
-
   // When a region having memory available to be allocated is added to the collection set, the region's available memory
   // should be subtracted from what's available.
   size_t                _young_available_bytes_collected;
@@ -132,16 +120,6 @@ class ShenandoahCollectionSet : public CHeapObj<mtGC> {
   // Returns the amount of garbage in old regions in the collection set.
   inline size_t get_old_garbage() const;
 
-  bool is_preselected(size_t region_idx) {
-    assert(_preselected_regions != nullptr, "Missing establish after abandon");
-    return _preselected_regions[region_idx];
-  }
-
-  bool* preselected_regions() {
-    assert(_preselected_regions != nullptr, "Null ptr");
-    return _preselected_regions;
-  }
-
   bool has_old_regions() const { return _has_old_regions; }
   size_t used()          const { return _used; }
   size_t live()          const { return _live; }