ysr@777: /* tonyp@3416: * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. ysr@777: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ysr@777: * ysr@777: * This code is free software; you can redistribute it and/or modify it ysr@777: * under the terms of the GNU General Public License version 2 only, as ysr@777: * published by the Free Software Foundation. ysr@777: * ysr@777: * This code is distributed in the hope that it will be useful, but WITHOUT ysr@777: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ysr@777: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ysr@777: * version 2 for more details (a copy is included in the LICENSE file that ysr@777: * accompanied this code). ysr@777: * ysr@777: * You should have received a copy of the GNU General Public License version ysr@777: * 2 along with this work; if not, write to the Free Software Foundation, ysr@777: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ysr@777: * trims@1907: * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA trims@1907: * or visit www.oracle.com if you need additional information or have any trims@1907: * questions. ysr@777: * ysr@777: */ ysr@777: stefank@2314: #include "precompiled.hpp" stefank@2314: #include "gc_implementation/g1/concurrentG1Refine.hpp" stefank@2314: #include "gc_implementation/g1/concurrentMark.hpp" stefank@2314: #include "gc_implementation/g1/concurrentMarkThread.inline.hpp" stefank@2314: #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" stefank@2314: #include "gc_implementation/g1/g1CollectorPolicy.hpp" tonyp@3114: #include "gc_implementation/g1/g1ErgoVerbose.hpp" stefank@2314: #include "gc_implementation/g1/heapRegionRemSet.hpp" stefank@2314: #include "gc_implementation/shared/gcPolicyCounters.hpp" stefank@2314: #include "runtime/arguments.hpp" stefank@2314: #include "runtime/java.hpp" stefank@2314: #include "runtime/mutexLocker.hpp" stefank@2314: #include "utilities/debug.hpp" ysr@777: ysr@777: // Different defaults for different number of GC threads ysr@777: // They were chosen by running GCOld and SPECjbb on debris with different ysr@777: // numbers of GC threads and choosing them based on the results ysr@777: ysr@777: // all the same ysr@777: static double rs_length_diff_defaults[] = { ysr@777: 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ysr@777: }; ysr@777: ysr@777: static double cost_per_card_ms_defaults[] = { ysr@777: 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015 ysr@777: }; ysr@777: ysr@777: // all the same tonyp@3337: static double young_cards_per_entry_ratio_defaults[] = { ysr@777: 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ysr@777: }; ysr@777: ysr@777: static double cost_per_entry_ms_defaults[] = { ysr@777: 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005 ysr@777: }; ysr@777: ysr@777: static double cost_per_byte_ms_defaults[] = { ysr@777: 0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009 ysr@777: }; ysr@777: ysr@777: // these should be pretty consistent ysr@777: static double constant_other_time_ms_defaults[] = { ysr@777: 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 ysr@777: }; ysr@777: ysr@777: ysr@777: static double young_other_cost_per_region_ms_defaults[] = { ysr@777: 0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1 ysr@777: }; ysr@777: ysr@777: static double non_young_other_cost_per_region_ms_defaults[] = { ysr@777: 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30 ysr@777: }; ysr@777: brutisso@2645: // Help class for avoiding interleaved logging brutisso@2645: class LineBuffer: public StackObj { brutisso@2645: brutisso@2645: private: brutisso@2645: static const int BUFFER_LEN = 1024; brutisso@2645: static const int INDENT_CHARS = 3; brutisso@2645: char _buffer[BUFFER_LEN]; brutisso@2645: int _indent_level; brutisso@2645: int _cur; brutisso@2645: brutisso@2645: void vappend(const char* format, va_list ap) { brutisso@2645: int res = vsnprintf(&_buffer[_cur], BUFFER_LEN - _cur, format, ap); brutisso@2645: if (res != -1) { brutisso@2645: _cur += res; brutisso@2645: } else { brutisso@2645: DEBUG_ONLY(warning("buffer too small in LineBuffer");) brutisso@2645: _buffer[BUFFER_LEN -1] = 0; brutisso@2645: _cur = BUFFER_LEN; // vsnprintf above should not add to _buffer if we are called again brutisso@2645: } brutisso@2645: } brutisso@2645: brutisso@2645: public: brutisso@2645: explicit LineBuffer(int indent_level): _indent_level(indent_level), _cur(0) { brutisso@2645: for (; (_cur < BUFFER_LEN && _cur < (_indent_level * INDENT_CHARS)); _cur++) { brutisso@2645: _buffer[_cur] = ' '; brutisso@2645: } brutisso@2645: } brutisso@2645: brutisso@2645: #ifndef PRODUCT brutisso@2645: ~LineBuffer() { brutisso@2645: assert(_cur == _indent_level * INDENT_CHARS, "pending data in buffer - append_and_print_cr() not called?"); brutisso@2645: } brutisso@2645: #endif brutisso@2645: brutisso@2645: void append(const char* format, ...) { brutisso@2645: va_list ap; brutisso@2645: va_start(ap, format); brutisso@2645: vappend(format, ap); brutisso@2645: va_end(ap); brutisso@2645: } brutisso@2645: brutisso@2645: void append_and_print_cr(const char* format, ...) { brutisso@2645: va_list ap; brutisso@2645: va_start(ap, format); brutisso@2645: vappend(format, ap); brutisso@2645: va_end(ap); brutisso@2645: gclog_or_tty->print_cr("%s", _buffer); brutisso@2645: _cur = _indent_level * INDENT_CHARS; brutisso@2645: } brutisso@2645: }; brutisso@2645: ysr@777: G1CollectorPolicy::G1CollectorPolicy() : jmasa@2188: _parallel_gc_threads(G1CollectedHeap::use_parallel_gc_threads() johnc@3021: ? ParallelGCThreads : 1), jmasa@2188: ysr@777: _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), ysr@777: _all_pause_times_ms(new NumberSeq()), ysr@777: _stop_world_start(0.0), ysr@777: _all_stop_world_times_ms(new NumberSeq()), ysr@777: _all_yield_times_ms(new NumberSeq()), ysr@777: apetrusenko@1112: _summary(new Summary()), ysr@777: johnc@3175: _cur_clear_ct_time_ms(0.0), johnc@3296: _mark_closure_time_ms(0.0), johnc@3175: johnc@3175: _cur_ref_proc_time_ms(0.0), johnc@3175: _cur_ref_enq_time_ms(0.0), johnc@3175: johnc@1325: #ifndef PRODUCT johnc@1325: _min_clear_cc_time_ms(-1.0), johnc@1325: _max_clear_cc_time_ms(-1.0), johnc@1325: _cur_clear_cc_time_ms(0.0), johnc@1325: _cum_clear_cc_time_ms(0.0), johnc@1325: _num_cc_clears(0L), johnc@1325: #endif ysr@777: ysr@777: _aux_num(10), ysr@777: _all_aux_times_ms(new NumberSeq[_aux_num]), ysr@777: _cur_aux_start_times_ms(new double[_aux_num]), ysr@777: _cur_aux_times_ms(new double[_aux_num]), ysr@777: _cur_aux_times_set(new bool[_aux_num]), ysr@777: ysr@777: _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), ysr@777: _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), ysr@777: ysr@777: _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _prev_collection_pause_end_ms(0.0), ysr@777: _pending_card_diff_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)), tonyp@3337: _young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), tonyp@3337: _mixed_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), tonyp@3337: _mixed_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _non_young_other_cost_per_region_ms_seq( ysr@777: new TruncatedSeq(TruncatedSeqLength)), ysr@777: ysr@777: _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: johnc@1186: _pause_time_target_ms((double) MaxGCPauseMillis), ysr@777: tonyp@3337: _gcs_are_young(true), tonyp@3337: _young_pause_num(0), tonyp@3337: _mixed_pause_num(0), ysr@777: ysr@777: _during_marking(false), ysr@777: _in_marking_window(false), ysr@777: _in_marking_window_im(false), ysr@777: ysr@777: _known_garbage_ratio(0.0), ysr@777: _known_garbage_bytes(0), ysr@777: ysr@777: _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)), ysr@777: tonyp@3337: _recent_prev_end_times_for_all_gcs_sec( tonyp@3337: new TruncatedSeq(NumPrevPausesForHeuristics)), ysr@777: ysr@777: _recent_avg_pause_time_ratio(0.0), ysr@777: ysr@777: _all_full_gc_times_ms(new NumberSeq()), ysr@777: tonyp@1794: _initiate_conc_mark_if_possible(false), tonyp@1794: _during_initial_mark_pause(false), tonyp@3337: _should_revert_to_young_gcs(false), tonyp@3337: _last_young_gc(false), tonyp@3337: _last_gc_was_young(false), ysr@777: tonyp@2961: _eden_bytes_before_gc(0), tonyp@2961: _survivor_bytes_before_gc(0), tonyp@2961: _capacity_before_gc(0), tonyp@2961: ysr@777: _prev_collection_pause_used_at_end_bytes(0), ysr@777: tonyp@3289: _eden_cset_region_length(0), tonyp@3289: _survivor_cset_region_length(0), tonyp@3289: _old_cset_region_length(0), tonyp@3289: ysr@777: _collection_set(NULL), johnc@1829: _collection_set_bytes_used_before(0), johnc@1829: johnc@1829: // Incremental CSet attributes johnc@1829: _inc_cset_build_state(Inactive), johnc@1829: _inc_cset_head(NULL), johnc@1829: _inc_cset_tail(NULL), johnc@1829: _inc_cset_bytes_used_before(0), johnc@1829: _inc_cset_max_finger(NULL), johnc@1829: _inc_cset_recorded_rs_lengths(0), tonyp@3356: _inc_cset_recorded_rs_lengths_diffs(0), johnc@1829: _inc_cset_predicted_elapsed_time_ms(0.0), tonyp@3356: _inc_cset_predicted_elapsed_time_ms_diffs(0.0), johnc@1829: ysr@777: #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away ysr@777: #pragma warning( disable:4355 ) // 'this' : used in base member initializer list ysr@777: #endif // _MSC_VER ysr@777: ysr@777: _short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived", ysr@777: G1YoungSurvRateNumRegionsSummary)), ysr@777: _survivor_surv_rate_group(new SurvRateGroup(this, "Survivor", apetrusenko@980: G1YoungSurvRateNumRegionsSummary)), ysr@777: // add here any more surv rate groups apetrusenko@980: _recorded_survivor_regions(0), apetrusenko@980: _recorded_survivor_head(NULL), apetrusenko@980: _recorded_survivor_tail(NULL), tonyp@1791: _survivors_age_table(true), tonyp@1791: tonyp@3114: _gc_overhead_perc(0.0) { tonyp@3114: tonyp@1377: // Set up the region size and associated fields. Given that the tonyp@1377: // policy is created before the heap, we have to set this up here, tonyp@1377: // so it's done as soon as possible. tonyp@1377: HeapRegion::setup_heap_region_size(Arguments::min_heap_size()); iveresov@1696: HeapRegionRemSet::setup_remset_size(); tonyp@1377: tonyp@3114: G1ErgoVerbose::initialize(); tonyp@3114: if (PrintAdaptiveSizePolicy) { tonyp@3114: // Currently, we only use a single switch for all the heuristics. tonyp@3114: G1ErgoVerbose::set_enabled(true); tonyp@3114: // Given that we don't currently have a verboseness level tonyp@3114: // parameter, we'll hardcode this to high. This can be easily tonyp@3114: // changed in the future. tonyp@3114: G1ErgoVerbose::set_level(ErgoHigh); tonyp@3114: } else { tonyp@3114: G1ErgoVerbose::set_enabled(false); tonyp@3114: } tonyp@3114: apetrusenko@1826: // Verify PLAB sizes johnc@3182: const size_t region_size = HeapRegion::GrainWords; apetrusenko@1826: if (YoungPLABSize > region_size || OldPLABSize > region_size) { apetrusenko@1826: char buffer[128]; johnc@3182: jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most "SIZE_FORMAT, apetrusenko@1826: OldPLABSize > region_size ? "Old" : "Young", region_size); apetrusenko@1826: vm_exit_during_initialization(buffer); apetrusenko@1826: } apetrusenko@1826: ysr@777: _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); ysr@777: _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; ysr@777: tonyp@1966: _par_last_gc_worker_start_times_ms = new double[_parallel_gc_threads]; ysr@777: _par_last_ext_root_scan_times_ms = new double[_parallel_gc_threads]; tonyp@3416: _par_last_satb_filtering_times_ms = new double[_parallel_gc_threads]; ysr@777: ysr@777: _par_last_update_rs_times_ms = new double[_parallel_gc_threads]; ysr@777: _par_last_update_rs_processed_buffers = new double[_parallel_gc_threads]; ysr@777: ysr@777: _par_last_scan_rs_times_ms = new double[_parallel_gc_threads]; ysr@777: ysr@777: _par_last_obj_copy_times_ms = new double[_parallel_gc_threads]; ysr@777: ysr@777: _par_last_termination_times_ms = new double[_parallel_gc_threads]; tonyp@1966: _par_last_termination_attempts = new double[_parallel_gc_threads]; tonyp@1966: _par_last_gc_worker_end_times_ms = new double[_parallel_gc_threads]; brutisso@2712: _par_last_gc_worker_times_ms = new double[_parallel_gc_threads]; johnc@3219: _par_last_gc_worker_other_times_ms = new double[_parallel_gc_threads]; ysr@777: ysr@777: // start conservatively johnc@1186: _expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis; ysr@777: ysr@777: int index; ysr@777: if (ParallelGCThreads == 0) ysr@777: index = 0; ysr@777: else if (ParallelGCThreads > 8) ysr@777: index = 7; ysr@777: else ysr@777: index = ParallelGCThreads - 1; ysr@777: ysr@777: _pending_card_diff_seq->add(0.0); ysr@777: _rs_length_diff_seq->add(rs_length_diff_defaults[index]); ysr@777: _cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]); tonyp@3337: _young_cards_per_entry_ratio_seq->add( tonyp@3337: young_cards_per_entry_ratio_defaults[index]); ysr@777: _cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]); ysr@777: _cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]); ysr@777: _constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]); ysr@777: _young_other_cost_per_region_ms_seq->add( ysr@777: young_other_cost_per_region_ms_defaults[index]); ysr@777: _non_young_other_cost_per_region_ms_seq->add( ysr@777: non_young_other_cost_per_region_ms_defaults[index]); ysr@777: tonyp@1965: // Below, we might need to calculate the pause time target based on tonyp@1965: // the pause interval. When we do so we are going to give G1 maximum tonyp@1965: // flexibility and allow it to do pauses when it needs to. So, we'll tonyp@1965: // arrange that the pause interval to be pause time target + 1 to tonyp@1965: // ensure that a) the pause time target is maximized with respect to tonyp@1965: // the pause interval and b) we maintain the invariant that pause tonyp@1965: // time target < pause interval. If the user does not want this tonyp@1965: // maximum flexibility, they will have to set the pause interval tonyp@1965: // explicitly. tonyp@1965: tonyp@1965: // First make sure that, if either parameter is set, its value is tonyp@1965: // reasonable. tonyp@1965: if (!FLAG_IS_DEFAULT(MaxGCPauseMillis)) { tonyp@1965: if (MaxGCPauseMillis < 1) { tonyp@1965: vm_exit_during_initialization("MaxGCPauseMillis should be " tonyp@1965: "greater than 0"); tonyp@1965: } tonyp@1965: } tonyp@1965: if (!FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { tonyp@1965: if (GCPauseIntervalMillis < 1) { tonyp@1965: vm_exit_during_initialization("GCPauseIntervalMillis should be " tonyp@1965: "greater than 0"); tonyp@1965: } tonyp@1965: } tonyp@1965: tonyp@1965: // Then, if the pause time target parameter was not set, set it to tonyp@1965: // the default value. tonyp@1965: if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) { tonyp@1965: if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { tonyp@1965: // The default pause time target in G1 is 200ms tonyp@1965: FLAG_SET_DEFAULT(MaxGCPauseMillis, 200); tonyp@1965: } else { tonyp@1965: // We do not allow the pause interval to be set without the tonyp@1965: // pause time target tonyp@1965: vm_exit_during_initialization("GCPauseIntervalMillis cannot be set " tonyp@1965: "without setting MaxGCPauseMillis"); tonyp@1965: } tonyp@1965: } tonyp@1965: tonyp@1965: // Then, if the interval parameter was not set, set it according to tonyp@1965: // the pause time target (this will also deal with the case when the tonyp@1965: // pause time target is the default value). tonyp@1965: if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { tonyp@1965: FLAG_SET_DEFAULT(GCPauseIntervalMillis, MaxGCPauseMillis + 1); tonyp@1965: } tonyp@1965: tonyp@1965: // Finally, make sure that the two parameters are consistent. tonyp@1965: if (MaxGCPauseMillis >= GCPauseIntervalMillis) { tonyp@1965: char buffer[256]; tonyp@1965: jio_snprintf(buffer, 256, tonyp@1965: "MaxGCPauseMillis (%u) should be less than " tonyp@1965: "GCPauseIntervalMillis (%u)", tonyp@1965: MaxGCPauseMillis, GCPauseIntervalMillis); tonyp@1965: vm_exit_during_initialization(buffer); tonyp@1965: } tonyp@1965: tonyp@1965: double max_gc_time = (double) MaxGCPauseMillis / 1000.0; johnc@1186: double time_slice = (double) GCPauseIntervalMillis / 1000.0; ysr@777: _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time); johnc@1186: _sigma = (double) G1ConfidencePercent / 100.0; ysr@777: ysr@777: // start conservatively (around 50ms is about right) ysr@777: _concurrent_mark_remark_times_ms->add(0.05); ysr@777: _concurrent_mark_cleanup_times_ms->add(0.20); ysr@777: _tenuring_threshold = MaxTenuringThreshold; tonyp@3066: // _max_survivor_regions will be calculated by tonyp@3119: // update_young_list_target_length() during initialization. tonyp@3066: _max_survivor_regions = 0; apetrusenko@980: tonyp@1791: assert(GCTimeRatio > 0, tonyp@1791: "we should have set it to a default value set_g1_gc_flags() " tonyp@1791: "if a user set it to 0"); tonyp@1791: _gc_overhead_perc = 100.0 * (1.0 / (1.0 + GCTimeRatio)); tonyp@1791: tonyp@3119: uintx reserve_perc = G1ReservePercent; tonyp@3119: // Put an artificial ceiling on this so that it's not set to a silly value. tonyp@3119: if (reserve_perc > 50) { tonyp@3119: reserve_perc = 50; tonyp@3119: warning("G1ReservePercent is set to a value that is too large, " tonyp@3119: "it's been updated to %u", reserve_perc); tonyp@3119: } tonyp@3119: _reserve_factor = (double) reserve_perc / 100.0; brutisso@3120: // This will be set when the heap is expanded tonyp@3119: // for the first time during initialization. tonyp@3119: _reserve_regions = 0; tonyp@3119: ysr@777: initialize_all(); tonyp@3209: _collectionSetChooser = new CollectionSetChooser(); brutisso@3358: _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::initialize_flags() { ysr@777: set_min_alignment(HeapRegion::GrainBytes); ysr@777: set_max_alignment(GenRemSet::max_alignment_constraint(rem_set_name())); apetrusenko@982: if (SurvivorRatio < 1) { apetrusenko@982: vm_exit_during_initialization("Invalid survivor ratio specified"); apetrusenko@982: } ysr@777: CollectorPolicy::initialize_flags(); ysr@777: } ysr@777: brutisso@3358: G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true) { brutisso@3358: assert(G1DefaultMinNewGenPercent <= G1DefaultMaxNewGenPercent, "Min larger than max"); brutisso@3358: assert(G1DefaultMinNewGenPercent > 0 && G1DefaultMinNewGenPercent < 100, "Min out of bounds"); brutisso@3358: assert(G1DefaultMaxNewGenPercent > 0 && G1DefaultMaxNewGenPercent < 100, "Max out of bounds"); brutisso@3120: brutisso@3120: if (FLAG_IS_CMDLINE(NewRatio)) { brutisso@3120: if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) { tonyp@3172: warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio"); brutisso@3120: } else { brutisso@3358: _sizer_kind = SizerNewRatio; brutisso@3358: _adaptive_size = false; brutisso@3358: return; brutisso@3120: } brutisso@3120: } brutisso@3120: brutisso@3358: if (FLAG_IS_CMDLINE(NewSize)) { brutisso@3358: _min_desired_young_length = MAX2((size_t) 1, NewSize / HeapRegion::GrainBytes); brutisso@3358: if (FLAG_IS_CMDLINE(MaxNewSize)) { brutisso@3358: _max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes); brutisso@3358: _sizer_kind = SizerMaxAndNewSize; brutisso@3358: _adaptive_size = _min_desired_young_length == _max_desired_young_length; brutisso@3358: } else { brutisso@3358: _sizer_kind = SizerNewSizeOnly; brutisso@3358: } brutisso@3358: } else if (FLAG_IS_CMDLINE(MaxNewSize)) { brutisso@3358: _max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes); brutisso@3358: _sizer_kind = SizerMaxNewSizeOnly; brutisso@3358: } brutisso@3358: } brutisso@3358: brutisso@3358: size_t G1YoungGenSizer::calculate_default_min_length(size_t new_number_of_heap_regions) { brutisso@3358: size_t default_value = (new_number_of_heap_regions * G1DefaultMinNewGenPercent) / 100; brutisso@3358: return MAX2((size_t)1, default_value); brutisso@3358: } brutisso@3358: brutisso@3358: size_t G1YoungGenSizer::calculate_default_max_length(size_t new_number_of_heap_regions) { brutisso@3358: size_t default_value = (new_number_of_heap_regions * G1DefaultMaxNewGenPercent) / 100; brutisso@3358: return MAX2((size_t)1, default_value); brutisso@3358: } brutisso@3358: brutisso@3358: void G1YoungGenSizer::heap_size_changed(size_t new_number_of_heap_regions) { brutisso@3358: assert(new_number_of_heap_regions > 0, "Heap must be initialized"); brutisso@3358: brutisso@3358: switch (_sizer_kind) { brutisso@3358: case SizerDefaults: brutisso@3358: _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions); brutisso@3358: _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions); brutisso@3358: break; brutisso@3358: case SizerNewSizeOnly: brutisso@3358: _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions); brutisso@3358: _max_desired_young_length = MAX2(_min_desired_young_length, _max_desired_young_length); brutisso@3358: break; brutisso@3358: case SizerMaxNewSizeOnly: brutisso@3358: _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions); brutisso@3358: _min_desired_young_length = MIN2(_min_desired_young_length, _max_desired_young_length); brutisso@3358: break; brutisso@3358: case SizerMaxAndNewSize: brutisso@3358: // Do nothing. Values set on the command line, don't update them at runtime. brutisso@3358: break; brutisso@3358: case SizerNewRatio: brutisso@3358: _min_desired_young_length = new_number_of_heap_regions / (NewRatio + 1); brutisso@3358: _max_desired_young_length = _min_desired_young_length; brutisso@3358: break; brutisso@3358: default: brutisso@3358: ShouldNotReachHere(); brutisso@3358: } brutisso@3358: brutisso@3120: assert(_min_desired_young_length <= _max_desired_young_length, "Invalid min/max young gen size values"); brutisso@3358: } brutisso@3358: brutisso@3358: void G1CollectorPolicy::init() { brutisso@3358: // Set aside an initial future to_space. brutisso@3358: _g1 = G1CollectedHeap::heap(); brutisso@3358: brutisso@3358: assert(Heap_lock->owned_by_self(), "Locking discipline."); brutisso@3358: brutisso@3358: initialize_gc_policy_counters(); brutisso@3358: brutisso@3120: if (adaptive_young_list_length()) { brutisso@3065: _young_list_fixed_length = 0; johnc@1829: } else { brutisso@3358: _young_list_fixed_length = _young_gen_sizer->min_desired_young_length(); ysr@777: } brutisso@3065: _free_regions_at_end_of_collection = _g1->free_regions(); tonyp@3119: update_young_list_target_length(); brutisso@3120: _prev_eden_capacity = _young_list_target_length * HeapRegion::GrainBytes; johnc@1829: johnc@1829: // We may immediately start allocating regions and placing them on the johnc@1829: // collection set list. Initialize the per-collection set info johnc@1829: start_incremental_cset_building(); ysr@777: } ysr@777: apetrusenko@980: // Create the jstat counters for the policy. tonyp@3119: void G1CollectorPolicy::initialize_gc_policy_counters() { brutisso@3065: _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3); apetrusenko@980: } apetrusenko@980: tonyp@3119: bool G1CollectorPolicy::predict_will_fit(size_t young_length, tonyp@3119: double base_time_ms, tonyp@3119: size_t base_free_regions, tonyp@3119: double target_pause_time_ms) { tonyp@3119: if (young_length >= base_free_regions) { tonyp@3119: // end condition 1: not enough space for the young regions tonyp@3119: return false; ysr@777: } tonyp@3119: tonyp@3119: double accum_surv_rate = accum_yg_surv_rate_pred((int)(young_length - 1)); tonyp@3119: size_t bytes_to_copy = tonyp@3119: (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes); tonyp@3119: double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy); tonyp@3119: double young_other_time_ms = predict_young_other_time_ms(young_length); tonyp@3119: double pause_time_ms = base_time_ms + copy_time_ms + young_other_time_ms; tonyp@3119: if (pause_time_ms > target_pause_time_ms) { tonyp@3119: // end condition 2: prediction is over the target pause time tonyp@3119: return false; tonyp@3119: } tonyp@3119: tonyp@3119: size_t free_bytes = tonyp@3119: (base_free_regions - young_length) * HeapRegion::GrainBytes; tonyp@3119: if ((2.0 * sigma()) * (double) bytes_to_copy > (double) free_bytes) { tonyp@3119: // end condition 3: out-of-space (conservatively!) tonyp@3119: return false; tonyp@3119: } tonyp@3119: tonyp@3119: // success! tonyp@3119: return true; ysr@777: } ysr@777: brutisso@3120: void G1CollectorPolicy::record_new_heap_size(size_t new_number_of_regions) { brutisso@3120: // re-calculate the necessary reserve brutisso@3120: double reserve_regions_d = (double) new_number_of_regions * _reserve_factor; tonyp@3119: // We use ceiling so that if reserve_regions_d is > 0.0 (but tonyp@3119: // smaller than 1.0) we'll get 1. tonyp@3119: _reserve_regions = (size_t) ceil(reserve_regions_d); brutisso@3120: brutisso@3358: _young_gen_sizer->heap_size_changed(new_number_of_regions); tonyp@3119: } tonyp@3119: tonyp@3119: size_t G1CollectorPolicy::calculate_young_list_desired_min_length( tonyp@3119: size_t base_min_length) { tonyp@3119: size_t desired_min_length = 0; ysr@777: if (adaptive_young_list_length()) { tonyp@3119: if (_alloc_rate_ms_seq->num() > 3) { tonyp@3119: double now_sec = os::elapsedTime(); tonyp@3119: double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0; tonyp@3119: double alloc_rate_ms = predict_alloc_rate_ms(); tonyp@3119: desired_min_length = (size_t) ceil(alloc_rate_ms * when_ms); tonyp@3119: } else { tonyp@3119: // otherwise we don't have enough info to make the prediction tonyp@3119: } ysr@777: } brutisso@3120: desired_min_length += base_min_length; brutisso@3120: // make sure we don't go below any user-defined minimum bound brutisso@3358: return MAX2(_young_gen_sizer->min_desired_young_length(), desired_min_length); ysr@777: } ysr@777: tonyp@3119: size_t G1CollectorPolicy::calculate_young_list_desired_max_length() { tonyp@3119: // Here, we might want to also take into account any additional tonyp@3119: // constraints (i.e., user-defined minimum bound). Currently, we tonyp@3119: // effectively don't set this bound. brutisso@3358: return _young_gen_sizer->max_desired_young_length(); tonyp@3119: } tonyp@3119: tonyp@3119: void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) { tonyp@3119: if (rs_lengths == (size_t) -1) { tonyp@3119: // if it's set to the default value (-1), we should predict it; tonyp@3119: // otherwise, use the given value. tonyp@3119: rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq); tonyp@3119: } tonyp@3119: tonyp@3119: // Calculate the absolute and desired min bounds. tonyp@3119: tonyp@3119: // This is how many young regions we already have (currently: the survivors). tonyp@3119: size_t base_min_length = recorded_survivor_regions(); tonyp@3119: // This is the absolute minimum young length, which ensures that we tonyp@3119: // can allocate one eden region in the worst-case. tonyp@3119: size_t absolute_min_length = base_min_length + 1; tonyp@3119: size_t desired_min_length = tonyp@3119: calculate_young_list_desired_min_length(base_min_length); tonyp@3119: if (desired_min_length < absolute_min_length) { tonyp@3119: desired_min_length = absolute_min_length; tonyp@3119: } tonyp@3119: tonyp@3119: // Calculate the absolute and desired max bounds. tonyp@3119: tonyp@3119: // We will try our best not to "eat" into the reserve. tonyp@3119: size_t absolute_max_length = 0; tonyp@3119: if (_free_regions_at_end_of_collection > _reserve_regions) { tonyp@3119: absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions; tonyp@3119: } tonyp@3119: size_t desired_max_length = calculate_young_list_desired_max_length(); tonyp@3119: if (desired_max_length > absolute_max_length) { tonyp@3119: desired_max_length = absolute_max_length; tonyp@3119: } tonyp@3119: tonyp@3119: size_t young_list_target_length = 0; tonyp@3119: if (adaptive_young_list_length()) { tonyp@3337: if (gcs_are_young()) { tonyp@3119: young_list_target_length = tonyp@3119: calculate_young_list_target_length(rs_lengths, tonyp@3119: base_min_length, tonyp@3119: desired_min_length, tonyp@3119: desired_max_length); tonyp@3119: _rs_lengths_prediction = rs_lengths; tonyp@3119: } else { tonyp@3119: // Don't calculate anything and let the code below bound it to tonyp@3119: // the desired_min_length, i.e., do the next GC as soon as tonyp@3119: // possible to maximize how many old regions we can add to it. ysr@777: } ysr@777: } else { tonyp@3337: if (gcs_are_young()) { tonyp@3119: young_list_target_length = _young_list_fixed_length; tonyp@3119: } else { tonyp@3337: // A bit arbitrary: during mixed GCs we allocate half tonyp@3119: // the young regions to try to add old regions to the CSet. tonyp@3119: young_list_target_length = _young_list_fixed_length / 2; tonyp@3119: // We choose to accept that we might go under the desired min tonyp@3119: // length given that we intentionally ask for a smaller young gen. tonyp@3119: desired_min_length = absolute_min_length; tonyp@3119: } ysr@777: } ysr@777: tonyp@3119: // Make sure we don't go over the desired max length, nor under the tonyp@3119: // desired min length. In case they clash, desired_min_length wins tonyp@3119: // which is why that test is second. tonyp@3119: if (young_list_target_length > desired_max_length) { tonyp@3119: young_list_target_length = desired_max_length; tonyp@3119: } tonyp@3119: if (young_list_target_length < desired_min_length) { tonyp@3119: young_list_target_length = desired_min_length; tonyp@3119: } tonyp@3119: tonyp@3119: assert(young_list_target_length > recorded_survivor_regions(), tonyp@3119: "we should be able to allocate at least one eden region"); tonyp@3119: assert(young_list_target_length >= absolute_min_length, "post-condition"); tonyp@3119: _young_list_target_length = young_list_target_length; tonyp@3119: tonyp@3119: update_max_gc_locker_expansion(); ysr@777: } ysr@777: tonyp@3119: size_t tonyp@3119: G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths, tonyp@3119: size_t base_min_length, tonyp@3119: size_t desired_min_length, tonyp@3119: size_t desired_max_length) { tonyp@3119: assert(adaptive_young_list_length(), "pre-condition"); tonyp@3337: assert(gcs_are_young(), "only call this for young GCs"); tonyp@3119: tonyp@3119: // In case some edge-condition makes the desired max length too small... tonyp@3119: if (desired_max_length <= desired_min_length) { tonyp@3119: return desired_min_length; tonyp@3119: } tonyp@3119: tonyp@3119: // We'll adjust min_young_length and max_young_length not to include tonyp@3119: // the already allocated young regions (i.e., so they reflect the tonyp@3119: // min and max eden regions we'll allocate). The base_min_length tonyp@3119: // will be reflected in the predictions by the tonyp@3119: // survivor_regions_evac_time prediction. tonyp@3119: assert(desired_min_length > base_min_length, "invariant"); tonyp@3119: size_t min_young_length = desired_min_length - base_min_length; tonyp@3119: assert(desired_max_length > base_min_length, "invariant"); tonyp@3119: size_t max_young_length = desired_max_length - base_min_length; tonyp@3119: tonyp@3119: double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0; tonyp@3119: double survivor_regions_evac_time = predict_survivor_regions_evac_time(); tonyp@3119: size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq); tonyp@3119: size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff(); tonyp@3119: size_t scanned_cards = predict_young_card_num(adj_rs_lengths); tonyp@3119: double base_time_ms = tonyp@3119: predict_base_elapsed_time_ms(pending_cards, scanned_cards) + tonyp@3119: survivor_regions_evac_time; tonyp@3119: size_t available_free_regions = _free_regions_at_end_of_collection; tonyp@3119: size_t base_free_regions = 0; tonyp@3119: if (available_free_regions > _reserve_regions) { tonyp@3119: base_free_regions = available_free_regions - _reserve_regions; tonyp@3119: } tonyp@3119: tonyp@3119: // Here, we will make sure that the shortest young length that tonyp@3119: // makes sense fits within the target pause time. tonyp@3119: tonyp@3119: if (predict_will_fit(min_young_length, base_time_ms, tonyp@3119: base_free_regions, target_pause_time_ms)) { tonyp@3119: // The shortest young length will fit into the target pause time; tonyp@3119: // we'll now check whether the absolute maximum number of young tonyp@3119: // regions will fit in the target pause time. If not, we'll do tonyp@3119: // a binary search between min_young_length and max_young_length. tonyp@3119: if (predict_will_fit(max_young_length, base_time_ms, tonyp@3119: base_free_regions, target_pause_time_ms)) { tonyp@3119: // The maximum young length will fit into the target pause time. tonyp@3119: // We are done so set min young length to the maximum length (as tonyp@3119: // the result is assumed to be returned in min_young_length). tonyp@3119: min_young_length = max_young_length; tonyp@3119: } else { tonyp@3119: // The maximum possible number of young regions will not fit within tonyp@3119: // the target pause time so we'll search for the optimal tonyp@3119: // length. The loop invariants are: tonyp@3119: // tonyp@3119: // min_young_length < max_young_length tonyp@3119: // min_young_length is known to fit into the target pause time tonyp@3119: // max_young_length is known not to fit into the target pause time tonyp@3119: // tonyp@3119: // Going into the loop we know the above hold as we've just tonyp@3119: // checked them. Every time around the loop we check whether tonyp@3119: // the middle value between min_young_length and tonyp@3119: // max_young_length fits into the target pause time. If it tonyp@3119: // does, it becomes the new min. If it doesn't, it becomes tonyp@3119: // the new max. This way we maintain the loop invariants. tonyp@3119: tonyp@3119: assert(min_young_length < max_young_length, "invariant"); tonyp@3119: size_t diff = (max_young_length - min_young_length) / 2; tonyp@3119: while (diff > 0) { tonyp@3119: size_t young_length = min_young_length + diff; tonyp@3119: if (predict_will_fit(young_length, base_time_ms, tonyp@3119: base_free_regions, target_pause_time_ms)) { tonyp@3119: min_young_length = young_length; tonyp@3119: } else { tonyp@3119: max_young_length = young_length; tonyp@3119: } tonyp@3119: assert(min_young_length < max_young_length, "invariant"); tonyp@3119: diff = (max_young_length - min_young_length) / 2; tonyp@3119: } tonyp@3119: // The results is min_young_length which, according to the tonyp@3119: // loop invariants, should fit within the target pause time. tonyp@3119: tonyp@3119: // These are the post-conditions of the binary search above: tonyp@3119: assert(min_young_length < max_young_length, tonyp@3119: "otherwise we should have discovered that max_young_length " tonyp@3119: "fits into the pause target and not done the binary search"); tonyp@3119: assert(predict_will_fit(min_young_length, base_time_ms, tonyp@3119: base_free_regions, target_pause_time_ms), tonyp@3119: "min_young_length, the result of the binary search, should " tonyp@3119: "fit into the pause target"); tonyp@3119: assert(!predict_will_fit(min_young_length + 1, base_time_ms, tonyp@3119: base_free_regions, target_pause_time_ms), tonyp@3119: "min_young_length, the result of the binary search, should be " tonyp@3119: "optimal, so no larger length should fit into the pause target"); tonyp@3119: } tonyp@3119: } else { tonyp@3119: // Even the minimum length doesn't fit into the pause time tonyp@3119: // target, return it as the result nevertheless. tonyp@3119: } tonyp@3119: return base_min_length + min_young_length; ysr@777: } ysr@777: apetrusenko@980: double G1CollectorPolicy::predict_survivor_regions_evac_time() { apetrusenko@980: double survivor_regions_evac_time = 0.0; apetrusenko@980: for (HeapRegion * r = _recorded_survivor_head; apetrusenko@980: r != NULL && r != _recorded_survivor_tail->get_next_young_region(); apetrusenko@980: r = r->get_next_young_region()) { apetrusenko@980: survivor_regions_evac_time += predict_region_elapsed_time_ms(r, true); apetrusenko@980: } apetrusenko@980: return survivor_regions_evac_time; apetrusenko@980: } apetrusenko@980: tonyp@3119: void G1CollectorPolicy::revise_young_list_target_length_if_necessary() { ysr@777: guarantee( adaptive_young_list_length(), "should not call this otherwise" ); ysr@777: johnc@1829: size_t rs_lengths = _g1->young_list()->sampled_rs_lengths(); ysr@777: if (rs_lengths > _rs_lengths_prediction) { ysr@777: // add 10% to avoid having to recalculate often ysr@777: size_t rs_lengths_prediction = rs_lengths * 1100 / 1000; tonyp@3119: update_young_list_target_length(rs_lengths_prediction); ysr@777: } ysr@777: } ysr@777: tonyp@3119: tonyp@3119: ysr@777: HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size, ysr@777: bool is_tlab, ysr@777: bool* gc_overhead_limit_was_exceeded) { ysr@777: guarantee(false, "Not using this policy feature yet."); ysr@777: return NULL; ysr@777: } ysr@777: ysr@777: // This method controls how a collector handles one or more ysr@777: // of its generations being fully allocated. ysr@777: HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size, ysr@777: bool is_tlab) { ysr@777: guarantee(false, "Not using this policy feature yet."); ysr@777: return NULL; ysr@777: } ysr@777: ysr@777: ysr@777: #ifndef PRODUCT ysr@777: bool G1CollectorPolicy::verify_young_ages() { johnc@1829: HeapRegion* head = _g1->young_list()->first_region(); ysr@777: return ysr@777: verify_young_ages(head, _short_lived_surv_rate_group); ysr@777: // also call verify_young_ages on any additional surv rate groups ysr@777: } ysr@777: ysr@777: bool ysr@777: G1CollectorPolicy::verify_young_ages(HeapRegion* head, ysr@777: SurvRateGroup *surv_rate_group) { ysr@777: guarantee( surv_rate_group != NULL, "pre-condition" ); ysr@777: ysr@777: const char* name = surv_rate_group->name(); ysr@777: bool ret = true; ysr@777: int prev_age = -1; ysr@777: ysr@777: for (HeapRegion* curr = head; ysr@777: curr != NULL; ysr@777: curr = curr->get_next_young_region()) { ysr@777: SurvRateGroup* group = curr->surv_rate_group(); ysr@777: if (group == NULL && !curr->is_survivor()) { ysr@777: gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name); ysr@777: ret = false; ysr@777: } ysr@777: ysr@777: if (surv_rate_group == group) { ysr@777: int age = curr->age_in_surv_rate_group(); ysr@777: ysr@777: if (age < 0) { ysr@777: gclog_or_tty->print_cr("## %s: encountered negative age", name); ysr@777: ret = false; ysr@777: } ysr@777: ysr@777: if (age <= prev_age) { ysr@777: gclog_or_tty->print_cr("## %s: region ages are not strictly increasing " ysr@777: "(%d, %d)", name, age, prev_age); ysr@777: ret = false; ysr@777: } ysr@777: prev_age = age; ysr@777: } ysr@777: } ysr@777: ysr@777: return ret; ysr@777: } ysr@777: #endif // PRODUCT ysr@777: ysr@777: void G1CollectorPolicy::record_full_collection_start() { ysr@777: _cur_collection_start_sec = os::elapsedTime(); ysr@777: // Release the future to-space so that it is available for compaction into. ysr@777: _g1->set_full_collection(); ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::record_full_collection_end() { ysr@777: // Consider this like a collection pause for the purposes of allocation ysr@777: // since last pause. ysr@777: double end_sec = os::elapsedTime(); ysr@777: double full_gc_time_sec = end_sec - _cur_collection_start_sec; ysr@777: double full_gc_time_ms = full_gc_time_sec * 1000.0; ysr@777: ysr@777: _all_full_gc_times_ms->add(full_gc_time_ms); ysr@777: tonyp@1030: update_recent_gc_times(end_sec, full_gc_time_ms); ysr@777: ysr@777: _g1->clear_full_collection(); ysr@777: tonyp@3337: // "Nuke" the heuristics that control the young/mixed GC tonyp@3337: // transitions and make sure we start with young GCs after the Full GC. tonyp@3337: set_gcs_are_young(true); tonyp@3337: _last_young_gc = false; tonyp@3337: _should_revert_to_young_gcs = false; tonyp@1794: clear_initiate_conc_mark_if_possible(); tonyp@1794: clear_during_initial_mark_pause(); ysr@777: _known_garbage_bytes = 0; ysr@777: _known_garbage_ratio = 0.0; ysr@777: _in_marking_window = false; ysr@777: _in_marking_window_im = false; ysr@777: ysr@777: _short_lived_surv_rate_group->start_adding_regions(); ysr@777: // also call this on any additional surv rate groups ysr@777: apetrusenko@980: record_survivor_regions(0, NULL, NULL); apetrusenko@980: ysr@777: _free_regions_at_end_of_collection = _g1->free_regions(); apetrusenko@980: // Reset survivors SurvRateGroup. apetrusenko@980: _survivor_surv_rate_group->reset(); tonyp@3119: update_young_list_target_length(); tonyp@3209: _collectionSetChooser->updateAfterFullCollection(); tonyp@2315: } ysr@777: ysr@777: void G1CollectorPolicy::record_stop_world_start() { ysr@777: _stop_world_start = os::elapsedTime(); ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, ysr@777: size_t start_used) { ysr@777: if (PrintGCDetails) { ysr@777: gclog_or_tty->stamp(PrintGCTimeStamps); ysr@777: gclog_or_tty->print("[GC pause"); tonyp@3337: gclog_or_tty->print(" (%s)", gcs_are_young() ? "young" : "mixed"); ysr@777: } ysr@777: tonyp@3416: if (!during_initial_mark_pause()) { tonyp@3416: // We only need to do this here as the policy will only be applied tonyp@3416: // to the GC we're about to start. so, no point is calculating this tonyp@3416: // every time we calculate / recalculate the target young length. tonyp@3416: update_survivors_policy(); tonyp@3416: } else { tonyp@3416: // The marking phase has a "we only copy implicitly live tonyp@3416: // objects during marking" invariant. The easiest way to ensure it tonyp@3416: // holds is not to allocate any survivor regions and tenure all tonyp@3416: // objects. In the future we might change this and handle survivor tonyp@3416: // regions specially during marking. tonyp@3416: tenure_all_objects(); tonyp@3416: } tonyp@3119: tonyp@2315: assert(_g1->used() == _g1->recalculate_used(), tonyp@2315: err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT, tonyp@2315: _g1->used(), _g1->recalculate_used())); ysr@777: ysr@777: double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0; ysr@777: _all_stop_world_times_ms->add(s_w_t_ms); ysr@777: _stop_world_start = 0.0; ysr@777: ysr@777: _cur_collection_start_sec = start_time_sec; ysr@777: _cur_collection_pause_used_at_start_bytes = start_used; ysr@777: _cur_collection_pause_used_regions_at_start = _g1->used_regions(); ysr@777: _pending_cards = _g1->pending_card_num(); ysr@777: _max_pending_cards = _g1->max_pending_card_num(); ysr@777: ysr@777: _bytes_in_collection_set_before_gc = 0; tonyp@3028: _bytes_copied_during_gc = 0; ysr@777: tonyp@2961: YoungList* young_list = _g1->young_list(); tonyp@2961: _eden_bytes_before_gc = young_list->eden_used_bytes(); tonyp@2961: _survivor_bytes_before_gc = young_list->survivor_used_bytes(); tonyp@2961: _capacity_before_gc = _g1->capacity(); tonyp@2961: ysr@777: #ifdef DEBUG ysr@777: // initialise these to something well known so that we can spot ysr@777: // if they are not set properly ysr@777: ysr@777: for (int i = 0; i < _parallel_gc_threads; ++i) { tonyp@1966: _par_last_gc_worker_start_times_ms[i] = -1234.0; tonyp@1966: _par_last_ext_root_scan_times_ms[i] = -1234.0; tonyp@3416: _par_last_satb_filtering_times_ms[i] = -1234.0; tonyp@1966: _par_last_update_rs_times_ms[i] = -1234.0; tonyp@1966: _par_last_update_rs_processed_buffers[i] = -1234.0; tonyp@1966: _par_last_scan_rs_times_ms[i] = -1234.0; tonyp@1966: _par_last_obj_copy_times_ms[i] = -1234.0; tonyp@1966: _par_last_termination_times_ms[i] = -1234.0; tonyp@1966: _par_last_termination_attempts[i] = -1234.0; tonyp@1966: _par_last_gc_worker_end_times_ms[i] = -1234.0; brutisso@2712: _par_last_gc_worker_times_ms[i] = -1234.0; johnc@3219: _par_last_gc_worker_other_times_ms[i] = -1234.0; ysr@777: } ysr@777: #endif ysr@777: ysr@777: for (int i = 0; i < _aux_num; ++i) { ysr@777: _cur_aux_times_ms[i] = 0.0; ysr@777: _cur_aux_times_set[i] = false; ysr@777: } ysr@777: johnc@3295: // This is initialized to zero here and is set during johnc@3219: // the evacuation pause if marking is in progress. johnc@3219: _cur_satb_drain_time_ms = 0.0; ysr@777: tonyp@3337: _last_gc_was_young = false; ysr@777: ysr@777: // do that for any other surv rate groups ysr@777: _short_lived_surv_rate_group->stop_adding_regions(); tonyp@1717: _survivors_age_table.clear(); apetrusenko@980: ysr@777: assert( verify_young_ages(), "region age verification" ); ysr@777: } ysr@777: brutisso@3065: void G1CollectorPolicy::record_concurrent_mark_init_end(double ysr@777: mark_init_elapsed_time_ms) { ysr@777: _during_marking = true; tonyp@1794: assert(!initiate_conc_mark_if_possible(), "we should have cleared it by now"); tonyp@1794: clear_during_initial_mark_pause(); ysr@777: _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms; ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::record_concurrent_mark_remark_start() { ysr@777: _mark_remark_start_sec = os::elapsedTime(); ysr@777: _during_marking = false; ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::record_concurrent_mark_remark_end() { ysr@777: double end_time_sec = os::elapsedTime(); ysr@777: double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0; ysr@777: _concurrent_mark_remark_times_ms->add(elapsed_time_ms); ysr@777: _cur_mark_stop_world_time_ms += elapsed_time_ms; ysr@777: _prev_collection_pause_end_ms += elapsed_time_ms; ysr@777: ysr@777: _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true); ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::record_concurrent_mark_cleanup_start() { ysr@777: _mark_cleanup_start_sec = os::elapsedTime(); ysr@777: } ysr@777: tonyp@3209: void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() { tonyp@3337: _should_revert_to_young_gcs = false; tonyp@3337: _last_young_gc = true; brutisso@3065: _in_marking_window = false; ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::record_concurrent_pause() { ysr@777: if (_stop_world_start > 0.0) { ysr@777: double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0; ysr@777: _all_yield_times_ms->add(yield_ms); ysr@777: } ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::record_concurrent_pause_end() { ysr@777: } ysr@777: ysr@777: template ysr@777: T sum_of(T* sum_arr, int start, int n, int N) { ysr@777: T sum = (T)0; ysr@777: for (int i = 0; i < n; i++) { ysr@777: int j = (start + i) % N; ysr@777: sum += sum_arr[j]; ysr@777: } ysr@777: return sum; ysr@777: } ysr@777: tonyp@1966: void G1CollectorPolicy::print_par_stats(int level, tonyp@1966: const char* str, brutisso@2712: double* data) { ysr@777: double min = data[0], max = data[0]; ysr@777: double total = 0.0; brutisso@2645: LineBuffer buf(level); brutisso@2645: buf.append("[%s (ms):", str); jmasa@3294: for (uint i = 0; i < no_of_gc_threads(); ++i) { ysr@777: double val = data[i]; ysr@777: if (val < min) ysr@777: min = val; ysr@777: if (val > max) ysr@777: max = val; ysr@777: total += val; brutisso@2645: buf.append(" %3.1lf", val); ysr@777: } brutisso@2712: buf.append_and_print_cr(""); jmasa@3294: double avg = total / (double) no_of_gc_threads(); brutisso@2712: buf.append_and_print_cr(" Avg: %5.1lf, Min: %5.1lf, Max: %5.1lf, Diff: %5.1lf]", brutisso@2712: avg, min, max, max - min); ysr@777: } ysr@777: tonyp@1966: void G1CollectorPolicy::print_par_sizes(int level, tonyp@1966: const char* str, brutisso@2712: double* data) { ysr@777: double min = data[0], max = data[0]; ysr@777: double total = 0.0; brutisso@2645: LineBuffer buf(level); brutisso@2645: buf.append("[%s :", str); jmasa@3294: for (uint i = 0; i < no_of_gc_threads(); ++i) { ysr@777: double val = data[i]; ysr@777: if (val < min) ysr@777: min = val; ysr@777: if (val > max) ysr@777: max = val; ysr@777: total += val; brutisso@2645: buf.append(" %d", (int) val); ysr@777: } brutisso@2712: buf.append_and_print_cr(""); jmasa@3294: double avg = total / (double) no_of_gc_threads(); brutisso@2712: buf.append_and_print_cr(" Sum: %d, Avg: %d, Min: %d, Max: %d, Diff: %d]", brutisso@2712: (int)total, (int)avg, (int)min, (int)max, (int)max - (int)min); ysr@777: } ysr@777: johnc@3219: void G1CollectorPolicy::print_stats(int level, johnc@3219: const char* str, johnc@3219: double value) { brutisso@2645: LineBuffer(level).append_and_print_cr("[%s: %5.1lf ms]", str, value); ysr@777: } ysr@777: johnc@3219: void G1CollectorPolicy::print_stats(int level, johnc@3219: const char* str, johnc@3219: int value) { brutisso@2645: LineBuffer(level).append_and_print_cr("[%s: %d]", str, value); ysr@777: } ysr@777: johnc@3219: double G1CollectorPolicy::avg_value(double* data) { jmasa@2188: if (G1CollectedHeap::use_parallel_gc_threads()) { ysr@777: double ret = 0.0; jmasa@3294: for (uint i = 0; i < no_of_gc_threads(); ++i) { ysr@777: ret += data[i]; johnc@3219: } jmasa@3294: return ret / (double) no_of_gc_threads(); ysr@777: } else { ysr@777: return data[0]; ysr@777: } ysr@777: } ysr@777: johnc@3219: double G1CollectorPolicy::max_value(double* data) { jmasa@2188: if (G1CollectedHeap::use_parallel_gc_threads()) { ysr@777: double ret = data[0]; jmasa@3294: for (uint i = 1; i < no_of_gc_threads(); ++i) { johnc@3219: if (data[i] > ret) { ysr@777: ret = data[i]; johnc@3219: } johnc@3219: } ysr@777: return ret; ysr@777: } else { ysr@777: return data[0]; ysr@777: } ysr@777: } ysr@777: johnc@3219: double G1CollectorPolicy::sum_of_values(double* data) { jmasa@2188: if (G1CollectedHeap::use_parallel_gc_threads()) { ysr@777: double sum = 0.0; jmasa@3294: for (uint i = 0; i < no_of_gc_threads(); i++) { ysr@777: sum += data[i]; johnc@3219: } ysr@777: return sum; ysr@777: } else { ysr@777: return data[0]; ysr@777: } ysr@777: } ysr@777: johnc@3219: double G1CollectorPolicy::max_sum(double* data1, double* data2) { ysr@777: double ret = data1[0] + data2[0]; ysr@777: jmasa@2188: if (G1CollectedHeap::use_parallel_gc_threads()) { jmasa@3294: for (uint i = 1; i < no_of_gc_threads(); ++i) { ysr@777: double data = data1[i] + data2[i]; johnc@3219: if (data > ret) { ysr@777: ret = data; johnc@3219: } ysr@777: } ysr@777: } ysr@777: return ret; ysr@777: } ysr@777: ysr@777: // Anything below that is considered to be zero ysr@777: #define MIN_TIMER_GRANULARITY 0.0000001 ysr@777: jmasa@3294: void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { ysr@777: double end_time_sec = os::elapsedTime(); ysr@777: double elapsed_ms = _last_pause_time_ms; jmasa@2188: bool parallel = G1CollectedHeap::use_parallel_gc_threads(); tonyp@3289: assert(_cur_collection_pause_used_regions_at_start >= cset_region_length(), tonyp@3289: "otherwise, the subtraction below does not make sense"); ysr@777: size_t rs_size = tonyp@3289: _cur_collection_pause_used_regions_at_start - cset_region_length(); ysr@777: size_t cur_used_bytes = _g1->used(); ysr@777: assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); ysr@777: bool last_pause_included_initial_mark = false; tonyp@2062: bool update_stats = !_g1->evacuation_failed(); jmasa@3294: set_no_of_gc_threads(no_of_gc_threads); ysr@777: ysr@777: #ifndef PRODUCT ysr@777: if (G1YoungSurvRateVerbose) { ysr@777: gclog_or_tty->print_cr(""); ysr@777: _short_lived_surv_rate_group->print(); ysr@777: // do that for any other surv rate groups too ysr@777: } ysr@777: #endif // PRODUCT ysr@777: brutisso@3065: last_pause_included_initial_mark = during_initial_mark_pause(); brutisso@3065: if (last_pause_included_initial_mark) brutisso@3065: record_concurrent_mark_init_end(0.0); brutisso@3065: tonyp@3114: size_t marking_initiating_used_threshold = brutisso@3065: (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; brutisso@3065: tonyp@3337: if (!_g1->mark_in_progress() && !_last_young_gc) { brutisso@3065: assert(!last_pause_included_initial_mark, "invariant"); tonyp@3114: if (cur_used_bytes > marking_initiating_used_threshold) { tonyp@3114: if (cur_used_bytes > _prev_collection_pause_used_at_end_bytes) { tonyp@1794: assert(!during_initial_mark_pause(), "we should not see this here"); tonyp@1794: tonyp@3114: ergo_verbose3(ErgoConcCycles, tonyp@3114: "request concurrent cycle initiation", tonyp@3114: ergo_format_reason("occupancy higher than threshold") tonyp@3114: ergo_format_byte("occupancy") tonyp@3114: ergo_format_byte_perc("threshold"), tonyp@3114: cur_used_bytes, tonyp@3114: marking_initiating_used_threshold, tonyp@3114: (double) InitiatingHeapOccupancyPercent); tonyp@3114: tonyp@1794: // Note: this might have already been set, if during the last tonyp@1794: // pause we decided to start a cycle but at the beginning of tonyp@1794: // this pause we decided to postpone it. That's OK. tonyp@1794: set_initiate_conc_mark_if_possible(); tonyp@3114: } else { tonyp@3114: ergo_verbose2(ErgoConcCycles, tonyp@3114: "do not request concurrent cycle initiation", tonyp@3114: ergo_format_reason("occupancy lower than previous occupancy") tonyp@3114: ergo_format_byte("occupancy") tonyp@3114: ergo_format_byte("previous occupancy"), tonyp@3114: cur_used_bytes, tonyp@3114: _prev_collection_pause_used_at_end_bytes); tonyp@3114: } ysr@777: } ysr@777: } ysr@777: brutisso@3065: _prev_collection_pause_used_at_end_bytes = cur_used_bytes; brutisso@3065: ysr@777: _mmu_tracker->add_pause(end_time_sec - elapsed_ms/1000.0, ysr@777: end_time_sec, false); ysr@777: ysr@777: // This assert is exempted when we're doing parallel collection pauses, ysr@777: // because the fragmentation caused by the parallel GC allocation buffers ysr@777: // can lead to more memory being used during collection than was used ysr@777: // before. Best leave this out until the fragmentation problem is fixed. ysr@777: // Pauses in which evacuation failed can also lead to negative ysr@777: // collections, since no space is reclaimed from a region containing an ysr@777: // object whose evacuation failed. ysr@777: // Further, we're now always doing parallel collection. But I'm still ysr@777: // leaving this here as a placeholder for a more precise assertion later. ysr@777: // (DLD, 10/05.) ysr@777: assert((true || parallel) // Always using GC LABs now. ysr@777: || _g1->evacuation_failed() ysr@777: || _cur_collection_pause_used_at_start_bytes >= cur_used_bytes, ysr@777: "Negative collection"); ysr@777: ysr@777: size_t freed_bytes = ysr@777: _cur_collection_pause_used_at_start_bytes - cur_used_bytes; ysr@777: size_t surviving_bytes = _collection_set_bytes_used_before - freed_bytes; johnc@1829: ysr@777: double survival_fraction = ysr@777: (double)surviving_bytes/ ysr@777: (double)_collection_set_bytes_used_before; ysr@777: johnc@3219: // These values are used to update the summary information that is johnc@3219: // displayed when TraceGen0Time is enabled, and are output as part johnc@3219: // of the PrintGCDetails output, in the non-parallel case. johnc@3219: johnc@3021: double ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms); tonyp@3416: double satb_filtering_time = avg_value(_par_last_satb_filtering_times_ms); johnc@3021: double update_rs_time = avg_value(_par_last_update_rs_times_ms); johnc@3021: double update_rs_processed_buffers = johnc@3021: sum_of_values(_par_last_update_rs_processed_buffers); johnc@3021: double scan_rs_time = avg_value(_par_last_scan_rs_times_ms); johnc@3021: double obj_copy_time = avg_value(_par_last_obj_copy_times_ms); johnc@3021: double termination_time = avg_value(_par_last_termination_times_ms); johnc@3021: johnc@3219: double known_time = ext_root_scan_time + tonyp@3416: satb_filtering_time + johnc@3219: update_rs_time + johnc@3219: scan_rs_time + johnc@3219: obj_copy_time; johnc@3219: johnc@3219: double other_time_ms = elapsed_ms; johnc@3219: johnc@3219: // Subtract the SATB drain time. It's initialized to zero at the johnc@3219: // start of the pause and is updated during the pause if marking johnc@3219: // is in progress. johnc@3219: other_time_ms -= _cur_satb_drain_time_ms; johnc@3219: johnc@3219: if (parallel) { johnc@3219: other_time_ms -= _cur_collection_par_time_ms; johnc@3219: } else { johnc@3219: other_time_ms -= known_time; johnc@3219: } johnc@3219: johnc@3219: // Subtract the time taken to clean the card table from the johnc@3219: // current value of "other time" johnc@3219: other_time_ms -= _cur_clear_ct_time_ms; johnc@3219: johnc@3296: // Subtract the time spent completing marking in the collection johnc@3296: // set. Note if marking is not in progress during the pause johnc@3296: // the value of _mark_closure_time_ms will be zero. johnc@3296: other_time_ms -= _mark_closure_time_ms; johnc@3296: johnc@3219: // TraceGen0Time and TraceGen1Time summary info updating. johnc@3219: _all_pause_times_ms->add(elapsed_ms); johnc@3021: tonyp@1030: if (update_stats) { johnc@3219: _summary->record_total_time_ms(elapsed_ms); johnc@3219: _summary->record_other_time_ms(other_time_ms); johnc@3219: johnc@3219: MainBodySummary* body_summary = _summary->main_body_summary(); johnc@3219: assert(body_summary != NULL, "should not be null!"); johnc@3219: johnc@3219: // This will be non-zero iff marking is currently in progress (i.e. johnc@3219: // _g1->mark_in_progress() == true) and the currrent pause was not johnc@3219: // an initial mark pause. Since the body_summary items are NumberSeqs, johnc@3219: // however, they have to be consistent and updated in lock-step with johnc@3219: // each other. Therefore we unconditionally record the SATB drain johnc@3219: // time - even if it's zero. johnc@3219: body_summary->record_satb_drain_time_ms(_cur_satb_drain_time_ms); johnc@3021: johnc@3021: body_summary->record_ext_root_scan_time_ms(ext_root_scan_time); tonyp@3416: body_summary->record_satb_filtering_time_ms(satb_filtering_time); johnc@3021: body_summary->record_update_rs_time_ms(update_rs_time); johnc@3021: body_summary->record_scan_rs_time_ms(scan_rs_time); johnc@3021: body_summary->record_obj_copy_time_ms(obj_copy_time); johnc@3219: johnc@3021: if (parallel) { johnc@3021: body_summary->record_parallel_time_ms(_cur_collection_par_time_ms); johnc@3021: body_summary->record_termination_time_ms(termination_time); johnc@3219: johnc@3219: double parallel_known_time = known_time + termination_time; johnc@3219: double parallel_other_time = _cur_collection_par_time_ms - parallel_known_time; johnc@3021: body_summary->record_parallel_other_time_ms(parallel_other_time); johnc@3021: } johnc@3219: johnc@3021: body_summary->record_mark_closure_time_ms(_mark_closure_time_ms); johnc@3219: body_summary->record_clear_ct_time_ms(_cur_clear_ct_time_ms); johnc@3021: ysr@777: // We exempt parallel collection from this check because Alloc Buffer ysr@777: // fragmentation can produce negative collections. Same with evac ysr@777: // failure. ysr@777: // Further, we're now always doing parallel collection. But I'm still ysr@777: // leaving this here as a placeholder for a more precise assertion later. ysr@777: // (DLD, 10/05. ysr@777: assert((true || parallel) ysr@777: || _g1->evacuation_failed() ysr@777: || surviving_bytes <= _collection_set_bytes_used_before, ysr@777: "Or else negative collection!"); johnc@3219: ysr@777: // this is where we update the allocation rate of the application ysr@777: double app_time_ms = ysr@777: (_cur_collection_start_sec * 1000.0 - _prev_collection_pause_end_ms); ysr@777: if (app_time_ms < MIN_TIMER_GRANULARITY) { ysr@777: // This usually happens due to the timer not having the required ysr@777: // granularity. Some Linuxes are the usual culprits. ysr@777: // We'll just set it to something (arbitrarily) small. ysr@777: app_time_ms = 1.0; ysr@777: } tonyp@3289: // We maintain the invariant that all objects allocated by mutator tonyp@3289: // threads will be allocated out of eden regions. So, we can use tonyp@3289: // the eden region number allocated since the previous GC to tonyp@3289: // calculate the application's allocate rate. The only exception tonyp@3289: // to that is humongous objects that are allocated separately. But tonyp@3289: // given that humongous object allocations do not really affect tonyp@3289: // either the pause's duration nor when the next pause will take tonyp@3289: // place we can safely ignore them here. tonyp@3289: size_t regions_allocated = eden_cset_region_length(); ysr@777: double alloc_rate_ms = (double) regions_allocated / app_time_ms; ysr@777: _alloc_rate_ms_seq->add(alloc_rate_ms); ysr@777: ysr@777: double interval_ms = ysr@777: (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0; ysr@777: update_recent_gc_times(end_time_sec, elapsed_ms); ysr@777: _recent_avg_pause_time_ratio = _recent_gc_times_ms->sum()/interval_ms; ysr@1521: if (recent_avg_pause_time_ratio() < 0.0 || ysr@1521: (recent_avg_pause_time_ratio() - 1.0 > 0.0)) { ysr@1521: #ifndef PRODUCT ysr@1521: // Dump info to allow post-facto debugging ysr@1521: gclog_or_tty->print_cr("recent_avg_pause_time_ratio() out of bounds"); ysr@1521: gclog_or_tty->print_cr("-------------------------------------------"); ysr@1521: gclog_or_tty->print_cr("Recent GC Times (ms):"); ysr@1521: _recent_gc_times_ms->dump(); ysr@1521: gclog_or_tty->print_cr("(End Time=%3.3f) Recent GC End Times (s):", end_time_sec); ysr@1521: _recent_prev_end_times_for_all_gcs_sec->dump(); ysr@1521: gclog_or_tty->print_cr("GC = %3.3f, Interval = %3.3f, Ratio = %3.3f", ysr@1521: _recent_gc_times_ms->sum(), interval_ms, recent_avg_pause_time_ratio()); ysr@1522: // In debug mode, terminate the JVM if the user wants to debug at this point. ysr@1522: assert(!G1FailOnFPError, "Debugging data for CR 6898948 has been dumped above"); ysr@1522: #endif // !PRODUCT ysr@1522: // Clip ratio between 0.0 and 1.0, and continue. This will be fixed in ysr@1522: // CR 6902692 by redoing the manner in which the ratio is incrementally computed. ysr@1521: if (_recent_avg_pause_time_ratio < 0.0) { ysr@1521: _recent_avg_pause_time_ratio = 0.0; ysr@1521: } else { ysr@1521: assert(_recent_avg_pause_time_ratio - 1.0 > 0.0, "Ctl-point invariant"); ysr@1521: _recent_avg_pause_time_ratio = 1.0; ysr@1521: } ysr@1521: } ysr@777: } ysr@777: johnc@3219: for (int i = 0; i < _aux_num; ++i) { johnc@3219: if (_cur_aux_times_set[i]) { johnc@3219: _all_aux_times_ms[i].add(_cur_aux_times_ms[i]); johnc@3219: } johnc@3219: } johnc@3219: johnc@3219: // PrintGCDetails output ysr@777: if (PrintGCDetails) { johnc@3219: bool print_marking_info = johnc@3219: _g1->mark_in_progress() && !last_pause_included_initial_mark; johnc@3219: tonyp@2062: gclog_or_tty->print_cr("%s, %1.8lf secs]", ysr@777: (last_pause_included_initial_mark) ? " (initial-mark)" : "", ysr@777: elapsed_ms / 1000.0); ysr@777: tonyp@2062: if (parallel) { tonyp@2062: print_stats(1, "Parallel Time", _cur_collection_par_time_ms); johnc@3219: print_par_stats(2, "GC Worker Start", _par_last_gc_worker_start_times_ms); johnc@3219: print_par_stats(2, "Ext Root Scanning", _par_last_ext_root_scan_times_ms); johnc@3219: if (print_marking_info) { tonyp@3416: print_par_stats(2, "SATB Filtering", _par_last_satb_filtering_times_ms); johnc@3219: } tonyp@2062: print_par_stats(2, "Update RS", _par_last_update_rs_times_ms); brutisso@2712: print_par_sizes(3, "Processed Buffers", _par_last_update_rs_processed_buffers); tonyp@2062: print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms); tonyp@2062: print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms); tonyp@2062: print_par_stats(2, "Termination", _par_last_termination_times_ms); brutisso@2712: print_par_sizes(3, "Termination Attempts", _par_last_termination_attempts); johnc@3219: print_par_stats(2, "GC Worker End", _par_last_gc_worker_end_times_ms); brutisso@2712: brutisso@2712: for (int i = 0; i < _parallel_gc_threads; i++) { brutisso@2712: _par_last_gc_worker_times_ms[i] = _par_last_gc_worker_end_times_ms[i] - _par_last_gc_worker_start_times_ms[i]; johnc@3219: johnc@3219: double worker_known_time = _par_last_ext_root_scan_times_ms[i] + tonyp@3416: _par_last_satb_filtering_times_ms[i] + johnc@3219: _par_last_update_rs_times_ms[i] + johnc@3219: _par_last_scan_rs_times_ms[i] + johnc@3219: _par_last_obj_copy_times_ms[i] + johnc@3219: _par_last_termination_times_ms[i]; johnc@3219: johnc@3219: _par_last_gc_worker_other_times_ms[i] = _cur_collection_par_time_ms - worker_known_time; brutisso@2712: } johnc@3219: print_par_stats(2, "GC Worker", _par_last_gc_worker_times_ms); johnc@3219: print_par_stats(2, "GC Worker Other", _par_last_gc_worker_other_times_ms); tonyp@2062: } else { johnc@3219: print_stats(1, "Ext Root Scanning", ext_root_scan_time); johnc@3219: if (print_marking_info) { tonyp@3416: print_stats(1, "SATB Filtering", satb_filtering_time); johnc@3219: } tonyp@2062: print_stats(1, "Update RS", update_rs_time); johnc@3219: print_stats(2, "Processed Buffers", (int)update_rs_processed_buffers); tonyp@2062: print_stats(1, "Scan RS", scan_rs_time); tonyp@2062: print_stats(1, "Object Copying", obj_copy_time); ysr@777: } johnc@3296: if (print_marking_info) { johnc@3296: print_stats(1, "Complete CSet Marking", _mark_closure_time_ms); johnc@3296: } johnc@3219: print_stats(1, "Clear CT", _cur_clear_ct_time_ms); johnc@1325: #ifndef PRODUCT johnc@1325: print_stats(1, "Cur Clear CC", _cur_clear_cc_time_ms); johnc@1325: print_stats(1, "Cum Clear CC", _cum_clear_cc_time_ms); johnc@1325: print_stats(1, "Min Clear CC", _min_clear_cc_time_ms); johnc@1325: print_stats(1, "Max Clear CC", _max_clear_cc_time_ms); johnc@1325: if (_num_cc_clears > 0) { johnc@1325: print_stats(1, "Avg Clear CC", _cum_clear_cc_time_ms / ((double)_num_cc_clears)); johnc@1325: } johnc@1325: #endif ysr@777: print_stats(1, "Other", other_time_ms); johnc@3296: print_stats(2, "Choose CSet", johnc@3296: (_recorded_young_cset_choice_time_ms + johnc@3296: _recorded_non_young_cset_choice_time_ms)); johnc@3175: print_stats(2, "Ref Proc", _cur_ref_proc_time_ms); johnc@3175: print_stats(2, "Ref Enq", _cur_ref_enq_time_ms); johnc@3296: print_stats(2, "Free CSet", johnc@3296: (_recorded_young_free_cset_time_ms + johnc@3296: _recorded_non_young_free_cset_time_ms)); johnc@1829: ysr@777: for (int i = 0; i < _aux_num; ++i) { ysr@777: if (_cur_aux_times_set[i]) { ysr@777: char buffer[96]; ysr@777: sprintf(buffer, "Aux%d", i); ysr@777: print_stats(1, buffer, _cur_aux_times_ms[i]); ysr@777: } ysr@777: } ysr@777: } ysr@777: ysr@777: // Update the efficiency-since-mark vars. ysr@777: double proc_ms = elapsed_ms * (double) _parallel_gc_threads; ysr@777: if (elapsed_ms < MIN_TIMER_GRANULARITY) { ysr@777: // This usually happens due to the timer not having the required ysr@777: // granularity. Some Linuxes are the usual culprits. ysr@777: // We'll just set it to something (arbitrarily) small. ysr@777: proc_ms = 1.0; ysr@777: } ysr@777: double cur_efficiency = (double) freed_bytes / proc_ms; ysr@777: ysr@777: bool new_in_marking_window = _in_marking_window; ysr@777: bool new_in_marking_window_im = false; tonyp@1794: if (during_initial_mark_pause()) { ysr@777: new_in_marking_window = true; ysr@777: new_in_marking_window_im = true; ysr@777: } ysr@777: tonyp@3337: if (_last_young_gc) { johnc@3178: if (!last_pause_included_initial_mark) { tonyp@3337: ergo_verbose2(ErgoMixedGCs, tonyp@3337: "start mixed GCs", johnc@3178: ergo_format_byte_perc("known garbage"), johnc@3178: _known_garbage_bytes, _known_garbage_ratio * 100.0); tonyp@3337: set_gcs_are_young(false); johnc@3178: } else { tonyp@3337: ergo_verbose0(ErgoMixedGCs, tonyp@3337: "do not start mixed GCs", johnc@3178: ergo_format_reason("concurrent cycle is about to start")); johnc@3178: } tonyp@3337: _last_young_gc = false; brutisso@3065: } brutisso@3065: tonyp@3337: if (!_last_gc_was_young) { tonyp@3337: if (_should_revert_to_young_gcs) { tonyp@3337: ergo_verbose2(ErgoMixedGCs, tonyp@3337: "end mixed GCs", tonyp@3337: ergo_format_reason("mixed GCs end requested") tonyp@3114: ergo_format_byte_perc("known garbage"), tonyp@3114: _known_garbage_bytes, _known_garbage_ratio * 100.0); tonyp@3337: set_gcs_are_young(true); tonyp@3114: } else if (_known_garbage_ratio < 0.05) { tonyp@3337: ergo_verbose3(ErgoMixedGCs, tonyp@3337: "end mixed GCs", tonyp@3114: ergo_format_reason("known garbage percent lower than threshold") tonyp@3114: ergo_format_byte_perc("known garbage") tonyp@3114: ergo_format_perc("threshold"), tonyp@3114: _known_garbage_bytes, _known_garbage_ratio * 100.0, tonyp@3114: 0.05 * 100.0); tonyp@3337: set_gcs_are_young(true); tonyp@3114: } else if (adaptive_young_list_length() && tonyp@3114: (get_gc_eff_factor() * cur_efficiency < predict_young_gc_eff())) { tonyp@3337: ergo_verbose5(ErgoMixedGCs, tonyp@3337: "end mixed GCs", tonyp@3114: ergo_format_reason("current GC efficiency lower than " tonyp@3337: "predicted young GC efficiency") tonyp@3114: ergo_format_double("GC efficiency factor") tonyp@3114: ergo_format_double("current GC efficiency") tonyp@3337: ergo_format_double("predicted young GC efficiency") tonyp@3114: ergo_format_byte_perc("known garbage"), tonyp@3114: get_gc_eff_factor(), cur_efficiency, tonyp@3114: predict_young_gc_eff(), tonyp@3114: _known_garbage_bytes, _known_garbage_ratio * 100.0); tonyp@3337: set_gcs_are_young(true); ysr@777: } brutisso@3065: } tonyp@3337: _should_revert_to_young_gcs = false; tonyp@3337: tonyp@3337: if (_last_gc_was_young && !_during_marking) { brutisso@3065: _young_gc_eff_seq->add(cur_efficiency); ysr@777: } ysr@777: ysr@777: _short_lived_surv_rate_group->start_adding_regions(); ysr@777: // do that for any other surv rate groupsx ysr@777: apetrusenko@1112: if (update_stats) { ysr@777: double pause_time_ms = elapsed_ms; ysr@777: ysr@777: size_t diff = 0; ysr@777: if (_max_pending_cards >= _pending_cards) ysr@777: diff = _max_pending_cards - _pending_cards; ysr@777: _pending_card_diff_seq->add((double) diff); ysr@777: ysr@777: double cost_per_card_ms = 0.0; ysr@777: if (_pending_cards > 0) { ysr@777: cost_per_card_ms = update_rs_time / (double) _pending_cards; ysr@777: _cost_per_card_ms_seq->add(cost_per_card_ms); ysr@777: } ysr@777: ysr@777: size_t cards_scanned = _g1->cards_scanned(); ysr@777: ysr@777: double cost_per_entry_ms = 0.0; ysr@777: if (cards_scanned > 10) { ysr@777: cost_per_entry_ms = scan_rs_time / (double) cards_scanned; tonyp@3337: if (_last_gc_was_young) { ysr@777: _cost_per_entry_ms_seq->add(cost_per_entry_ms); tonyp@3337: } else { tonyp@3337: _mixed_cost_per_entry_ms_seq->add(cost_per_entry_ms); tonyp@3337: } ysr@777: } ysr@777: ysr@777: if (_max_rs_lengths > 0) { ysr@777: double cards_per_entry_ratio = ysr@777: (double) cards_scanned / (double) _max_rs_lengths; tonyp@3337: if (_last_gc_was_young) { tonyp@3337: _young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); tonyp@3337: } else { tonyp@3337: _mixed_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); tonyp@3337: } ysr@777: } ysr@777: tonyp@3356: // This is defensive. For a while _max_rs_lengths could get tonyp@3356: // smaller than _recorded_rs_lengths which was causing tonyp@3356: // rs_length_diff to get very large and mess up the RSet length tonyp@3356: // predictions. The reason was unsafe concurrent updates to the tonyp@3356: // _inc_cset_recorded_rs_lengths field which the code below guards tonyp@3356: // against (see CR 7118202). This bug has now been fixed (see CR tonyp@3356: // 7119027). However, I'm still worried that tonyp@3356: // _inc_cset_recorded_rs_lengths might still end up somewhat tonyp@3356: // inaccurate. The concurrent refinement thread calculates an tonyp@3356: // RSet's length concurrently with other CR threads updating it tonyp@3356: // which might cause it to calculate the length incorrectly (if, tonyp@3356: // say, it's in mid-coarsening). So I'll leave in the defensive tonyp@3356: // conditional below just in case. tonyp@3326: size_t rs_length_diff = 0; tonyp@3326: if (_max_rs_lengths > _recorded_rs_lengths) { tonyp@3326: rs_length_diff = _max_rs_lengths - _recorded_rs_lengths; tonyp@3326: } tonyp@3326: _rs_length_diff_seq->add((double) rs_length_diff); ysr@777: ysr@777: size_t copied_bytes = surviving_bytes; ysr@777: double cost_per_byte_ms = 0.0; ysr@777: if (copied_bytes > 0) { ysr@777: cost_per_byte_ms = obj_copy_time / (double) copied_bytes; tonyp@3337: if (_in_marking_window) { ysr@777: _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms); tonyp@3337: } else { ysr@777: _cost_per_byte_ms_seq->add(cost_per_byte_ms); tonyp@3337: } ysr@777: } ysr@777: ysr@777: double all_other_time_ms = pause_time_ms - johnc@1829: (update_rs_time + scan_rs_time + obj_copy_time + ysr@777: _mark_closure_time_ms + termination_time); ysr@777: ysr@777: double young_other_time_ms = 0.0; tonyp@3289: if (young_cset_region_length() > 0) { ysr@777: young_other_time_ms = ysr@777: _recorded_young_cset_choice_time_ms + ysr@777: _recorded_young_free_cset_time_ms; ysr@777: _young_other_cost_per_region_ms_seq->add(young_other_time_ms / tonyp@3289: (double) young_cset_region_length()); ysr@777: } ysr@777: double non_young_other_time_ms = 0.0; tonyp@3289: if (old_cset_region_length() > 0) { ysr@777: non_young_other_time_ms = ysr@777: _recorded_non_young_cset_choice_time_ms + ysr@777: _recorded_non_young_free_cset_time_ms; ysr@777: ysr@777: _non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms / tonyp@3289: (double) old_cset_region_length()); ysr@777: } ysr@777: ysr@777: double constant_other_time_ms = all_other_time_ms - ysr@777: (young_other_time_ms + non_young_other_time_ms); ysr@777: _constant_other_time_ms_seq->add(constant_other_time_ms); ysr@777: ysr@777: double survival_ratio = 0.0; ysr@777: if (_bytes_in_collection_set_before_gc > 0) { tonyp@3028: survival_ratio = (double) _bytes_copied_during_gc / tonyp@3028: (double) _bytes_in_collection_set_before_gc; ysr@777: } ysr@777: ysr@777: _pending_cards_seq->add((double) _pending_cards); ysr@777: _rs_lengths_seq->add((double) _max_rs_lengths); ysr@777: ysr@777: double expensive_region_limit_ms = johnc@1186: (double) MaxGCPauseMillis - predict_constant_other_time_ms(); ysr@777: if (expensive_region_limit_ms < 0.0) { ysr@777: // this means that the other time was predicted to be longer than ysr@777: // than the max pause time johnc@1186: expensive_region_limit_ms = (double) MaxGCPauseMillis; ysr@777: } ysr@777: _expensive_region_limit_ms = expensive_region_limit_ms; ysr@777: } ysr@777: ysr@777: _in_marking_window = new_in_marking_window; ysr@777: _in_marking_window_im = new_in_marking_window_im; ysr@777: _free_regions_at_end_of_collection = _g1->free_regions(); tonyp@3119: update_young_list_target_length(); ysr@777: iveresov@1546: // Note that _mmu_tracker->max_gc_time() returns the time in seconds. tonyp@1717: double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; iveresov@1546: adjust_concurrent_refinement(update_rs_time, update_rs_processed_buffers, update_rs_time_goal_ms); tonyp@3209: tonyp@3209: assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end."); ysr@777: } ysr@777: tonyp@2961: #define EXT_SIZE_FORMAT "%d%s" tonyp@2961: #define EXT_SIZE_PARAMS(bytes) \ tonyp@2961: byte_size_in_proper_unit((bytes)), \ tonyp@2961: proper_unit_for_byte_size((bytes)) tonyp@2961: tonyp@2961: void G1CollectorPolicy::print_heap_transition() { tonyp@2961: if (PrintGCDetails) { tonyp@2961: YoungList* young_list = _g1->young_list(); tonyp@2961: size_t eden_bytes = young_list->eden_used_bytes(); tonyp@2961: size_t survivor_bytes = young_list->survivor_used_bytes(); tonyp@2961: size_t used_before_gc = _cur_collection_pause_used_at_start_bytes; tonyp@2961: size_t used = _g1->used(); tonyp@2961: size_t capacity = _g1->capacity(); brutisso@3120: size_t eden_capacity = brutisso@3120: (_young_list_target_length * HeapRegion::GrainBytes) - survivor_bytes; tonyp@2961: tonyp@2961: gclog_or_tty->print_cr( brutisso@3120: " [Eden: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->"EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT") " brutisso@3120: "Survivors: "EXT_SIZE_FORMAT"->"EXT_SIZE_FORMAT" " brutisso@3120: "Heap: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->" brutisso@3120: EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")]", brutisso@3120: EXT_SIZE_PARAMS(_eden_bytes_before_gc), brutisso@3120: EXT_SIZE_PARAMS(_prev_eden_capacity), brutisso@3120: EXT_SIZE_PARAMS(eden_bytes), brutisso@3120: EXT_SIZE_PARAMS(eden_capacity), brutisso@3120: EXT_SIZE_PARAMS(_survivor_bytes_before_gc), brutisso@3120: EXT_SIZE_PARAMS(survivor_bytes), brutisso@3120: EXT_SIZE_PARAMS(used_before_gc), brutisso@3120: EXT_SIZE_PARAMS(_capacity_before_gc), brutisso@3120: EXT_SIZE_PARAMS(used), brutisso@3120: EXT_SIZE_PARAMS(capacity)); brutisso@3120: brutisso@3120: _prev_eden_capacity = eden_capacity; tonyp@2961: } else if (PrintGC) { tonyp@2961: _g1->print_size_transition(gclog_or_tty, tonyp@2961: _cur_collection_pause_used_at_start_bytes, tonyp@2961: _g1->used(), _g1->capacity()); tonyp@2961: } tonyp@2961: } tonyp@2961: iveresov@1546: void G1CollectorPolicy::adjust_concurrent_refinement(double update_rs_time, iveresov@1546: double update_rs_processed_buffers, iveresov@1546: double goal_ms) { iveresov@1546: DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); iveresov@1546: ConcurrentG1Refine *cg1r = G1CollectedHeap::heap()->concurrent_g1_refine(); iveresov@1546: tonyp@1717: if (G1UseAdaptiveConcRefinement) { iveresov@1546: const int k_gy = 3, k_gr = 6; iveresov@1546: const double inc_k = 1.1, dec_k = 0.9; iveresov@1546: iveresov@1546: int g = cg1r->green_zone(); iveresov@1546: if (update_rs_time > goal_ms) { iveresov@1546: g = (int)(g * dec_k); // Can become 0, that's OK. That would mean a mutator-only processing. iveresov@1546: } else { iveresov@1546: if (update_rs_time < goal_ms && update_rs_processed_buffers > g) { iveresov@1546: g = (int)MAX2(g * inc_k, g + 1.0); iveresov@1546: } iveresov@1546: } iveresov@1546: // Change the refinement threads params iveresov@1546: cg1r->set_green_zone(g); iveresov@1546: cg1r->set_yellow_zone(g * k_gy); iveresov@1546: cg1r->set_red_zone(g * k_gr); iveresov@1546: cg1r->reinitialize_threads(); iveresov@1546: iveresov@1546: int processing_threshold_delta = MAX2((int)(cg1r->green_zone() * sigma()), 1); iveresov@1546: int processing_threshold = MIN2(cg1r->green_zone() + processing_threshold_delta, iveresov@1546: cg1r->yellow_zone()); iveresov@1546: // Change the barrier params iveresov@1546: dcqs.set_process_completed_threshold(processing_threshold); iveresov@1546: dcqs.set_max_completed_queue(cg1r->red_zone()); iveresov@1546: } iveresov@1546: iveresov@1546: int curr_queue_size = dcqs.completed_buffers_num(); iveresov@1546: if (curr_queue_size >= cg1r->yellow_zone()) { iveresov@1546: dcqs.set_completed_queue_padding(curr_queue_size); iveresov@1546: } else { iveresov@1546: dcqs.set_completed_queue_padding(0); iveresov@1546: } iveresov@1546: dcqs.notify_if_necessary(); iveresov@1546: } iveresov@1546: ysr@777: double ysr@777: G1CollectorPolicy:: ysr@777: predict_young_collection_elapsed_time_ms(size_t adjustment) { ysr@777: guarantee( adjustment == 0 || adjustment == 1, "invariant" ); ysr@777: ysr@777: G1CollectedHeap* g1h = G1CollectedHeap::heap(); johnc@1829: size_t young_num = g1h->young_list()->length(); ysr@777: if (young_num == 0) ysr@777: return 0.0; ysr@777: ysr@777: young_num += adjustment; ysr@777: size_t pending_cards = predict_pending_cards(); johnc@1829: size_t rs_lengths = g1h->young_list()->sampled_rs_lengths() + ysr@777: predict_rs_length_diff(); ysr@777: size_t card_num; tonyp@3337: if (gcs_are_young()) { ysr@777: card_num = predict_young_card_num(rs_lengths); tonyp@3337: } else { ysr@777: card_num = predict_non_young_card_num(rs_lengths); tonyp@3337: } ysr@777: size_t young_byte_size = young_num * HeapRegion::GrainBytes; ysr@777: double accum_yg_surv_rate = ysr@777: _short_lived_surv_rate_group->accum_surv_rate(adjustment); ysr@777: ysr@777: size_t bytes_to_copy = ysr@777: (size_t) (accum_yg_surv_rate * (double) HeapRegion::GrainBytes); ysr@777: ysr@777: return ysr@777: predict_rs_update_time_ms(pending_cards) + ysr@777: predict_rs_scan_time_ms(card_num) + ysr@777: predict_object_copy_time_ms(bytes_to_copy) + ysr@777: predict_young_other_time_ms(young_num) + ysr@777: predict_constant_other_time_ms(); ysr@777: } ysr@777: ysr@777: double ysr@777: G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) { ysr@777: size_t rs_length = predict_rs_length_diff(); ysr@777: size_t card_num; tonyp@3337: if (gcs_are_young()) { ysr@777: card_num = predict_young_card_num(rs_length); tonyp@3337: } else { ysr@777: card_num = predict_non_young_card_num(rs_length); tonyp@3337: } ysr@777: return predict_base_elapsed_time_ms(pending_cards, card_num); ysr@777: } ysr@777: ysr@777: double ysr@777: G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards, ysr@777: size_t scanned_cards) { ysr@777: return ysr@777: predict_rs_update_time_ms(pending_cards) + ysr@777: predict_rs_scan_time_ms(scanned_cards) + ysr@777: predict_constant_other_time_ms(); ysr@777: } ysr@777: ysr@777: double ysr@777: G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr, ysr@777: bool young) { ysr@777: size_t rs_length = hr->rem_set()->occupied(); ysr@777: size_t card_num; tonyp@3337: if (gcs_are_young()) { ysr@777: card_num = predict_young_card_num(rs_length); tonyp@3337: } else { ysr@777: card_num = predict_non_young_card_num(rs_length); tonyp@3337: } ysr@777: size_t bytes_to_copy = predict_bytes_to_copy(hr); ysr@777: ysr@777: double region_elapsed_time_ms = ysr@777: predict_rs_scan_time_ms(card_num) + ysr@777: predict_object_copy_time_ms(bytes_to_copy); ysr@777: ysr@777: if (young) ysr@777: region_elapsed_time_ms += predict_young_other_time_ms(1); ysr@777: else ysr@777: region_elapsed_time_ms += predict_non_young_other_time_ms(1); ysr@777: ysr@777: return region_elapsed_time_ms; ysr@777: } ysr@777: ysr@777: size_t ysr@777: G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) { ysr@777: size_t bytes_to_copy; ysr@777: if (hr->is_marked()) ysr@777: bytes_to_copy = hr->max_live_bytes(); ysr@777: else { ysr@777: guarantee( hr->is_young() && hr->age_in_surv_rate_group() != -1, ysr@777: "invariant" ); ysr@777: int age = hr->age_in_surv_rate_group(); apetrusenko@980: double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group()); ysr@777: bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate); ysr@777: } ysr@777: ysr@777: return bytes_to_copy; ysr@777: } ysr@777: ysr@777: void tonyp@3289: G1CollectorPolicy::init_cset_region_lengths(size_t eden_cset_region_length, tonyp@3289: size_t survivor_cset_region_length) { tonyp@3289: _eden_cset_region_length = eden_cset_region_length; tonyp@3289: _survivor_cset_region_length = survivor_cset_region_length; tonyp@3289: _old_cset_region_length = 0; johnc@1829: } johnc@1829: johnc@1829: void G1CollectorPolicy::set_recorded_rs_lengths(size_t rs_lengths) { johnc@1829: _recorded_rs_lengths = rs_lengths; johnc@1829: } johnc@1829: ysr@777: void G1CollectorPolicy::check_if_region_is_too_expensive(double ysr@777: predicted_time_ms) { ysr@777: // I don't think we need to do this when in young GC mode since ysr@777: // marking will be initiated next time we hit the soft limit anyway... ysr@777: if (predicted_time_ms > _expensive_region_limit_ms) { tonyp@3337: ergo_verbose2(ErgoMixedGCs, tonyp@3337: "request mixed GCs end", tonyp@3114: ergo_format_reason("predicted region time higher than threshold") tonyp@3114: ergo_format_ms("predicted region time") tonyp@3114: ergo_format_ms("threshold"), tonyp@3114: predicted_time_ms, _expensive_region_limit_ms); tonyp@3337: // no point in doing another mixed GC tonyp@3337: _should_revert_to_young_gcs = true; ysr@777: } ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::update_recent_gc_times(double end_time_sec, ysr@777: double elapsed_ms) { ysr@777: _recent_gc_times_ms->add(elapsed_ms); ysr@777: _recent_prev_end_times_for_all_gcs_sec->add(end_time_sec); ysr@777: _prev_collection_pause_end_ms = end_time_sec * 1000.0; ysr@777: } ysr@777: ysr@777: size_t G1CollectorPolicy::expansion_amount() { tonyp@3114: double recent_gc_overhead = recent_avg_pause_time_ratio() * 100.0; tonyp@3114: double threshold = _gc_overhead_perc; tonyp@3114: if (recent_gc_overhead > threshold) { johnc@1186: // We will double the existing space, or take johnc@1186: // G1ExpandByPercentOfAvailable % of the available expansion johnc@1186: // space, whichever is smaller, bounded below by a minimum johnc@1186: // expansion (unless that's all that's left.) ysr@777: const size_t min_expand_bytes = 1*M; johnc@2504: size_t reserved_bytes = _g1->max_capacity(); ysr@777: size_t committed_bytes = _g1->capacity(); ysr@777: size_t uncommitted_bytes = reserved_bytes - committed_bytes; ysr@777: size_t expand_bytes; ysr@777: size_t expand_bytes_via_pct = johnc@1186: uncommitted_bytes * G1ExpandByPercentOfAvailable / 100; ysr@777: expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes); ysr@777: expand_bytes = MAX2(expand_bytes, min_expand_bytes); ysr@777: expand_bytes = MIN2(expand_bytes, uncommitted_bytes); tonyp@3114: tonyp@3114: ergo_verbose5(ErgoHeapSizing, tonyp@3114: "attempt heap expansion", tonyp@3114: ergo_format_reason("recent GC overhead higher than " tonyp@3114: "threshold after GC") tonyp@3114: ergo_format_perc("recent GC overhead") tonyp@3114: ergo_format_perc("threshold") tonyp@3114: ergo_format_byte("uncommitted") tonyp@3114: ergo_format_byte_perc("calculated expansion amount"), tonyp@3114: recent_gc_overhead, threshold, tonyp@3114: uncommitted_bytes, tonyp@3114: expand_bytes_via_pct, (double) G1ExpandByPercentOfAvailable); tonyp@3114: ysr@777: return expand_bytes; ysr@777: } else { ysr@777: return 0; ysr@777: } ysr@777: } ysr@777: ysr@777: class CountCSClosure: public HeapRegionClosure { ysr@777: G1CollectorPolicy* _g1_policy; ysr@777: public: ysr@777: CountCSClosure(G1CollectorPolicy* g1_policy) : ysr@777: _g1_policy(g1_policy) {} ysr@777: bool doHeapRegion(HeapRegion* r) { ysr@777: _g1_policy->_bytes_in_collection_set_before_gc += r->used(); ysr@777: return false; ysr@777: } ysr@777: }; ysr@777: ysr@777: void G1CollectorPolicy::count_CS_bytes_used() { ysr@777: CountCSClosure cs_closure(this); ysr@777: _g1->collection_set_iterate(&cs_closure); ysr@777: } ysr@777: johnc@3219: void G1CollectorPolicy::print_summary(int level, johnc@3219: const char* str, johnc@3219: NumberSeq* seq) const { ysr@777: double sum = seq->sum(); brutisso@2645: LineBuffer(level + 1).append_and_print_cr("%-24s = %8.2lf s (avg = %8.2lf ms)", ysr@777: str, sum / 1000.0, seq->avg()); ysr@777: } ysr@777: johnc@3219: void G1CollectorPolicy::print_summary_sd(int level, johnc@3219: const char* str, johnc@3219: NumberSeq* seq) const { ysr@777: print_summary(level, str, seq); brutisso@2645: LineBuffer(level + 6).append_and_print_cr("(num = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", ysr@777: seq->num(), seq->sd(), seq->maximum()); ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::check_other_times(int level, ysr@777: NumberSeq* other_times_ms, ysr@777: NumberSeq* calc_other_times_ms) const { ysr@777: bool should_print = false; brutisso@2645: LineBuffer buf(level + 2); ysr@777: ysr@777: double max_sum = MAX2(fabs(other_times_ms->sum()), ysr@777: fabs(calc_other_times_ms->sum())); ysr@777: double min_sum = MIN2(fabs(other_times_ms->sum()), ysr@777: fabs(calc_other_times_ms->sum())); ysr@777: double sum_ratio = max_sum / min_sum; ysr@777: if (sum_ratio > 1.1) { ysr@777: should_print = true; brutisso@2645: buf.append_and_print_cr("## CALCULATED OTHER SUM DOESN'T MATCH RECORDED ###"); ysr@777: } ysr@777: ysr@777: double max_avg = MAX2(fabs(other_times_ms->avg()), ysr@777: fabs(calc_other_times_ms->avg())); ysr@777: double min_avg = MIN2(fabs(other_times_ms->avg()), ysr@777: fabs(calc_other_times_ms->avg())); ysr@777: double avg_ratio = max_avg / min_avg; ysr@777: if (avg_ratio > 1.1) { ysr@777: should_print = true; brutisso@2645: buf.append_and_print_cr("## CALCULATED OTHER AVG DOESN'T MATCH RECORDED ###"); ysr@777: } ysr@777: ysr@777: if (other_times_ms->sum() < -0.01) { brutisso@2645: buf.append_and_print_cr("## RECORDED OTHER SUM IS NEGATIVE ###"); ysr@777: } ysr@777: ysr@777: if (other_times_ms->avg() < -0.01) { brutisso@2645: buf.append_and_print_cr("## RECORDED OTHER AVG IS NEGATIVE ###"); ysr@777: } ysr@777: ysr@777: if (calc_other_times_ms->sum() < -0.01) { ysr@777: should_print = true; brutisso@2645: buf.append_and_print_cr("## CALCULATED OTHER SUM IS NEGATIVE ###"); ysr@777: } ysr@777: ysr@777: if (calc_other_times_ms->avg() < -0.01) { ysr@777: should_print = true; brutisso@2645: buf.append_and_print_cr("## CALCULATED OTHER AVG IS NEGATIVE ###"); ysr@777: } ysr@777: ysr@777: if (should_print) ysr@777: print_summary(level, "Other(Calc)", calc_other_times_ms); ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::print_summary(PauseSummary* summary) const { jmasa@2188: bool parallel = G1CollectedHeap::use_parallel_gc_threads(); ysr@777: MainBodySummary* body_summary = summary->main_body_summary(); ysr@777: if (summary->get_total_seq()->num() > 0) { apetrusenko@1112: print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq()); ysr@777: if (body_summary != NULL) { ysr@777: if (parallel) { ysr@777: print_summary(1, "Parallel Time", body_summary->get_parallel_seq()); johnc@3219: print_summary(2, "Ext Root Scanning", body_summary->get_ext_root_scan_seq()); tonyp@3416: print_summary(2, "SATB Filtering", body_summary->get_satb_filtering_seq()); ysr@777: print_summary(2, "Update RS", body_summary->get_update_rs_seq()); ysr@777: print_summary(2, "Scan RS", body_summary->get_scan_rs_seq()); ysr@777: print_summary(2, "Object Copy", body_summary->get_obj_copy_seq()); ysr@777: print_summary(2, "Termination", body_summary->get_termination_seq()); johnc@3219: print_summary(2, "Parallel Other", body_summary->get_parallel_other_seq()); ysr@777: { ysr@777: NumberSeq* other_parts[] = { ysr@777: body_summary->get_ext_root_scan_seq(), tonyp@3416: body_summary->get_satb_filtering_seq(), johnc@3219: body_summary->get_update_rs_seq(), ysr@777: body_summary->get_scan_rs_seq(), ysr@777: body_summary->get_obj_copy_seq(), ysr@777: body_summary->get_termination_seq() ysr@777: }; ysr@777: NumberSeq calc_other_times_ms(body_summary->get_parallel_seq(), johnc@2134: 6, other_parts); ysr@777: check_other_times(2, body_summary->get_parallel_other_seq(), ysr@777: &calc_other_times_ms); ysr@777: } ysr@777: } else { johnc@3219: print_summary(1, "Ext Root Scanning", body_summary->get_ext_root_scan_seq()); tonyp@3416: print_summary(1, "SATB Filtering", body_summary->get_satb_filtering_seq()); ysr@777: print_summary(1, "Update RS", body_summary->get_update_rs_seq()); ysr@777: print_summary(1, "Scan RS", body_summary->get_scan_rs_seq()); ysr@777: print_summary(1, "Object Copy", body_summary->get_obj_copy_seq()); ysr@777: } ysr@777: } johnc@3219: print_summary(1, "Mark Closure", body_summary->get_mark_closure_seq()); johnc@3219: print_summary(1, "Clear CT", body_summary->get_clear_ct_seq()); ysr@777: print_summary(1, "Other", summary->get_other_seq()); ysr@777: { johnc@2134: if (body_summary != NULL) { johnc@2134: NumberSeq calc_other_times_ms; johnc@2134: if (parallel) { johnc@2134: // parallel johnc@2134: NumberSeq* other_parts[] = { johnc@2134: body_summary->get_satb_drain_seq(), johnc@2134: body_summary->get_parallel_seq(), johnc@2134: body_summary->get_clear_ct_seq() johnc@2134: }; johnc@2134: calc_other_times_ms = NumberSeq(summary->get_total_seq(), johnc@2134: 3, other_parts); johnc@2134: } else { johnc@2134: // serial johnc@2134: NumberSeq* other_parts[] = { johnc@2134: body_summary->get_satb_drain_seq(), johnc@2134: body_summary->get_update_rs_seq(), johnc@2134: body_summary->get_ext_root_scan_seq(), tonyp@3416: body_summary->get_satb_filtering_seq(), johnc@2134: body_summary->get_scan_rs_seq(), johnc@2134: body_summary->get_obj_copy_seq() johnc@2134: }; johnc@2134: calc_other_times_ms = NumberSeq(summary->get_total_seq(), johnc@2134: 6, other_parts); johnc@2134: } johnc@2134: check_other_times(1, summary->get_other_seq(), &calc_other_times_ms); ysr@777: } ysr@777: } ysr@777: } else { brutisso@2645: LineBuffer(1).append_and_print_cr("none"); ysr@777: } brutisso@2645: LineBuffer(0).append_and_print_cr(""); ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::print_tracing_info() const { ysr@777: if (TraceGen0Time) { ysr@777: gclog_or_tty->print_cr("ALL PAUSES"); ysr@777: print_summary_sd(0, "Total", _all_pause_times_ms); ysr@777: gclog_or_tty->print_cr(""); ysr@777: gclog_or_tty->print_cr(""); tonyp@3337: gclog_or_tty->print_cr(" Young GC Pauses: %8d", _young_pause_num); tonyp@3337: gclog_or_tty->print_cr(" Mixed GC Pauses: %8d", _mixed_pause_num); ysr@777: gclog_or_tty->print_cr(""); ysr@777: apetrusenko@1112: gclog_or_tty->print_cr("EVACUATION PAUSES"); apetrusenko@1112: print_summary(_summary); ysr@777: ysr@777: gclog_or_tty->print_cr("MISC"); ysr@777: print_summary_sd(0, "Stop World", _all_stop_world_times_ms); ysr@777: print_summary_sd(0, "Yields", _all_yield_times_ms); ysr@777: for (int i = 0; i < _aux_num; ++i) { ysr@777: if (_all_aux_times_ms[i].num() > 0) { ysr@777: char buffer[96]; ysr@777: sprintf(buffer, "Aux%d", i); ysr@777: print_summary_sd(0, buffer, &_all_aux_times_ms[i]); ysr@777: } ysr@777: } ysr@777: } ysr@777: if (TraceGen1Time) { ysr@777: if (_all_full_gc_times_ms->num() > 0) { ysr@777: gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s", ysr@777: _all_full_gc_times_ms->num(), ysr@777: _all_full_gc_times_ms->sum() / 1000.0); ysr@777: gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times_ms->avg()); ysr@777: gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", ysr@777: _all_full_gc_times_ms->sd(), ysr@777: _all_full_gc_times_ms->maximum()); ysr@777: } ysr@777: } ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::print_yg_surv_rate_info() const { ysr@777: #ifndef PRODUCT ysr@777: _short_lived_surv_rate_group->print_surv_rate_summary(); ysr@777: // add this call for any other surv rate groups ysr@777: #endif // PRODUCT ysr@777: } ysr@777: ysr@777: #ifndef PRODUCT ysr@777: // for debugging, bit of a hack... ysr@777: static char* ysr@777: region_num_to_mbs(int length) { ysr@777: static char buffer[64]; ysr@777: double bytes = (double) (length * HeapRegion::GrainBytes); ysr@777: double mbs = bytes / (double) (1024 * 1024); ysr@777: sprintf(buffer, "%7.2lfMB", mbs); ysr@777: return buffer; ysr@777: } ysr@777: #endif // PRODUCT ysr@777: apetrusenko@980: size_t G1CollectorPolicy::max_regions(int purpose) { ysr@777: switch (purpose) { ysr@777: case GCAllocForSurvived: apetrusenko@980: return _max_survivor_regions; ysr@777: case GCAllocForTenured: apetrusenko@980: return REGIONS_UNLIMITED; ysr@777: default: apetrusenko@980: ShouldNotReachHere(); apetrusenko@980: return REGIONS_UNLIMITED; ysr@777: }; ysr@777: } ysr@777: tonyp@3119: void G1CollectorPolicy::update_max_gc_locker_expansion() { tonyp@2333: size_t expansion_region_num = 0; tonyp@2333: if (GCLockerEdenExpansionPercent > 0) { tonyp@2333: double perc = (double) GCLockerEdenExpansionPercent / 100.0; tonyp@2333: double expansion_region_num_d = perc * (double) _young_list_target_length; tonyp@2333: // We use ceiling so that if expansion_region_num_d is > 0.0 (but tonyp@2333: // less than 1.0) we'll get 1. tonyp@2333: expansion_region_num = (size_t) ceil(expansion_region_num_d); tonyp@2333: } else { tonyp@2333: assert(expansion_region_num == 0, "sanity"); tonyp@2333: } tonyp@2333: _young_list_max_length = _young_list_target_length + expansion_region_num; tonyp@2333: assert(_young_list_target_length <= _young_list_max_length, "post-condition"); tonyp@2333: } tonyp@2333: apetrusenko@980: // Calculates survivor space parameters. tonyp@3119: void G1CollectorPolicy::update_survivors_policy() { tonyp@3119: double max_survivor_regions_d = tonyp@3119: (double) _young_list_target_length / (double) SurvivorRatio; tonyp@3119: // We use ceiling so that if max_survivor_regions_d is > 0.0 (but tonyp@3119: // smaller than 1.0) we'll get 1. tonyp@3119: _max_survivor_regions = (size_t) ceil(max_survivor_regions_d); tonyp@3119: tonyp@3066: _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( apetrusenko@980: HeapRegion::GrainWords * _max_survivor_regions); apetrusenko@980: } apetrusenko@980: ysr@777: #ifndef PRODUCT ysr@777: class HRSortIndexIsOKClosure: public HeapRegionClosure { ysr@777: CollectionSetChooser* _chooser; ysr@777: public: ysr@777: HRSortIndexIsOKClosure(CollectionSetChooser* chooser) : ysr@777: _chooser(chooser) {} ysr@777: ysr@777: bool doHeapRegion(HeapRegion* r) { ysr@777: if (!r->continuesHumongous()) { ysr@777: assert(_chooser->regionProperlyOrdered(r), "Ought to be."); ysr@777: } ysr@777: return false; ysr@777: } ysr@777: }; ysr@777: tonyp@3209: bool G1CollectorPolicy::assertMarkedBytesDataOK() { ysr@777: HRSortIndexIsOKClosure cl(_collectionSetChooser); ysr@777: _g1->heap_region_iterate(&cl); ysr@777: return true; ysr@777: } ysr@777: #endif ysr@777: tonyp@3114: bool G1CollectorPolicy::force_initial_mark_if_outside_cycle( tonyp@3114: GCCause::Cause gc_cause) { tonyp@2011: bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); tonyp@2011: if (!during_cycle) { tonyp@3114: ergo_verbose1(ErgoConcCycles, tonyp@3114: "request concurrent cycle initiation", tonyp@3114: ergo_format_reason("requested by GC cause") tonyp@3114: ergo_format_str("GC cause"), tonyp@3114: GCCause::to_string(gc_cause)); tonyp@2011: set_initiate_conc_mark_if_possible(); tonyp@2011: return true; tonyp@2011: } else { tonyp@3114: ergo_verbose1(ErgoConcCycles, tonyp@3114: "do not request concurrent cycle initiation", tonyp@3114: ergo_format_reason("concurrent cycle already in progress") tonyp@3114: ergo_format_str("GC cause"), tonyp@3114: GCCause::to_string(gc_cause)); tonyp@2011: return false; tonyp@2011: } tonyp@2011: } tonyp@2011: ysr@777: void tonyp@1794: G1CollectorPolicy::decide_on_conc_mark_initiation() { tonyp@1794: // We are about to decide on whether this pause will be an tonyp@1794: // initial-mark pause. tonyp@1794: tonyp@1794: // First, during_initial_mark_pause() should not be already set. We tonyp@1794: // will set it here if we have to. However, it should be cleared by tonyp@1794: // the end of the pause (it's only set for the duration of an tonyp@1794: // initial-mark pause). tonyp@1794: assert(!during_initial_mark_pause(), "pre-condition"); tonyp@1794: tonyp@1794: if (initiate_conc_mark_if_possible()) { tonyp@1794: // We had noticed on a previous pause that the heap occupancy has tonyp@1794: // gone over the initiating threshold and we should start a tonyp@1794: // concurrent marking cycle. So we might initiate one. tonyp@1794: tonyp@1794: bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); tonyp@1794: if (!during_cycle) { tonyp@1794: // The concurrent marking thread is not "during a cycle", i.e., tonyp@1794: // it has completed the last one. So we can go ahead and tonyp@1794: // initiate a new cycle. tonyp@1794: tonyp@1794: set_during_initial_mark_pause(); tonyp@3337: // We do not allow mixed GCs during marking. tonyp@3337: if (!gcs_are_young()) { tonyp@3337: set_gcs_are_young(true); tonyp@3337: ergo_verbose0(ErgoMixedGCs, tonyp@3337: "end mixed GCs", johnc@3178: ergo_format_reason("concurrent cycle is about to start")); johnc@3178: } tonyp@1794: tonyp@1794: // And we can now clear initiate_conc_mark_if_possible() as tonyp@1794: // we've already acted on it. tonyp@1794: clear_initiate_conc_mark_if_possible(); tonyp@3114: tonyp@3114: ergo_verbose0(ErgoConcCycles, tonyp@3114: "initiate concurrent cycle", tonyp@3114: ergo_format_reason("concurrent cycle initiation requested")); tonyp@1794: } else { tonyp@1794: // The concurrent marking thread is still finishing up the tonyp@1794: // previous cycle. If we start one right now the two cycles tonyp@1794: // overlap. In particular, the concurrent marking thread might tonyp@1794: // be in the process of clearing the next marking bitmap (which tonyp@1794: // we will use for the next cycle if we start one). Starting a tonyp@1794: // cycle now will be bad given that parts of the marking tonyp@1794: // information might get cleared by the marking thread. And we tonyp@1794: // cannot wait for the marking thread to finish the cycle as it tonyp@1794: // periodically yields while clearing the next marking bitmap tonyp@1794: // and, if it's in a yield point, it's waiting for us to tonyp@1794: // finish. So, at this point we will not start a cycle and we'll tonyp@1794: // let the concurrent marking thread complete the last one. tonyp@3114: ergo_verbose0(ErgoConcCycles, tonyp@3114: "do not initiate concurrent cycle", tonyp@3114: ergo_format_reason("concurrent cycle already in progress")); tonyp@1794: } tonyp@1794: } tonyp@1794: } tonyp@1794: ysr@777: class KnownGarbageClosure: public HeapRegionClosure { ysr@777: CollectionSetChooser* _hrSorted; ysr@777: ysr@777: public: ysr@777: KnownGarbageClosure(CollectionSetChooser* hrSorted) : ysr@777: _hrSorted(hrSorted) ysr@777: {} ysr@777: ysr@777: bool doHeapRegion(HeapRegion* r) { ysr@777: // We only include humongous regions in collection ysr@777: // sets when concurrent mark shows that their contained object is ysr@777: // unreachable. ysr@777: ysr@777: // Do we have any marking information for this region? ysr@777: if (r->is_marked()) { ysr@777: // We don't include humongous regions in collection ysr@777: // sets because we collect them immediately at the end of a marking ysr@777: // cycle. We also don't include young regions because we *must* ysr@777: // include them in the next collection pause. ysr@777: if (!r->isHumongous() && !r->is_young()) { ysr@777: _hrSorted->addMarkedHeapRegion(r); ysr@777: } ysr@777: } ysr@777: return false; ysr@777: } ysr@777: }; ysr@777: ysr@777: class ParKnownGarbageHRClosure: public HeapRegionClosure { ysr@777: CollectionSetChooser* _hrSorted; ysr@777: jint _marked_regions_added; ysr@777: jint _chunk_size; ysr@777: jint _cur_chunk_idx; ysr@777: jint _cur_chunk_end; // Cur chunk [_cur_chunk_idx, _cur_chunk_end) ysr@777: int _worker; ysr@777: int _invokes; ysr@777: ysr@777: void get_new_chunk() { ysr@777: _cur_chunk_idx = _hrSorted->getParMarkedHeapRegionChunk(_chunk_size); ysr@777: _cur_chunk_end = _cur_chunk_idx + _chunk_size; ysr@777: } ysr@777: void add_region(HeapRegion* r) { ysr@777: if (_cur_chunk_idx == _cur_chunk_end) { ysr@777: get_new_chunk(); ysr@777: } ysr@777: assert(_cur_chunk_idx < _cur_chunk_end, "postcondition"); ysr@777: _hrSorted->setMarkedHeapRegion(_cur_chunk_idx, r); ysr@777: _marked_regions_added++; ysr@777: _cur_chunk_idx++; ysr@777: } ysr@777: ysr@777: public: ysr@777: ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted, ysr@777: jint chunk_size, ysr@777: int worker) : ysr@777: _hrSorted(hrSorted), _chunk_size(chunk_size), _worker(worker), ysr@777: _marked_regions_added(0), _cur_chunk_idx(0), _cur_chunk_end(0), ysr@777: _invokes(0) ysr@777: {} ysr@777: ysr@777: bool doHeapRegion(HeapRegion* r) { ysr@777: // We only include humongous regions in collection ysr@777: // sets when concurrent mark shows that their contained object is ysr@777: // unreachable. ysr@777: _invokes++; ysr@777: ysr@777: // Do we have any marking information for this region? ysr@777: if (r->is_marked()) { ysr@777: // We don't include humongous regions in collection ysr@777: // sets because we collect them immediately at the end of a marking ysr@777: // cycle. ysr@777: // We also do not include young regions in collection sets ysr@777: if (!r->isHumongous() && !r->is_young()) { ysr@777: add_region(r); ysr@777: } ysr@777: } ysr@777: return false; ysr@777: } ysr@777: jint marked_regions_added() { return _marked_regions_added; } ysr@777: int invokes() { return _invokes; } ysr@777: }; ysr@777: ysr@777: class ParKnownGarbageTask: public AbstractGangTask { ysr@777: CollectionSetChooser* _hrSorted; ysr@777: jint _chunk_size; ysr@777: G1CollectedHeap* _g1; ysr@777: public: ysr@777: ParKnownGarbageTask(CollectionSetChooser* hrSorted, jint chunk_size) : ysr@777: AbstractGangTask("ParKnownGarbageTask"), ysr@777: _hrSorted(hrSorted), _chunk_size(chunk_size), ysr@777: _g1(G1CollectedHeap::heap()) ysr@777: {} ysr@777: jmasa@3357: void work(uint worker_id) { jmasa@3357: ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, jmasa@3357: _chunk_size, jmasa@3357: worker_id); ysr@777: // Back to zero for the claim value. jmasa@3357: _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, worker_id, jmasa@3294: _g1->workers()->active_workers(), tonyp@790: HeapRegion::InitialClaimValue); ysr@777: jint regions_added = parKnownGarbageCl.marked_regions_added(); ysr@777: _hrSorted->incNumMarkedHeapRegions(regions_added); ysr@777: if (G1PrintParCleanupStats) { brutisso@2645: gclog_or_tty->print_cr(" Thread %d called %d times, added %d regions to list.", jmasa@3357: worker_id, parKnownGarbageCl.invokes(), regions_added); ysr@777: } ysr@777: } ysr@777: }; ysr@777: ysr@777: void jmasa@3294: G1CollectorPolicy::record_concurrent_mark_cleanup_end(int no_of_gc_threads) { tonyp@3209: double start_sec; tonyp@3209: if (G1PrintParCleanupStats) { tonyp@3209: start_sec = os::elapsedTime(); tonyp@3209: } ysr@777: ysr@777: _collectionSetChooser->clearMarkedHeapRegions(); tonyp@3209: double clear_marked_end_sec; ysr@777: if (G1PrintParCleanupStats) { tonyp@3209: clear_marked_end_sec = os::elapsedTime(); tonyp@3209: gclog_or_tty->print_cr(" clear marked regions: %8.3f ms.", tonyp@3209: (clear_marked_end_sec - start_sec) * 1000.0); ysr@777: } tonyp@3209: jmasa@2188: if (G1CollectedHeap::use_parallel_gc_threads()) { ysr@777: const size_t OverpartitionFactor = 4; jmasa@3294: size_t WorkUnit; jmasa@3294: // The use of MinChunkSize = 8 in the original code jmasa@3294: // causes some assertion failures when the total number of jmasa@3294: // region is less than 8. The code here tries to fix that. jmasa@3294: // Should the original code also be fixed? jmasa@3294: if (no_of_gc_threads > 0) { jmasa@3294: const size_t MinWorkUnit = jmasa@3294: MAX2(_g1->n_regions() / no_of_gc_threads, (size_t) 1U); jmasa@3294: WorkUnit = jmasa@3294: MAX2(_g1->n_regions() / (no_of_gc_threads * OverpartitionFactor), jmasa@3294: MinWorkUnit); jmasa@3294: } else { jmasa@3294: assert(no_of_gc_threads > 0, jmasa@3294: "The active gc workers should be greater than 0"); jmasa@3294: // In a product build do something reasonable to avoid a crash. jmasa@3294: const size_t MinWorkUnit = jmasa@3294: MAX2(_g1->n_regions() / ParallelGCThreads, (size_t) 1U); jmasa@3294: WorkUnit = jmasa@3294: MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor), jmasa@3294: MinWorkUnit); jmasa@3294: } ysr@777: _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(), kvn@1926: WorkUnit); ysr@777: ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser, kvn@1926: (int) WorkUnit); ysr@777: _g1->workers()->run_task(&parKnownGarbageTask); tonyp@790: tonyp@790: assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue), tonyp@790: "sanity check"); ysr@777: } else { ysr@777: KnownGarbageClosure knownGarbagecl(_collectionSetChooser); ysr@777: _g1->heap_region_iterate(&knownGarbagecl); ysr@777: } tonyp@3209: double known_garbage_end_sec; ysr@777: if (G1PrintParCleanupStats) { tonyp@3209: known_garbage_end_sec = os::elapsedTime(); ysr@777: gclog_or_tty->print_cr(" compute known garbage: %8.3f ms.", tonyp@3209: (known_garbage_end_sec - clear_marked_end_sec) * 1000.0); ysr@777: } tonyp@3209: ysr@777: _collectionSetChooser->sortMarkedHeapRegions(); tonyp@3209: double end_sec = os::elapsedTime(); ysr@777: if (G1PrintParCleanupStats) { ysr@777: gclog_or_tty->print_cr(" sorting: %8.3f ms.", tonyp@3209: (end_sec - known_garbage_end_sec) * 1000.0); ysr@777: } ysr@777: tonyp@3209: double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0; tonyp@3209: _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); tonyp@3209: _cur_mark_stop_world_time_ms += elapsed_time_ms; tonyp@3209: _prev_collection_pause_end_ms += elapsed_time_ms; tonyp@3209: _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_sec, true); ysr@777: } ysr@777: johnc@1829: // Add the heap region at the head of the non-incremental collection set tonyp@3289: void G1CollectorPolicy::add_old_region_to_cset(HeapRegion* hr) { johnc@1829: assert(_inc_cset_build_state == Active, "Precondition"); johnc@1829: assert(!hr->is_young(), "non-incremental add of young region"); johnc@1829: johnc@1829: assert(!hr->in_collection_set(), "should not already be in the CSet"); ysr@777: hr->set_in_collection_set(true); ysr@777: hr->set_next_in_collection_set(_collection_set); ysr@777: _collection_set = hr; ysr@777: _collection_set_bytes_used_before += hr->used(); tonyp@961: _g1->register_region_with_in_cset_fast_test(hr); tonyp@3289: size_t rs_length = hr->rem_set()->occupied(); tonyp@3289: _recorded_rs_lengths += rs_length; tonyp@3289: _old_cset_region_length += 1; ysr@777: } ysr@777: johnc@1829: // Initialize the per-collection-set information johnc@1829: void G1CollectorPolicy::start_incremental_cset_building() { johnc@1829: assert(_inc_cset_build_state == Inactive, "Precondition"); johnc@1829: johnc@1829: _inc_cset_head = NULL; johnc@1829: _inc_cset_tail = NULL; johnc@1829: _inc_cset_bytes_used_before = 0; johnc@1829: johnc@1829: _inc_cset_max_finger = 0; johnc@1829: _inc_cset_recorded_rs_lengths = 0; tonyp@3356: _inc_cset_recorded_rs_lengths_diffs = 0; tonyp@3356: _inc_cset_predicted_elapsed_time_ms = 0.0; tonyp@3356: _inc_cset_predicted_elapsed_time_ms_diffs = 0.0; johnc@1829: _inc_cset_build_state = Active; johnc@1829: } johnc@1829: tonyp@3356: void G1CollectorPolicy::finalize_incremental_cset_building() { tonyp@3356: assert(_inc_cset_build_state == Active, "Precondition"); tonyp@3356: assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint"); tonyp@3356: tonyp@3356: // The two "main" fields, _inc_cset_recorded_rs_lengths and tonyp@3356: // _inc_cset_predicted_elapsed_time_ms, are updated by the thread tonyp@3356: // that adds a new region to the CSet. Further updates by the tonyp@3356: // concurrent refinement thread that samples the young RSet lengths tonyp@3356: // are accumulated in the *_diffs fields. Here we add the diffs to tonyp@3356: // the "main" fields. tonyp@3356: tonyp@3356: if (_inc_cset_recorded_rs_lengths_diffs >= 0) { tonyp@3356: _inc_cset_recorded_rs_lengths += _inc_cset_recorded_rs_lengths_diffs; tonyp@3356: } else { tonyp@3356: // This is defensive. The diff should in theory be always positive tonyp@3356: // as RSets can only grow between GCs. However, given that we tonyp@3356: // sample their size concurrently with other threads updating them tonyp@3356: // it's possible that we might get the wrong size back, which tonyp@3356: // could make the calculations somewhat inaccurate. tonyp@3356: size_t diffs = (size_t) (-_inc_cset_recorded_rs_lengths_diffs); tonyp@3356: if (_inc_cset_recorded_rs_lengths >= diffs) { tonyp@3356: _inc_cset_recorded_rs_lengths -= diffs; tonyp@3356: } else { tonyp@3356: _inc_cset_recorded_rs_lengths = 0; tonyp@3356: } tonyp@3356: } tonyp@3356: _inc_cset_predicted_elapsed_time_ms += tonyp@3356: _inc_cset_predicted_elapsed_time_ms_diffs; tonyp@3356: tonyp@3356: _inc_cset_recorded_rs_lengths_diffs = 0; tonyp@3356: _inc_cset_predicted_elapsed_time_ms_diffs = 0.0; tonyp@3356: } tonyp@3356: johnc@1829: void G1CollectorPolicy::add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length) { johnc@1829: // This routine is used when: johnc@1829: // * adding survivor regions to the incremental cset at the end of an johnc@1829: // evacuation pause, johnc@1829: // * adding the current allocation region to the incremental cset johnc@1829: // when it is retired, and johnc@1829: // * updating existing policy information for a region in the johnc@1829: // incremental cset via young list RSet sampling. johnc@1829: // Therefore this routine may be called at a safepoint by the johnc@1829: // VM thread, or in-between safepoints by mutator threads (when johnc@1829: // retiring the current allocation region) or a concurrent johnc@1829: // refine thread (RSet sampling). johnc@1829: johnc@1829: double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, true); johnc@1829: size_t used_bytes = hr->used(); johnc@1829: _inc_cset_recorded_rs_lengths += rs_length; johnc@1829: _inc_cset_predicted_elapsed_time_ms += region_elapsed_time_ms; johnc@1829: _inc_cset_bytes_used_before += used_bytes; johnc@1829: johnc@1829: // Cache the values we have added to the aggregated informtion johnc@1829: // in the heap region in case we have to remove this region from johnc@1829: // the incremental collection set, or it is updated by the johnc@1829: // rset sampling code johnc@1829: hr->set_recorded_rs_length(rs_length); johnc@1829: hr->set_predicted_elapsed_time_ms(region_elapsed_time_ms); johnc@1829: } johnc@1829: tonyp@3356: void G1CollectorPolicy::update_incremental_cset_info(HeapRegion* hr, tonyp@3356: size_t new_rs_length) { tonyp@3356: // Update the CSet information that is dependent on the new RS length tonyp@3356: assert(hr->is_young(), "Precondition"); tonyp@3356: assert(!SafepointSynchronize::is_at_safepoint(), tonyp@3356: "should not be at a safepoint"); tonyp@3356: tonyp@3356: // We could have updated _inc_cset_recorded_rs_lengths and tonyp@3356: // _inc_cset_predicted_elapsed_time_ms directly but we'd need to do tonyp@3356: // that atomically, as this code is executed by a concurrent tonyp@3356: // refinement thread, potentially concurrently with a mutator thread tonyp@3356: // allocating a new region and also updating the same fields. To tonyp@3356: // avoid the atomic operations we accumulate these updates on two tonyp@3356: // separate fields (*_diffs) and we'll just add them to the "main" tonyp@3356: // fields at the start of a GC. tonyp@3356: tonyp@3356: ssize_t old_rs_length = (ssize_t) hr->recorded_rs_length(); tonyp@3356: ssize_t rs_lengths_diff = (ssize_t) new_rs_length - old_rs_length; tonyp@3356: _inc_cset_recorded_rs_lengths_diffs += rs_lengths_diff; tonyp@3356: johnc@1829: double old_elapsed_time_ms = hr->predicted_elapsed_time_ms(); tonyp@3356: double new_region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, true); tonyp@3356: double elapsed_ms_diff = new_region_elapsed_time_ms - old_elapsed_time_ms; tonyp@3356: _inc_cset_predicted_elapsed_time_ms_diffs += elapsed_ms_diff; tonyp@3356: tonyp@3356: hr->set_recorded_rs_length(new_rs_length); tonyp@3356: hr->set_predicted_elapsed_time_ms(new_region_elapsed_time_ms); johnc@1829: } johnc@1829: johnc@1829: void G1CollectorPolicy::add_region_to_incremental_cset_common(HeapRegion* hr) { tonyp@3289: assert(hr->is_young(), "invariant"); tonyp@3289: assert(hr->young_index_in_cset() > -1, "should have already been set"); johnc@1829: assert(_inc_cset_build_state == Active, "Precondition"); johnc@1829: johnc@1829: // We need to clear and set the cached recorded/cached collection set johnc@1829: // information in the heap region here (before the region gets added johnc@1829: // to the collection set). An individual heap region's cached values johnc@1829: // are calculated, aggregated with the policy collection set info, johnc@1829: // and cached in the heap region here (initially) and (subsequently) johnc@1829: // by the Young List sampling code. johnc@1829: johnc@1829: size_t rs_length = hr->rem_set()->occupied(); johnc@1829: add_to_incremental_cset_info(hr, rs_length); johnc@1829: johnc@1829: HeapWord* hr_end = hr->end(); johnc@1829: _inc_cset_max_finger = MAX2(_inc_cset_max_finger, hr_end); johnc@1829: johnc@1829: assert(!hr->in_collection_set(), "invariant"); johnc@1829: hr->set_in_collection_set(true); johnc@1829: assert( hr->next_in_collection_set() == NULL, "invariant"); johnc@1829: johnc@1829: _g1->register_region_with_in_cset_fast_test(hr); johnc@1829: } johnc@1829: johnc@1829: // Add the region at the RHS of the incremental cset johnc@1829: void G1CollectorPolicy::add_region_to_incremental_cset_rhs(HeapRegion* hr) { johnc@1829: // We should only ever be appending survivors at the end of a pause johnc@1829: assert( hr->is_survivor(), "Logic"); johnc@1829: johnc@1829: // Do the 'common' stuff johnc@1829: add_region_to_incremental_cset_common(hr); johnc@1829: johnc@1829: // Now add the region at the right hand side johnc@1829: if (_inc_cset_tail == NULL) { johnc@1829: assert(_inc_cset_head == NULL, "invariant"); johnc@1829: _inc_cset_head = hr; johnc@1829: } else { johnc@1829: _inc_cset_tail->set_next_in_collection_set(hr); johnc@1829: } johnc@1829: _inc_cset_tail = hr; johnc@1829: } johnc@1829: johnc@1829: // Add the region to the LHS of the incremental cset johnc@1829: void G1CollectorPolicy::add_region_to_incremental_cset_lhs(HeapRegion* hr) { johnc@1829: // Survivors should be added to the RHS at the end of a pause johnc@1829: assert(!hr->is_survivor(), "Logic"); johnc@1829: johnc@1829: // Do the 'common' stuff johnc@1829: add_region_to_incremental_cset_common(hr); johnc@1829: johnc@1829: // Add the region at the left hand side johnc@1829: hr->set_next_in_collection_set(_inc_cset_head); johnc@1829: if (_inc_cset_head == NULL) { johnc@1829: assert(_inc_cset_tail == NULL, "Invariant"); johnc@1829: _inc_cset_tail = hr; johnc@1829: } johnc@1829: _inc_cset_head = hr; johnc@1829: } johnc@1829: johnc@1829: #ifndef PRODUCT johnc@1829: void G1CollectorPolicy::print_collection_set(HeapRegion* list_head, outputStream* st) { johnc@1829: assert(list_head == inc_cset_head() || list_head == collection_set(), "must be"); johnc@1829: johnc@1829: st->print_cr("\nCollection_set:"); johnc@1829: HeapRegion* csr = list_head; johnc@1829: while (csr != NULL) { johnc@1829: HeapRegion* next = csr->next_in_collection_set(); johnc@1829: assert(csr->in_collection_set(), "bad CS"); johnc@1829: st->print_cr(" [%08x-%08x], t: %08x, P: %08x, N: %08x, C: %08x, " johnc@1829: "age: %4d, y: %d, surv: %d", johnc@1829: csr->bottom(), csr->end(), johnc@1829: csr->top(), johnc@1829: csr->prev_top_at_mark_start(), johnc@1829: csr->next_top_at_mark_start(), johnc@1829: csr->top_at_conc_mark_count(), johnc@1829: csr->age_in_surv_rate_group_cond(), johnc@1829: csr->is_young(), johnc@1829: csr->is_survivor()); johnc@1829: csr = next; johnc@1829: } johnc@1829: } johnc@1829: #endif // !PRODUCT johnc@1829: tonyp@3209: void G1CollectorPolicy::choose_collection_set(double target_pause_time_ms) { johnc@1829: // Set this here - in case we're not doing young collections. johnc@1829: double non_young_start_time_sec = os::elapsedTime(); johnc@1829: tonyp@3114: YoungList* young_list = _g1->young_list(); tonyp@3356: finalize_incremental_cset_building(); tonyp@3114: tonyp@2011: guarantee(target_pause_time_ms > 0.0, tonyp@2011: err_msg("target_pause_time_ms = %1.6lf should be positive", tonyp@2011: target_pause_time_ms)); tonyp@2011: guarantee(_collection_set == NULL, "Precondition"); ysr@777: ysr@777: double base_time_ms = predict_base_elapsed_time_ms(_pending_cards); ysr@777: double predicted_pause_time_ms = base_time_ms; ysr@777: tonyp@2011: double time_remaining_ms = target_pause_time_ms - base_time_ms; ysr@777: tonyp@3114: ergo_verbose3(ErgoCSetConstruction | ErgoHigh, tonyp@3114: "start choosing CSet", tonyp@3114: ergo_format_ms("predicted base time") tonyp@3114: ergo_format_ms("remaining time") tonyp@3114: ergo_format_ms("target pause time"), tonyp@3114: base_time_ms, time_remaining_ms, target_pause_time_ms); tonyp@3114: ysr@777: // the 10% and 50% values are arbitrary... tonyp@3114: double threshold = 0.10 * target_pause_time_ms; tonyp@3114: if (time_remaining_ms < threshold) { tonyp@3114: double prev_time_remaining_ms = time_remaining_ms; tonyp@2011: time_remaining_ms = 0.50 * target_pause_time_ms; tonyp@3114: ergo_verbose3(ErgoCSetConstruction, tonyp@3114: "adjust remaining time", tonyp@3114: ergo_format_reason("remaining time lower than threshold") tonyp@3114: ergo_format_ms("remaining time") tonyp@3114: ergo_format_ms("threshold") tonyp@3114: ergo_format_ms("adjusted remaining time"), tonyp@3114: prev_time_remaining_ms, threshold, time_remaining_ms); ysr@777: } ysr@777: tonyp@3114: size_t expansion_bytes = _g1->expansion_regions() * HeapRegion::GrainBytes; tonyp@3114: tonyp@3114: HeapRegion* hr; tonyp@3114: double young_start_time_sec = os::elapsedTime(); ysr@777: apetrusenko@1112: _collection_set_bytes_used_before = 0; tonyp@3337: _last_gc_was_young = gcs_are_young() ? true : false; tonyp@3337: tonyp@3337: if (_last_gc_was_young) { tonyp@3337: ++_young_pause_num; tonyp@3114: } else { tonyp@3337: ++_mixed_pause_num; tonyp@3114: } brutisso@3065: brutisso@3065: // The young list is laid with the survivor regions from the previous brutisso@3065: // pause are appended to the RHS of the young list, i.e. brutisso@3065: // [Newly Young Regions ++ Survivors from last pause]. brutisso@3065: tonyp@3289: size_t survivor_region_length = young_list->survivor_length(); tonyp@3289: size_t eden_region_length = young_list->length() - survivor_region_length; tonyp@3289: init_cset_region_lengths(eden_region_length, survivor_region_length); tonyp@3114: hr = young_list->first_survivor_region(); brutisso@3065: while (hr != NULL) { brutisso@3065: assert(hr->is_survivor(), "badly formed young list"); brutisso@3065: hr->set_young(); brutisso@3065: hr = hr->get_next_young_region(); brutisso@3065: } brutisso@3065: tonyp@3114: // Clear the fields that point to the survivor list - they are all young now. tonyp@3114: young_list->clear_survivors(); brutisso@3065: brutisso@3065: _collection_set = _inc_cset_head; brutisso@3065: _collection_set_bytes_used_before = _inc_cset_bytes_used_before; brutisso@3065: time_remaining_ms -= _inc_cset_predicted_elapsed_time_ms; brutisso@3065: predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms; brutisso@3065: tonyp@3114: ergo_verbose3(ErgoCSetConstruction | ErgoHigh, tonyp@3114: "add young regions to CSet", tonyp@3114: ergo_format_region("eden") tonyp@3114: ergo_format_region("survivors") tonyp@3114: ergo_format_ms("predicted young region time"), tonyp@3289: eden_region_length, survivor_region_length, tonyp@3114: _inc_cset_predicted_elapsed_time_ms); tonyp@3114: brutisso@3065: // The number of recorded young regions is the incremental brutisso@3065: // collection set's current size brutisso@3065: set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); brutisso@3065: brutisso@3065: double young_end_time_sec = os::elapsedTime(); brutisso@3065: _recorded_young_cset_choice_time_ms = brutisso@3065: (young_end_time_sec - young_start_time_sec) * 1000.0; brutisso@3065: brutisso@3065: // We are doing young collections so reset this. brutisso@3065: non_young_start_time_sec = young_end_time_sec; brutisso@3065: tonyp@3337: if (!gcs_are_young()) { ysr@777: bool should_continue = true; ysr@777: NumberSeq seq; ysr@777: double avg_prediction = 100000000000000000.0; // something very large johnc@1829: tonyp@3114: double prev_predicted_pause_time_ms = predicted_pause_time_ms; ysr@777: do { tonyp@3289: // Note that add_old_region_to_cset() increments the tonyp@3289: // _old_cset_region_length field and cset_region_length() returns the tonyp@3289: // sum of _eden_cset_region_length, _survivor_cset_region_length, and tonyp@3289: // _old_cset_region_length. So, as old regions are added to the tonyp@3289: // CSet, _old_cset_region_length will be incremented and tonyp@3289: // cset_region_length(), which is used below, will always reflect tonyp@3289: // the the total number of regions added up to this point to the CSet. tonyp@3289: ysr@777: hr = _collectionSetChooser->getNextMarkedRegion(time_remaining_ms, ysr@777: avg_prediction); apetrusenko@1112: if (hr != NULL) { tonyp@3268: _g1->old_set_remove(hr); ysr@777: double predicted_time_ms = predict_region_elapsed_time_ms(hr, false); ysr@777: time_remaining_ms -= predicted_time_ms; ysr@777: predicted_pause_time_ms += predicted_time_ms; tonyp@3289: add_old_region_to_cset(hr); ysr@777: seq.add(predicted_time_ms); ysr@777: avg_prediction = seq.avg() + seq.sd(); ysr@777: } tonyp@3114: tonyp@3114: should_continue = true; tonyp@3114: if (hr == NULL) { tonyp@3114: // No need for an ergo verbose message here, tonyp@3114: // getNextMarkRegion() does this when it returns NULL. tonyp@3114: should_continue = false; tonyp@3114: } else { tonyp@3114: if (adaptive_young_list_length()) { tonyp@3114: if (time_remaining_ms < 0.0) { tonyp@3114: ergo_verbose1(ErgoCSetConstruction, tonyp@3114: "stop adding old regions to CSet", tonyp@3114: ergo_format_reason("remaining time is lower than 0") tonyp@3114: ergo_format_ms("remaining time"), tonyp@3114: time_remaining_ms); tonyp@3114: should_continue = false; tonyp@3114: } tonyp@3114: } else { tonyp@3289: if (cset_region_length() >= _young_list_fixed_length) { tonyp@3114: ergo_verbose2(ErgoCSetConstruction, tonyp@3114: "stop adding old regions to CSet", tonyp@3126: ergo_format_reason("CSet length reached target") tonyp@3114: ergo_format_region("CSet") tonyp@3114: ergo_format_region("young target"), tonyp@3289: cset_region_length(), _young_list_fixed_length); tonyp@3114: should_continue = false; tonyp@3114: } tonyp@3114: } tonyp@3114: } ysr@777: } while (should_continue); ysr@777: ysr@777: if (!adaptive_young_list_length() && tonyp@3337: cset_region_length() < _young_list_fixed_length) { tonyp@3114: ergo_verbose2(ErgoCSetConstruction, tonyp@3337: "request mixed GCs end", tonyp@3114: ergo_format_reason("CSet length lower than target") tonyp@3114: ergo_format_region("CSet") tonyp@3114: ergo_format_region("young target"), tonyp@3289: cset_region_length(), _young_list_fixed_length); tonyp@3337: _should_revert_to_young_gcs = true; tonyp@3114: } tonyp@3114: tonyp@3114: ergo_verbose2(ErgoCSetConstruction | ErgoHigh, tonyp@3114: "add old regions to CSet", tonyp@3114: ergo_format_region("old") tonyp@3114: ergo_format_ms("predicted old region time"), tonyp@3289: old_cset_region_length(), tonyp@3114: predicted_pause_time_ms - prev_predicted_pause_time_ms); ysr@777: } ysr@777: johnc@1829: stop_incremental_cset_building(); johnc@1829: ysr@777: count_CS_bytes_used(); ysr@777: tonyp@3114: ergo_verbose5(ErgoCSetConstruction, tonyp@3114: "finish choosing CSet", tonyp@3114: ergo_format_region("eden") tonyp@3114: ergo_format_region("survivors") tonyp@3114: ergo_format_region("old") tonyp@3114: ergo_format_ms("predicted pause time") tonyp@3114: ergo_format_ms("target pause time"), tonyp@3289: eden_region_length, survivor_region_length, tonyp@3289: old_cset_region_length(), tonyp@3114: predicted_pause_time_ms, target_pause_time_ms); tonyp@3114: ysr@777: double non_young_end_time_sec = os::elapsedTime(); ysr@777: _recorded_non_young_cset_choice_time_ms = ysr@777: (non_young_end_time_sec - non_young_start_time_sec) * 1000.0; ysr@777: }