ysr@777: /* drchase@6680: * Copyright (c) 2001, 2014, 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: drchase@6680: #ifndef __clang_major__ drchase@6680: #define ATTRIBUTE_PRINTF(x,y) // FIXME, formats are a mess. drchase@6680: #endif drchase@6680: 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" brutisso@3923: #include "gc_implementation/g1/g1GCPhaseTimes.hpp" brutisso@3710: #include "gc_implementation/g1/g1Log.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: 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: _stop_world_start(0.0), 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: _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), ysr@777: ysr@777: _during_marking(false), ysr@777: _in_marking_window(false), ysr@777: _in_marking_window_im(false), 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: tonyp@1794: _initiate_conc_mark_if_possible(false), tonyp@1794: _during_initial_mark_pause(false), tonyp@3337: _last_young_gc(false), tonyp@3337: _last_gc_was_young(false), ysr@777: johnc@5123: _eden_used_bytes_before_gc(0), johnc@5123: _survivor_used_bytes_before_gc(0), johnc@5123: _heap_used_bytes_before_gc(0), johnc@5123: _metaspace_used_bytes_before_gc(0), johnc@5123: _eden_capacity_bytes_before_gc(0), johnc@5123: _heap_capacity_bytes_before_gc(0), tonyp@2961: 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. brutisso@5646: brutisso@5646: // It would have been natural to pass initial_heap_byte_size() and brutisso@5646: // max_heap_byte_size() to setup_heap_region_size() but those have brutisso@5646: // not been set up at this point since they should be aligned with brutisso@5646: // the region size. So, there is a circular dependency here. We base brutisso@5646: // the region size on the heap size, but the heap size should be brutisso@5646: // aligned with the region size. To get around this we use the brutisso@5646: // unaligned values for the heap. brutisso@5646: HeapRegion::setup_heap_region_size(InitialHeapSize, MaxHeapSize); 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: brutisso@3923: _phase_times = new G1GCPhaseTimes(_parallel_gc_threads); ysr@777: brutisso@3923: int index = MIN2(_parallel_gc_threads - 1, 7); ysr@777: 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); poonam@4650: poonam@4650: uintx confidence_perc = G1ConfidencePercent; poonam@4650: // Put an artificial ceiling on this so that it's not set to a silly value. poonam@4650: if (confidence_perc > 100) { poonam@4650: confidence_perc = 100; poonam@4650: warning("G1ConfidencePercent is set to a value that is too large, " poonam@4650: "it's been updated to %u", confidence_perc); poonam@4650: } poonam@4650: _sigma = (double) confidence_perc / 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: tonyp@3209: _collectionSetChooser = new CollectionSetChooser(); jwilhelm@6085: } jwilhelm@6085: jwilhelm@6085: void G1CollectorPolicy::initialize_alignments() { jwilhelm@6085: _space_alignment = HeapRegion::GrainBytes; jwilhelm@6085: size_t card_table_alignment = GenRemSet::max_alignment_constraint(GenRemSet::CardTable); jwilhelm@6085: size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size(); jwilhelm@6085: _heap_alignment = MAX3(card_table_alignment, _space_alignment, page_size); ysr@777: } ysr@777: ysr@777: void G1CollectorPolicy::initialize_flags() { jwilhelm@6085: if (G1HeapRegionSize != HeapRegion::GrainBytes) { jwilhelm@6085: FLAG_SET_ERGO(uintx, G1HeapRegionSize, HeapRegion::GrainBytes); jwilhelm@6085: } jwilhelm@6085: apetrusenko@982: if (SurvivorRatio < 1) { apetrusenko@982: vm_exit_during_initialization("Invalid survivor ratio specified"); apetrusenko@982: } ysr@777: CollectorPolicy::initialize_flags(); jwilhelm@6085: _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags ysr@777: } ysr@777: jwilhelm@6085: void G1CollectorPolicy::post_heap_initialize() { jwilhelm@6085: uintx max_regions = G1CollectedHeap::heap()->max_regions(); jwilhelm@6085: size_t max_young_size = (size_t)_young_gen_sizer->max_young_length(max_regions) * HeapRegion::GrainBytes; jwilhelm@6085: if (max_young_size != MaxNewSize) { jwilhelm@6085: FLAG_SET_ERGO(uintx, MaxNewSize, max_young_size); jwilhelm@6085: } jwilhelm@6085: } brutisso@3120: jwilhelm@6085: G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true), jwilhelm@6085: _min_desired_young_length(0), _max_desired_young_length(0) { 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: jwilhelm@6085: if (NewSize > MaxNewSize) { jwilhelm@6085: if (FLAG_IS_CMDLINE(MaxNewSize)) { jwilhelm@6085: warning("NewSize (" SIZE_FORMAT "k) is greater than the MaxNewSize (" SIZE_FORMAT "k). " jwilhelm@6085: "A new max generation size of " SIZE_FORMAT "k will be used.", jwilhelm@6085: NewSize/K, MaxNewSize/K, NewSize/K); jwilhelm@6085: } jwilhelm@6085: MaxNewSize = NewSize; jwilhelm@5933: } jwilhelm@5933: brutisso@3358: if (FLAG_IS_CMDLINE(NewSize)) { tonyp@3713: _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes), tonyp@3713: 1U); brutisso@3358: if (FLAG_IS_CMDLINE(MaxNewSize)) { tonyp@3713: _max_desired_young_length = tonyp@3713: MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), tonyp@3713: 1U); 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)) { tonyp@3713: _max_desired_young_length = tonyp@3713: MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), tonyp@3713: 1U); brutisso@3358: _sizer_kind = SizerMaxNewSizeOnly; brutisso@3358: } brutisso@3358: } brutisso@3358: tonyp@3713: uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) { johnc@4385: uint default_value = (new_number_of_heap_regions * G1NewSizePercent) / 100; tonyp@3713: return MAX2(1U, default_value); brutisso@3358: } brutisso@3358: tonyp@3713: uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) { johnc@4385: uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100; tonyp@3713: return MAX2(1U, default_value); brutisso@3358: } brutisso@3358: jwilhelm@6085: void G1YoungGenSizer::recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length) { jwilhelm@6085: assert(number_of_heap_regions > 0, "Heap must be initialized"); brutisso@3358: brutisso@3358: switch (_sizer_kind) { brutisso@3358: case SizerDefaults: jwilhelm@6085: *min_young_length = calculate_default_min_length(number_of_heap_regions); jwilhelm@6085: *max_young_length = calculate_default_max_length(number_of_heap_regions); brutisso@3358: break; brutisso@3358: case SizerNewSizeOnly: jwilhelm@6085: *max_young_length = calculate_default_max_length(number_of_heap_regions); jwilhelm@6085: *max_young_length = MAX2(*min_young_length, *max_young_length); brutisso@3358: break; brutisso@3358: case SizerMaxNewSizeOnly: jwilhelm@6085: *min_young_length = calculate_default_min_length(number_of_heap_regions); jwilhelm@6085: *min_young_length = MIN2(*min_young_length, *max_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: jwilhelm@6085: *min_young_length = number_of_heap_regions / (NewRatio + 1); jwilhelm@6085: *max_young_length = *min_young_length; brutisso@3358: break; brutisso@3358: default: brutisso@3358: ShouldNotReachHere(); brutisso@3358: } brutisso@3358: jwilhelm@6085: assert(*min_young_length <= *max_young_length, "Invalid min/max young gen size values"); jwilhelm@6085: } jwilhelm@6085: jwilhelm@6085: uint G1YoungGenSizer::max_young_length(uint number_of_heap_regions) { jwilhelm@6085: // We need to pass the desired values because recalculation may not update these jwilhelm@6085: // values in some cases. jwilhelm@6085: uint temp = _min_desired_young_length; jwilhelm@6085: uint result = _max_desired_young_length; jwilhelm@6085: recalculate_min_max_young_length(number_of_heap_regions, &temp, &result); jwilhelm@6085: return result; jwilhelm@6085: } jwilhelm@6085: jwilhelm@6085: void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) { jwilhelm@6085: recalculate_min_max_young_length(new_number_of_heap_regions, &_min_desired_young_length, jwilhelm@6085: &_max_desired_young_length); 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(); 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@3713: bool G1CollectorPolicy::predict_will_fit(uint young_length, tonyp@3119: double base_time_ms, tonyp@3713: uint 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@3713: 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@3713: (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: tonyp@3713: void G1CollectorPolicy::record_new_heap_size(uint 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@3713: _reserve_regions = (uint) ceil(reserve_regions_d); brutisso@3120: brutisso@3358: _young_gen_sizer->heap_size_changed(new_number_of_regions); tonyp@3119: } tonyp@3119: tonyp@3713: uint G1CollectorPolicy::calculate_young_list_desired_min_length( tonyp@3713: uint base_min_length) { tonyp@3713: uint 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@3713: desired_min_length = (uint) 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@3713: uint 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@3713: uint 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@3713: uint absolute_min_length = base_min_length + 1; tonyp@3713: uint 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@3713: uint 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@3713: uint 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@3713: uint 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@3539: // The user asked for a fixed young gen so we'll fix the young gen tonyp@3539: // whether the next GC is young or mixed. tonyp@3539: young_list_target_length = _young_list_fixed_length; 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@3713: uint tonyp@3119: G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths, tonyp@3713: uint base_min_length, tonyp@3713: uint desired_min_length, tonyp@3713: uint 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@3713: uint min_young_length = desired_min_length - base_min_length; tonyp@3119: assert(desired_max_length > base_min_length, "invariant"); tonyp@3713: uint 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@3713: uint available_free_regions = _free_regions_at_end_of_collection; tonyp@3713: uint 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@3713: uint diff = (max_young_length - min_young_length) / 2; tonyp@3119: while (diff > 0) { tonyp@3713: uint 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()) { johnc@3998: survivor_regions_evac_time += predict_region_elapsed_time_ms(r, gcs_are_young()); 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() { brutisso@3923: _full_collection_start_sec = os::elapsedTime(); johnc@5123: record_heap_size_info_at_start(true /* full */); 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(); brutisso@3923: double full_gc_time_sec = end_sec - _full_collection_start_sec; ysr@777: double full_gc_time_ms = full_gc_time_sec * 1000.0; ysr@777: brutisso@3812: _trace_gen1_time_data.record_full_collection(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@1794: clear_initiate_conc_mark_if_possible(); tonyp@1794: clear_during_initial_mark_pause(); 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@3714: _collectionSetChooser->clear(); tonyp@2315: } ysr@777: ysr@777: void G1CollectorPolicy::record_stop_world_start() { ysr@777: _stop_world_start = os::elapsedTime(); ysr@777: } ysr@777: johnc@4929: void G1CollectorPolicy::record_collection_pause_start(double start_time_sec) { tonyp@3464: // We only need to do this here as the policy will only be applied tonyp@3464: // to the GC we're about to start. so, no point is calculating this tonyp@3464: // every time we calculate / recalculate the target young length. tonyp@3464: update_survivors_policy(); 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; brutisso@3812: _trace_gen0_time_data.record_start_collection(s_w_t_ms); ysr@777: _stop_world_start = 0.0; ysr@777: johnc@5123: record_heap_size_info_at_start(false /* full */); johnc@4929: brutisso@4015: phase_times()->record_cur_collection_start_sec(start_time_sec); ysr@777: _pending_cards = _g1->pending_card_num(); ysr@777: johnc@3998: _collection_set_bytes_used_before = 0; tonyp@3028: _bytes_copied_during_gc = 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: _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; brutisso@3812: _trace_gen0_time_data.record_yield_time(yield_ms); ysr@777: } ysr@777: } ysr@777: brutisso@3461: bool G1CollectorPolicy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) { brutisso@3461: if (_g1->concurrent_mark()->cmThread()->during_cycle()) { brutisso@3456: return false; brutisso@3456: } brutisso@3456: brutisso@3456: size_t marking_initiating_used_threshold = brutisso@3456: (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; brutisso@3456: size_t cur_used_bytes = _g1->non_young_capacity_bytes(); brutisso@3461: size_t alloc_byte_size = alloc_word_size * HeapWordSize; brutisso@3461: brutisso@3461: if ((cur_used_bytes + alloc_byte_size) > marking_initiating_used_threshold) { brutisso@5398: if (gcs_are_young() && !_last_young_gc) { brutisso@3461: ergo_verbose5(ErgoConcCycles, brutisso@3456: "request concurrent cycle initiation", brutisso@3456: ergo_format_reason("occupancy higher than threshold") brutisso@3456: ergo_format_byte("occupancy") brutisso@3461: ergo_format_byte("allocation request") brutisso@3456: ergo_format_byte_perc("threshold") brutisso@3456: ergo_format_str("source"), brutisso@3456: cur_used_bytes, brutisso@3461: alloc_byte_size, brutisso@3456: marking_initiating_used_threshold, brutisso@3456: (double) InitiatingHeapOccupancyPercent, brutisso@3456: source); brutisso@3456: return true; brutisso@3456: } else { brutisso@3461: ergo_verbose5(ErgoConcCycles, brutisso@3456: "do not request concurrent cycle initiation", brutisso@3456: ergo_format_reason("still doing mixed collections") brutisso@3456: ergo_format_byte("occupancy") brutisso@3461: ergo_format_byte("allocation request") brutisso@3456: ergo_format_byte_perc("threshold") brutisso@3456: ergo_format_str("source"), brutisso@3456: cur_used_bytes, brutisso@3461: alloc_byte_size, brutisso@3456: marking_initiating_used_threshold, brutisso@3456: (double) InitiatingHeapOccupancyPercent, brutisso@3456: source); brutisso@3456: } brutisso@3456: } brutisso@3456: brutisso@3456: return false; brutisso@3456: } brutisso@3456: ysr@777: // Anything below that is considered to be zero ysr@777: #define MIN_TIMER_GRANULARITY 0.0000001 ysr@777: sla@5237: void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms, EvacuationInfo& evacuation_info) { ysr@777: double end_time_sec = os::elapsedTime(); 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(); ysr@777: ysr@777: #ifndef PRODUCT ysr@777: if (G1YoungSurvRateVerbose) { drchase@6680: gclog_or_tty->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@3456: if (last_pause_included_initial_mark) { brutisso@3065: record_concurrent_mark_init_end(0.0); brutisso@5398: } else if (need_to_start_conc_mark("end of GC")) { brutisso@3456: // Note: this might have already been set, if during the last brutisso@3456: // pause we decided to start a cycle but at the beginning of brutisso@3456: // this pause we decided to postpone it. That's OK. brutisso@3456: set_initiate_conc_mark_if_possible(); brutisso@3456: } brutisso@3065: brutisso@3923: _mmu_tracker->add_pause(end_time_sec - pause_time_ms/1000.0, ysr@777: end_time_sec, false); ysr@777: sla@5237: evacuation_info.set_collectionset_used_before(_collection_set_bytes_used_before); sla@5237: evacuation_info.set_bytes_copied(_bytes_copied_during_gc); sla@5237: tonyp@1030: if (update_stats) { brutisso@3923: _trace_gen0_time_data.record_end_collection(pause_time_ms, phase_times()); ysr@777: // this is where we update the allocation rate of the application ysr@777: double app_time_ms = brutisso@4015: (phase_times()->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@3713: uint 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; brutisso@3923: update_recent_gc_times(end_time_sec, pause_time_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: } johnc@5123: 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) { tonyp@3539: // This is supposed to to be the "last young GC" before we start tonyp@3539: // doing mixed GCs. Here we decide whether to start mixed GCs or not. tonyp@3539: johnc@3178: if (!last_pause_included_initial_mark) { tonyp@3539: if (next_gc_should_be_mixed("start mixed GCs", tonyp@3539: "do not start mixed GCs")) { tonyp@3539: set_gcs_are_young(false); tonyp@3539: } 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@3539: // This is a mixed GC. Here we decide whether to continue doing tonyp@3539: // mixed GCs or not. tonyp@3539: tonyp@3539: if (!next_gc_should_be_mixed("continue mixed GCs", tonyp@3539: "do not continue mixed GCs")) { tonyp@3337: set_gcs_are_young(true); ysr@777: } brutisso@3065: } tonyp@3337: 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 cost_per_card_ms = 0.0; ysr@777: if (_pending_cards > 0) { brutisso@4015: cost_per_card_ms = phase_times()->average_last_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) { brutisso@4015: cost_per_entry_ms = phase_times()->average_last_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: johnc@5123: size_t freed_bytes = _heap_used_bytes_before_gc - cur_used_bytes; johnc@5123: size_t copied_bytes = _collection_set_bytes_used_before - freed_bytes; ysr@777: double cost_per_byte_ms = 0.0; johnc@5123: ysr@777: if (copied_bytes > 0) { brutisso@4015: cost_per_byte_ms = phase_times()->average_last_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 - brutisso@4015: (phase_times()->average_last_update_rs_time() + phase_times()->average_last_scan_rs_time() brutisso@4015: + phase_times()->average_last_obj_copy_time() + phase_times()->average_last_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 = brutisso@4015: phase_times()->young_cset_choice_time_ms() + brutisso@4015: phase_times()->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 = brutisso@4015: phase_times()->non_young_cset_choice_time_ms() + brutisso@4015: phase_times()->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; johnc@3998: if (_collection_set_bytes_used_before > 0) { tonyp@3028: survival_ratio = (double) _bytes_copied_during_gc / johnc@3998: (double) _collection_set_bytes_used_before; 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: 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; brutisso@4015: adjust_concurrent_refinement(phase_times()->average_last_update_rs_time(), brutisso@4015: phase_times()->sum_last_update_rs_processed_buffers(), update_rs_time_goal_ms); tonyp@3209: tonyp@3714: _collectionSetChooser->verify(); ysr@777: } ysr@777: brutisso@3762: #define EXT_SIZE_FORMAT "%.1f%s" tonyp@2961: #define EXT_SIZE_PARAMS(bytes) \ brutisso@3762: byte_size_in_proper_unit((double)(bytes)), \ tonyp@2961: proper_unit_for_byte_size((bytes)) tonyp@2961: johnc@5123: void G1CollectorPolicy::record_heap_size_info_at_start(bool full) { johnc@4929: YoungList* young_list = _g1->young_list(); johnc@5123: _eden_used_bytes_before_gc = young_list->eden_used_bytes(); johnc@5123: _survivor_used_bytes_before_gc = young_list->survivor_used_bytes(); johnc@5123: _heap_capacity_bytes_before_gc = _g1->capacity(); johnc@5123: _heap_used_bytes_before_gc = _g1->used(); johnc@4929: _cur_collection_pause_used_regions_at_start = _g1->used_regions(); johnc@4929: johnc@5123: _eden_capacity_bytes_before_gc = johnc@5123: (_young_list_target_length * HeapRegion::GrainBytes) - _survivor_used_bytes_before_gc; johnc@4929: johnc@5123: if (full) { ehelin@6609: _metaspace_used_bytes_before_gc = MetaspaceAux::used_bytes(); johnc@5123: } johnc@4929: } johnc@4929: tonyp@2961: void G1CollectorPolicy::print_heap_transition() { brutisso@4015: _g1->print_size_transition(gclog_or_tty, johnc@5123: _heap_used_bytes_before_gc, johnc@5123: _g1->used(), johnc@5123: _g1->capacity()); brutisso@4015: } brutisso@4015: johnc@5123: void G1CollectorPolicy::print_detailed_heap_transition(bool full) { johnc@5123: YoungList* young_list = _g1->young_list(); tonyp@2961: johnc@5123: size_t eden_used_bytes_after_gc = young_list->eden_used_bytes(); johnc@5123: size_t survivor_used_bytes_after_gc = young_list->survivor_used_bytes(); johnc@5123: size_t heap_used_bytes_after_gc = _g1->used(); johnc@5123: johnc@5123: size_t heap_capacity_bytes_after_gc = _g1->capacity(); johnc@5123: size_t eden_capacity_bytes_after_gc = johnc@5123: (_young_list_target_length * HeapRegion::GrainBytes) - survivor_used_bytes_after_gc; johnc@5123: johnc@5123: gclog_or_tty->print( johnc@5123: " [Eden: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->"EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT") " johnc@5123: "Survivors: "EXT_SIZE_FORMAT"->"EXT_SIZE_FORMAT" " johnc@5123: "Heap: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->" johnc@5123: EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")]", johnc@5123: EXT_SIZE_PARAMS(_eden_used_bytes_before_gc), johnc@5123: EXT_SIZE_PARAMS(_eden_capacity_bytes_before_gc), johnc@5123: EXT_SIZE_PARAMS(eden_used_bytes_after_gc), johnc@5123: EXT_SIZE_PARAMS(eden_capacity_bytes_after_gc), johnc@5123: EXT_SIZE_PARAMS(_survivor_used_bytes_before_gc), johnc@5123: EXT_SIZE_PARAMS(survivor_used_bytes_after_gc), johnc@5123: EXT_SIZE_PARAMS(_heap_used_bytes_before_gc), johnc@5123: EXT_SIZE_PARAMS(_heap_capacity_bytes_before_gc), johnc@5123: EXT_SIZE_PARAMS(heap_used_bytes_after_gc), johnc@5123: EXT_SIZE_PARAMS(heap_capacity_bytes_after_gc)); johnc@5123: johnc@5123: if (full) { johnc@5123: MetaspaceAux::print_metaspace_change(_metaspace_used_bytes_before_gc); johnc@5123: } johnc@5123: johnc@5123: gclog_or_tty->cr(); 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 johnc@3998: G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards, johnc@3998: size_t scanned_cards) { johnc@3998: return johnc@3998: predict_rs_update_time_ms(pending_cards) + johnc@3998: predict_rs_scan_time_ms(scanned_cards) + johnc@3998: predict_constant_other_time_ms(); johnc@3998: } johnc@3998: johnc@3998: 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: tonyp@3713: size_t 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 { tonyp@3539: assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "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: return bytes_to_copy; ysr@777: } ysr@777: johnc@3998: double johnc@3998: G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr, johnc@3998: bool for_young_gc) { johnc@3998: size_t rs_length = hr->rem_set()->occupied(); johnc@3998: size_t card_num; johnc@3998: johnc@3998: // Predicting the number of cards is based on which type of GC johnc@3998: // we're predicting for. johnc@3998: if (for_young_gc) { johnc@3998: card_num = predict_young_card_num(rs_length); johnc@3998: } else { johnc@3998: card_num = predict_non_young_card_num(rs_length); johnc@3998: } johnc@3998: size_t bytes_to_copy = predict_bytes_to_copy(hr); johnc@3998: johnc@3998: double region_elapsed_time_ms = johnc@3998: predict_rs_scan_time_ms(card_num) + johnc@3998: predict_object_copy_time_ms(bytes_to_copy); johnc@3998: johnc@3998: // The prediction of the "other" time for this region is based johnc@3998: // upon the region type and NOT the GC type. johnc@3998: if (hr->is_young()) { johnc@3998: region_elapsed_time_ms += predict_young_other_time_ms(1); johnc@3998: } else { johnc@3998: region_elapsed_time_ms += predict_non_young_other_time_ms(1); johnc@3998: } johnc@3998: return region_elapsed_time_ms; johnc@3998: } johnc@3998: ysr@777: void tonyp@3713: G1CollectorPolicy::init_cset_region_lengths(uint eden_cset_region_length, tonyp@3713: uint 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::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: void G1CollectorPolicy::print_tracing_info() const { brutisso@3812: _trace_gen0_time_data.print(); brutisso@3812: _trace_gen1_time_data.print(); 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: tonyp@3713: uint 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@3713: uint 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@3713: expansion_region_num = (uint) 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@3713: _max_survivor_regions = (uint) 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: 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 { tonyp@3539: G1CollectedHeap* _g1h; ysr@777: CollectionSetChooser* _hrSorted; ysr@777: ysr@777: public: ysr@777: KnownGarbageClosure(CollectionSetChooser* hrSorted) : tonyp@3539: _g1h(G1CollectedHeap::heap()), _hrSorted(hrSorted) { } 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()) { tonyp@3539: // We will skip any region that's currently used as an old GC tonyp@3539: // alloc region (we should not consider those for collection tonyp@3539: // before we fill them up). tonyp@3714: if (_hrSorted->should_add(r) && !_g1h->is_old_gc_alloc_region(r)) { tonyp@3714: _hrSorted->add_region(r); ysr@777: } ysr@777: } ysr@777: return false; ysr@777: } ysr@777: }; ysr@777: ysr@777: class ParKnownGarbageHRClosure: public HeapRegionClosure { tonyp@3539: G1CollectedHeap* _g1h; tonyp@3957: CSetChooserParUpdater _cset_updater; ysr@777: ysr@777: public: ysr@777: ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted, tonyp@3714: uint chunk_size) : tonyp@3957: _g1h(G1CollectedHeap::heap()), tonyp@3957: _cset_updater(hrSorted, true /* parallel */, chunk_size) { } ysr@777: ysr@777: bool doHeapRegion(HeapRegion* r) { ysr@777: // Do we have any marking information for this region? ysr@777: if (r->is_marked()) { tonyp@3539: // We will skip any region that's currently used as an old GC tonyp@3539: // alloc region (we should not consider those for collection tonyp@3539: // before we fill them up). tonyp@3957: if (_cset_updater.should_add(r) && !_g1h->is_old_gc_alloc_region(r)) { tonyp@3957: _cset_updater.add_region(r); ysr@777: } ysr@777: } ysr@777: return false; ysr@777: } ysr@777: }; ysr@777: ysr@777: class ParKnownGarbageTask: public AbstractGangTask { ysr@777: CollectionSetChooser* _hrSorted; tonyp@3714: uint _chunk_size; ysr@777: G1CollectedHeap* _g1; ysr@777: public: tonyp@3714: ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size) : ysr@777: AbstractGangTask("ParKnownGarbageTask"), ysr@777: _hrSorted(hrSorted), _chunk_size(chunk_size), tonyp@3539: _g1(G1CollectedHeap::heap()) { } ysr@777: jmasa@3357: void work(uint worker_id) { tonyp@3714: ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size); tonyp@3714: 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: } ysr@777: }; ysr@777: ysr@777: void jmasa@3294: G1CollectorPolicy::record_concurrent_mark_cleanup_end(int no_of_gc_threads) { tonyp@3714: _collectionSetChooser->clear(); tonyp@3209: tonyp@3713: uint region_num = _g1->n_regions(); jmasa@2188: if (G1CollectedHeap::use_parallel_gc_threads()) { tonyp@3713: const uint OverpartitionFactor = 4; tonyp@3713: uint 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) { tonyp@3713: const uint MinWorkUnit = MAX2(region_num / no_of_gc_threads, 1U); tonyp@3713: WorkUnit = MAX2(region_num / (no_of_gc_threads * OverpartitionFactor), tonyp@3713: 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. tonyp@3713: const uint MinWorkUnit = MAX2(region_num / (uint) ParallelGCThreads, 1U); jmasa@3294: WorkUnit = tonyp@3713: MAX2(region_num / (uint) (ParallelGCThreads * OverpartitionFactor), jmasa@3294: MinWorkUnit); jmasa@3294: } tonyp@3714: _collectionSetChooser->prepare_for_par_region_addition(_g1->n_regions(), tonyp@3714: 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: tonyp@3714: _collectionSetChooser->sort_regions(); tonyp@3714: tonyp@3209: double end_sec = os::elapsedTime(); 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@3998: double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); 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(); johnc@3998: double new_region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); 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@3731: st->print_cr(" "HR_FORMAT", P: "PTR_FORMAT "N: "PTR_FORMAT", age: %4d", johnc@3731: HR_FORMAT_PARAMS(csr), johnc@3731: csr->prev_top_at_mark_start(), csr->next_top_at_mark_start(), johnc@3731: csr->age_in_surv_rate_group_cond()); johnc@1829: csr = next; johnc@1829: } johnc@1829: } johnc@1829: #endif // !PRODUCT johnc@1829: johnc@4681: double G1CollectorPolicy::reclaimable_bytes_perc(size_t reclaimable_bytes) { johnc@4681: // Returns the given amount of reclaimable bytes (that represents johnc@4681: // the amount of reclaimable space still to be collected) as a johnc@4681: // percentage of the current heap capacity. johnc@4681: size_t capacity_bytes = _g1->capacity(); johnc@4681: return (double) reclaimable_bytes * 100.0 / (double) capacity_bytes; johnc@4681: } johnc@4681: tonyp@3539: bool G1CollectorPolicy::next_gc_should_be_mixed(const char* true_action_str, tonyp@3539: const char* false_action_str) { tonyp@3539: CollectionSetChooser* cset_chooser = _collectionSetChooser; tonyp@3714: if (cset_chooser->is_empty()) { tonyp@3539: ergo_verbose0(ErgoMixedGCs, tonyp@3539: false_action_str, tonyp@3539: ergo_format_reason("candidate old regions not available")); tonyp@3539: return false; tonyp@3539: } johnc@4681: johnc@4681: // Is the amount of uncollected reclaimable space above G1HeapWastePercent? tonyp@3714: size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes(); johnc@4681: double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes); tonyp@3667: double threshold = (double) G1HeapWastePercent; johnc@4681: if (reclaimable_perc <= threshold) { tonyp@3539: ergo_verbose4(ErgoMixedGCs, tonyp@3539: false_action_str, johnc@4681: ergo_format_reason("reclaimable percentage not over threshold") tonyp@3539: ergo_format_region("candidate old regions") tonyp@3539: ergo_format_byte_perc("reclaimable") tonyp@3539: ergo_format_perc("threshold"), tonyp@3714: cset_chooser->remaining_regions(), johnc@4681: reclaimable_bytes, johnc@4681: reclaimable_perc, threshold); tonyp@3539: return false; tonyp@3539: } tonyp@3539: tonyp@3539: ergo_verbose4(ErgoMixedGCs, tonyp@3539: true_action_str, tonyp@3539: ergo_format_reason("candidate old regions available") tonyp@3539: ergo_format_region("candidate old regions") tonyp@3539: ergo_format_byte_perc("reclaimable") tonyp@3539: ergo_format_perc("threshold"), tonyp@3714: cset_chooser->remaining_regions(), johnc@4681: reclaimable_bytes, johnc@4681: reclaimable_perc, threshold); tonyp@3539: return true; tonyp@3539: } tonyp@3539: johnc@4681: uint G1CollectorPolicy::calc_min_old_cset_length() { johnc@4681: // The min old CSet region bound is based on the maximum desired johnc@4681: // number of mixed GCs after a cycle. I.e., even if some old regions johnc@4681: // look expensive, we should add them to the CSet anyway to make johnc@4681: // sure we go through the available old regions in no more than the johnc@4681: // maximum desired number of mixed GCs. johnc@4681: // johnc@4681: // The calculation is based on the number of marked regions we added johnc@4681: // to the CSet chooser in the first place, not how many remain, so johnc@4681: // that the result is the same during all mixed GCs that follow a cycle. johnc@4681: johnc@4681: const size_t region_num = (size_t) _collectionSetChooser->length(); johnc@4681: const size_t gc_num = (size_t) MAX2(G1MixedGCCountTarget, (uintx) 1); johnc@4681: size_t result = region_num / gc_num; johnc@4681: // emulate ceiling johnc@4681: if (result * gc_num < region_num) { johnc@4681: result += 1; johnc@4681: } johnc@4681: return (uint) result; johnc@4681: } johnc@4681: johnc@4681: uint G1CollectorPolicy::calc_max_old_cset_length() { johnc@4681: // The max old CSet region bound is based on the threshold expressed johnc@4681: // as a percentage of the heap size. I.e., it should bound the johnc@4681: // number of old regions added to the CSet irrespective of how many johnc@4681: // of them are available. johnc@4681: johnc@4681: G1CollectedHeap* g1h = G1CollectedHeap::heap(); johnc@4681: const size_t region_num = g1h->n_regions(); johnc@4681: const size_t perc = (size_t) G1OldCSetRegionThresholdPercent; johnc@4681: size_t result = region_num * perc / 100; johnc@4681: // emulate ceiling johnc@4681: if (100 * result < region_num * perc) { johnc@4681: result += 1; johnc@4681: } johnc@4681: return (uint) result; johnc@4681: } johnc@4681: johnc@4681: sla@5237: void G1CollectorPolicy::finalize_cset(double target_pause_time_ms, EvacuationInfo& evacuation_info) { johnc@3998: double 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; johnc@4681: double time_remaining_ms = MAX2(target_pause_time_ms - base_time_ms, 0.0); ysr@777: johnc@3998: ergo_verbose4(ErgoCSetConstruction | ErgoHigh, tonyp@3114: "start choosing CSet", johnc@3998: ergo_format_size("_pending_cards") tonyp@3114: ergo_format_ms("predicted base time") tonyp@3114: ergo_format_ms("remaining time") tonyp@3114: ergo_format_ms("target pause time"), johnc@3998: _pending_cards, base_time_ms, time_remaining_ms, target_pause_time_ms); tonyp@3114: tonyp@3337: _last_gc_was_young = gcs_are_young() ? true : false; tonyp@3337: tonyp@3337: if (_last_gc_was_young) { brutisso@3812: _trace_gen0_time_data.increment_young_collection_count(); tonyp@3114: } else { brutisso@3812: _trace_gen0_time_data.increment_mixed_collection_count(); 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@3713: uint survivor_region_length = young_list->survivor_length(); tonyp@3713: uint eden_region_length = young_list->length() - survivor_region_length; tonyp@3289: init_cset_region_lengths(eden_region_length, survivor_region_length); johnc@3998: johnc@3998: HeapRegion* 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; johnc@4681: time_remaining_ms = MAX2(time_remaining_ms - _inc_cset_predicted_elapsed_time_ms, 0.0); 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@4015: phase_times()->record_young_cset_choice_time_ms((young_end_time_sec - young_start_time_sec) * 1000.0); brutisso@3065: johnc@3998: // Set the start of the non-young choice time. johnc@3998: double non_young_start_time_sec = young_end_time_sec; brutisso@3065: tonyp@3337: if (!gcs_are_young()) { tonyp@3539: CollectionSetChooser* cset_chooser = _collectionSetChooser; tonyp@3714: cset_chooser->verify(); johnc@4681: const uint min_old_cset_length = calc_min_old_cset_length(); johnc@4681: const uint max_old_cset_length = calc_max_old_cset_length(); tonyp@3713: tonyp@3713: uint expensive_region_num = 0; tonyp@3539: bool check_time_remaining = adaptive_young_list_length(); johnc@3998: tonyp@3539: HeapRegion* hr = cset_chooser->peek(); tonyp@3539: while (hr != NULL) { tonyp@3539: if (old_cset_region_length() >= max_old_cset_length) { tonyp@3539: // Added maximum number of old regions to the CSet. tonyp@3539: ergo_verbose2(ErgoCSetConstruction, tonyp@3539: "finish adding old regions to CSet", tonyp@3539: ergo_format_reason("old CSet region num reached max") tonyp@3539: ergo_format_region("old") tonyp@3539: ergo_format_region("max"), tonyp@3539: old_cset_region_length(), max_old_cset_length); tonyp@3539: break; ysr@777: } tonyp@3114: johnc@4681: johnc@4681: // Stop adding regions if the remaining reclaimable space is johnc@4681: // not above G1HeapWastePercent. johnc@4681: size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes(); johnc@4681: double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes); johnc@4681: double threshold = (double) G1HeapWastePercent; johnc@4681: if (reclaimable_perc <= threshold) { johnc@4681: // We've added enough old regions that the amount of uncollected johnc@4681: // reclaimable space is at or below the waste threshold. Stop johnc@4681: // adding old regions to the CSet. johnc@4681: ergo_verbose5(ErgoCSetConstruction, johnc@4681: "finish adding old regions to CSet", johnc@4681: ergo_format_reason("reclaimable percentage not over threshold") johnc@4681: ergo_format_region("old") johnc@4681: ergo_format_region("max") johnc@4681: ergo_format_byte_perc("reclaimable") johnc@4681: ergo_format_perc("threshold"), johnc@4681: old_cset_region_length(), johnc@4681: max_old_cset_length, johnc@4681: reclaimable_bytes, johnc@4681: reclaimable_perc, threshold); johnc@4681: break; johnc@4681: } johnc@4681: johnc@3998: double predicted_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); tonyp@3539: if (check_time_remaining) { tonyp@3539: if (predicted_time_ms > time_remaining_ms) { tonyp@3539: // Too expensive for the current CSet. tonyp@3539: tonyp@3539: if (old_cset_region_length() >= min_old_cset_length) { tonyp@3539: // We have added the minimum number of old regions to the CSet, tonyp@3539: // we are done with this CSet. tonyp@3539: ergo_verbose4(ErgoCSetConstruction, tonyp@3539: "finish adding old regions to CSet", tonyp@3539: ergo_format_reason("predicted time is too high") tonyp@3539: ergo_format_ms("predicted time") tonyp@3539: ergo_format_ms("remaining time") tonyp@3539: ergo_format_region("old") tonyp@3539: ergo_format_region("min"), tonyp@3539: predicted_time_ms, time_remaining_ms, tonyp@3539: old_cset_region_length(), min_old_cset_length); tonyp@3539: break; tonyp@3539: } tonyp@3539: tonyp@3539: // We'll add it anyway given that we haven't reached the tonyp@3539: // minimum number of old regions. tonyp@3539: expensive_region_num += 1; tonyp@3539: } tonyp@3114: } else { tonyp@3539: if (old_cset_region_length() >= min_old_cset_length) { tonyp@3539: // In the non-auto-tuning case, we'll finish adding regions tonyp@3539: // to the CSet if we reach the minimum. tonyp@3539: ergo_verbose2(ErgoCSetConstruction, tonyp@3539: "finish adding old regions to CSet", tonyp@3539: ergo_format_reason("old CSet region num reached min") tonyp@3539: ergo_format_region("old") tonyp@3539: ergo_format_region("min"), tonyp@3539: old_cset_region_length(), min_old_cset_length); tonyp@3539: break; tonyp@3114: } tonyp@3114: } tonyp@3539: tonyp@3539: // We will add this region to the CSet. johnc@4681: time_remaining_ms = MAX2(time_remaining_ms - predicted_time_ms, 0.0); tonyp@3539: predicted_pause_time_ms += predicted_time_ms; tonyp@3539: cset_chooser->remove_and_move_to_next(hr); tonyp@3539: _g1->old_set_remove(hr); tonyp@3539: add_old_region_to_cset(hr); tonyp@3539: tonyp@3539: hr = cset_chooser->peek(); tonyp@3114: } tonyp@3539: if (hr == NULL) { tonyp@3539: ergo_verbose0(ErgoCSetConstruction, tonyp@3539: "finish adding old regions to CSet", tonyp@3539: ergo_format_reason("candidate old regions not available")); tonyp@3539: } tonyp@3539: tonyp@3539: if (expensive_region_num > 0) { tonyp@3539: // We print the information once here at the end, predicated on tonyp@3539: // whether we added any apparently expensive regions or not, to tonyp@3539: // avoid generating output per region. tonyp@3539: ergo_verbose4(ErgoCSetConstruction, tonyp@3539: "added expensive regions to CSet", tonyp@3539: ergo_format_reason("old CSet region num not reached min") tonyp@3539: ergo_format_region("old") tonyp@3539: ergo_format_region("expensive") tonyp@3539: ergo_format_region("min") tonyp@3539: ergo_format_ms("remaining time"), tonyp@3539: old_cset_region_length(), tonyp@3539: expensive_region_num, tonyp@3539: min_old_cset_length, tonyp@3539: time_remaining_ms); tonyp@3539: } tonyp@3539: tonyp@3714: cset_chooser->verify(); ysr@777: } ysr@777: johnc@1829: stop_incremental_cset_building(); johnc@1829: 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(); brutisso@4015: phase_times()->record_non_young_cset_choice_time_ms((non_young_end_time_sec - non_young_start_time_sec) * 1000.0); sla@5237: evacuation_info.set_collectionset_regions(cset_region_length()); ysr@777: } brutisso@3812: brutisso@3812: void TraceGen0TimeData::record_start_collection(double time_to_stop_the_world_ms) { brutisso@3812: if(TraceGen0Time) { brutisso@3812: _all_stop_world_times_ms.add(time_to_stop_the_world_ms); brutisso@3812: } brutisso@3812: } brutisso@3812: brutisso@3812: void TraceGen0TimeData::record_yield_time(double yield_time_ms) { brutisso@3812: if(TraceGen0Time) { brutisso@3812: _all_yield_times_ms.add(yield_time_ms); brutisso@3812: } brutisso@3812: } brutisso@3812: brutisso@3923: void TraceGen0TimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) { brutisso@3812: if(TraceGen0Time) { brutisso@3923: _total.add(pause_time_ms); brutisso@3923: _other.add(pause_time_ms - phase_times->accounted_time_ms()); brutisso@4015: _root_region_scan_wait.add(phase_times->root_region_scan_wait_time_ms()); brutisso@4015: _parallel.add(phase_times->cur_collection_par_time_ms()); brutisso@4015: _ext_root_scan.add(phase_times->average_last_ext_root_scan_time()); brutisso@4015: _satb_filtering.add(phase_times->average_last_satb_filtering_times_ms()); brutisso@4015: _update_rs.add(phase_times->average_last_update_rs_time()); brutisso@4015: _scan_rs.add(phase_times->average_last_scan_rs_time()); brutisso@4015: _obj_copy.add(phase_times->average_last_obj_copy_time()); brutisso@4015: _termination.add(phase_times->average_last_termination_time()); brutisso@3923: brutisso@4015: double parallel_known_time = phase_times->average_last_ext_root_scan_time() + brutisso@4015: phase_times->average_last_satb_filtering_times_ms() + brutisso@4015: phase_times->average_last_update_rs_time() + brutisso@4015: phase_times->average_last_scan_rs_time() + brutisso@4015: phase_times->average_last_obj_copy_time() + brutisso@4015: + phase_times->average_last_termination_time(); brutisso@3923: brutisso@4015: double parallel_other_time = phase_times->cur_collection_par_time_ms() - parallel_known_time; brutisso@3923: _parallel_other.add(parallel_other_time); brutisso@4015: _clear_ct.add(phase_times->cur_clear_ct_time_ms()); brutisso@3812: } brutisso@3812: } brutisso@3812: brutisso@3812: void TraceGen0TimeData::increment_young_collection_count() { brutisso@3812: if(TraceGen0Time) { brutisso@3812: ++_young_pause_num; brutisso@3812: } brutisso@3812: } brutisso@3812: brutisso@3812: void TraceGen0TimeData::increment_mixed_collection_count() { brutisso@3812: if(TraceGen0Time) { brutisso@3812: ++_mixed_pause_num; brutisso@3812: } brutisso@3812: } brutisso@3812: brutisso@3923: void TraceGen0TimeData::print_summary(const char* str, brutisso@3812: const NumberSeq* seq) const { brutisso@3812: double sum = seq->sum(); brutisso@3923: gclog_or_tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)", brutisso@3812: str, sum / 1000.0, seq->avg()); brutisso@3812: } brutisso@3812: brutisso@3923: void TraceGen0TimeData::print_summary_sd(const char* str, brutisso@3812: const NumberSeq* seq) const { brutisso@3923: print_summary(str, seq); brutisso@3923: gclog_or_tty->print_cr("%+45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", brutisso@3923: "(num", seq->num(), seq->sd(), seq->maximum()); brutisso@3812: } brutisso@3812: brutisso@3812: void TraceGen0TimeData::print() const { brutisso@3812: if (!TraceGen0Time) { brutisso@3812: return; brutisso@3812: } brutisso@3812: brutisso@3812: gclog_or_tty->print_cr("ALL PAUSES"); brutisso@3923: print_summary_sd(" Total", &_total); drchase@6680: gclog_or_tty->cr(); drchase@6680: gclog_or_tty->cr(); brutisso@3812: gclog_or_tty->print_cr(" Young GC Pauses: %8d", _young_pause_num); brutisso@3812: gclog_or_tty->print_cr(" Mixed GC Pauses: %8d", _mixed_pause_num); drchase@6680: gclog_or_tty->cr(); brutisso@3812: brutisso@3812: gclog_or_tty->print_cr("EVACUATION PAUSES"); brutisso@3812: brutisso@3812: if (_young_pause_num == 0 && _mixed_pause_num == 0) { brutisso@3812: gclog_or_tty->print_cr("none"); brutisso@3812: } else { brutisso@3923: print_summary_sd(" Evacuation Pauses", &_total); brutisso@3923: print_summary(" Root Region Scan Wait", &_root_region_scan_wait); brutisso@3923: print_summary(" Parallel Time", &_parallel); brutisso@3923: print_summary(" Ext Root Scanning", &_ext_root_scan); brutisso@3923: print_summary(" SATB Filtering", &_satb_filtering); brutisso@3923: print_summary(" Update RS", &_update_rs); brutisso@3923: print_summary(" Scan RS", &_scan_rs); brutisso@3923: print_summary(" Object Copy", &_obj_copy); brutisso@3923: print_summary(" Termination", &_termination); brutisso@3923: print_summary(" Parallel Other", &_parallel_other); brutisso@3923: print_summary(" Clear CT", &_clear_ct); brutisso@3923: print_summary(" Other", &_other); brutisso@3812: } drchase@6680: gclog_or_tty->cr(); brutisso@3812: brutisso@3812: gclog_or_tty->print_cr("MISC"); brutisso@3923: print_summary_sd(" Stop World", &_all_stop_world_times_ms); brutisso@3923: print_summary_sd(" Yields", &_all_yield_times_ms); brutisso@3812: } brutisso@3812: brutisso@3812: void TraceGen1TimeData::record_full_collection(double full_gc_time_ms) { brutisso@3812: if (TraceGen1Time) { brutisso@3812: _all_full_gc_times.add(full_gc_time_ms); brutisso@3812: } brutisso@3812: } brutisso@3812: brutisso@3812: void TraceGen1TimeData::print() const { brutisso@3812: if (!TraceGen1Time) { brutisso@3812: return; brutisso@3812: } brutisso@3812: brutisso@3812: if (_all_full_gc_times.num() > 0) { brutisso@3812: gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s", brutisso@3812: _all_full_gc_times.num(), brutisso@3812: _all_full_gc_times.sum() / 1000.0); brutisso@3812: gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times.avg()); brutisso@3812: gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", brutisso@3812: _all_full_gc_times.sd(), brutisso@3812: _all_full_gc_times.maximum()); brutisso@3812: } brutisso@3812: }