jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp

equal deleted inserted replaced

-:e68b5a95367b
+:28b6fe22e43d
 _all_full_gc_times_ms(new NumberSeq()),
 _initiate_conc_mark_if_possible(false),
 _during_initial_mark_pause(false),
-_should_revert_to_young_gcs(false),
 _last_young_gc(false),
 _last_gc_was_young(false),
 _eden_bytes_before_gc(0),
 _survivor_bytes_before_gc(0),
 _par_last_termination_times_ms = new double[_parallel_gc_threads];
 _par_last_termination_attempts = new double[_parallel_gc_threads];
 _par_last_gc_worker_end_times_ms = new double[_parallel_gc_threads];
 _par_last_gc_worker_times_ms = new double[_parallel_gc_threads];
 _par_last_gc_worker_other_times_ms = new double[_parallel_gc_threads];
-// start conservatively
-_expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis;
 int index;
 if (ParallelGCThreads == 0)
 index = 0;
 else if (ParallelGCThreads > 8)
 // Don't calculate anything and let the code below bound it to
 // the desired_min_length, i.e., do the next GC as soon as
 // possible to maximize how many old regions we can add to it.
 }
 } else {
-if (gcs_are_young()) {
+// The user asked for a fixed young gen so we'll fix the young gen
-young_list_target_length = _young_list_fixed_length;
+// whether the next GC is young or mixed.
-} else {
+young_list_target_length = _young_list_fixed_length;
-// A bit arbitrary: during mixed GCs we allocate half
-// the young regions to try to add old regions to the CSet.
-young_list_target_length = _young_list_fixed_length / 2;
-// We choose to accept that we might go under the desired min
-// length given that we intentionally ask for a smaller young gen.
-desired_min_length = absolute_min_length;
-}
 }
 // Make sure we don't go over the desired max length, nor under the
 // desired min length. In case they clash, desired_min_length wins
 // which is why that test is second.
 // "Nuke" the heuristics that control the young/mixed GC
 // transitions and make sure we start with young GCs after the Full GC.
 set_gcs_are_young(true);
 _last_young_gc = false;
-_should_revert_to_young_gcs = false;
 clear_initiate_conc_mark_if_possible();
 clear_during_initial_mark_pause();
 _known_garbage_bytes = 0;
 _known_garbage_ratio = 0.0;
 _in_marking_window = false;
 _free_regions_at_end_of_collection = _g1->free_regions();
 // Reset survivors SurvRateGroup.
 _survivor_surv_rate_group->reset();
 update_young_list_target_length();
-_collectionSetChooser->updateAfterFullCollection();
+_collectionSetChooser->clearMarkedHeapRegions();
 }
 void G1CollectorPolicy::record_stop_world_start() {
 _stop_world_start = os::elapsedTime();
 }
 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() {
 _mark_cleanup_start_sec = os::elapsedTime();
 }
 void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() {
-_should_revert_to_young_gcs = false;
 _last_young_gc = true;
 _in_marking_window = false;
 }
 void G1CollectorPolicy::record_concurrent_pause() {
 #endif // PRODUCT
 last_pause_included_initial_mark = during_initial_mark_pause();
 if (last_pause_included_initial_mark) {
 record_concurrent_mark_init_end(0.0);
-}
+} else if (!_last_young_gc && need_to_start_conc_mark("end of GC")) {
-if (!_last_young_gc && need_to_start_conc_mark("end of GC")) {
 // Note: this might have already been set, if during the last
 // pause we decided to start a cycle but at the beginning of
 // this pause we decided to postpone it. That's OK.
 set_initiate_conc_mark_if_possible();
 }
 new_in_marking_window = true;
 new_in_marking_window_im = true;
 }
 if (_last_young_gc) {
+// This is supposed to to be the "last young GC" before we start
+// doing mixed GCs. Here we decide whether to start mixed GCs or not.
 if (!last_pause_included_initial_mark) {
-ergo_verbose2(ErgoMixedGCs,
+if (next_gc_should_be_mixed("start mixed GCs",
-"start mixed GCs",
+"do not start mixed GCs")) {
-ergo_format_byte_perc("known garbage"),
+set_gcs_are_young(false);
-_known_garbage_bytes, _known_garbage_ratio * 100.0);
+}
-set_gcs_are_young(false);
 } else {
 ergo_verbose0(ErgoMixedGCs,
 "do not start mixed GCs",
 ergo_format_reason("concurrent cycle is about to start"));
 }
 _last_young_gc = false;
 }
 if (!_last_gc_was_young) {
-if (_should_revert_to_young_gcs) {
+// This is a mixed GC. Here we decide whether to continue doing
-ergo_verbose2(ErgoMixedGCs,
+// mixed GCs or not.
-"end mixed GCs",
-ergo_format_reason("mixed GCs end requested")
+if (!next_gc_should_be_mixed("continue mixed GCs",
-ergo_format_byte_perc("known garbage"),
+"do not continue mixed GCs")) {
-_known_garbage_bytes, _known_garbage_ratio * 100.0);
 set_gcs_are_young(true);
-} else if (_known_garbage_ratio < 0.05) {
+}
-ergo_verbose3(ErgoMixedGCs,
+}
-"end mixed GCs",
-ergo_format_reason("known garbage percent lower than threshold")
-ergo_format_byte_perc("known garbage")
-ergo_format_perc("threshold"),
-_known_garbage_bytes, _known_garbage_ratio * 100.0,
-0.05 * 100.0);
-set_gcs_are_young(true);
-} else if (adaptive_young_list_length() &&
-(get_gc_eff_factor() * cur_efficiency < predict_young_gc_eff())) {
-ergo_verbose5(ErgoMixedGCs,
-"end mixed GCs",
-ergo_format_reason("current GC efficiency lower than "
-"predicted young GC efficiency")
-ergo_format_double("GC efficiency factor")
-ergo_format_double("current GC efficiency")
-ergo_format_double("predicted young GC efficiency")
-ergo_format_byte_perc("known garbage"),
-get_gc_eff_factor(), cur_efficiency,
-predict_young_gc_eff(),
-_known_garbage_bytes, _known_garbage_ratio * 100.0);
-set_gcs_are_young(true);
-}
-}
-_should_revert_to_young_gcs = false;
 if (_last_gc_was_young && !_during_marking) {
 _young_gc_eff_seq->add(cur_efficiency);
 }
 (double) _bytes_in_collection_set_before_gc;
 }
 _pending_cards_seq->add((double) _pending_cards);
 _rs_lengths_seq->add((double) _max_rs_lengths);
-double expensive_region_limit_ms =
-(double) MaxGCPauseMillis - predict_constant_other_time_ms();
-if (expensive_region_limit_ms < 0.0) {
-// this means that the other time was predicted to be longer than
-// than the max pause time
-expensive_region_limit_ms = (double) MaxGCPauseMillis;
-}
-_expensive_region_limit_ms = expensive_region_limit_ms;
 }
 _in_marking_window = new_in_marking_window;
 _in_marking_window_im = new_in_marking_window_im;
 _free_regions_at_end_of_collection = _g1->free_regions();
 G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) {
 size_t bytes_to_copy;
 if (hr->is_marked())
 bytes_to_copy = hr->max_live_bytes();
 else {
-guarantee( hr->is_young() && hr->age_in_surv_rate_group() != -1,
+assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "invariant");
-"invariant" );
 int age = hr->age_in_surv_rate_group();
 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group());
 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate);
 }
 return bytes_to_copy;
 }
 void
 G1CollectorPolicy::init_cset_region_lengths(size_t eden_cset_region_length,
 _old_cset_region_length      = 0;
 }
 void G1CollectorPolicy::set_recorded_rs_lengths(size_t rs_lengths) {
 _recorded_rs_lengths = rs_lengths;
-}
-void G1CollectorPolicy::check_if_region_is_too_expensive(double
-predicted_time_ms) {
-// I don't think we need to do this when in young GC mode since
-// marking will be initiated next time we hit the soft limit anyway...
-if (predicted_time_ms > _expensive_region_limit_ms) {
-ergo_verbose2(ErgoMixedGCs,
-"request mixed GCs end",
-ergo_format_reason("predicted region time higher than threshold")
-ergo_format_ms("predicted region time")
-ergo_format_ms("threshold"),
-predicted_time_ms, _expensive_region_limit_ms);
-// no point in doing another mixed GC
-_should_revert_to_young_gcs = true;
-}
 }
 void G1CollectorPolicy::update_recent_gc_times(double end_time_sec,
 double elapsed_ms) {
 _recent_gc_times_ms->add(elapsed_ms);
 }
 }
 }
 class KnownGarbageClosure: public HeapRegionClosure {
+G1CollectedHeap* _g1h;
 CollectionSetChooser* _hrSorted;
 public:
 KnownGarbageClosure(CollectionSetChooser* hrSorted) :
-_hrSorted(hrSorted)
+_g1h(G1CollectedHeap::heap()), _hrSorted(hrSorted) { }
-{}
 bool doHeapRegion(HeapRegion* r) {
 // We only include humongous regions in collection
 // sets when concurrent mark shows that their contained object is
 // unreachable.
 // Do we have any marking information for this region?
 if (r->is_marked()) {
-// We don't include humongous regions in collection
+// We will skip any region that's currently used as an old GC
-// sets because we collect them immediately at the end of a marking
+// alloc region (we should not consider those for collection
-// cycle.  We also don't include young regions because we *must*
+// before we fill them up).
-// include them in the next collection pause.
+if (_hrSorted->shouldAdd(r) && !_g1h->is_old_gc_alloc_region(r)) {
-if (!r->isHumongous() && !r->is_young()) {
 _hrSorted->addMarkedHeapRegion(r);
 }
 }
 return false;
 }
 };
 class ParKnownGarbageHRClosure: public HeapRegionClosure {
+G1CollectedHeap* _g1h;
 CollectionSetChooser* _hrSorted;
 jint _marked_regions_added;
+size_t _reclaimable_bytes_added;
 jint _chunk_size;
 jint _cur_chunk_idx;
 jint _cur_chunk_end; // Cur chunk [_cur_chunk_idx, _cur_chunk_end)
 int _worker;
 int _invokes;
 get_new_chunk();
 }
 assert(_cur_chunk_idx < _cur_chunk_end, "postcondition");
 _hrSorted->setMarkedHeapRegion(_cur_chunk_idx, r);
 _marked_regions_added++;
+_reclaimable_bytes_added += r->reclaimable_bytes();
 _cur_chunk_idx++;
 }
 public:
 ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted,
 jint chunk_size,
 int worker) :
-_hrSorted(hrSorted), _chunk_size(chunk_size), _worker(worker),
+_g1h(G1CollectedHeap::heap()),
-_marked_regions_added(0), _cur_chunk_idx(0), _cur_chunk_end(0),
+_hrSorted(hrSorted), _chunk_size(chunk_size), _worker(worker),
-_invokes(0)
+_marked_regions_added(0), _reclaimable_bytes_added(0),
-{}
+_cur_chunk_idx(0), _cur_chunk_end(0), _invokes(0) { }
 bool doHeapRegion(HeapRegion* r) {
 // We only include humongous regions in collection
 // sets when concurrent mark shows that their contained object is
 // unreachable.
 _invokes++;
 // Do we have any marking information for this region?
 if (r->is_marked()) {
-// We don't include humongous regions in collection
+// We will skip any region that's currently used as an old GC
-// sets because we collect them immediately at the end of a marking
+// alloc region (we should not consider those for collection
-// cycle.
+// before we fill them up).
-// We also do not include young regions in collection sets
+if (_hrSorted->shouldAdd(r) && !_g1h->is_old_gc_alloc_region(r)) {
-if (!r->isHumongous() && !r->is_young()) {
 add_region(r);
 }
 }
 return false;
 }
 jint marked_regions_added() { return _marked_regions_added; }
+size_t reclaimable_bytes_added() { return _reclaimable_bytes_added; }
 int invokes() { return _invokes; }
 };
 class ParKnownGarbageTask: public AbstractGangTask {
 CollectionSetChooser* _hrSorted;
 G1CollectedHeap* _g1;
 public:
 ParKnownGarbageTask(CollectionSetChooser* hrSorted, jint chunk_size) :
 AbstractGangTask("ParKnownGarbageTask"),
 _hrSorted(hrSorted), _chunk_size(chunk_size),
-_g1(G1CollectedHeap::heap())
+_g1(G1CollectedHeap::heap()) { }
-{}
 void work(uint worker_id) {
 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted,
 _chunk_size,
 worker_id);
 // Back to zero for the claim value.
 _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, worker_id,
 _g1->workers()->active_workers(),
 HeapRegion::InitialClaimValue);
 jint regions_added = parKnownGarbageCl.marked_regions_added();
-_hrSorted->incNumMarkedHeapRegions(regions_added);
+size_t reclaimable_bytes_added =
+parKnownGarbageCl.reclaimable_bytes_added();
+_hrSorted->updateTotals(regions_added, reclaimable_bytes_added);
 if (G1PrintParCleanupStats) {
 gclog_or_tty->print_cr("     Thread %d called %d times, added %d regions to list.",
 worker_id, parKnownGarbageCl.invokes(), regions_added);
 }
 }
 csr = next;
 }
 }
 #endif // !PRODUCT
-void G1CollectorPolicy::choose_collection_set(double target_pause_time_ms) {
+bool G1CollectorPolicy::next_gc_should_be_mixed(const char* true_action_str,
+const char* false_action_str) {
+CollectionSetChooser* cset_chooser = _collectionSetChooser;
+if (cset_chooser->isEmpty()) {
+ergo_verbose0(ErgoMixedGCs,
+false_action_str,
+ergo_format_reason("candidate old regions not available"));
+return false;
+}
+size_t reclaimable_bytes = cset_chooser->remainingReclaimableBytes();
+size_t capacity_bytes = _g1->capacity();
+double perc = (double) reclaimable_bytes * 100.0 / (double) capacity_bytes;
+double threshold = (double) G1OldReclaimableThresholdPercent;
+if (perc < threshold) {
+ergo_verbose4(ErgoMixedGCs,
+false_action_str,
+ergo_format_reason("reclaimable percentage lower than threshold")
+ergo_format_region("candidate old regions")
+ergo_format_byte_perc("reclaimable")
+ergo_format_perc("threshold"),
+cset_chooser->remainingRegions(),
+reclaimable_bytes, perc, threshold);
+return false;
+}
+ergo_verbose4(ErgoMixedGCs,
+true_action_str,
+ergo_format_reason("candidate old regions available")
+ergo_format_region("candidate old regions")
+ergo_format_byte_perc("reclaimable")
+ergo_format_perc("threshold"),
+cset_chooser->remainingRegions(),
+reclaimable_bytes, perc, threshold);
+return true;
+}
+void G1CollectorPolicy::finalize_cset(double target_pause_time_ms) {
 // Set this here - in case we're not doing young collections.
 double non_young_start_time_sec = os::elapsedTime();
 YoungList* young_list = _g1->young_list();
 finalize_incremental_cset_building();
 target_pause_time_ms));
 guarantee(_collection_set == NULL, "Precondition");
 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards);
 double predicted_pause_time_ms = base_time_ms;
 double time_remaining_ms = target_pause_time_ms - base_time_ms;
 ergo_verbose3(ErgoCSetConstruction | ErgoHigh,
 "start choosing CSet",
 ergo_format_ms("predicted base time")
 ergo_format_ms("remaining time")
 ergo_format_ms("target pause time"),
 base_time_ms, time_remaining_ms, target_pause_time_ms);
-// the 10% and 50% values are arbitrary...
-double threshold = 0.10 * target_pause_time_ms;
-if (time_remaining_ms < threshold) {
-double prev_time_remaining_ms = time_remaining_ms;
-time_remaining_ms = 0.50 * target_pause_time_ms;
-ergo_verbose3(ErgoCSetConstruction,
-"adjust remaining time",
-ergo_format_reason("remaining time lower than threshold")
-ergo_format_ms("remaining time")
-ergo_format_ms("threshold")
-ergo_format_ms("adjusted remaining time"),
-prev_time_remaining_ms, threshold, time_remaining_ms);
-}
-size_t expansion_bytes = _g1->expansion_regions() * HeapRegion::GrainBytes;
 HeapRegion* hr;
 double young_start_time_sec = os::elapsedTime();
 _collection_set_bytes_used_before = 0;
 // We are doing young collections so reset this.
 non_young_start_time_sec = young_end_time_sec;
 if (!gcs_are_young()) {
-bool should_continue = true;
+CollectionSetChooser* cset_chooser = _collectionSetChooser;
-NumberSeq seq;
+assert(cset_chooser->verify(), "CSet Chooser verification - pre");
-double avg_prediction = 100000000000000000.0; // something very large
+const size_t min_old_cset_length = cset_chooser->calcMinOldCSetLength();
+const size_t max_old_cset_length = cset_chooser->calcMaxOldCSetLength();
-double prev_predicted_pause_time_ms = predicted_pause_time_ms;
-do {
+size_t expensive_region_num = 0;
-// Note that add_old_region_to_cset() increments the
+bool check_time_remaining = adaptive_young_list_length();
-// _old_cset_region_length field and cset_region_length() returns the
+HeapRegion* hr = cset_chooser->peek();
-// sum of _eden_cset_region_length, _survivor_cset_region_length, and
+while (hr != NULL) {
-// _old_cset_region_length. So, as old regions are added to the
+if (old_cset_region_length() >= max_old_cset_length) {
-// CSet, _old_cset_region_length will be incremented and
+// Added maximum number of old regions to the CSet.
-// cset_region_length(), which is used below, will always reflect
+ergo_verbose2(ErgoCSetConstruction,
-// the the total number of regions added up to this point to the CSet.
+"finish adding old regions to CSet",
+ergo_format_reason("old CSet region num reached max")
-hr = _collectionSetChooser->getNextMarkedRegion(time_remaining_ms,
+ergo_format_region("old")
-avg_prediction);
+ergo_format_region("max"),
-if (hr != NULL) {
+old_cset_region_length(), max_old_cset_length);
-_g1->old_set_remove(hr);
+break;
-double predicted_time_ms = predict_region_elapsed_time_ms(hr, false);
-time_remaining_ms -= predicted_time_ms;
-predicted_pause_time_ms += predicted_time_ms;
-add_old_region_to_cset(hr);
-seq.add(predicted_time_ms);
-avg_prediction = seq.avg() + seq.sd();
 }
-should_continue = true;
+double predicted_time_ms = predict_region_elapsed_time_ms(hr, false);
-if (hr == NULL) {
+if (check_time_remaining) {
-// No need for an ergo verbose message here,
+if (predicted_time_ms > time_remaining_ms) {
-// getNextMarkRegion() does this when it returns NULL.
+// Too expensive for the current CSet.
-should_continue = false;
+if (old_cset_region_length() >= min_old_cset_length) {
+// We have added the minimum number of old regions to the CSet,
+// we are done with this CSet.
+ergo_verbose4(ErgoCSetConstruction,
+"finish adding old regions to CSet",
+ergo_format_reason("predicted time is too high")
+ergo_format_ms("predicted time")
+ergo_format_ms("remaining time")
+ergo_format_region("old")
+ergo_format_region("min"),
+predicted_time_ms, time_remaining_ms,
+old_cset_region_length(), min_old_cset_length);
+break;
+}
+// We'll add it anyway given that we haven't reached the
+// minimum number of old regions.
+expensive_region_num += 1;
+}
 } else {
-if (adaptive_young_list_length()) {
+if (old_cset_region_length() >= min_old_cset_length) {
-if (time_remaining_ms < 0.0) {
+// In the non-auto-tuning case, we'll finish adding regions
-ergo_verbose1(ErgoCSetConstruction,
+// to the CSet if we reach the minimum.
-"stop adding old regions to CSet",
+ergo_verbose2(ErgoCSetConstruction,
-ergo_format_reason("remaining time is lower than 0")
+"finish adding old regions to CSet",
-ergo_format_ms("remaining time"),
+ergo_format_reason("old CSet region num reached min")
-time_remaining_ms);
+ergo_format_region("old")
-should_continue = false;
+ergo_format_region("min"),
-}
+old_cset_region_length(), min_old_cset_length);
-} else {
+break;
-if (cset_region_length() >= _young_list_fixed_length) {
-ergo_verbose2(ErgoCSetConstruction,
-"stop adding old regions to CSet",
-ergo_format_reason("CSet length reached target")
-ergo_format_region("CSet")
-ergo_format_region("young target"),
-cset_region_length(), _young_list_fixed_length);
-should_continue = false;
-}
 }
 }
-} while (should_continue);
+// We will add this region to the CSet.
-if (!adaptive_young_list_length() &&
+time_remaining_ms -= predicted_time_ms;
-cset_region_length() < _young_list_fixed_length) {
+predicted_pause_time_ms += predicted_time_ms;
-ergo_verbose2(ErgoCSetConstruction,
+cset_chooser->remove_and_move_to_next(hr);
-"request mixed GCs end",
+_g1->old_set_remove(hr);
-ergo_format_reason("CSet length lower than target")
+add_old_region_to_cset(hr);
-ergo_format_region("CSet")
-ergo_format_region("young target"),
+hr = cset_chooser->peek();
-cset_region_length(), _young_list_fixed_length);
+}
-_should_revert_to_young_gcs  = true;
+if (hr == NULL) {
-}
+ergo_verbose0(ErgoCSetConstruction,
+"finish adding old regions to CSet",
-ergo_verbose2(ErgoCSetConstruction | ErgoHigh,
+ergo_format_reason("candidate old regions not available"));
-"add old regions to CSet",
+}
-ergo_format_region("old")
-ergo_format_ms("predicted old region time"),
+if (expensive_region_num > 0) {
-old_cset_region_length(),
+// We print the information once here at the end, predicated on
-predicted_pause_time_ms - prev_predicted_pause_time_ms);
+// whether we added any apparently expensive regions or not, to
+// avoid generating output per region.
+ergo_verbose4(ErgoCSetConstruction,
+"added expensive regions to CSet",
+ergo_format_reason("old CSet region num not reached min")
+ergo_format_region("old")
+ergo_format_region("expensive")
+ergo_format_region("min")
+ergo_format_ms("remaining time"),
+old_cset_region_length(),
+expensive_region_num,
+min_old_cset_length,
+time_remaining_ms);
+}
+assert(cset_chooser->verify(), "CSet Chooser verification - post");
 }
 stop_incremental_cset_building();
 count_CS_bytes_used();

changeset 11756	28b6fe22e43d
parent 11584	e1df4d08a1f4
child 12228	15ffdb8224fe