--- old/src/share/vm/gc/g1/g1CollectorPolicy.cpp 2015-11-06 11:38:10.215446484 +0100 +++ new/src/share/vm/gc/g1/g1CollectorPolicy.cpp 2015-11-06 11:38:10.129443976 +0100 @@ -28,6 +28,7 @@ #include "gc/g1/concurrentMarkThread.inline.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" +#include "gc/g1/g1IHOPControl.hpp" #include "gc/g1/g1ErgoVerbose.hpp" #include "gc/g1/g1GCPhaseTimes.hpp" #include "gc/g1/g1Log.hpp" @@ -148,7 +149,11 @@ _recorded_survivor_tail(NULL), _survivors_age_table(true), - _gc_overhead_perc(0.0) { + _gc_overhead_perc(0.0), + + _last_old_allocated_bytes(0), + _ihop_control(NULL), + _initial_mark_to_mixed() { // SurvRateGroups below must be initialized after the predictor because they // indirectly use it through this object passed to their constructor. @@ -288,6 +293,12 @@ _collectionSetChooser = new CollectionSetChooser(); } +G1CollectorPolicy::~G1CollectorPolicy() { + if (_ihop_control != NULL) { + delete _ihop_control; + } +} + double G1CollectorPolicy::get_new_prediction(TruncatedSeq const* seq) const { return _predictor.get_new_prediction(seq); } @@ -317,6 +328,8 @@ if (max_young_size != MaxNewSize) { FLAG_SET_ERGO(size_t, MaxNewSize, max_young_size); } + + _ihop_control = create_ihop_control(); } G1CollectorState* G1CollectorPolicy::collector_state() const { return _g1->collector_state(); } @@ -511,24 +524,24 @@ return _young_gen_sizer->max_desired_young_length(); } -void G1CollectorPolicy::update_young_list_max_and_target_length() { - update_young_list_max_and_target_length(get_new_prediction(_rs_lengths_seq)); +void G1CollectorPolicy::update_young_list_max_and_target_length(size_t* unbounded_target_length) { + update_young_list_max_and_target_length(get_new_prediction(_rs_lengths_seq), unbounded_target_length); } -void G1CollectorPolicy::update_young_list_max_and_target_length(size_t rs_lengths) { - update_young_list_target_length(rs_lengths); +void G1CollectorPolicy::update_young_list_max_and_target_length(size_t rs_lengths, size_t* unbounded_target_length) { + update_young_list_target_length(rs_lengths, unbounded_target_length); update_max_gc_locker_expansion(); } -void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) { - _young_list_target_length = bounded_young_list_target_length(rs_lengths); +void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths, size_t* unbounded_target_length) { + _young_list_target_length = bounded_young_list_target_length(rs_lengths, unbounded_target_length); } void G1CollectorPolicy::update_young_list_target_length() { update_young_list_target_length(get_new_prediction(_rs_lengths_seq)); } -uint G1CollectorPolicy::bounded_young_list_target_length(size_t rs_lengths) const { +uint G1CollectorPolicy::bounded_young_list_target_length(size_t rs_lengths, size_t* unbounded_target_length) const { // Calculate the absolute and desired min bounds. // This is how many young regions we already have (currently: the survivors). @@ -541,15 +554,7 @@ desired_min_length = MAX2(desired_min_length, absolute_min_length); // Calculate the absolute and desired max bounds. - // We will try our best not to "eat" into the reserve. - uint absolute_max_length = 0; - if (_free_regions_at_end_of_collection > _reserve_regions) { - absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions; - } uint desired_max_length = calculate_young_list_desired_max_length(); - if (desired_max_length > absolute_max_length) { - desired_max_length = absolute_max_length; - } uint young_list_target_length = 0; if (adaptive_young_list_length()) { @@ -570,6 +575,19 @@ young_list_target_length = _young_list_fixed_length; } + if (unbounded_target_length != NULL) { + *unbounded_target_length = young_list_target_length; + } + + // We will try our best not to "eat" into the reserve. + uint absolute_max_length = 0; + if (_free_regions_at_end_of_collection > _reserve_regions) { + absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions; + } + if (desired_max_length > absolute_max_length) { + desired_max_length = absolute_max_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. @@ -827,6 +845,10 @@ update_young_list_max_and_target_length(); update_rs_lengths_prediction(); _collectionSetChooser->clear(); + + _last_old_allocated_bytes = 0; + + record_pause(FullGC, _full_collection_start_sec, end_sec); } void G1CollectorPolicy::record_stop_world_start() { @@ -884,7 +906,7 @@ _cur_mark_stop_world_time_ms += elapsed_time_ms; _prev_collection_pause_end_ms += elapsed_time_ms; - _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec); + record_pause(Remark, _mark_remark_start_sec, end_time_sec); } void G1CollectorPolicy::record_concurrent_mark_cleanup_start() { @@ -895,6 +917,10 @@ bool should_continue_with_reclaim = next_gc_should_be_mixed("request last young-only gc", "skip last young-only gc"); collector_state()->set_last_young_gc(should_continue_with_reclaim); + // We abort the marking phase. + if (!should_continue_with_reclaim) { + abort_time_to_mixed_tracking(); + } collector_state()->set_in_marking_window(false); } @@ -941,12 +967,13 @@ return false; } - size_t marking_initiating_used_threshold = - (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; + size_t marking_initiating_used_threshold = _ihop_control->get_conc_mark_start_threshold(); + size_t cur_used_bytes = _g1->non_young_capacity_bytes(); size_t alloc_byte_size = alloc_word_size * HeapWordSize; + size_t marking_request_bytes = cur_used_bytes + alloc_byte_size; - if ((cur_used_bytes + alloc_byte_size) > marking_initiating_used_threshold) { + if (marking_request_bytes > marking_initiating_used_threshold) { if (collector_state()->gcs_are_young() && !collector_state()->last_young_gc()) { ergo_verbose5(ErgoConcCycles, "request concurrent cycle initiation", @@ -958,7 +985,7 @@ cur_used_bytes, alloc_byte_size, marking_initiating_used_threshold, - (double) InitiatingHeapOccupancyPercent, + (double) marking_initiating_used_threshold / _g1->capacity() * 100, source); return true; } else { @@ -987,8 +1014,6 @@ double end_time_sec = os::elapsedTime(); assert(_cur_collection_pause_used_regions_at_start >= cset_region_length(), "otherwise, the subtraction below does not make sense"); - size_t rs_size = - _cur_collection_pause_used_regions_at_start - cset_region_length(); size_t cur_used_bytes = _g1->used(); assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); bool last_pause_included_initial_mark = false; @@ -1002,6 +1027,8 @@ } #endif // PRODUCT + record_pause(young_gc_pause_kind(), end_time_sec - pause_time_ms / 1000.0, end_time_sec); + last_pause_included_initial_mark = collector_state()->during_initial_mark_pause(); if (last_pause_included_initial_mark) { record_concurrent_mark_init_end(0.0); @@ -1009,12 +1036,12 @@ maybe_start_marking(); } - _mmu_tracker->add_pause(end_time_sec - pause_time_ms/1000.0, end_time_sec); + double app_time_ms = 1.0; if (update_stats) { _trace_young_gen_time_data.record_end_collection(pause_time_ms, phase_times()); // this is where we update the allocation rate of the application - double app_time_ms = + app_time_ms = (phase_times()->cur_collection_start_sec() * 1000.0 - _prev_collection_pause_end_ms); if (app_time_ms < MIN_TIMER_GRANULARITY) { // This usually happens due to the timer not having the required @@ -1079,6 +1106,9 @@ if (next_gc_should_be_mixed("start mixed GCs", "do not start mixed GCs")) { collector_state()->set_gcs_are_young(false); + } else { + // We aborted the mixed GC phase early. + abort_time_to_mixed_tracking(); } collector_state()->set_last_young_gc(false); @@ -1087,7 +1117,6 @@ if (!collector_state()->last_gc_was_young()) { // This is a mixed GC. Here we decide whether to continue doing // mixed GCs or not. - if (!next_gc_should_be_mixed("continue mixed GCs", "do not continue mixed GCs")) { collector_state()->set_gcs_are_young(true); @@ -1179,9 +1208,30 @@ collector_state()->set_in_marking_window(new_in_marking_window); collector_state()->set_in_marking_window_im(new_in_marking_window_im); _free_regions_at_end_of_collection = _g1->num_free_regions(); - update_young_list_max_and_target_length(); + // IHOP control wants to know the expected young gen length if it were not + // restrained by the heap reserve. Using the actual length would make the + // prediction too small and the limit the young gen every time we get to the + // predicted target occupancy. + size_t last_unrestrained_young_length = 0; + update_young_list_max_and_target_length(&last_unrestrained_young_length); update_rs_lengths_prediction(); + double marking_to_mixed_time = -1.0; + if (!collector_state()->last_gc_was_young() && _initial_mark_to_mixed.has_result()) { + marking_to_mixed_time = _initial_mark_to_mixed.last_marking_time(); + assert(marking_to_mixed_time > 0.0, + "Initial mark to mixed time must be larger than zero but is %.3f", + marking_to_mixed_time); + } + // Only update IHOP information on regular GCs. + if (update_stats) { + update_ihop_statistics(marking_to_mixed_time, + app_time_ms / 1000.0, + _last_old_allocated_bytes, + last_unrestrained_young_length * HeapRegion::GrainBytes); + } + _last_old_allocated_bytes = 0; + // Note that _mmu_tracker->max_gc_time() returns the time in seconds. double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; @@ -1207,6 +1257,44 @@ _collectionSetChooser->verify(); } +G1IHOPControl* G1CollectorPolicy::create_ihop_control() const { + return new G1StaticIHOPControl(InitiatingHeapOccupancyPercent, + G1CollectedHeap::heap()->max_capacity()); +} + +void G1CollectorPolicy::update_ihop_statistics(double marking_time, + double mutator_time_s, + size_t mutator_alloc_bytes, + size_t young_gen_size) { + bool report = false; + + // To avoid using really small times that may be caused by e.g. back-to-back gcs + // we filter them out. + double const min_valid_time = 1e-6; + + if (marking_time > min_valid_time) { + _ihop_control->update_time_to_mixed(marking_time); + report = true; + } + + // As an approximation for the young gc promotion rates during marking we use + // all of them. In many applications there are only a few if any young gcs during + // marking, which makes any prediction useless. This increases the accuracy of the + // prediction. + if (collector_state()->last_gc_was_young() && mutator_time_s > min_valid_time) { + _ihop_control->update_allocation_info(mutator_time_s, mutator_alloc_bytes, young_gen_size); + report = true; + } + + if (report) { + report_ihop_statistics(); + } +} + +void G1CollectorPolicy::report_ihop_statistics() { + _ihop_control->print(); +} + #define EXT_SIZE_FORMAT "%.1f%s" #define EXT_SIZE_PARAMS(bytes) \ byte_size_in_proper_unit((double)(bytes)), \ @@ -1719,8 +1807,7 @@ return MAX2(n_regions / (n_workers * overpartition_factor), min_chunk_size); } -void -G1CollectorPolicy::record_concurrent_mark_cleanup_end() { +void G1CollectorPolicy::record_concurrent_mark_cleanup_end() { _collectionSetChooser->clear(); WorkGang* workers = _g1->workers(); @@ -1739,7 +1826,8 @@ _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); _cur_mark_stop_world_time_ms += elapsed_time_ms; _prev_collection_pause_end_ms += elapsed_time_ms; - _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_sec); + + record_pause(Cleanup, _mark_cleanup_start_sec, end_sec); } // Add the heap region at the head of the non-incremental collection set @@ -1955,6 +2043,59 @@ } } +G1CollectorPolicy::PauseKind G1CollectorPolicy::young_gc_pause_kind() const { + assert(!collector_state()->full_collection(), "must be"); + if (collector_state()->during_initial_mark_pause()) { + assert(collector_state()->last_gc_was_young(), "must be"); + assert(!collector_state()->last_young_gc(), "must be"); + return InitialMarkGC; + } else if (collector_state()->last_young_gc()) { + assert(!collector_state()->during_initial_mark_pause(), "must be"); + assert(collector_state()->last_gc_was_young(), "must be"); + return LastYoungGC; + } else if (!collector_state()->last_gc_was_young()) { + assert(!collector_state()->during_initial_mark_pause(), "must be"); + assert(!collector_state()->last_young_gc(), "must be"); + return MixedGC; + } else { + assert(collector_state()->last_gc_was_young(), "must be"); + assert(!collector_state()->during_initial_mark_pause(), "must be"); + assert(!collector_state()->last_young_gc(), "must be"); + return YoungOnlyGC; + } +} + +void G1CollectorPolicy::record_pause(PauseKind kind, double start, double end) { + // Manage the MMU tracker. For some reason it ignores Full GCs. + if (kind != FullGC) { + _mmu_tracker->add_pause(start, end); + } + // Manage the mutator time tracking from initial mark to first mixed gc. + switch (kind) { + case FullGC: + abort_time_to_mixed_tracking(); + break; + case Cleanup: + case Remark: + case YoungOnlyGC: + case LastYoungGC: + _initial_mark_to_mixed.add_pause(end - start); + break; + case InitialMarkGC: + _initial_mark_to_mixed.record_initial_mark_end(end); + break; + case MixedGC: + _initial_mark_to_mixed.record_mixed_gc_start(start); + break; + default: + ShouldNotReachHere(); + } +} + +void G1CollectorPolicy::abort_time_to_mixed_tracking() { + _initial_mark_to_mixed.reset(); +} + bool G1CollectorPolicy::next_gc_should_be_mixed(const char* true_action_str, const char* false_action_str) const { CollectionSetChooser* cset_chooser = _collectionSetChooser;