< prev index next >

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

Print this page
@@ -1,7 +1,7 @@
  /*
-  * Copyright (c) 2018, 2020, Red Hat, Inc. All rights reserved.
+  * Copyright (c) 2018, 2021, Red Hat, Inc. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

@@ -22,16 +22,19 @@
   *
   */
  
  #include "precompiled.hpp"
  #include "gc/shared/gcCause.hpp"
+ #include "gc/shenandoah/shenandoahAllocRequest.hpp"
  #include "gc/shenandoah/shenandoahCollectionSet.inline.hpp"
  #include "gc/shenandoah/shenandoahCollectorPolicy.hpp"
+ #include "gc/shenandoah/shenandoahGeneration.hpp"
  #include "gc/shenandoah/shenandoahHeap.inline.hpp"
  #include "gc/shenandoah/shenandoahHeapRegion.inline.hpp"
  #include "gc/shenandoah/shenandoahMarkingContext.inline.hpp"
  #include "gc/shenandoah/heuristics/shenandoahHeuristics.hpp"
+ #include "gc/shenandoah/mode/shenandoahMode.hpp"
  #include "logging/log.hpp"
  #include "logging/logTag.hpp"
  #include "runtime/globals_extension.hpp"
  
  int ShenandoahHeuristics::compare_by_garbage(RegionData a, RegionData b) {

@@ -40,14 +43,16 @@
    else if (a._garbage < b._garbage)
      return 1;
    else return 0;
  }
  
- ShenandoahHeuristics::ShenandoahHeuristics() :
+ ShenandoahHeuristics::ShenandoahHeuristics(ShenandoahGeneration* generation) :
+   _generation(generation),
    _region_data(NULL),
    _degenerated_cycles_in_a_row(0),
    _successful_cycles_in_a_row(0),
+   _guaranteed_gc_interval(0),
    _cycle_start(os::elapsedTime()),
    _last_cycle_end(0),
    _gc_times_learned(0),
    _gc_time_penalties(0),
    _gc_time_history(new TruncatedSeq(10, ShenandoahAdaptiveDecayFactor)),

@@ -66,15 +71,18 @@
  
  ShenandoahHeuristics::~ShenandoahHeuristics() {
    FREE_C_HEAP_ARRAY(RegionGarbage, _region_data);
  }
  
- void ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) {
-   assert(collection_set->count() == 0, "Must be empty");
- 
+ // Returns true iff the chosen collection set includes old-gen regions
+ bool ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set, ShenandoahOldHeuristics* old_heuristics) {
+   bool result = false;
    ShenandoahHeap* heap = ShenandoahHeap::heap();
  
+   assert(collection_set->count() == 0, "Must be empty");
+   assert(_generation->generation_mode() != OLD, "Old GC invokes ShenandoahOldHeuristics::choose_collection_set()");
+ 
    // Check all pinned regions have updated status before choosing the collection set.
    heap->assert_pinned_region_status();
  
    // Step 1. Build up the region candidates we care about, rejecting losers and accepting winners right away.
  

@@ -90,14 +98,17 @@
    size_t immediate_regions = 0;
  
    size_t free = 0;
    size_t free_regions = 0;
  
-   ShenandoahMarkingContext* const ctx = heap->complete_marking_context();
+   ShenandoahMarkingContext* const ctx = _generation->complete_marking_context();
  
    for (size_t i = 0; i < num_regions; i++) {
      ShenandoahHeapRegion* region = heap->get_region(i);
+     if (!in_generation(region)) {
+       continue;
+     }
  
      size_t garbage = region->garbage();
      total_garbage += garbage;
  
      if (region->is_empty()) {

@@ -108,16 +119,26 @@
          // We can recycle it right away and put it in the free set.
          immediate_regions++;
          immediate_garbage += garbage;
          region->make_trash_immediate();
        } else {
+         assert (_generation->generation_mode() != OLD, "OLD is handled elsewhere");
+ 
          // This is our candidate for later consideration.
          candidates[cand_idx]._region = region;
+         if (heap->mode()->is_generational() && (region->age() >= InitialTenuringThreshold)) {
+           // Bias selection of regions that have reached tenure age
+           for (int i = region->age() - InitialTenuringThreshold; i >= 0; i--) {
+             // Avoid floating-point math with integer multiply and shift.
+             garbage = (garbage * ShenandoahTenuredRegionUsageBias) >> ShenandoahTenuredRegionUsageBiasLogBase2;
+           }
+         }
          candidates[cand_idx]._garbage = garbage;
          cand_idx++;
        }
      } 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 = ctx->is_marked(cast_to_oop(region->bottom()));
        assert(reg_live == bm_live,

@@ -147,10 +168,20 @@
            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);
  
    if (immediate_percent <= ShenandoahImmediateThreshold) {
+ 
+     if (old_heuristics != NULL) {
+       if (old_heuristics->prime_collection_set(collection_set)) {
+         result = true;
+       }
+     }
+     // else, this is global collection and doesn't need to prime_collection_set
+ 
+     // Add young-gen regions into the collection set.  This is a virtual call, implemented differently by each
+     // of the heuristics subclasses.
      choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free);
    }
  
    size_t cset_percent = (total_garbage == 0) ? 0 : (collection_set->garbage() * 100 / total_garbage);
  

@@ -170,10 +201,11 @@
                       immediate_percent,
  
                       byte_size_in_proper_unit(collection_set->garbage()),
                       proper_unit_for_byte_size(collection_set->garbage()),
                       cset_percent);
+   return result;
  }
  
  void ShenandoahHeuristics::record_cycle_start() {
    _cycle_start = os::elapsedTime();
  }

@@ -188,15 +220,15 @@
      // Some of vmTestbase/metaspace tests depend on following line to count GC cycles
      log_info(gc)("Trigger: %s", GCCause::to_string(GCCause::_metadata_GC_threshold));
      return true;
    }
  
-   if (ShenandoahGuaranteedGCInterval > 0) {
+   if (_guaranteed_gc_interval > 0) {
      double last_time_ms = (os::elapsedTime() - _last_cycle_end) * 1000;
-     if (last_time_ms > ShenandoahGuaranteedGCInterval) {
-       log_info(gc)("Trigger: Time since last GC (%.0f ms) is larger than guaranteed interval (" UINTX_FORMAT " ms)",
-                    last_time_ms, ShenandoahGuaranteedGCInterval);
+     if (last_time_ms > _guaranteed_gc_interval) {
+       log_info(gc)("Trigger (%s): Time since last GC (%.0f ms) is larger than guaranteed interval (" UINTX_FORMAT " ms)",
+                    _generation->name(), last_time_ms, _guaranteed_gc_interval);
        return true;
      }
    }
  
    return false;

@@ -206,11 +238,11 @@
    return _degenerated_cycles_in_a_row <= ShenandoahFullGCThreshold;
  }
  
  void ShenandoahHeuristics::adjust_penalty(intx step) {
    assert(0 <= _gc_time_penalties && _gc_time_penalties <= 100,
-           "In range before adjustment: " INTX_FORMAT, _gc_time_penalties);
+          "In range before adjustment: " INTX_FORMAT, _gc_time_penalties);
  
    intx new_val = _gc_time_penalties + step;
    if (new_val < 0) {
      new_val = 0;
    }

@@ -218,11 +250,11 @@
      new_val = 100;
    }
    _gc_time_penalties = new_val;
  
    assert(0 <= _gc_time_penalties && _gc_time_penalties <= 100,
-           "In range after adjustment: " INTX_FORMAT, _gc_time_penalties);
+          "In range after adjustment: " INTX_FORMAT, _gc_time_penalties);
  }
  
  void ShenandoahHeuristics::record_success_concurrent() {
    _degenerated_cycles_in_a_row = 0;
    _successful_cycles_in_a_row++;

@@ -286,5 +318,12 @@
  }
  
  double ShenandoahHeuristics::time_since_last_gc() const {
    return os::elapsedTime() - _cycle_start;
  }
+ 
+ bool ShenandoahHeuristics::in_generation(ShenandoahHeapRegion* region) {
+   return ((_generation->generation_mode() == GLOBAL)
+           || (_generation->generation_mode() == YOUNG && region->affiliation() == YOUNG_GENERATION)
+           || (_generation->generation_mode() == OLD && region->affiliation() == OLD_GENERATION));
+ }
+ 
< prev index next >