Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 2152:0fa27f37d4d4
6977804: G1: remove the zero-filling thread
Summary: This changeset removes the zero-filling thread from G1 and collapses the two free region lists we had before (the "free" and "unclean" lists) into one. The new free list uses the new heap region sets / lists abstractions that we'll ultimately use it to keep track of all regions in the heap. A heap region set was also introduced for the humongous regions. Finally, this change increases the concurrency between the thread that completes freeing regions (after a cleanup pause) and the rest of the system (before we'd have to wait for said thread to complete before allocating a new region). The changest also includes a lot of refactoring and code simplification.
Reviewed-by: jcoomes, johnc
| author | tonyp |
|---|---|
| date | Wed, 19 Jan 2011 19:30:42 -0500 |
| parents | 016a3628c885 |
| children | c33825b68624 |
| rev | line source |
|---|---|
| 342 | 1 /* |
| 2152 | 2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. |
| 342 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "gc_implementation/g1/concurrentG1Refine.hpp" | |
| 27 #include "gc_implementation/g1/concurrentMark.hpp" | |
| 28 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp" | |
| 29 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 30 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
| 31 #include "gc_implementation/g1/heapRegionRemSet.hpp" | |
| 32 #include "gc_implementation/shared/gcPolicyCounters.hpp" | |
| 33 #include "runtime/arguments.hpp" | |
| 34 #include "runtime/java.hpp" | |
| 35 #include "runtime/mutexLocker.hpp" | |
| 36 #include "utilities/debug.hpp" | |
| 342 | 37 |
| 38 #define PREDICTIONS_VERBOSE 0 | |
| 39 | |
| 40 // <NEW PREDICTION> | |
| 41 | |
| 42 // Different defaults for different number of GC threads | |
| 43 // They were chosen by running GCOld and SPECjbb on debris with different | |
| 44 // numbers of GC threads and choosing them based on the results | |
| 45 | |
| 46 // all the same | |
| 47 static double rs_length_diff_defaults[] = { | |
| 48 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 | |
| 49 }; | |
| 50 | |
| 51 static double cost_per_card_ms_defaults[] = { | |
| 52 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015 | |
| 53 }; | |
| 54 | |
| 55 // all the same | |
| 56 static double fully_young_cards_per_entry_ratio_defaults[] = { | |
| 57 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 | |
| 58 }; | |
| 59 | |
| 60 static double cost_per_entry_ms_defaults[] = { | |
| 61 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005 | |
| 62 }; | |
| 63 | |
| 64 static double cost_per_byte_ms_defaults[] = { | |
| 65 0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009 | |
| 66 }; | |
| 67 | |
| 68 // these should be pretty consistent | |
| 69 static double constant_other_time_ms_defaults[] = { | |
| 70 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 | |
| 71 }; | |
| 72 | |
| 73 | |
| 74 static double young_other_cost_per_region_ms_defaults[] = { | |
| 75 0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1 | |
| 76 }; | |
| 77 | |
| 78 static double non_young_other_cost_per_region_ms_defaults[] = { | |
| 79 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30 | |
| 80 }; | |
| 81 | |
| 82 // </NEW PREDICTION> | |
| 83 | |
| 84 G1CollectorPolicy::G1CollectorPolicy() : | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
85 _parallel_gc_threads(G1CollectedHeap::use_parallel_gc_threads() |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
86 ? ParallelGCThreads : 1), |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
87 |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
88 |
| 342 | 89 _n_pauses(0), |
| 90 _recent_CH_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 91 _recent_G1_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 92 _recent_evac_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 93 _recent_pause_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 94 _recent_rs_sizes(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 95 _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 96 _all_pause_times_ms(new NumberSeq()), | |
| 97 _stop_world_start(0.0), | |
| 98 _all_stop_world_times_ms(new NumberSeq()), | |
| 99 _all_yield_times_ms(new NumberSeq()), | |
| 100 | |
| 101 _all_mod_union_times_ms(new NumberSeq()), | |
| 102 | |
| 677 | 103 _summary(new Summary()), |
| 342 | 104 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
105 #ifndef PRODUCT |
| 342 | 106 _cur_clear_ct_time_ms(0.0), |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
107 _min_clear_cc_time_ms(-1.0), |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
108 _max_clear_cc_time_ms(-1.0), |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
109 _cur_clear_cc_time_ms(0.0), |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
110 _cum_clear_cc_time_ms(0.0), |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
111 _num_cc_clears(0L), |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
112 #endif |
| 342 | 113 |
| 114 _region_num_young(0), | |
| 115 _region_num_tenured(0), | |
| 116 _prev_region_num_young(0), | |
| 117 _prev_region_num_tenured(0), | |
| 118 | |
| 119 _aux_num(10), | |
| 120 _all_aux_times_ms(new NumberSeq[_aux_num]), | |
| 121 _cur_aux_start_times_ms(new double[_aux_num]), | |
| 122 _cur_aux_times_ms(new double[_aux_num]), | |
| 123 _cur_aux_times_set(new bool[_aux_num]), | |
| 124 | |
| 125 _concurrent_mark_init_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 126 _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 127 _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 128 | |
| 129 // <NEW PREDICTION> | |
| 130 | |
| 131 _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 132 _prev_collection_pause_end_ms(0.0), | |
| 133 _pending_card_diff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 134 _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 135 _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 136 _fully_young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 137 _partially_young_cards_per_entry_ratio_seq( | |
| 138 new TruncatedSeq(TruncatedSeqLength)), | |
| 139 _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 140 _partially_young_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 141 _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 142 _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 143 _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 144 _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 145 _non_young_other_cost_per_region_ms_seq( | |
| 146 new TruncatedSeq(TruncatedSeqLength)), | |
| 147 | |
| 148 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 149 _scanned_cards_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 150 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 151 | |
| 751 | 152 _pause_time_target_ms((double) MaxGCPauseMillis), |
| 342 | 153 |
| 154 // </NEW PREDICTION> | |
| 155 | |
| 156 _in_young_gc_mode(false), | |
| 157 _full_young_gcs(true), | |
| 158 _full_young_pause_num(0), | |
| 159 _partial_young_pause_num(0), | |
| 160 | |
| 161 _during_marking(false), | |
| 162 _in_marking_window(false), | |
| 163 _in_marking_window_im(false), | |
| 164 | |
| 165 _known_garbage_ratio(0.0), | |
| 166 _known_garbage_bytes(0), | |
| 167 | |
| 168 _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
| 169 | |
| 170 _recent_prev_end_times_for_all_gcs_sec(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 171 | |
| 172 _recent_CS_bytes_used_before(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 173 _recent_CS_bytes_surviving(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
| 174 | |
| 175 _recent_avg_pause_time_ratio(0.0), | |
| 176 _num_markings(0), | |
| 177 _n_marks(0), | |
| 178 _n_pauses_at_mark_end(0), | |
| 179 | |
| 180 _all_full_gc_times_ms(new NumberSeq()), | |
| 181 | |
| 182 // G1PausesBtwnConcMark defaults to -1 | |
| 183 // so the hack is to do the cast QQQ FIXME | |
| 184 _pauses_btwn_concurrent_mark((size_t)G1PausesBtwnConcMark), | |
| 185 _n_marks_since_last_pause(0), | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
186 _initiate_conc_mark_if_possible(false), |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
187 _during_initial_mark_pause(false), |
| 342 | 188 _should_revert_to_full_young_gcs(false), |
| 189 _last_full_young_gc(false), | |
| 190 | |
| 191 _prev_collection_pause_used_at_end_bytes(0), | |
| 192 | |
| 193 _collection_set(NULL), | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
194 _collection_set_size(0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
195 _collection_set_bytes_used_before(0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
196 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
197 // Incremental CSet attributes |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
198 _inc_cset_build_state(Inactive), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
199 _inc_cset_head(NULL), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
200 _inc_cset_tail(NULL), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
201 _inc_cset_size(0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
202 _inc_cset_young_index(0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
203 _inc_cset_bytes_used_before(0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
204 _inc_cset_max_finger(NULL), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
205 _inc_cset_recorded_young_bytes(0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
206 _inc_cset_recorded_rs_lengths(0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
207 _inc_cset_predicted_elapsed_time_ms(0.0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
208 _inc_cset_predicted_bytes_to_copy(0), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
209 |
| 342 | 210 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away |
| 211 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
| 212 #endif // _MSC_VER | |
| 213 | |
| 214 _short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived", | |
| 215 G1YoungSurvRateNumRegionsSummary)), | |
| 216 _survivor_surv_rate_group(new SurvRateGroup(this, "Survivor", | |
| 545 | 217 G1YoungSurvRateNumRegionsSummary)), |
| 342 | 218 // add here any more surv rate groups |
| 545 | 219 _recorded_survivor_regions(0), |
| 220 _recorded_survivor_head(NULL), | |
| 221 _recorded_survivor_tail(NULL), | |
| 1356 | 222 _survivors_age_table(true), |
| 223 | |
| 224 _gc_overhead_perc(0.0) | |
| 545 | 225 |
| 342 | 226 { |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
227 // Set up the region size and associated fields. Given that the |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
228 // policy is created before the heap, we have to set this up here, |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
229 // so it's done as soon as possible. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
230 HeapRegion::setup_heap_region_size(Arguments::min_heap_size()); |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1111
diff
changeset
|
231 HeapRegionRemSet::setup_remset_size(); |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
232 |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
233 // Verify PLAB sizes |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
234 const uint region_size = HeapRegion::GrainWords; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
235 if (YoungPLABSize > region_size || OldPLABSize > region_size) { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
236 char buffer[128]; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
237 jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most %u", |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
238 OldPLABSize > region_size ? "Old" : "Young", region_size); |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
239 vm_exit_during_initialization(buffer); |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
240 } |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
241 |
| 342 | 242 _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); |
| 243 _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; | |
| 244 | |
| 1611 | 245 _par_last_gc_worker_start_times_ms = new double[_parallel_gc_threads]; |
| 342 | 246 _par_last_ext_root_scan_times_ms = new double[_parallel_gc_threads]; |
| 247 _par_last_mark_stack_scan_times_ms = new double[_parallel_gc_threads]; | |
| 248 | |
| 249 _par_last_update_rs_times_ms = new double[_parallel_gc_threads]; | |
| 250 _par_last_update_rs_processed_buffers = new double[_parallel_gc_threads]; | |
| 251 | |
| 252 _par_last_scan_rs_times_ms = new double[_parallel_gc_threads]; | |
| 253 | |
| 254 _par_last_obj_copy_times_ms = new double[_parallel_gc_threads]; | |
| 255 | |
| 256 _par_last_termination_times_ms = new double[_parallel_gc_threads]; | |
| 1611 | 257 _par_last_termination_attempts = new double[_parallel_gc_threads]; |
| 258 _par_last_gc_worker_end_times_ms = new double[_parallel_gc_threads]; | |
| 342 | 259 |
| 260 // start conservatively | |
| 751 | 261 _expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis; |
| 342 | 262 |
| 263 // <NEW PREDICTION> | |
| 264 | |
| 265 int index; | |
| 266 if (ParallelGCThreads == 0) | |
| 267 index = 0; | |
| 268 else if (ParallelGCThreads > 8) | |
| 269 index = 7; | |
| 270 else | |
| 271 index = ParallelGCThreads - 1; | |
| 272 | |
| 273 _pending_card_diff_seq->add(0.0); | |
| 274 _rs_length_diff_seq->add(rs_length_diff_defaults[index]); | |
| 275 _cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]); | |
| 276 _fully_young_cards_per_entry_ratio_seq->add( | |
| 277 fully_young_cards_per_entry_ratio_defaults[index]); | |
| 278 _cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]); | |
| 279 _cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]); | |
| 280 _constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]); | |
| 281 _young_other_cost_per_region_ms_seq->add( | |
| 282 young_other_cost_per_region_ms_defaults[index]); | |
| 283 _non_young_other_cost_per_region_ms_seq->add( | |
| 284 non_young_other_cost_per_region_ms_defaults[index]); | |
| 285 | |
| 286 // </NEW PREDICTION> | |
| 287 | |
|
1610
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
288 // Below, we might need to calculate the pause time target based on |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
289 // the pause interval. When we do so we are going to give G1 maximum |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
290 // flexibility and allow it to do pauses when it needs to. So, we'll |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
291 // arrange that the pause interval to be pause time target + 1 to |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
292 // ensure that a) the pause time target is maximized with respect to |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
293 // the pause interval and b) we maintain the invariant that pause |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
294 // time target < pause interval. If the user does not want this |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
295 // maximum flexibility, they will have to set the pause interval |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
296 // explicitly. |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
297 |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
298 // First make sure that, if either parameter is set, its value is |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
299 // reasonable. |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
300 if (!FLAG_IS_DEFAULT(MaxGCPauseMillis)) { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
301 if (MaxGCPauseMillis < 1) { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
302 vm_exit_during_initialization("MaxGCPauseMillis should be " |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
303 "greater than 0"); |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
304 } |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
305 } |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
306 if (!FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
307 if (GCPauseIntervalMillis < 1) { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
308 vm_exit_during_initialization("GCPauseIntervalMillis should be " |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
309 "greater than 0"); |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
310 } |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
311 } |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
312 |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
313 // Then, if the pause time target parameter was not set, set it to |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
314 // the default value. |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
315 if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
316 if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
317 // The default pause time target in G1 is 200ms |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
318 FLAG_SET_DEFAULT(MaxGCPauseMillis, 200); |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
319 } else { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
320 // We do not allow the pause interval to be set without the |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
321 // pause time target |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
322 vm_exit_during_initialization("GCPauseIntervalMillis cannot be set " |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
323 "without setting MaxGCPauseMillis"); |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
324 } |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
325 } |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
326 |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
327 // Then, if the interval parameter was not set, set it according to |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
328 // the pause time target (this will also deal with the case when the |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
329 // pause time target is the default value). |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
330 if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
331 FLAG_SET_DEFAULT(GCPauseIntervalMillis, MaxGCPauseMillis + 1); |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
332 } |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
333 |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
334 // Finally, make sure that the two parameters are consistent. |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
335 if (MaxGCPauseMillis >= GCPauseIntervalMillis) { |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
336 char buffer[256]; |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
337 jio_snprintf(buffer, 256, |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
338 "MaxGCPauseMillis (%u) should be less than " |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
339 "GCPauseIntervalMillis (%u)", |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
340 MaxGCPauseMillis, GCPauseIntervalMillis); |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
341 vm_exit_during_initialization(buffer); |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
342 } |
|
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
343 |
| 751 | 344 double max_gc_time = (double) MaxGCPauseMillis / 1000.0; |
|
1610
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
345 double time_slice = (double) GCPauseIntervalMillis / 1000.0; |
| 342 | 346 _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time); |
| 751 | 347 _sigma = (double) G1ConfidencePercent / 100.0; |
| 342 | 348 |
| 349 // start conservatively (around 50ms is about right) | |
| 350 _concurrent_mark_init_times_ms->add(0.05); | |
| 351 _concurrent_mark_remark_times_ms->add(0.05); | |
| 352 _concurrent_mark_cleanup_times_ms->add(0.20); | |
| 353 _tenuring_threshold = MaxTenuringThreshold; | |
| 354 | |
| 1282 | 355 // if G1FixedSurvivorSpaceSize is 0 which means the size is not |
| 356 // fixed, then _max_survivor_regions will be calculated at | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
357 // calculate_young_list_target_length during initialization |
| 1282 | 358 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes; |
| 545 | 359 |
| 1356 | 360 assert(GCTimeRatio > 0, |
| 361 "we should have set it to a default value set_g1_gc_flags() " | |
| 362 "if a user set it to 0"); | |
| 363 _gc_overhead_perc = 100.0 * (1.0 / (1.0 + GCTimeRatio)); | |
| 364 | |
| 342 | 365 initialize_all(); |
| 366 } | |
| 367 | |
| 368 // Increment "i", mod "len" | |
| 369 static void inc_mod(int& i, int len) { | |
| 370 i++; if (i == len) i = 0; | |
| 371 } | |
| 372 | |
| 373 void G1CollectorPolicy::initialize_flags() { | |
| 374 set_min_alignment(HeapRegion::GrainBytes); | |
| 375 set_max_alignment(GenRemSet::max_alignment_constraint(rem_set_name())); | |
|
547
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
376 if (SurvivorRatio < 1) { |
|
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
377 vm_exit_during_initialization("Invalid survivor ratio specified"); |
|
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
378 } |
| 342 | 379 CollectorPolicy::initialize_flags(); |
| 380 } | |
| 381 | |
|
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
382 // The easiest way to deal with the parsing of the NewSize / |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
383 // MaxNewSize / etc. parameteres is to re-use the code in the |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
384 // TwoGenerationCollectorPolicy class. This is similar to what |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
385 // ParallelScavenge does with its GenerationSizer class (see |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
386 // ParallelScavengeHeap::initialize()). We might change this in the |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
387 // future, but it's a good start. |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
388 class G1YoungGenSizer : public TwoGenerationCollectorPolicy { |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
389 size_t size_to_region_num(size_t byte_size) { |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
390 return MAX2((size_t) 1, byte_size / HeapRegion::GrainBytes); |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
391 } |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
392 |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
393 public: |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
394 G1YoungGenSizer() { |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
395 initialize_flags(); |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
396 initialize_size_info(); |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
397 } |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
398 |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
399 size_t min_young_region_num() { |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
400 return size_to_region_num(_min_gen0_size); |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
401 } |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
402 size_t initial_young_region_num() { |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
403 return size_to_region_num(_initial_gen0_size); |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
404 } |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
405 size_t max_young_region_num() { |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
406 return size_to_region_num(_max_gen0_size); |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
407 } |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
408 }; |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
409 |
| 342 | 410 void G1CollectorPolicy::init() { |
| 411 // Set aside an initial future to_space. | |
| 412 _g1 = G1CollectedHeap::heap(); | |
| 413 | |
| 414 assert(Heap_lock->owned_by_self(), "Locking discipline."); | |
| 415 | |
| 545 | 416 initialize_gc_policy_counters(); |
| 417 | |
| 342 | 418 if (G1Gen) { |
| 419 _in_young_gc_mode = true; | |
| 420 | |
|
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
421 G1YoungGenSizer sizer; |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
422 size_t initial_region_num = sizer.initial_young_region_num(); |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
423 |
|
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
424 if (UseAdaptiveSizePolicy) { |
| 342 | 425 set_adaptive_young_list_length(true); |
| 426 _young_list_fixed_length = 0; | |
| 427 } else { | |
| 428 set_adaptive_young_list_length(false); | |
|
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
429 _young_list_fixed_length = initial_region_num; |
| 342 | 430 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
431 _free_regions_at_end_of_collection = _g1->free_regions(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
432 calculate_young_list_min_length(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
433 guarantee( _young_list_min_length == 0, "invariant, not enough info" ); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
434 calculate_young_list_target_length(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
435 } else { |
| 342 | 436 _young_list_fixed_length = 0; |
| 437 _in_young_gc_mode = false; | |
| 438 } | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
439 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
440 // We may immediately start allocating regions and placing them on the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
441 // collection set list. Initialize the per-collection set info |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
442 start_incremental_cset_building(); |
| 342 | 443 } |
| 444 | |
| 545 | 445 // Create the jstat counters for the policy. |
| 446 void G1CollectorPolicy::initialize_gc_policy_counters() | |
| 447 { | |
| 448 _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 2 + G1Gen); | |
| 449 } | |
| 450 | |
| 342 | 451 void G1CollectorPolicy::calculate_young_list_min_length() { |
| 452 _young_list_min_length = 0; | |
| 453 | |
| 454 if (!adaptive_young_list_length()) | |
| 455 return; | |
| 456 | |
| 457 if (_alloc_rate_ms_seq->num() > 3) { | |
| 458 double now_sec = os::elapsedTime(); | |
| 459 double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0; | |
| 460 double alloc_rate_ms = predict_alloc_rate_ms(); | |
| 1973 | 461 size_t min_regions = (size_t) ceil(alloc_rate_ms * when_ms); |
| 462 size_t current_region_num = _g1->young_list()->length(); | |
| 342 | 463 _young_list_min_length = min_regions + current_region_num; |
| 464 } | |
| 465 } | |
| 466 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
467 void G1CollectorPolicy::calculate_young_list_target_length() { |
| 342 | 468 if (adaptive_young_list_length()) { |
| 469 size_t rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
470 calculate_young_list_target_length(rs_lengths); |
| 342 | 471 } else { |
| 472 if (full_young_gcs()) | |
| 473 _young_list_target_length = _young_list_fixed_length; | |
| 474 else | |
| 475 _young_list_target_length = _young_list_fixed_length / 2; | |
| 476 } | |
| 1973 | 477 |
| 478 // Make sure we allow the application to allocate at least one | |
| 479 // region before we need to do a collection again. | |
| 480 size_t min_length = _g1->young_list()->length() + 1; | |
| 481 _young_list_target_length = MAX2(_young_list_target_length, min_length); | |
|
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
482 calculate_max_gc_locker_expansion(); |
| 545 | 483 calculate_survivors_policy(); |
| 342 | 484 } |
| 485 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
486 void G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths) { |
| 342 | 487 guarantee( adaptive_young_list_length(), "pre-condition" ); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
488 guarantee( !_in_marking_window || !_last_full_young_gc, "invariant" ); |
| 342 | 489 |
| 490 double start_time_sec = os::elapsedTime(); | |
| 1282 | 491 size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1ReservePercent); |
| 342 | 492 min_reserve_perc = MIN2((size_t) 50, min_reserve_perc); |
| 493 size_t reserve_regions = | |
| 494 (size_t) ((double) min_reserve_perc * (double) _g1->n_regions() / 100.0); | |
| 495 | |
| 496 if (full_young_gcs() && _free_regions_at_end_of_collection > 0) { | |
| 497 // we are in fully-young mode and there are free regions in the heap | |
| 498 | |
| 545 | 499 double survivor_regions_evac_time = |
| 500 predict_survivor_regions_evac_time(); | |
| 501 | |
| 342 | 502 double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0; |
| 503 size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq); | |
| 504 size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff(); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
505 size_t scanned_cards = predict_young_card_num(adj_rs_lengths); |
| 545 | 506 double base_time_ms = predict_base_elapsed_time_ms(pending_cards, scanned_cards) |
| 507 + survivor_regions_evac_time; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
508 |
| 342 | 509 // the result |
| 510 size_t final_young_length = 0; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
511 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
512 size_t init_free_regions = |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
513 MAX2((size_t)0, _free_regions_at_end_of_collection - reserve_regions); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
514 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
515 // if we're still under the pause target... |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
516 if (base_time_ms <= target_pause_time_ms) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
517 // We make sure that the shortest young length that makes sense |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
518 // fits within the target pause time. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
519 size_t min_young_length = 1; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
520 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
521 if (predict_will_fit(min_young_length, base_time_ms, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
522 init_free_regions, target_pause_time_ms)) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
523 // The shortest young length will fit within the target pause time; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
524 // we'll now check whether the absolute maximum number of young |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
525 // regions will fit in the target pause time. If not, we'll do |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
526 // a binary search between min_young_length and max_young_length |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
527 size_t abs_max_young_length = _free_regions_at_end_of_collection - 1; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
528 size_t max_young_length = abs_max_young_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
529 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
530 if (max_young_length > min_young_length) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
531 // Let's check if the initial max young length will fit within the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
532 // target pause. If so then there is no need to search for a maximal |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
533 // young length - we'll return the initial maximum |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
534 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
535 if (predict_will_fit(max_young_length, base_time_ms, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
536 init_free_regions, target_pause_time_ms)) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
537 // The maximum young length will satisfy the target pause time. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
538 // We are done so set min young length to this maximum length. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
539 // The code after the loop will then set final_young_length using |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
540 // the value cached in the minimum length. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
541 min_young_length = max_young_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
542 } else { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
543 // The maximum possible number of young regions will not fit within |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
544 // the target pause time so let's search.... |
| 342 | 545 |
| 546 size_t diff = (max_young_length - min_young_length) / 2; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
547 max_young_length = min_young_length + diff; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
548 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
549 while (max_young_length > min_young_length) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
550 if (predict_will_fit(max_young_length, base_time_ms, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
551 init_free_regions, target_pause_time_ms)) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
552 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
553 // The current max young length will fit within the target |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
554 // pause time. Note we do not exit the loop here. By setting |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
555 // min = max, and then increasing the max below means that |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
556 // we will continue searching for an upper bound in the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
557 // range [max..max+diff] |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
558 min_young_length = max_young_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
559 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
560 diff = (max_young_length - min_young_length) / 2; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
561 max_young_length = min_young_length + diff; |
| 342 | 562 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
563 // the above loop found a maximal young length that will fit |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
564 // within the target pause time. |
| 342 | 565 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
566 assert(min_young_length <= abs_max_young_length, "just checking"); |
| 342 | 567 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
568 final_young_length = min_young_length; |
| 342 | 569 } |
| 570 } | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
571 // and we're done! |
| 342 | 572 |
| 573 // we should have at least one region in the target young length | |
| 545 | 574 _young_list_target_length = |
| 1973 | 575 final_young_length + _recorded_survivor_regions; |
| 342 | 576 |
| 577 // let's keep an eye of how long we spend on this calculation | |
| 578 // right now, I assume that we'll print it when we need it; we | |
| 579 // should really adde it to the breakdown of a pause | |
| 580 double end_time_sec = os::elapsedTime(); | |
| 581 double elapsed_time_ms = (end_time_sec - start_time_sec) * 1000.0; | |
| 582 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
583 #ifdef TRACE_CALC_YOUNG_LENGTH |
| 342 | 584 // leave this in for debugging, just in case |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
585 gclog_or_tty->print_cr("target = %1.1lf ms, young = " SIZE_FORMAT ", " |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
586 "elapsed %1.2lf ms, (%s%s) " SIZE_FORMAT SIZE_FORMAT, |
| 342 | 587 target_pause_time_ms, |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
588 _young_list_target_length |
| 342 | 589 elapsed_time_ms, |
| 590 full_young_gcs() ? "full" : "partial", | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
591 during_initial_mark_pause() ? " i-m" : "", |
| 545 | 592 _in_marking_window, |
| 593 _in_marking_window_im); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
594 #endif // TRACE_CALC_YOUNG_LENGTH |
| 342 | 595 |
| 596 if (_young_list_target_length < _young_list_min_length) { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
597 // bummer; this means that, if we do a pause when the maximal |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
598 // length dictates, we'll violate the pause spacing target (the |
| 342 | 599 // min length was calculate based on the application's current |
| 600 // alloc rate); | |
| 601 | |
| 602 // so, we have to bite the bullet, and allocate the minimum | |
| 603 // number. We'll violate our target, but we just can't meet it. | |
| 604 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
605 #ifdef TRACE_CALC_YOUNG_LENGTH |
| 342 | 606 // leave this in for debugging, just in case |
| 607 gclog_or_tty->print_cr("adjusted target length from " | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
608 SIZE_FORMAT " to " SIZE_FORMAT, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
609 _young_list_target_length, _young_list_min_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
610 #endif // TRACE_CALC_YOUNG_LENGTH |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
611 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
612 _young_list_target_length = _young_list_min_length; |
| 342 | 613 } |
| 614 } else { | |
| 615 // we are in a partially-young mode or we've run out of regions (due | |
| 616 // to evacuation failure) | |
| 617 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
618 #ifdef TRACE_CALC_YOUNG_LENGTH |
| 342 | 619 // leave this in for debugging, just in case |
| 620 gclog_or_tty->print_cr("(partial) setting target to " SIZE_FORMAT | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
621 _young_list_min_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
622 #endif // TRACE_CALC_YOUNG_LENGTH |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
623 // we'll do the pause as soon as possible by choosing the minimum |
| 1973 | 624 _young_list_target_length = _young_list_min_length; |
| 342 | 625 } |
| 626 | |
| 627 _rs_lengths_prediction = rs_lengths; | |
| 628 } | |
| 629 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
630 // This is used by: calculate_young_list_target_length(rs_length). It |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
631 // returns true iff: |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
632 // the predicted pause time for the given young list will not overflow |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
633 // the target pause time |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
634 // and: |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
635 // the predicted amount of surviving data will not overflow the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
636 // the amount of free space available for survivor regions. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
637 // |
| 342 | 638 bool |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
639 G1CollectorPolicy::predict_will_fit(size_t young_length, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
640 double base_time_ms, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
641 size_t init_free_regions, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
642 double target_pause_time_ms) { |
| 342 | 643 |
| 644 if (young_length >= init_free_regions) | |
| 645 // end condition 1: not enough space for the young regions | |
| 646 return false; | |
| 647 | |
| 648 double accum_surv_rate_adj = 0.0; | |
| 649 double accum_surv_rate = | |
| 650 accum_yg_surv_rate_pred((int)(young_length - 1)) - accum_surv_rate_adj; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
651 |
| 342 | 652 size_t bytes_to_copy = |
| 653 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
654 |
| 342 | 655 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
656 |
| 342 | 657 double young_other_time_ms = |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
658 predict_young_other_time_ms(young_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
659 |
| 342 | 660 double pause_time_ms = |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
661 base_time_ms + copy_time_ms + young_other_time_ms; |
| 342 | 662 |
| 663 if (pause_time_ms > target_pause_time_ms) | |
| 664 // end condition 2: over the target pause time | |
| 665 return false; | |
| 666 | |
| 667 size_t free_bytes = | |
| 668 (init_free_regions - young_length) * HeapRegion::GrainBytes; | |
| 669 | |
| 670 if ((2.0 + sigma()) * (double) bytes_to_copy > (double) free_bytes) | |
| 671 // end condition 3: out of to-space (conservatively) | |
| 672 return false; | |
| 673 | |
| 674 // success! | |
| 675 return true; | |
| 676 } | |
| 677 | |
| 545 | 678 double G1CollectorPolicy::predict_survivor_regions_evac_time() { |
| 679 double survivor_regions_evac_time = 0.0; | |
| 680 for (HeapRegion * r = _recorded_survivor_head; | |
| 681 r != NULL && r != _recorded_survivor_tail->get_next_young_region(); | |
| 682 r = r->get_next_young_region()) { | |
| 683 survivor_regions_evac_time += predict_region_elapsed_time_ms(r, true); | |
| 684 } | |
| 685 return survivor_regions_evac_time; | |
| 686 } | |
| 687 | |
| 342 | 688 void G1CollectorPolicy::check_prediction_validity() { |
| 689 guarantee( adaptive_young_list_length(), "should not call this otherwise" ); | |
| 690 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
691 size_t rs_lengths = _g1->young_list()->sampled_rs_lengths(); |
| 342 | 692 if (rs_lengths > _rs_lengths_prediction) { |
| 693 // add 10% to avoid having to recalculate often | |
| 694 size_t rs_lengths_prediction = rs_lengths * 1100 / 1000; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
695 calculate_young_list_target_length(rs_lengths_prediction); |
| 342 | 696 } |
| 697 } | |
| 698 | |
| 699 HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size, | |
| 700 bool is_tlab, | |
| 701 bool* gc_overhead_limit_was_exceeded) { | |
| 702 guarantee(false, "Not using this policy feature yet."); | |
| 703 return NULL; | |
| 704 } | |
| 705 | |
| 706 // This method controls how a collector handles one or more | |
| 707 // of its generations being fully allocated. | |
| 708 HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size, | |
| 709 bool is_tlab) { | |
| 710 guarantee(false, "Not using this policy feature yet."); | |
| 711 return NULL; | |
| 712 } | |
| 713 | |
| 714 | |
| 715 #ifndef PRODUCT | |
| 716 bool G1CollectorPolicy::verify_young_ages() { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
717 HeapRegion* head = _g1->young_list()->first_region(); |
| 342 | 718 return |
| 719 verify_young_ages(head, _short_lived_surv_rate_group); | |
| 720 // also call verify_young_ages on any additional surv rate groups | |
| 721 } | |
| 722 | |
| 723 bool | |
| 724 G1CollectorPolicy::verify_young_ages(HeapRegion* head, | |
| 725 SurvRateGroup *surv_rate_group) { | |
| 726 guarantee( surv_rate_group != NULL, "pre-condition" ); | |
| 727 | |
| 728 const char* name = surv_rate_group->name(); | |
| 729 bool ret = true; | |
| 730 int prev_age = -1; | |
| 731 | |
| 732 for (HeapRegion* curr = head; | |
| 733 curr != NULL; | |
| 734 curr = curr->get_next_young_region()) { | |
| 735 SurvRateGroup* group = curr->surv_rate_group(); | |
| 736 if (group == NULL && !curr->is_survivor()) { | |
| 737 gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name); | |
| 738 ret = false; | |
| 739 } | |
| 740 | |
| 741 if (surv_rate_group == group) { | |
| 742 int age = curr->age_in_surv_rate_group(); | |
| 743 | |
| 744 if (age < 0) { | |
| 745 gclog_or_tty->print_cr("## %s: encountered negative age", name); | |
| 746 ret = false; | |
| 747 } | |
| 748 | |
| 749 if (age <= prev_age) { | |
| 750 gclog_or_tty->print_cr("## %s: region ages are not strictly increasing " | |
| 751 "(%d, %d)", name, age, prev_age); | |
| 752 ret = false; | |
| 753 } | |
| 754 prev_age = age; | |
| 755 } | |
| 756 } | |
| 757 | |
| 758 return ret; | |
| 759 } | |
| 760 #endif // PRODUCT | |
| 761 | |
| 762 void G1CollectorPolicy::record_full_collection_start() { | |
| 763 _cur_collection_start_sec = os::elapsedTime(); | |
| 764 // Release the future to-space so that it is available for compaction into. | |
| 765 _g1->set_full_collection(); | |
| 766 } | |
| 767 | |
| 768 void G1CollectorPolicy::record_full_collection_end() { | |
| 769 // Consider this like a collection pause for the purposes of allocation | |
| 770 // since last pause. | |
| 771 double end_sec = os::elapsedTime(); | |
| 772 double full_gc_time_sec = end_sec - _cur_collection_start_sec; | |
| 773 double full_gc_time_ms = full_gc_time_sec * 1000.0; | |
| 774 | |
| 775 _all_full_gc_times_ms->add(full_gc_time_ms); | |
| 776 | |
|
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
777 update_recent_gc_times(end_sec, full_gc_time_ms); |
| 342 | 778 |
| 779 _g1->clear_full_collection(); | |
| 780 | |
| 781 // "Nuke" the heuristics that control the fully/partially young GC | |
| 782 // transitions and make sure we start with fully young GCs after the | |
| 783 // Full GC. | |
| 784 set_full_young_gcs(true); | |
| 785 _last_full_young_gc = false; | |
| 786 _should_revert_to_full_young_gcs = false; | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
787 clear_initiate_conc_mark_if_possible(); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
788 clear_during_initial_mark_pause(); |
| 342 | 789 _known_garbage_bytes = 0; |
| 790 _known_garbage_ratio = 0.0; | |
| 791 _in_marking_window = false; | |
| 792 _in_marking_window_im = false; | |
| 793 | |
| 794 _short_lived_surv_rate_group->start_adding_regions(); | |
| 795 // also call this on any additional surv rate groups | |
| 796 | |
| 545 | 797 record_survivor_regions(0, NULL, NULL); |
| 798 | |
| 342 | 799 _prev_region_num_young = _region_num_young; |
| 800 _prev_region_num_tenured = _region_num_tenured; | |
| 801 | |
| 802 _free_regions_at_end_of_collection = _g1->free_regions(); | |
| 545 | 803 // Reset survivors SurvRateGroup. |
| 804 _survivor_surv_rate_group->reset(); | |
| 342 | 805 calculate_young_list_min_length(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
806 calculate_young_list_target_length(); |
| 1973 | 807 } |
| 342 | 808 |
| 809 void G1CollectorPolicy::record_before_bytes(size_t bytes) { | |
| 810 _bytes_in_to_space_before_gc += bytes; | |
| 811 } | |
| 812 | |
| 813 void G1CollectorPolicy::record_after_bytes(size_t bytes) { | |
| 814 _bytes_in_to_space_after_gc += bytes; | |
| 815 } | |
| 816 | |
| 817 void G1CollectorPolicy::record_stop_world_start() { | |
| 818 _stop_world_start = os::elapsedTime(); | |
| 819 } | |
| 820 | |
| 821 void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, | |
| 822 size_t start_used) { | |
| 823 if (PrintGCDetails) { | |
| 824 gclog_or_tty->stamp(PrintGCTimeStamps); | |
| 825 gclog_or_tty->print("[GC pause"); | |
| 826 if (in_young_gc_mode()) | |
| 827 gclog_or_tty->print(" (%s)", full_young_gcs() ? "young" : "partial"); | |
| 828 } | |
| 829 | |
| 1973 | 830 assert(_g1->used() == _g1->recalculate_used(), |
| 831 err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT, | |
| 832 _g1->used(), _g1->recalculate_used())); | |
| 342 | 833 |
| 834 double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0; | |
| 835 _all_stop_world_times_ms->add(s_w_t_ms); | |
| 836 _stop_world_start = 0.0; | |
| 837 | |
| 838 _cur_collection_start_sec = start_time_sec; | |
| 839 _cur_collection_pause_used_at_start_bytes = start_used; | |
| 840 _cur_collection_pause_used_regions_at_start = _g1->used_regions(); | |
| 841 _pending_cards = _g1->pending_card_num(); | |
| 842 _max_pending_cards = _g1->max_pending_card_num(); | |
| 843 | |
| 844 _bytes_in_to_space_before_gc = 0; | |
| 845 _bytes_in_to_space_after_gc = 0; | |
| 846 _bytes_in_collection_set_before_gc = 0; | |
| 847 | |
| 848 #ifdef DEBUG | |
| 849 // initialise these to something well known so that we can spot | |
| 850 // if they are not set properly | |
| 851 | |
| 852 for (int i = 0; i < _parallel_gc_threads; ++i) { | |
| 1611 | 853 _par_last_gc_worker_start_times_ms[i] = -1234.0; |
| 854 _par_last_ext_root_scan_times_ms[i] = -1234.0; | |
| 855 _par_last_mark_stack_scan_times_ms[i] = -1234.0; | |
| 856 _par_last_update_rs_times_ms[i] = -1234.0; | |
| 857 _par_last_update_rs_processed_buffers[i] = -1234.0; | |
| 858 _par_last_scan_rs_times_ms[i] = -1234.0; | |
| 859 _par_last_obj_copy_times_ms[i] = -1234.0; | |
| 860 _par_last_termination_times_ms[i] = -1234.0; | |
| 861 _par_last_termination_attempts[i] = -1234.0; | |
| 862 _par_last_gc_worker_end_times_ms[i] = -1234.0; | |
| 342 | 863 } |
| 864 #endif | |
| 865 | |
| 866 for (int i = 0; i < _aux_num; ++i) { | |
| 867 _cur_aux_times_ms[i] = 0.0; | |
| 868 _cur_aux_times_set[i] = false; | |
| 869 } | |
| 870 | |
| 871 _satb_drain_time_set = false; | |
| 872 _last_satb_drain_processed_buffers = -1; | |
| 873 | |
| 874 if (in_young_gc_mode()) | |
| 875 _last_young_gc_full = false; | |
| 876 | |
| 877 // do that for any other surv rate groups | |
| 878 _short_lived_surv_rate_group->stop_adding_regions(); | |
| 1282 | 879 _survivors_age_table.clear(); |
| 545 | 880 |
| 342 | 881 assert( verify_young_ages(), "region age verification" ); |
| 882 } | |
| 883 | |
| 884 void G1CollectorPolicy::record_mark_closure_time(double mark_closure_time_ms) { | |
| 885 _mark_closure_time_ms = mark_closure_time_ms; | |
| 886 } | |
| 887 | |
| 888 void G1CollectorPolicy::record_concurrent_mark_init_start() { | |
| 889 _mark_init_start_sec = os::elapsedTime(); | |
| 890 guarantee(!in_young_gc_mode(), "should not do be here in young GC mode"); | |
| 891 } | |
| 892 | |
| 893 void G1CollectorPolicy::record_concurrent_mark_init_end_pre(double | |
| 894 mark_init_elapsed_time_ms) { | |
| 895 _during_marking = true; | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
896 assert(!initiate_conc_mark_if_possible(), "we should have cleared it by now"); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
897 clear_during_initial_mark_pause(); |
| 342 | 898 _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms; |
| 899 } | |
| 900 | |
| 901 void G1CollectorPolicy::record_concurrent_mark_init_end() { | |
| 902 double end_time_sec = os::elapsedTime(); | |
| 903 double elapsed_time_ms = (end_time_sec - _mark_init_start_sec) * 1000.0; | |
| 904 _concurrent_mark_init_times_ms->add(elapsed_time_ms); | |
| 905 record_concurrent_mark_init_end_pre(elapsed_time_ms); | |
| 906 | |
| 907 _mmu_tracker->add_pause(_mark_init_start_sec, end_time_sec, true); | |
| 908 } | |
| 909 | |
| 910 void G1CollectorPolicy::record_concurrent_mark_remark_start() { | |
| 911 _mark_remark_start_sec = os::elapsedTime(); | |
| 912 _during_marking = false; | |
| 913 } | |
| 914 | |
| 915 void G1CollectorPolicy::record_concurrent_mark_remark_end() { | |
| 916 double end_time_sec = os::elapsedTime(); | |
| 917 double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0; | |
| 918 _concurrent_mark_remark_times_ms->add(elapsed_time_ms); | |
| 919 _cur_mark_stop_world_time_ms += elapsed_time_ms; | |
| 920 _prev_collection_pause_end_ms += elapsed_time_ms; | |
| 921 | |
| 922 _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true); | |
| 923 } | |
| 924 | |
| 925 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() { | |
| 926 _mark_cleanup_start_sec = os::elapsedTime(); | |
| 927 } | |
| 928 | |
| 929 void | |
| 930 G1CollectorPolicy::record_concurrent_mark_cleanup_end(size_t freed_bytes, | |
| 931 size_t max_live_bytes) { | |
| 932 record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes); | |
| 933 record_concurrent_mark_cleanup_end_work2(); | |
| 934 } | |
| 935 | |
| 936 void | |
| 937 G1CollectorPolicy:: | |
| 938 record_concurrent_mark_cleanup_end_work1(size_t freed_bytes, | |
| 939 size_t max_live_bytes) { | |
| 940 if (_n_marks < 2) _n_marks++; | |
| 941 if (G1PolicyVerbose > 0) | |
| 942 gclog_or_tty->print_cr("At end of marking, max_live is " SIZE_FORMAT " MB " | |
| 943 " (of " SIZE_FORMAT " MB heap).", | |
| 944 max_live_bytes/M, _g1->capacity()/M); | |
| 945 } | |
| 946 | |
| 947 // The important thing about this is that it includes "os::elapsedTime". | |
| 948 void G1CollectorPolicy::record_concurrent_mark_cleanup_end_work2() { | |
| 949 double end_time_sec = os::elapsedTime(); | |
| 950 double elapsed_time_ms = (end_time_sec - _mark_cleanup_start_sec)*1000.0; | |
| 951 _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); | |
| 952 _cur_mark_stop_world_time_ms += elapsed_time_ms; | |
| 953 _prev_collection_pause_end_ms += elapsed_time_ms; | |
| 954 | |
| 955 _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_time_sec, true); | |
| 956 | |
| 957 _num_markings++; | |
| 958 | |
| 959 // We did a marking, so reset the "since_last_mark" variables. | |
| 960 double considerConcMarkCost = 1.0; | |
| 961 // If there are available processors, concurrent activity is free... | |
| 962 if (Threads::number_of_non_daemon_threads() * 2 < | |
| 963 os::active_processor_count()) { | |
| 964 considerConcMarkCost = 0.0; | |
| 965 } | |
| 966 _n_pauses_at_mark_end = _n_pauses; | |
| 967 _n_marks_since_last_pause++; | |
| 968 } | |
| 969 | |
| 970 void | |
| 971 G1CollectorPolicy::record_concurrent_mark_cleanup_completed() { | |
| 972 if (in_young_gc_mode()) { | |
| 973 _should_revert_to_full_young_gcs = false; | |
| 974 _last_full_young_gc = true; | |
| 975 _in_marking_window = false; | |
| 976 if (adaptive_young_list_length()) | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
977 calculate_young_list_target_length(); |
| 342 | 978 } |
| 979 } | |
| 980 | |
| 981 void G1CollectorPolicy::record_concurrent_pause() { | |
| 982 if (_stop_world_start > 0.0) { | |
| 983 double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0; | |
| 984 _all_yield_times_ms->add(yield_ms); | |
| 985 } | |
| 986 } | |
| 987 | |
| 988 void G1CollectorPolicy::record_concurrent_pause_end() { | |
| 989 } | |
| 990 | |
| 991 void G1CollectorPolicy::record_collection_pause_end_CH_strong_roots() { | |
| 992 _cur_CH_strong_roots_end_sec = os::elapsedTime(); | |
| 993 _cur_CH_strong_roots_dur_ms = | |
| 994 (_cur_CH_strong_roots_end_sec - _cur_collection_start_sec) * 1000.0; | |
| 995 } | |
| 996 | |
| 997 void G1CollectorPolicy::record_collection_pause_end_G1_strong_roots() { | |
| 998 _cur_G1_strong_roots_end_sec = os::elapsedTime(); | |
| 999 _cur_G1_strong_roots_dur_ms = | |
| 1000 (_cur_G1_strong_roots_end_sec - _cur_CH_strong_roots_end_sec) * 1000.0; | |
| 1001 } | |
| 1002 | |
| 1003 template<class T> | |
| 1004 T sum_of(T* sum_arr, int start, int n, int N) { | |
| 1005 T sum = (T)0; | |
| 1006 for (int i = 0; i < n; i++) { | |
| 1007 int j = (start + i) % N; | |
| 1008 sum += sum_arr[j]; | |
| 1009 } | |
| 1010 return sum; | |
| 1011 } | |
| 1012 | |
| 1611 | 1013 void G1CollectorPolicy::print_par_stats(int level, |
| 1014 const char* str, | |
| 1015 double* data, | |
| 342 | 1016 bool summary) { |
| 1017 double min = data[0], max = data[0]; | |
| 1018 double total = 0.0; | |
| 1019 int j; | |
| 1020 for (j = 0; j < level; ++j) | |
| 1021 gclog_or_tty->print(" "); | |
| 1022 gclog_or_tty->print("[%s (ms):", str); | |
| 1023 for (uint i = 0; i < ParallelGCThreads; ++i) { | |
| 1024 double val = data[i]; | |
| 1025 if (val < min) | |
| 1026 min = val; | |
| 1027 if (val > max) | |
| 1028 max = val; | |
| 1029 total += val; | |
| 1030 gclog_or_tty->print(" %3.1lf", val); | |
| 1031 } | |
| 1032 if (summary) { | |
| 1033 gclog_or_tty->print_cr(""); | |
| 1034 double avg = total / (double) ParallelGCThreads; | |
| 1035 gclog_or_tty->print(" "); | |
| 1036 for (j = 0; j < level; ++j) | |
| 1037 gclog_or_tty->print(" "); | |
| 1038 gclog_or_tty->print("Avg: %5.1lf, Min: %5.1lf, Max: %5.1lf", | |
| 1039 avg, min, max); | |
| 1040 } | |
| 1041 gclog_or_tty->print_cr("]"); | |
| 1042 } | |
| 1043 | |
| 1611 | 1044 void G1CollectorPolicy::print_par_sizes(int level, |
| 1045 const char* str, | |
| 1046 double* data, | |
| 1047 bool summary) { | |
| 342 | 1048 double min = data[0], max = data[0]; |
| 1049 double total = 0.0; | |
| 1050 int j; | |
| 1051 for (j = 0; j < level; ++j) | |
| 1052 gclog_or_tty->print(" "); | |
| 1053 gclog_or_tty->print("[%s :", str); | |
| 1054 for (uint i = 0; i < ParallelGCThreads; ++i) { | |
| 1055 double val = data[i]; | |
| 1056 if (val < min) | |
| 1057 min = val; | |
| 1058 if (val > max) | |
| 1059 max = val; | |
| 1060 total += val; | |
| 1061 gclog_or_tty->print(" %d", (int) val); | |
| 1062 } | |
| 1063 if (summary) { | |
| 1064 gclog_or_tty->print_cr(""); | |
| 1065 double avg = total / (double) ParallelGCThreads; | |
| 1066 gclog_or_tty->print(" "); | |
| 1067 for (j = 0; j < level; ++j) | |
| 1068 gclog_or_tty->print(" "); | |
| 1069 gclog_or_tty->print("Sum: %d, Avg: %d, Min: %d, Max: %d", | |
| 1070 (int)total, (int)avg, (int)min, (int)max); | |
| 1071 } | |
| 1072 gclog_or_tty->print_cr("]"); | |
| 1073 } | |
| 1074 | |
| 1075 void G1CollectorPolicy::print_stats (int level, | |
| 1076 const char* str, | |
| 1077 double value) { | |
| 1078 for (int j = 0; j < level; ++j) | |
| 1079 gclog_or_tty->print(" "); | |
| 1080 gclog_or_tty->print_cr("[%s: %5.1lf ms]", str, value); | |
| 1081 } | |
| 1082 | |
| 1083 void G1CollectorPolicy::print_stats (int level, | |
| 1084 const char* str, | |
| 1085 int value) { | |
| 1086 for (int j = 0; j < level; ++j) | |
| 1087 gclog_or_tty->print(" "); | |
| 1088 gclog_or_tty->print_cr("[%s: %d]", str, value); | |
| 1089 } | |
| 1090 | |
| 1091 double G1CollectorPolicy::avg_value (double* data) { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1092 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 1093 double ret = 0.0; |
| 1094 for (uint i = 0; i < ParallelGCThreads; ++i) | |
| 1095 ret += data[i]; | |
| 1096 return ret / (double) ParallelGCThreads; | |
| 1097 } else { | |
| 1098 return data[0]; | |
| 1099 } | |
| 1100 } | |
| 1101 | |
| 1102 double G1CollectorPolicy::max_value (double* data) { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1103 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 1104 double ret = data[0]; |
| 1105 for (uint i = 1; i < ParallelGCThreads; ++i) | |
| 1106 if (data[i] > ret) | |
| 1107 ret = data[i]; | |
| 1108 return ret; | |
| 1109 } else { | |
| 1110 return data[0]; | |
| 1111 } | |
| 1112 } | |
| 1113 | |
| 1114 double G1CollectorPolicy::sum_of_values (double* data) { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1115 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 1116 double sum = 0.0; |
| 1117 for (uint i = 0; i < ParallelGCThreads; i++) | |
| 1118 sum += data[i]; | |
| 1119 return sum; | |
| 1120 } else { | |
| 1121 return data[0]; | |
| 1122 } | |
| 1123 } | |
| 1124 | |
| 1125 double G1CollectorPolicy::max_sum (double* data1, | |
| 1126 double* data2) { | |
| 1127 double ret = data1[0] + data2[0]; | |
| 1128 | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1129 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 1130 for (uint i = 1; i < ParallelGCThreads; ++i) { |
| 1131 double data = data1[i] + data2[i]; | |
| 1132 if (data > ret) | |
| 1133 ret = data; | |
| 1134 } | |
| 1135 } | |
| 1136 return ret; | |
| 1137 } | |
| 1138 | |
| 1139 // Anything below that is considered to be zero | |
| 1140 #define MIN_TIMER_GRANULARITY 0.0000001 | |
| 1141 | |
| 1707 | 1142 void G1CollectorPolicy::record_collection_pause_end() { |
| 342 | 1143 double end_time_sec = os::elapsedTime(); |
| 1144 double elapsed_ms = _last_pause_time_ms; | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1145 bool parallel = G1CollectedHeap::use_parallel_gc_threads(); |
| 342 | 1146 double evac_ms = (end_time_sec - _cur_G1_strong_roots_end_sec) * 1000.0; |
| 1147 size_t rs_size = | |
| 1148 _cur_collection_pause_used_regions_at_start - collection_set_size(); | |
| 1149 size_t cur_used_bytes = _g1->used(); | |
| 1150 assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); | |
| 1151 bool last_pause_included_initial_mark = false; | |
| 1707 | 1152 bool update_stats = !_g1->evacuation_failed(); |
| 342 | 1153 |
| 1154 #ifndef PRODUCT | |
| 1155 if (G1YoungSurvRateVerbose) { | |
| 1156 gclog_or_tty->print_cr(""); | |
| 1157 _short_lived_surv_rate_group->print(); | |
| 1158 // do that for any other surv rate groups too | |
| 1159 } | |
| 1160 #endif // PRODUCT | |
| 1161 | |
| 1162 if (in_young_gc_mode()) { | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1163 last_pause_included_initial_mark = during_initial_mark_pause(); |
| 342 | 1164 if (last_pause_included_initial_mark) |
| 1165 record_concurrent_mark_init_end_pre(0.0); | |
| 1166 | |
| 1167 size_t min_used_targ = | |
|
1283
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1282
diff
changeset
|
1168 (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; |
| 342 | 1169 |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1170 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1171 if (!_g1->mark_in_progress() && !_last_full_young_gc) { |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1172 assert(!last_pause_included_initial_mark, "invariant"); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1173 if (cur_used_bytes > min_used_targ && |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1174 cur_used_bytes > _prev_collection_pause_used_at_end_bytes) { |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1175 assert(!during_initial_mark_pause(), "we should not see this here"); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1176 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1177 // Note: this might have already been set, if during the last |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1178 // pause we decided to start a cycle but at the beginning of |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1179 // this pause we decided to postpone it. That's OK. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1180 set_initiate_conc_mark_if_possible(); |
| 342 | 1181 } |
| 1182 } | |
| 1183 | |
| 1184 _prev_collection_pause_used_at_end_bytes = cur_used_bytes; | |
| 1185 } | |
| 1186 | |
| 1187 _mmu_tracker->add_pause(end_time_sec - elapsed_ms/1000.0, | |
| 1188 end_time_sec, false); | |
| 1189 | |
| 1190 guarantee(_cur_collection_pause_used_regions_at_start >= | |
| 1191 collection_set_size(), | |
| 1192 "Negative RS size?"); | |
| 1193 | |
| 1194 // This assert is exempted when we're doing parallel collection pauses, | |
| 1195 // because the fragmentation caused by the parallel GC allocation buffers | |
| 1196 // can lead to more memory being used during collection than was used | |
| 1197 // before. Best leave this out until the fragmentation problem is fixed. | |
| 1198 // Pauses in which evacuation failed can also lead to negative | |
| 1199 // collections, since no space is reclaimed from a region containing an | |
| 1200 // object whose evacuation failed. | |
| 1201 // Further, we're now always doing parallel collection. But I'm still | |
| 1202 // leaving this here as a placeholder for a more precise assertion later. | |
| 1203 // (DLD, 10/05.) | |
| 1204 assert((true || parallel) // Always using GC LABs now. | |
| 1205 || _g1->evacuation_failed() | |
| 1206 || _cur_collection_pause_used_at_start_bytes >= cur_used_bytes, | |
| 1207 "Negative collection"); | |
| 1208 | |
| 1209 size_t freed_bytes = | |
| 1210 _cur_collection_pause_used_at_start_bytes - cur_used_bytes; | |
| 1211 size_t surviving_bytes = _collection_set_bytes_used_before - freed_bytes; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1212 |
| 342 | 1213 double survival_fraction = |
| 1214 (double)surviving_bytes/ | |
| 1215 (double)_collection_set_bytes_used_before; | |
| 1216 | |
| 1217 _n_pauses++; | |
| 1218 | |
|
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
1219 if (update_stats) { |
| 342 | 1220 _recent_CH_strong_roots_times_ms->add(_cur_CH_strong_roots_dur_ms); |
| 1221 _recent_G1_strong_roots_times_ms->add(_cur_G1_strong_roots_dur_ms); | |
| 1222 _recent_evac_times_ms->add(evac_ms); | |
| 1223 _recent_pause_times_ms->add(elapsed_ms); | |
| 1224 | |
| 1225 _recent_rs_sizes->add(rs_size); | |
| 1226 | |
| 1227 // We exempt parallel collection from this check because Alloc Buffer | |
| 1228 // fragmentation can produce negative collections. Same with evac | |
| 1229 // failure. | |
| 1230 // Further, we're now always doing parallel collection. But I'm still | |
| 1231 // leaving this here as a placeholder for a more precise assertion later. | |
| 1232 // (DLD, 10/05. | |
| 1233 assert((true || parallel) | |
| 1234 || _g1->evacuation_failed() | |
| 1235 || surviving_bytes <= _collection_set_bytes_used_before, | |
| 1236 "Or else negative collection!"); | |
| 1237 _recent_CS_bytes_used_before->add(_collection_set_bytes_used_before); | |
| 1238 _recent_CS_bytes_surviving->add(surviving_bytes); | |
| 1239 | |
| 1240 // this is where we update the allocation rate of the application | |
| 1241 double app_time_ms = | |
| 1242 (_cur_collection_start_sec * 1000.0 - _prev_collection_pause_end_ms); | |
| 1243 if (app_time_ms < MIN_TIMER_GRANULARITY) { | |
| 1244 // This usually happens due to the timer not having the required | |
| 1245 // granularity. Some Linuxes are the usual culprits. | |
| 1246 // We'll just set it to something (arbitrarily) small. | |
| 1247 app_time_ms = 1.0; | |
| 1248 } | |
| 1249 size_t regions_allocated = | |
| 1250 (_region_num_young - _prev_region_num_young) + | |
| 1251 (_region_num_tenured - _prev_region_num_tenured); | |
| 1252 double alloc_rate_ms = (double) regions_allocated / app_time_ms; | |
| 1253 _alloc_rate_ms_seq->add(alloc_rate_ms); | |
| 1254 _prev_region_num_young = _region_num_young; | |
| 1255 _prev_region_num_tenured = _region_num_tenured; | |
| 1256 | |
| 1257 double interval_ms = | |
| 1258 (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0; | |
| 1259 update_recent_gc_times(end_time_sec, elapsed_ms); | |
| 1260 _recent_avg_pause_time_ratio = _recent_gc_times_ms->sum()/interval_ms; | |
|
1086
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1261 if (recent_avg_pause_time_ratio() < 0.0 || |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1262 (recent_avg_pause_time_ratio() - 1.0 > 0.0)) { |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1263 #ifndef PRODUCT |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1264 // Dump info to allow post-facto debugging |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1265 gclog_or_tty->print_cr("recent_avg_pause_time_ratio() out of bounds"); |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1266 gclog_or_tty->print_cr("-------------------------------------------"); |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1267 gclog_or_tty->print_cr("Recent GC Times (ms):"); |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1268 _recent_gc_times_ms->dump(); |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1269 gclog_or_tty->print_cr("(End Time=%3.3f) Recent GC End Times (s):", end_time_sec); |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1270 _recent_prev_end_times_for_all_gcs_sec->dump(); |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1271 gclog_or_tty->print_cr("GC = %3.3f, Interval = %3.3f, Ratio = %3.3f", |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1272 _recent_gc_times_ms->sum(), interval_ms, recent_avg_pause_time_ratio()); |
|
1087
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1273 // In debug mode, terminate the JVM if the user wants to debug at this point. |
|
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1274 assert(!G1FailOnFPError, "Debugging data for CR 6898948 has been dumped above"); |
|
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1275 #endif // !PRODUCT |
|
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1276 // Clip ratio between 0.0 and 1.0, and continue. This will be fixed in |
|
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1277 // CR 6902692 by redoing the manner in which the ratio is incrementally computed. |
|
1086
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1278 if (_recent_avg_pause_time_ratio < 0.0) { |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1279 _recent_avg_pause_time_ratio = 0.0; |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1280 } else { |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1281 assert(_recent_avg_pause_time_ratio - 1.0 > 0.0, "Ctl-point invariant"); |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1282 _recent_avg_pause_time_ratio = 1.0; |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1283 } |
|
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1284 } |
| 342 | 1285 } |
| 1286 | |
| 1287 if (G1PolicyVerbose > 1) { | |
| 1288 gclog_or_tty->print_cr(" Recording collection pause(%d)", _n_pauses); | |
| 1289 } | |
| 1290 | |
| 1707 | 1291 PauseSummary* summary = _summary; |
| 342 | 1292 |
| 1293 double ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms); | |
| 1294 double mark_stack_scan_time = avg_value(_par_last_mark_stack_scan_times_ms); | |
| 1295 double update_rs_time = avg_value(_par_last_update_rs_times_ms); | |
| 1296 double update_rs_processed_buffers = | |
| 1297 sum_of_values(_par_last_update_rs_processed_buffers); | |
| 1298 double scan_rs_time = avg_value(_par_last_scan_rs_times_ms); | |
| 1299 double obj_copy_time = avg_value(_par_last_obj_copy_times_ms); | |
| 1300 double termination_time = avg_value(_par_last_termination_times_ms); | |
| 1301 | |
|
648
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1302 double parallel_other_time = _cur_collection_par_time_ms - |
|
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1303 (update_rs_time + ext_root_scan_time + mark_stack_scan_time + |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1304 scan_rs_time + obj_copy_time + termination_time); |
|
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
1305 if (update_stats) { |
| 342 | 1306 MainBodySummary* body_summary = summary->main_body_summary(); |
| 1307 guarantee(body_summary != NULL, "should not be null!"); | |
| 1308 | |
| 1309 if (_satb_drain_time_set) | |
| 1310 body_summary->record_satb_drain_time_ms(_cur_satb_drain_time_ms); | |
| 1311 else | |
| 1312 body_summary->record_satb_drain_time_ms(0.0); | |
| 1313 body_summary->record_ext_root_scan_time_ms(ext_root_scan_time); | |
| 1314 body_summary->record_mark_stack_scan_time_ms(mark_stack_scan_time); | |
| 1315 body_summary->record_update_rs_time_ms(update_rs_time); | |
| 1316 body_summary->record_scan_rs_time_ms(scan_rs_time); | |
| 1317 body_summary->record_obj_copy_time_ms(obj_copy_time); | |
| 1318 if (parallel) { | |
| 1319 body_summary->record_parallel_time_ms(_cur_collection_par_time_ms); | |
| 1320 body_summary->record_clear_ct_time_ms(_cur_clear_ct_time_ms); | |
| 1321 body_summary->record_termination_time_ms(termination_time); | |
| 1322 body_summary->record_parallel_other_time_ms(parallel_other_time); | |
| 1323 } | |
| 1324 body_summary->record_mark_closure_time_ms(_mark_closure_time_ms); | |
| 1325 } | |
| 1326 | |
| 1327 if (G1PolicyVerbose > 1) { | |
| 1328 gclog_or_tty->print_cr(" ET: %10.6f ms (avg: %10.6f ms)\n" | |
| 1329 " CH Strong: %10.6f ms (avg: %10.6f ms)\n" | |
| 1330 " G1 Strong: %10.6f ms (avg: %10.6f ms)\n" | |
| 1331 " Evac: %10.6f ms (avg: %10.6f ms)\n" | |
| 1332 " ET-RS: %10.6f ms (avg: %10.6f ms)\n" | |
| 1333 " |RS|: " SIZE_FORMAT, | |
| 1334 elapsed_ms, recent_avg_time_for_pauses_ms(), | |
| 1335 _cur_CH_strong_roots_dur_ms, recent_avg_time_for_CH_strong_ms(), | |
| 1336 _cur_G1_strong_roots_dur_ms, recent_avg_time_for_G1_strong_ms(), | |
| 1337 evac_ms, recent_avg_time_for_evac_ms(), | |
| 1338 scan_rs_time, | |
| 1339 recent_avg_time_for_pauses_ms() - | |
| 1340 recent_avg_time_for_G1_strong_ms(), | |
| 1341 rs_size); | |
| 1342 | |
| 1343 gclog_or_tty->print_cr(" Used at start: " SIZE_FORMAT"K" | |
| 1344 " At end " SIZE_FORMAT "K\n" | |
| 1345 " garbage : " SIZE_FORMAT "K" | |
| 1346 " of " SIZE_FORMAT "K\n" | |
| 1347 " survival : %6.2f%% (%6.2f%% avg)", | |
| 1348 _cur_collection_pause_used_at_start_bytes/K, | |
| 1349 _g1->used()/K, freed_bytes/K, | |
| 1350 _collection_set_bytes_used_before/K, | |
| 1351 survival_fraction*100.0, | |
| 1352 recent_avg_survival_fraction()*100.0); | |
| 1353 gclog_or_tty->print_cr(" Recent %% gc pause time: %6.2f", | |
| 1354 recent_avg_pause_time_ratio() * 100.0); | |
| 1355 } | |
| 1356 | |
| 1357 double other_time_ms = elapsed_ms; | |
| 1358 | |
| 1707 | 1359 if (_satb_drain_time_set) { |
| 1360 other_time_ms -= _cur_satb_drain_time_ms; | |
| 1361 } | |
| 1362 | |
| 1363 if (parallel) { | |
| 1364 other_time_ms -= _cur_collection_par_time_ms + _cur_clear_ct_time_ms; | |
| 1365 } else { | |
| 1366 other_time_ms -= | |
| 1367 update_rs_time + | |
| 1368 ext_root_scan_time + mark_stack_scan_time + | |
| 1369 scan_rs_time + obj_copy_time; | |
| 342 | 1370 } |
| 1371 | |
| 1372 if (PrintGCDetails) { | |
| 1707 | 1373 gclog_or_tty->print_cr("%s, %1.8lf secs]", |
| 342 | 1374 (last_pause_included_initial_mark) ? " (initial-mark)" : "", |
| 1375 elapsed_ms / 1000.0); | |
| 1376 | |
| 1707 | 1377 if (_satb_drain_time_set) { |
| 1378 print_stats(1, "SATB Drain Time", _cur_satb_drain_time_ms); | |
| 1379 } | |
| 1380 if (_last_satb_drain_processed_buffers >= 0) { | |
| 1381 print_stats(2, "Processed Buffers", _last_satb_drain_processed_buffers); | |
| 1382 } | |
| 1383 if (parallel) { | |
| 1384 print_stats(1, "Parallel Time", _cur_collection_par_time_ms); | |
| 1385 print_par_stats(2, "GC Worker Start Time", | |
| 1386 _par_last_gc_worker_start_times_ms, false); | |
| 1387 print_par_stats(2, "Update RS", _par_last_update_rs_times_ms); | |
| 1388 print_par_sizes(3, "Processed Buffers", | |
| 1389 _par_last_update_rs_processed_buffers, true); | |
| 1390 print_par_stats(2, "Ext Root Scanning", | |
| 1391 _par_last_ext_root_scan_times_ms); | |
| 1392 print_par_stats(2, "Mark Stack Scanning", | |
| 1393 _par_last_mark_stack_scan_times_ms); | |
| 1394 print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms); | |
| 1395 print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms); | |
| 1396 print_par_stats(2, "Termination", _par_last_termination_times_ms); | |
| 1397 print_par_sizes(3, "Termination Attempts", | |
| 1398 _par_last_termination_attempts, true); | |
| 1399 print_par_stats(2, "GC Worker End Time", | |
| 1400 _par_last_gc_worker_end_times_ms, false); | |
| 1401 print_stats(2, "Other", parallel_other_time); | |
| 1402 print_stats(1, "Clear CT", _cur_clear_ct_time_ms); | |
| 1403 } else { | |
| 1404 print_stats(1, "Update RS", update_rs_time); | |
| 1405 print_stats(2, "Processed Buffers", | |
| 1406 (int)update_rs_processed_buffers); | |
| 1407 print_stats(1, "Ext Root Scanning", ext_root_scan_time); | |
| 1408 print_stats(1, "Mark Stack Scanning", mark_stack_scan_time); | |
| 1409 print_stats(1, "Scan RS", scan_rs_time); | |
| 1410 print_stats(1, "Object Copying", obj_copy_time); | |
| 342 | 1411 } |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1412 #ifndef PRODUCT |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1413 print_stats(1, "Cur Clear CC", _cur_clear_cc_time_ms); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1414 print_stats(1, "Cum Clear CC", _cum_clear_cc_time_ms); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1415 print_stats(1, "Min Clear CC", _min_clear_cc_time_ms); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1416 print_stats(1, "Max Clear CC", _max_clear_cc_time_ms); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1417 if (_num_cc_clears > 0) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1418 print_stats(1, "Avg Clear CC", _cum_clear_cc_time_ms / ((double)_num_cc_clears)); |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1419 } |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1420 #endif |
| 342 | 1421 print_stats(1, "Other", other_time_ms); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1422 print_stats(2, "Choose CSet", _recorded_young_cset_choice_time_ms); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1423 |
| 342 | 1424 for (int i = 0; i < _aux_num; ++i) { |
| 1425 if (_cur_aux_times_set[i]) { | |
| 1426 char buffer[96]; | |
| 1427 sprintf(buffer, "Aux%d", i); | |
| 1428 print_stats(1, buffer, _cur_aux_times_ms[i]); | |
| 1429 } | |
| 1430 } | |
| 1431 } | |
| 1432 if (PrintGCDetails) | |
| 1433 gclog_or_tty->print(" ["); | |
| 1434 if (PrintGC || PrintGCDetails) | |
| 1435 _g1->print_size_transition(gclog_or_tty, | |
| 1436 _cur_collection_pause_used_at_start_bytes, | |
| 1437 _g1->used(), _g1->capacity()); | |
| 1438 if (PrintGCDetails) | |
| 1439 gclog_or_tty->print_cr("]"); | |
| 1440 | |
| 1441 _all_pause_times_ms->add(elapsed_ms); | |
|
648
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1442 if (update_stats) { |
|
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1443 summary->record_total_time_ms(elapsed_ms); |
|
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1444 summary->record_other_time_ms(other_time_ms); |
|
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1445 } |
| 342 | 1446 for (int i = 0; i < _aux_num; ++i) |
| 1447 if (_cur_aux_times_set[i]) | |
| 1448 _all_aux_times_ms[i].add(_cur_aux_times_ms[i]); | |
| 1449 | |
| 1450 // Reset marks-between-pauses counter. | |
| 1451 _n_marks_since_last_pause = 0; | |
| 1452 | |
| 1453 // Update the efficiency-since-mark vars. | |
| 1454 double proc_ms = elapsed_ms * (double) _parallel_gc_threads; | |
| 1455 if (elapsed_ms < MIN_TIMER_GRANULARITY) { | |
| 1456 // This usually happens due to the timer not having the required | |
| 1457 // granularity. Some Linuxes are the usual culprits. | |
| 1458 // We'll just set it to something (arbitrarily) small. | |
| 1459 proc_ms = 1.0; | |
| 1460 } | |
| 1461 double cur_efficiency = (double) freed_bytes / proc_ms; | |
| 1462 | |
| 1463 bool new_in_marking_window = _in_marking_window; | |
| 1464 bool new_in_marking_window_im = false; | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1465 if (during_initial_mark_pause()) { |
| 342 | 1466 new_in_marking_window = true; |
| 1467 new_in_marking_window_im = true; | |
| 1468 } | |
| 1469 | |
| 1470 if (in_young_gc_mode()) { | |
| 1471 if (_last_full_young_gc) { | |
| 1472 set_full_young_gcs(false); | |
| 1473 _last_full_young_gc = false; | |
| 1474 } | |
| 1475 | |
| 1476 if ( !_last_young_gc_full ) { | |
| 1477 if ( _should_revert_to_full_young_gcs || | |
| 1478 _known_garbage_ratio < 0.05 || | |
| 1479 (adaptive_young_list_length() && | |
| 1480 (get_gc_eff_factor() * cur_efficiency < predict_young_gc_eff())) ) { | |
| 1481 set_full_young_gcs(true); | |
| 1482 } | |
| 1483 } | |
| 1484 _should_revert_to_full_young_gcs = false; | |
| 1485 | |
| 1486 if (_last_young_gc_full && !_during_marking) | |
| 1487 _young_gc_eff_seq->add(cur_efficiency); | |
| 1488 } | |
| 1489 | |
| 1490 _short_lived_surv_rate_group->start_adding_regions(); | |
| 1491 // do that for any other surv rate groupsx | |
| 1492 | |
| 1493 // <NEW PREDICTION> | |
| 1494 | |
| 677 | 1495 if (update_stats) { |
| 342 | 1496 double pause_time_ms = elapsed_ms; |
| 1497 | |
| 1498 size_t diff = 0; | |
| 1499 if (_max_pending_cards >= _pending_cards) | |
| 1500 diff = _max_pending_cards - _pending_cards; | |
| 1501 _pending_card_diff_seq->add((double) diff); | |
| 1502 | |
| 1503 double cost_per_card_ms = 0.0; | |
| 1504 if (_pending_cards > 0) { | |
| 1505 cost_per_card_ms = update_rs_time / (double) _pending_cards; | |
| 1506 _cost_per_card_ms_seq->add(cost_per_card_ms); | |
| 1507 } | |
| 1508 | |
| 1509 size_t cards_scanned = _g1->cards_scanned(); | |
| 1510 | |
| 1511 double cost_per_entry_ms = 0.0; | |
| 1512 if (cards_scanned > 10) { | |
| 1513 cost_per_entry_ms = scan_rs_time / (double) cards_scanned; | |
| 1514 if (_last_young_gc_full) | |
| 1515 _cost_per_entry_ms_seq->add(cost_per_entry_ms); | |
| 1516 else | |
| 1517 _partially_young_cost_per_entry_ms_seq->add(cost_per_entry_ms); | |
| 1518 } | |
| 1519 | |
| 1520 if (_max_rs_lengths > 0) { | |
| 1521 double cards_per_entry_ratio = | |
| 1522 (double) cards_scanned / (double) _max_rs_lengths; | |
| 1523 if (_last_young_gc_full) | |
| 1524 _fully_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); | |
| 1525 else | |
| 1526 _partially_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); | |
| 1527 } | |
| 1528 | |
| 1529 size_t rs_length_diff = _max_rs_lengths - _recorded_rs_lengths; | |
| 1530 if (rs_length_diff >= 0) | |
| 1531 _rs_length_diff_seq->add((double) rs_length_diff); | |
| 1532 | |
| 1533 size_t copied_bytes = surviving_bytes; | |
| 1534 double cost_per_byte_ms = 0.0; | |
| 1535 if (copied_bytes > 0) { | |
| 1536 cost_per_byte_ms = obj_copy_time / (double) copied_bytes; | |
| 1537 if (_in_marking_window) | |
| 1538 _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms); | |
| 1539 else | |
| 1540 _cost_per_byte_ms_seq->add(cost_per_byte_ms); | |
| 1541 } | |
| 1542 | |
| 1543 double all_other_time_ms = pause_time_ms - | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1544 (update_rs_time + scan_rs_time + obj_copy_time + |
| 342 | 1545 _mark_closure_time_ms + termination_time); |
| 1546 | |
| 1547 double young_other_time_ms = 0.0; | |
| 1548 if (_recorded_young_regions > 0) { | |
| 1549 young_other_time_ms = | |
| 1550 _recorded_young_cset_choice_time_ms + | |
| 1551 _recorded_young_free_cset_time_ms; | |
| 1552 _young_other_cost_per_region_ms_seq->add(young_other_time_ms / | |
| 1553 (double) _recorded_young_regions); | |
| 1554 } | |
| 1555 double non_young_other_time_ms = 0.0; | |
| 1556 if (_recorded_non_young_regions > 0) { | |
| 1557 non_young_other_time_ms = | |
| 1558 _recorded_non_young_cset_choice_time_ms + | |
| 1559 _recorded_non_young_free_cset_time_ms; | |
| 1560 | |
| 1561 _non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms / | |
| 1562 (double) _recorded_non_young_regions); | |
| 1563 } | |
| 1564 | |
| 1565 double constant_other_time_ms = all_other_time_ms - | |
| 1566 (young_other_time_ms + non_young_other_time_ms); | |
| 1567 _constant_other_time_ms_seq->add(constant_other_time_ms); | |
| 1568 | |
| 1569 double survival_ratio = 0.0; | |
| 1570 if (_bytes_in_collection_set_before_gc > 0) { | |
| 1571 survival_ratio = (double) bytes_in_to_space_during_gc() / | |
| 1572 (double) _bytes_in_collection_set_before_gc; | |
| 1573 } | |
| 1574 | |
| 1575 _pending_cards_seq->add((double) _pending_cards); | |
| 1576 _scanned_cards_seq->add((double) cards_scanned); | |
| 1577 _rs_lengths_seq->add((double) _max_rs_lengths); | |
| 1578 | |
| 1579 double expensive_region_limit_ms = | |
| 751 | 1580 (double) MaxGCPauseMillis - predict_constant_other_time_ms(); |
| 342 | 1581 if (expensive_region_limit_ms < 0.0) { |
| 1582 // this means that the other time was predicted to be longer than | |
| 1583 // than the max pause time | |
| 751 | 1584 expensive_region_limit_ms = (double) MaxGCPauseMillis; |
| 342 | 1585 } |
| 1586 _expensive_region_limit_ms = expensive_region_limit_ms; | |
| 1587 | |
| 1588 if (PREDICTIONS_VERBOSE) { | |
| 1589 gclog_or_tty->print_cr(""); | |
| 1590 gclog_or_tty->print_cr("PREDICTIONS %1.4lf %d " | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1591 "REGIONS %d %d %d " |
| 342 | 1592 "PENDING_CARDS %d %d " |
| 1593 "CARDS_SCANNED %d %d " | |
| 1594 "RS_LENGTHS %d %d " | |
| 1595 "RS_UPDATE %1.6lf %1.6lf RS_SCAN %1.6lf %1.6lf " | |
| 1596 "SURVIVAL_RATIO %1.6lf %1.6lf " | |
| 1597 "OBJECT_COPY %1.6lf %1.6lf OTHER_CONSTANT %1.6lf %1.6lf " | |
| 1598 "OTHER_YOUNG %1.6lf %1.6lf " | |
| 1599 "OTHER_NON_YOUNG %1.6lf %1.6lf " | |
| 1600 "VTIME_DIFF %1.6lf TERMINATION %1.6lf " | |
| 1601 "ELAPSED %1.6lf %1.6lf ", | |
| 1602 _cur_collection_start_sec, | |
| 1603 (!_last_young_gc_full) ? 2 : | |
| 1604 (last_pause_included_initial_mark) ? 1 : 0, | |
| 1605 _recorded_region_num, | |
| 1606 _recorded_young_regions, | |
| 1607 _recorded_non_young_regions, | |
| 1608 _predicted_pending_cards, _pending_cards, | |
| 1609 _predicted_cards_scanned, cards_scanned, | |
| 1610 _predicted_rs_lengths, _max_rs_lengths, | |
| 1611 _predicted_rs_update_time_ms, update_rs_time, | |
| 1612 _predicted_rs_scan_time_ms, scan_rs_time, | |
| 1613 _predicted_survival_ratio, survival_ratio, | |
| 1614 _predicted_object_copy_time_ms, obj_copy_time, | |
| 1615 _predicted_constant_other_time_ms, constant_other_time_ms, | |
| 1616 _predicted_young_other_time_ms, young_other_time_ms, | |
| 1617 _predicted_non_young_other_time_ms, | |
| 1618 non_young_other_time_ms, | |
| 1619 _vtime_diff_ms, termination_time, | |
| 1620 _predicted_pause_time_ms, elapsed_ms); | |
| 1621 } | |
| 1622 | |
| 1623 if (G1PolicyVerbose > 0) { | |
| 1624 gclog_or_tty->print_cr("Pause Time, predicted: %1.4lfms (predicted %s), actual: %1.4lfms", | |
| 1625 _predicted_pause_time_ms, | |
| 1626 (_within_target) ? "within" : "outside", | |
| 1627 elapsed_ms); | |
| 1628 } | |
| 1629 | |
| 1630 } | |
| 1631 | |
| 1632 _in_marking_window = new_in_marking_window; | |
| 1633 _in_marking_window_im = new_in_marking_window_im; | |
| 1634 _free_regions_at_end_of_collection = _g1->free_regions(); | |
| 1635 calculate_young_list_min_length(); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1636 calculate_young_list_target_length(); |
| 342 | 1637 |
| 1111 | 1638 // Note that _mmu_tracker->max_gc_time() returns the time in seconds. |
| 1282 | 1639 double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; |
| 1111 | 1640 adjust_concurrent_refinement(update_rs_time, update_rs_processed_buffers, update_rs_time_goal_ms); |
| 342 | 1641 // </NEW PREDICTION> |
| 1642 } | |
| 1643 | |
| 1644 // <NEW PREDICTION> | |
| 1645 | |
| 1111 | 1646 void G1CollectorPolicy::adjust_concurrent_refinement(double update_rs_time, |
| 1647 double update_rs_processed_buffers, | |
| 1648 double goal_ms) { | |
| 1649 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 1650 ConcurrentG1Refine *cg1r = G1CollectedHeap::heap()->concurrent_g1_refine(); | |
| 1651 | |
| 1282 | 1652 if (G1UseAdaptiveConcRefinement) { |
| 1111 | 1653 const int k_gy = 3, k_gr = 6; |
| 1654 const double inc_k = 1.1, dec_k = 0.9; | |
| 1655 | |
| 1656 int g = cg1r->green_zone(); | |
| 1657 if (update_rs_time > goal_ms) { | |
| 1658 g = (int)(g * dec_k); // Can become 0, that's OK. That would mean a mutator-only processing. | |
| 1659 } else { | |
| 1660 if (update_rs_time < goal_ms && update_rs_processed_buffers > g) { | |
| 1661 g = (int)MAX2(g * inc_k, g + 1.0); | |
| 1662 } | |
| 1663 } | |
| 1664 // Change the refinement threads params | |
| 1665 cg1r->set_green_zone(g); | |
| 1666 cg1r->set_yellow_zone(g * k_gy); | |
| 1667 cg1r->set_red_zone(g * k_gr); | |
| 1668 cg1r->reinitialize_threads(); | |
| 1669 | |
| 1670 int processing_threshold_delta = MAX2((int)(cg1r->green_zone() * sigma()), 1); | |
| 1671 int processing_threshold = MIN2(cg1r->green_zone() + processing_threshold_delta, | |
| 1672 cg1r->yellow_zone()); | |
| 1673 // Change the barrier params | |
| 1674 dcqs.set_process_completed_threshold(processing_threshold); | |
| 1675 dcqs.set_max_completed_queue(cg1r->red_zone()); | |
| 1676 } | |
| 1677 | |
| 1678 int curr_queue_size = dcqs.completed_buffers_num(); | |
| 1679 if (curr_queue_size >= cg1r->yellow_zone()) { | |
| 1680 dcqs.set_completed_queue_padding(curr_queue_size); | |
| 1681 } else { | |
| 1682 dcqs.set_completed_queue_padding(0); | |
| 1683 } | |
| 1684 dcqs.notify_if_necessary(); | |
| 1685 } | |
| 1686 | |
| 342 | 1687 double |
| 1688 G1CollectorPolicy:: | |
| 1689 predict_young_collection_elapsed_time_ms(size_t adjustment) { | |
| 1690 guarantee( adjustment == 0 || adjustment == 1, "invariant" ); | |
| 1691 | |
| 1692 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1693 size_t young_num = g1h->young_list()->length(); |
| 342 | 1694 if (young_num == 0) |
| 1695 return 0.0; | |
| 1696 | |
| 1697 young_num += adjustment; | |
| 1698 size_t pending_cards = predict_pending_cards(); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1699 size_t rs_lengths = g1h->young_list()->sampled_rs_lengths() + |
| 342 | 1700 predict_rs_length_diff(); |
| 1701 size_t card_num; | |
| 1702 if (full_young_gcs()) | |
| 1703 card_num = predict_young_card_num(rs_lengths); | |
| 1704 else | |
| 1705 card_num = predict_non_young_card_num(rs_lengths); | |
| 1706 size_t young_byte_size = young_num * HeapRegion::GrainBytes; | |
| 1707 double accum_yg_surv_rate = | |
| 1708 _short_lived_surv_rate_group->accum_surv_rate(adjustment); | |
| 1709 | |
| 1710 size_t bytes_to_copy = | |
| 1711 (size_t) (accum_yg_surv_rate * (double) HeapRegion::GrainBytes); | |
| 1712 | |
| 1713 return | |
| 1714 predict_rs_update_time_ms(pending_cards) + | |
| 1715 predict_rs_scan_time_ms(card_num) + | |
| 1716 predict_object_copy_time_ms(bytes_to_copy) + | |
| 1717 predict_young_other_time_ms(young_num) + | |
| 1718 predict_constant_other_time_ms(); | |
| 1719 } | |
| 1720 | |
| 1721 double | |
| 1722 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) { | |
| 1723 size_t rs_length = predict_rs_length_diff(); | |
| 1724 size_t card_num; | |
| 1725 if (full_young_gcs()) | |
| 1726 card_num = predict_young_card_num(rs_length); | |
| 1727 else | |
| 1728 card_num = predict_non_young_card_num(rs_length); | |
| 1729 return predict_base_elapsed_time_ms(pending_cards, card_num); | |
| 1730 } | |
| 1731 | |
| 1732 double | |
| 1733 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards, | |
| 1734 size_t scanned_cards) { | |
| 1735 return | |
| 1736 predict_rs_update_time_ms(pending_cards) + | |
| 1737 predict_rs_scan_time_ms(scanned_cards) + | |
| 1738 predict_constant_other_time_ms(); | |
| 1739 } | |
| 1740 | |
| 1741 double | |
| 1742 G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr, | |
| 1743 bool young) { | |
| 1744 size_t rs_length = hr->rem_set()->occupied(); | |
| 1745 size_t card_num; | |
| 1746 if (full_young_gcs()) | |
| 1747 card_num = predict_young_card_num(rs_length); | |
| 1748 else | |
| 1749 card_num = predict_non_young_card_num(rs_length); | |
| 1750 size_t bytes_to_copy = predict_bytes_to_copy(hr); | |
| 1751 | |
| 1752 double region_elapsed_time_ms = | |
| 1753 predict_rs_scan_time_ms(card_num) + | |
| 1754 predict_object_copy_time_ms(bytes_to_copy); | |
| 1755 | |
| 1756 if (young) | |
| 1757 region_elapsed_time_ms += predict_young_other_time_ms(1); | |
| 1758 else | |
| 1759 region_elapsed_time_ms += predict_non_young_other_time_ms(1); | |
| 1760 | |
| 1761 return region_elapsed_time_ms; | |
| 1762 } | |
| 1763 | |
| 1764 size_t | |
| 1765 G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) { | |
| 1766 size_t bytes_to_copy; | |
| 1767 if (hr->is_marked()) | |
| 1768 bytes_to_copy = hr->max_live_bytes(); | |
| 1769 else { | |
| 1770 guarantee( hr->is_young() && hr->age_in_surv_rate_group() != -1, | |
| 1771 "invariant" ); | |
| 1772 int age = hr->age_in_surv_rate_group(); | |
| 545 | 1773 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group()); |
| 342 | 1774 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate); |
| 1775 } | |
| 1776 | |
| 1777 return bytes_to_copy; | |
| 1778 } | |
| 1779 | |
| 1780 void | |
| 1781 G1CollectorPolicy::start_recording_regions() { | |
| 1782 _recorded_rs_lengths = 0; | |
| 1783 _recorded_young_regions = 0; | |
| 1784 _recorded_non_young_regions = 0; | |
| 1785 | |
| 1786 #if PREDICTIONS_VERBOSE | |
| 1787 _recorded_marked_bytes = 0; | |
| 1788 _recorded_young_bytes = 0; | |
| 1789 _predicted_bytes_to_copy = 0; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1790 _predicted_rs_lengths = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1791 _predicted_cards_scanned = 0; |
| 342 | 1792 #endif // PREDICTIONS_VERBOSE |
| 1793 } | |
| 1794 | |
| 1795 void | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1796 G1CollectorPolicy::record_cset_region_info(HeapRegion* hr, bool young) { |
| 342 | 1797 #if PREDICTIONS_VERBOSE |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1798 if (!young) { |
| 342 | 1799 _recorded_marked_bytes += hr->max_live_bytes(); |
| 1800 } | |
| 1801 _predicted_bytes_to_copy += predict_bytes_to_copy(hr); | |
| 1802 #endif // PREDICTIONS_VERBOSE | |
| 1803 | |
| 1804 size_t rs_length = hr->rem_set()->occupied(); | |
| 1805 _recorded_rs_lengths += rs_length; | |
| 1806 } | |
| 1807 | |
| 1808 void | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1809 G1CollectorPolicy::record_non_young_cset_region(HeapRegion* hr) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1810 assert(!hr->is_young(), "should not call this"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1811 ++_recorded_non_young_regions; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1812 record_cset_region_info(hr, false); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1813 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1814 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1815 void |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1816 G1CollectorPolicy::set_recorded_young_regions(size_t n_regions) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1817 _recorded_young_regions = n_regions; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1818 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1819 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1820 void G1CollectorPolicy::set_recorded_young_bytes(size_t bytes) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1821 #if PREDICTIONS_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1822 _recorded_young_bytes = bytes; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1823 #endif // PREDICTIONS_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1824 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1825 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1826 void G1CollectorPolicy::set_recorded_rs_lengths(size_t rs_lengths) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1827 _recorded_rs_lengths = rs_lengths; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1828 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1829 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1830 void G1CollectorPolicy::set_predicted_bytes_to_copy(size_t bytes) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1831 _predicted_bytes_to_copy = bytes; |
| 342 | 1832 } |
| 1833 | |
| 1834 void | |
| 1835 G1CollectorPolicy::end_recording_regions() { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1836 // The _predicted_pause_time_ms field is referenced in code |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1837 // not under PREDICTIONS_VERBOSE. Let's initialize it. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1838 _predicted_pause_time_ms = -1.0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1839 |
| 342 | 1840 #if PREDICTIONS_VERBOSE |
| 1841 _predicted_pending_cards = predict_pending_cards(); | |
| 1842 _predicted_rs_lengths = _recorded_rs_lengths + predict_rs_length_diff(); | |
| 1843 if (full_young_gcs()) | |
| 1844 _predicted_cards_scanned += predict_young_card_num(_predicted_rs_lengths); | |
| 1845 else | |
| 1846 _predicted_cards_scanned += | |
| 1847 predict_non_young_card_num(_predicted_rs_lengths); | |
| 1848 _recorded_region_num = _recorded_young_regions + _recorded_non_young_regions; | |
| 1849 | |
| 1850 _predicted_rs_update_time_ms = | |
| 1851 predict_rs_update_time_ms(_g1->pending_card_num()); | |
| 1852 _predicted_rs_scan_time_ms = | |
| 1853 predict_rs_scan_time_ms(_predicted_cards_scanned); | |
| 1854 _predicted_object_copy_time_ms = | |
| 1855 predict_object_copy_time_ms(_predicted_bytes_to_copy); | |
| 1856 _predicted_constant_other_time_ms = | |
| 1857 predict_constant_other_time_ms(); | |
| 1858 _predicted_young_other_time_ms = | |
| 1859 predict_young_other_time_ms(_recorded_young_regions); | |
| 1860 _predicted_non_young_other_time_ms = | |
| 1861 predict_non_young_other_time_ms(_recorded_non_young_regions); | |
| 1862 | |
| 1863 _predicted_pause_time_ms = | |
| 1864 _predicted_rs_update_time_ms + | |
| 1865 _predicted_rs_scan_time_ms + | |
| 1866 _predicted_object_copy_time_ms + | |
| 1867 _predicted_constant_other_time_ms + | |
| 1868 _predicted_young_other_time_ms + | |
| 1869 _predicted_non_young_other_time_ms; | |
| 1870 #endif // PREDICTIONS_VERBOSE | |
| 1871 } | |
| 1872 | |
| 1873 void G1CollectorPolicy::check_if_region_is_too_expensive(double | |
| 1874 predicted_time_ms) { | |
| 1875 // I don't think we need to do this when in young GC mode since | |
| 1876 // marking will be initiated next time we hit the soft limit anyway... | |
| 1877 if (predicted_time_ms > _expensive_region_limit_ms) { | |
| 1878 if (!in_young_gc_mode()) { | |
| 1879 set_full_young_gcs(true); | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1880 // We might want to do something different here. However, |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1881 // right now we don't support the non-generational G1 mode |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1882 // (and in fact we are planning to remove the associated code, |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1883 // see CR 6814390). So, let's leave it as is and this will be |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1884 // removed some time in the future |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1885 ShouldNotReachHere(); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1886 set_during_initial_mark_pause(); |
| 342 | 1887 } else |
| 1888 // no point in doing another partial one | |
| 1889 _should_revert_to_full_young_gcs = true; | |
| 1890 } | |
| 1891 } | |
| 1892 | |
| 1893 // </NEW PREDICTION> | |
| 1894 | |
| 1895 | |
| 1896 void G1CollectorPolicy::update_recent_gc_times(double end_time_sec, | |
| 1897 double elapsed_ms) { | |
| 1898 _recent_gc_times_ms->add(elapsed_ms); | |
| 1899 _recent_prev_end_times_for_all_gcs_sec->add(end_time_sec); | |
| 1900 _prev_collection_pause_end_ms = end_time_sec * 1000.0; | |
| 1901 } | |
| 1902 | |
| 1903 double G1CollectorPolicy::recent_avg_time_for_pauses_ms() { | |
| 751 | 1904 if (_recent_pause_times_ms->num() == 0) return (double) MaxGCPauseMillis; |
| 342 | 1905 else return _recent_pause_times_ms->avg(); |
| 1906 } | |
| 1907 | |
| 1908 double G1CollectorPolicy::recent_avg_time_for_CH_strong_ms() { | |
| 1909 if (_recent_CH_strong_roots_times_ms->num() == 0) | |
| 751 | 1910 return (double)MaxGCPauseMillis/3.0; |
| 342 | 1911 else return _recent_CH_strong_roots_times_ms->avg(); |
| 1912 } | |
| 1913 | |
| 1914 double G1CollectorPolicy::recent_avg_time_for_G1_strong_ms() { | |
| 1915 if (_recent_G1_strong_roots_times_ms->num() == 0) | |
| 751 | 1916 return (double)MaxGCPauseMillis/3.0; |
| 342 | 1917 else return _recent_G1_strong_roots_times_ms->avg(); |
| 1918 } | |
| 1919 | |
| 1920 double G1CollectorPolicy::recent_avg_time_for_evac_ms() { | |
| 751 | 1921 if (_recent_evac_times_ms->num() == 0) return (double)MaxGCPauseMillis/3.0; |
| 342 | 1922 else return _recent_evac_times_ms->avg(); |
| 1923 } | |
| 1924 | |
| 1925 int G1CollectorPolicy::number_of_recent_gcs() { | |
| 1926 assert(_recent_CH_strong_roots_times_ms->num() == | |
| 1927 _recent_G1_strong_roots_times_ms->num(), "Sequence out of sync"); | |
| 1928 assert(_recent_G1_strong_roots_times_ms->num() == | |
| 1929 _recent_evac_times_ms->num(), "Sequence out of sync"); | |
| 1930 assert(_recent_evac_times_ms->num() == | |
| 1931 _recent_pause_times_ms->num(), "Sequence out of sync"); | |
| 1932 assert(_recent_pause_times_ms->num() == | |
| 1933 _recent_CS_bytes_used_before->num(), "Sequence out of sync"); | |
| 1934 assert(_recent_CS_bytes_used_before->num() == | |
| 1935 _recent_CS_bytes_surviving->num(), "Sequence out of sync"); | |
| 1936 return _recent_pause_times_ms->num(); | |
| 1937 } | |
| 1938 | |
| 1939 double G1CollectorPolicy::recent_avg_survival_fraction() { | |
| 1940 return recent_avg_survival_fraction_work(_recent_CS_bytes_surviving, | |
| 1941 _recent_CS_bytes_used_before); | |
| 1942 } | |
| 1943 | |
| 1944 double G1CollectorPolicy::last_survival_fraction() { | |
| 1945 return last_survival_fraction_work(_recent_CS_bytes_surviving, | |
| 1946 _recent_CS_bytes_used_before); | |
| 1947 } | |
| 1948 | |
| 1949 double | |
| 1950 G1CollectorPolicy::recent_avg_survival_fraction_work(TruncatedSeq* surviving, | |
| 1951 TruncatedSeq* before) { | |
| 1952 assert(surviving->num() == before->num(), "Sequence out of sync"); | |
| 1953 if (before->sum() > 0.0) { | |
| 1954 double recent_survival_rate = surviving->sum() / before->sum(); | |
| 1955 // We exempt parallel collection from this check because Alloc Buffer | |
| 1956 // fragmentation can produce negative collections. | |
| 1957 // Further, we're now always doing parallel collection. But I'm still | |
| 1958 // leaving this here as a placeholder for a more precise assertion later. | |
| 1959 // (DLD, 10/05.) | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1960 assert((true || G1CollectedHeap::use_parallel_gc_threads()) || |
| 342 | 1961 _g1->evacuation_failed() || |
| 1962 recent_survival_rate <= 1.0, "Or bad frac"); | |
| 1963 return recent_survival_rate; | |
| 1964 } else { | |
| 1965 return 1.0; // Be conservative. | |
| 1966 } | |
| 1967 } | |
| 1968 | |
| 1969 double | |
| 1970 G1CollectorPolicy::last_survival_fraction_work(TruncatedSeq* surviving, | |
| 1971 TruncatedSeq* before) { | |
| 1972 assert(surviving->num() == before->num(), "Sequence out of sync"); | |
| 1973 if (surviving->num() > 0 && before->last() > 0.0) { | |
| 1974 double last_survival_rate = surviving->last() / before->last(); | |
| 1975 // We exempt parallel collection from this check because Alloc Buffer | |
| 1976 // fragmentation can produce negative collections. | |
| 1977 // Further, we're now always doing parallel collection. But I'm still | |
| 1978 // leaving this here as a placeholder for a more precise assertion later. | |
| 1979 // (DLD, 10/05.) | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1980 assert((true || G1CollectedHeap::use_parallel_gc_threads()) || |
| 342 | 1981 last_survival_rate <= 1.0, "Or bad frac"); |
| 1982 return last_survival_rate; | |
| 1983 } else { | |
| 1984 return 1.0; | |
| 1985 } | |
| 1986 } | |
| 1987 | |
| 1988 static const int survival_min_obs = 5; | |
| 1989 static double survival_min_obs_limits[] = { 0.9, 0.7, 0.5, 0.3, 0.1 }; | |
| 1990 static const double min_survival_rate = 0.1; | |
| 1991 | |
| 1992 double | |
| 1993 G1CollectorPolicy::conservative_avg_survival_fraction_work(double avg, | |
| 1994 double latest) { | |
| 1995 double res = avg; | |
| 1996 if (number_of_recent_gcs() < survival_min_obs) { | |
| 1997 res = MAX2(res, survival_min_obs_limits[number_of_recent_gcs()]); | |
| 1998 } | |
| 1999 res = MAX2(res, latest); | |
| 2000 res = MAX2(res, min_survival_rate); | |
| 2001 // In the parallel case, LAB fragmentation can produce "negative | |
| 2002 // collections"; so can evac failure. Cap at 1.0 | |
| 2003 res = MIN2(res, 1.0); | |
| 2004 return res; | |
| 2005 } | |
| 2006 | |
| 2007 size_t G1CollectorPolicy::expansion_amount() { | |
| 1356 | 2008 if ((recent_avg_pause_time_ratio() * 100.0) > _gc_overhead_perc) { |
| 751 | 2009 // We will double the existing space, or take |
| 2010 // G1ExpandByPercentOfAvailable % of the available expansion | |
| 2011 // space, whichever is smaller, bounded below by a minimum | |
| 2012 // expansion (unless that's all that's left.) | |
| 342 | 2013 const size_t min_expand_bytes = 1*M; |
| 2014 size_t reserved_bytes = _g1->g1_reserved_obj_bytes(); | |
| 2015 size_t committed_bytes = _g1->capacity(); | |
| 2016 size_t uncommitted_bytes = reserved_bytes - committed_bytes; | |
| 2017 size_t expand_bytes; | |
| 2018 size_t expand_bytes_via_pct = | |
| 751 | 2019 uncommitted_bytes * G1ExpandByPercentOfAvailable / 100; |
| 342 | 2020 expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes); |
| 2021 expand_bytes = MAX2(expand_bytes, min_expand_bytes); | |
| 2022 expand_bytes = MIN2(expand_bytes, uncommitted_bytes); | |
| 2023 if (G1PolicyVerbose > 1) { | |
| 2024 gclog_or_tty->print("Decided to expand: ratio = %5.2f, " | |
| 2025 "committed = %d%s, uncommited = %d%s, via pct = %d%s.\n" | |
| 2026 " Answer = %d.\n", | |
| 2027 recent_avg_pause_time_ratio(), | |
| 2028 byte_size_in_proper_unit(committed_bytes), | |
| 2029 proper_unit_for_byte_size(committed_bytes), | |
| 2030 byte_size_in_proper_unit(uncommitted_bytes), | |
| 2031 proper_unit_for_byte_size(uncommitted_bytes), | |
| 2032 byte_size_in_proper_unit(expand_bytes_via_pct), | |
| 2033 proper_unit_for_byte_size(expand_bytes_via_pct), | |
| 2034 byte_size_in_proper_unit(expand_bytes), | |
| 2035 proper_unit_for_byte_size(expand_bytes)); | |
| 2036 } | |
| 2037 return expand_bytes; | |
| 2038 } else { | |
| 2039 return 0; | |
| 2040 } | |
| 2041 } | |
| 2042 | |
| 2043 void G1CollectorPolicy::note_start_of_mark_thread() { | |
| 2044 _mark_thread_startup_sec = os::elapsedTime(); | |
| 2045 } | |
| 2046 | |
| 2047 class CountCSClosure: public HeapRegionClosure { | |
| 2048 G1CollectorPolicy* _g1_policy; | |
| 2049 public: | |
| 2050 CountCSClosure(G1CollectorPolicy* g1_policy) : | |
| 2051 _g1_policy(g1_policy) {} | |
| 2052 bool doHeapRegion(HeapRegion* r) { | |
| 2053 _g1_policy->_bytes_in_collection_set_before_gc += r->used(); | |
| 2054 return false; | |
| 2055 } | |
| 2056 }; | |
| 2057 | |
| 2058 void G1CollectorPolicy::count_CS_bytes_used() { | |
| 2059 CountCSClosure cs_closure(this); | |
| 2060 _g1->collection_set_iterate(&cs_closure); | |
| 2061 } | |
| 2062 | |
| 2063 static void print_indent(int level) { | |
| 2064 for (int j = 0; j < level+1; ++j) | |
| 2065 gclog_or_tty->print(" "); | |
| 2066 } | |
| 2067 | |
| 2068 void G1CollectorPolicy::print_summary (int level, | |
| 2069 const char* str, | |
| 2070 NumberSeq* seq) const { | |
| 2071 double sum = seq->sum(); | |
| 2072 print_indent(level); | |
| 2073 gclog_or_tty->print_cr("%-24s = %8.2lf s (avg = %8.2lf ms)", | |
| 2074 str, sum / 1000.0, seq->avg()); | |
| 2075 } | |
| 2076 | |
| 2077 void G1CollectorPolicy::print_summary_sd (int level, | |
| 2078 const char* str, | |
| 2079 NumberSeq* seq) const { | |
| 2080 print_summary(level, str, seq); | |
| 2081 print_indent(level + 5); | |
| 2082 gclog_or_tty->print_cr("(num = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", | |
| 2083 seq->num(), seq->sd(), seq->maximum()); | |
| 2084 } | |
| 2085 | |
| 2086 void G1CollectorPolicy::check_other_times(int level, | |
| 2087 NumberSeq* other_times_ms, | |
| 2088 NumberSeq* calc_other_times_ms) const { | |
| 2089 bool should_print = false; | |
| 2090 | |
| 2091 double max_sum = MAX2(fabs(other_times_ms->sum()), | |
| 2092 fabs(calc_other_times_ms->sum())); | |
| 2093 double min_sum = MIN2(fabs(other_times_ms->sum()), | |
| 2094 fabs(calc_other_times_ms->sum())); | |
| 2095 double sum_ratio = max_sum / min_sum; | |
| 2096 if (sum_ratio > 1.1) { | |
| 2097 should_print = true; | |
| 2098 print_indent(level + 1); | |
| 2099 gclog_or_tty->print_cr("## CALCULATED OTHER SUM DOESN'T MATCH RECORDED ###"); | |
| 2100 } | |
| 2101 | |
| 2102 double max_avg = MAX2(fabs(other_times_ms->avg()), | |
| 2103 fabs(calc_other_times_ms->avg())); | |
| 2104 double min_avg = MIN2(fabs(other_times_ms->avg()), | |
| 2105 fabs(calc_other_times_ms->avg())); | |
| 2106 double avg_ratio = max_avg / min_avg; | |
| 2107 if (avg_ratio > 1.1) { | |
| 2108 should_print = true; | |
| 2109 print_indent(level + 1); | |
| 2110 gclog_or_tty->print_cr("## CALCULATED OTHER AVG DOESN'T MATCH RECORDED ###"); | |
| 2111 } | |
| 2112 | |
| 2113 if (other_times_ms->sum() < -0.01) { | |
| 2114 print_indent(level + 1); | |
| 2115 gclog_or_tty->print_cr("## RECORDED OTHER SUM IS NEGATIVE ###"); | |
| 2116 } | |
| 2117 | |
| 2118 if (other_times_ms->avg() < -0.01) { | |
| 2119 print_indent(level + 1); | |
| 2120 gclog_or_tty->print_cr("## RECORDED OTHER AVG IS NEGATIVE ###"); | |
| 2121 } | |
| 2122 | |
| 2123 if (calc_other_times_ms->sum() < -0.01) { | |
| 2124 should_print = true; | |
| 2125 print_indent(level + 1); | |
| 2126 gclog_or_tty->print_cr("## CALCULATED OTHER SUM IS NEGATIVE ###"); | |
| 2127 } | |
| 2128 | |
| 2129 if (calc_other_times_ms->avg() < -0.01) { | |
| 2130 should_print = true; | |
| 2131 print_indent(level + 1); | |
| 2132 gclog_or_tty->print_cr("## CALCULATED OTHER AVG IS NEGATIVE ###"); | |
| 2133 } | |
| 2134 | |
| 2135 if (should_print) | |
| 2136 print_summary(level, "Other(Calc)", calc_other_times_ms); | |
| 2137 } | |
| 2138 | |
| 2139 void G1CollectorPolicy::print_summary(PauseSummary* summary) const { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
2140 bool parallel = G1CollectedHeap::use_parallel_gc_threads(); |
| 342 | 2141 MainBodySummary* body_summary = summary->main_body_summary(); |
| 2142 if (summary->get_total_seq()->num() > 0) { | |
| 677 | 2143 print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq()); |
| 342 | 2144 if (body_summary != NULL) { |
| 2145 print_summary(1, "SATB Drain", body_summary->get_satb_drain_seq()); | |
| 2146 if (parallel) { | |
| 2147 print_summary(1, "Parallel Time", body_summary->get_parallel_seq()); | |
| 2148 print_summary(2, "Update RS", body_summary->get_update_rs_seq()); | |
| 2149 print_summary(2, "Ext Root Scanning", | |
| 2150 body_summary->get_ext_root_scan_seq()); | |
| 2151 print_summary(2, "Mark Stack Scanning", | |
| 2152 body_summary->get_mark_stack_scan_seq()); | |
| 2153 print_summary(2, "Scan RS", body_summary->get_scan_rs_seq()); | |
| 2154 print_summary(2, "Object Copy", body_summary->get_obj_copy_seq()); | |
| 2155 print_summary(2, "Termination", body_summary->get_termination_seq()); | |
| 2156 print_summary(2, "Other", body_summary->get_parallel_other_seq()); | |
| 2157 { | |
| 2158 NumberSeq* other_parts[] = { | |
| 2159 body_summary->get_update_rs_seq(), | |
| 2160 body_summary->get_ext_root_scan_seq(), | |
| 2161 body_summary->get_mark_stack_scan_seq(), | |
| 2162 body_summary->get_scan_rs_seq(), | |
| 2163 body_summary->get_obj_copy_seq(), | |
| 2164 body_summary->get_termination_seq() | |
| 2165 }; | |
| 2166 NumberSeq calc_other_times_ms(body_summary->get_parallel_seq(), | |
| 1779 | 2167 6, other_parts); |
| 342 | 2168 check_other_times(2, body_summary->get_parallel_other_seq(), |
| 2169 &calc_other_times_ms); | |
| 2170 } | |
| 2171 print_summary(1, "Mark Closure", body_summary->get_mark_closure_seq()); | |
| 2172 print_summary(1, "Clear CT", body_summary->get_clear_ct_seq()); | |
| 2173 } else { | |
| 2174 print_summary(1, "Update RS", body_summary->get_update_rs_seq()); | |
| 2175 print_summary(1, "Ext Root Scanning", | |
| 2176 body_summary->get_ext_root_scan_seq()); | |
| 2177 print_summary(1, "Mark Stack Scanning", | |
| 2178 body_summary->get_mark_stack_scan_seq()); | |
| 2179 print_summary(1, "Scan RS", body_summary->get_scan_rs_seq()); | |
| 2180 print_summary(1, "Object Copy", body_summary->get_obj_copy_seq()); | |
| 2181 } | |
| 2182 } | |
| 2183 print_summary(1, "Other", summary->get_other_seq()); | |
| 2184 { | |
| 1779 | 2185 if (body_summary != NULL) { |
| 2186 NumberSeq calc_other_times_ms; | |
| 2187 if (parallel) { | |
| 2188 // parallel | |
| 2189 NumberSeq* other_parts[] = { | |
| 2190 body_summary->get_satb_drain_seq(), | |
| 2191 body_summary->get_parallel_seq(), | |
| 2192 body_summary->get_clear_ct_seq() | |
| 2193 }; | |
| 2194 calc_other_times_ms = NumberSeq(summary->get_total_seq(), | |
| 2195 3, other_parts); | |
| 2196 } else { | |
| 2197 // serial | |
| 2198 NumberSeq* other_parts[] = { | |
| 2199 body_summary->get_satb_drain_seq(), | |
| 2200 body_summary->get_update_rs_seq(), | |
| 2201 body_summary->get_ext_root_scan_seq(), | |
| 2202 body_summary->get_mark_stack_scan_seq(), | |
| 2203 body_summary->get_scan_rs_seq(), | |
| 2204 body_summary->get_obj_copy_seq() | |
| 2205 }; | |
| 2206 calc_other_times_ms = NumberSeq(summary->get_total_seq(), | |
| 2207 6, other_parts); | |
| 2208 } | |
| 2209 check_other_times(1, summary->get_other_seq(), &calc_other_times_ms); | |
| 342 | 2210 } |
| 2211 } | |
| 2212 } else { | |
| 2213 print_indent(0); | |
| 2214 gclog_or_tty->print_cr("none"); | |
| 2215 } | |
| 2216 gclog_or_tty->print_cr(""); | |
| 2217 } | |
| 2218 | |
| 2219 void G1CollectorPolicy::print_tracing_info() const { | |
| 2220 if (TraceGen0Time) { | |
| 2221 gclog_or_tty->print_cr("ALL PAUSES"); | |
| 2222 print_summary_sd(0, "Total", _all_pause_times_ms); | |
| 2223 gclog_or_tty->print_cr(""); | |
| 2224 gclog_or_tty->print_cr(""); | |
| 2225 gclog_or_tty->print_cr(" Full Young GC Pauses: %8d", _full_young_pause_num); | |
| 2226 gclog_or_tty->print_cr(" Partial Young GC Pauses: %8d", _partial_young_pause_num); | |
| 2227 gclog_or_tty->print_cr(""); | |
| 2228 | |
| 677 | 2229 gclog_or_tty->print_cr("EVACUATION PAUSES"); |
| 2230 print_summary(_summary); | |
| 342 | 2231 |
| 2232 gclog_or_tty->print_cr("MISC"); | |
| 2233 print_summary_sd(0, "Stop World", _all_stop_world_times_ms); | |
| 2234 print_summary_sd(0, "Yields", _all_yield_times_ms); | |
| 2235 for (int i = 0; i < _aux_num; ++i) { | |
| 2236 if (_all_aux_times_ms[i].num() > 0) { | |
| 2237 char buffer[96]; | |
| 2238 sprintf(buffer, "Aux%d", i); | |
| 2239 print_summary_sd(0, buffer, &_all_aux_times_ms[i]); | |
| 2240 } | |
| 2241 } | |
| 2242 | |
| 2243 size_t all_region_num = _region_num_young + _region_num_tenured; | |
| 2244 gclog_or_tty->print_cr(" New Regions %8d, Young %8d (%6.2lf%%), " | |
| 2245 "Tenured %8d (%6.2lf%%)", | |
| 2246 all_region_num, | |
| 2247 _region_num_young, | |
| 2248 (double) _region_num_young / (double) all_region_num * 100.0, | |
| 2249 _region_num_tenured, | |
| 2250 (double) _region_num_tenured / (double) all_region_num * 100.0); | |
| 2251 } | |
| 2252 if (TraceGen1Time) { | |
| 2253 if (_all_full_gc_times_ms->num() > 0) { | |
| 2254 gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s", | |
| 2255 _all_full_gc_times_ms->num(), | |
| 2256 _all_full_gc_times_ms->sum() / 1000.0); | |
| 2257 gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times_ms->avg()); | |
| 2258 gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", | |
| 2259 _all_full_gc_times_ms->sd(), | |
| 2260 _all_full_gc_times_ms->maximum()); | |
| 2261 } | |
| 2262 } | |
| 2263 } | |
| 2264 | |
| 2265 void G1CollectorPolicy::print_yg_surv_rate_info() const { | |
| 2266 #ifndef PRODUCT | |
| 2267 _short_lived_surv_rate_group->print_surv_rate_summary(); | |
| 2268 // add this call for any other surv rate groups | |
| 2269 #endif // PRODUCT | |
| 2270 } | |
| 2271 | |
| 1973 | 2272 void |
| 2273 G1CollectorPolicy::update_region_num(bool young) { | |
| 2274 if (young) { | |
| 342 | 2275 ++_region_num_young; |
| 2276 } else { | |
| 2277 ++_region_num_tenured; | |
| 2278 } | |
| 2279 } | |
| 2280 | |
| 2281 #ifndef PRODUCT | |
| 2282 // for debugging, bit of a hack... | |
| 2283 static char* | |
| 2284 region_num_to_mbs(int length) { | |
| 2285 static char buffer[64]; | |
| 2286 double bytes = (double) (length * HeapRegion::GrainBytes); | |
| 2287 double mbs = bytes / (double) (1024 * 1024); | |
| 2288 sprintf(buffer, "%7.2lfMB", mbs); | |
| 2289 return buffer; | |
| 2290 } | |
| 2291 #endif // PRODUCT | |
| 2292 | |
| 545 | 2293 size_t G1CollectorPolicy::max_regions(int purpose) { |
| 342 | 2294 switch (purpose) { |
| 2295 case GCAllocForSurvived: | |
| 545 | 2296 return _max_survivor_regions; |
| 342 | 2297 case GCAllocForTenured: |
| 545 | 2298 return REGIONS_UNLIMITED; |
| 342 | 2299 default: |
| 545 | 2300 ShouldNotReachHere(); |
| 2301 return REGIONS_UNLIMITED; | |
| 342 | 2302 }; |
| 2303 } | |
| 2304 | |
|
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2305 void G1CollectorPolicy::calculate_max_gc_locker_expansion() { |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2306 size_t expansion_region_num = 0; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2307 if (GCLockerEdenExpansionPercent > 0) { |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2308 double perc = (double) GCLockerEdenExpansionPercent / 100.0; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2309 double expansion_region_num_d = perc * (double) _young_list_target_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2310 // We use ceiling so that if expansion_region_num_d is > 0.0 (but |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2311 // less than 1.0) we'll get 1. |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2312 expansion_region_num = (size_t) ceil(expansion_region_num_d); |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2313 } else { |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2314 assert(expansion_region_num == 0, "sanity"); |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2315 } |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2316 _young_list_max_length = _young_list_target_length + expansion_region_num; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2317 assert(_young_list_target_length <= _young_list_max_length, "post-condition"); |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2318 } |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2319 |
| 545 | 2320 // Calculates survivor space parameters. |
| 2321 void G1CollectorPolicy::calculate_survivors_policy() | |
| 2322 { | |
| 2323 if (G1FixedSurvivorSpaceSize == 0) { | |
| 2324 _max_survivor_regions = _young_list_target_length / SurvivorRatio; | |
| 2325 } else { | |
|
547
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
2326 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes; |
| 545 | 2327 } |
| 2328 | |
| 2329 if (G1FixedTenuringThreshold) { | |
| 2330 _tenuring_threshold = MaxTenuringThreshold; | |
| 2331 } else { | |
| 2332 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( | |
| 2333 HeapRegion::GrainWords * _max_survivor_regions); | |
| 2334 } | |
| 2335 } | |
| 2336 | |
| 342 | 2337 #ifndef PRODUCT |
| 2338 class HRSortIndexIsOKClosure: public HeapRegionClosure { | |
| 2339 CollectionSetChooser* _chooser; | |
| 2340 public: | |
| 2341 HRSortIndexIsOKClosure(CollectionSetChooser* chooser) : | |
| 2342 _chooser(chooser) {} | |
| 2343 | |
| 2344 bool doHeapRegion(HeapRegion* r) { | |
| 2345 if (!r->continuesHumongous()) { | |
| 2346 assert(_chooser->regionProperlyOrdered(r), "Ought to be."); | |
| 2347 } | |
| 2348 return false; | |
| 2349 } | |
| 2350 }; | |
| 2351 | |
| 2352 bool G1CollectorPolicy_BestRegionsFirst::assertMarkedBytesDataOK() { | |
| 2353 HRSortIndexIsOKClosure cl(_collectionSetChooser); | |
| 2354 _g1->heap_region_iterate(&cl); | |
| 2355 return true; | |
| 2356 } | |
| 2357 #endif | |
| 2358 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2359 bool |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2360 G1CollectorPolicy::force_initial_mark_if_outside_cycle() { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2361 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2362 if (!during_cycle) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2363 set_initiate_conc_mark_if_possible(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2364 return true; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2365 } else { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2366 return false; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2367 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2368 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2369 |
| 342 | 2370 void |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2371 G1CollectorPolicy::decide_on_conc_mark_initiation() { |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2372 // We are about to decide on whether this pause will be an |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2373 // initial-mark pause. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2374 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2375 // First, during_initial_mark_pause() should not be already set. We |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2376 // will set it here if we have to. However, it should be cleared by |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2377 // the end of the pause (it's only set for the duration of an |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2378 // initial-mark pause). |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2379 assert(!during_initial_mark_pause(), "pre-condition"); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2380 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2381 if (initiate_conc_mark_if_possible()) { |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2382 // We had noticed on a previous pause that the heap occupancy has |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2383 // gone over the initiating threshold and we should start a |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2384 // concurrent marking cycle. So we might initiate one. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2385 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2386 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2387 if (!during_cycle) { |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2388 // The concurrent marking thread is not "during a cycle", i.e., |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2389 // it has completed the last one. So we can go ahead and |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2390 // initiate a new cycle. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2391 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2392 set_during_initial_mark_pause(); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2393 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2394 // And we can now clear initiate_conc_mark_if_possible() as |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2395 // we've already acted on it. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2396 clear_initiate_conc_mark_if_possible(); |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2397 } else { |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2398 // The concurrent marking thread is still finishing up the |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2399 // previous cycle. If we start one right now the two cycles |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2400 // overlap. In particular, the concurrent marking thread might |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2401 // be in the process of clearing the next marking bitmap (which |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2402 // we will use for the next cycle if we start one). Starting a |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2403 // cycle now will be bad given that parts of the marking |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2404 // information might get cleared by the marking thread. And we |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2405 // cannot wait for the marking thread to finish the cycle as it |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2406 // periodically yields while clearing the next marking bitmap |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2407 // and, if it's in a yield point, it's waiting for us to |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2408 // finish. So, at this point we will not start a cycle and we'll |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2409 // let the concurrent marking thread complete the last one. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2410 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2411 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2412 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2413 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2414 void |
| 342 | 2415 G1CollectorPolicy_BestRegionsFirst:: |
| 2416 record_collection_pause_start(double start_time_sec, size_t start_used) { | |
| 2417 G1CollectorPolicy::record_collection_pause_start(start_time_sec, start_used); | |
| 2418 } | |
| 2419 | |
| 2420 class NextNonCSElemFinder: public HeapRegionClosure { | |
| 2421 HeapRegion* _res; | |
| 2422 public: | |
| 2423 NextNonCSElemFinder(): _res(NULL) {} | |
| 2424 bool doHeapRegion(HeapRegion* r) { | |
| 2425 if (!r->in_collection_set()) { | |
| 2426 _res = r; | |
| 2427 return true; | |
| 2428 } else { | |
| 2429 return false; | |
| 2430 } | |
| 2431 } | |
| 2432 HeapRegion* res() { return _res; } | |
| 2433 }; | |
| 2434 | |
| 2435 class KnownGarbageClosure: public HeapRegionClosure { | |
| 2436 CollectionSetChooser* _hrSorted; | |
| 2437 | |
| 2438 public: | |
| 2439 KnownGarbageClosure(CollectionSetChooser* hrSorted) : | |
| 2440 _hrSorted(hrSorted) | |
| 2441 {} | |
| 2442 | |
| 2443 bool doHeapRegion(HeapRegion* r) { | |
| 2444 // We only include humongous regions in collection | |
| 2445 // sets when concurrent mark shows that their contained object is | |
| 2446 // unreachable. | |
| 2447 | |
| 2448 // Do we have any marking information for this region? | |
| 2449 if (r->is_marked()) { | |
| 2450 // We don't include humongous regions in collection | |
| 2451 // sets because we collect them immediately at the end of a marking | |
| 2452 // cycle. We also don't include young regions because we *must* | |
| 2453 // include them in the next collection pause. | |
| 2454 if (!r->isHumongous() && !r->is_young()) { | |
| 2455 _hrSorted->addMarkedHeapRegion(r); | |
| 2456 } | |
| 2457 } | |
| 2458 return false; | |
| 2459 } | |
| 2460 }; | |
| 2461 | |
| 2462 class ParKnownGarbageHRClosure: public HeapRegionClosure { | |
| 2463 CollectionSetChooser* _hrSorted; | |
| 2464 jint _marked_regions_added; | |
| 2465 jint _chunk_size; | |
| 2466 jint _cur_chunk_idx; | |
| 2467 jint _cur_chunk_end; // Cur chunk [_cur_chunk_idx, _cur_chunk_end) | |
| 2468 int _worker; | |
| 2469 int _invokes; | |
| 2470 | |
| 2471 void get_new_chunk() { | |
| 2472 _cur_chunk_idx = _hrSorted->getParMarkedHeapRegionChunk(_chunk_size); | |
| 2473 _cur_chunk_end = _cur_chunk_idx + _chunk_size; | |
| 2474 } | |
| 2475 void add_region(HeapRegion* r) { | |
| 2476 if (_cur_chunk_idx == _cur_chunk_end) { | |
| 2477 get_new_chunk(); | |
| 2478 } | |
| 2479 assert(_cur_chunk_idx < _cur_chunk_end, "postcondition"); | |
| 2480 _hrSorted->setMarkedHeapRegion(_cur_chunk_idx, r); | |
| 2481 _marked_regions_added++; | |
| 2482 _cur_chunk_idx++; | |
| 2483 } | |
| 2484 | |
| 2485 public: | |
| 2486 ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted, | |
| 2487 jint chunk_size, | |
| 2488 int worker) : | |
| 2489 _hrSorted(hrSorted), _chunk_size(chunk_size), _worker(worker), | |
| 2490 _marked_regions_added(0), _cur_chunk_idx(0), _cur_chunk_end(0), | |
| 2491 _invokes(0) | |
| 2492 {} | |
| 2493 | |
| 2494 bool doHeapRegion(HeapRegion* r) { | |
| 2495 // We only include humongous regions in collection | |
| 2496 // sets when concurrent mark shows that their contained object is | |
| 2497 // unreachable. | |
| 2498 _invokes++; | |
| 2499 | |
| 2500 // Do we have any marking information for this region? | |
| 2501 if (r->is_marked()) { | |
| 2502 // We don't include humongous regions in collection | |
| 2503 // sets because we collect them immediately at the end of a marking | |
| 2504 // cycle. | |
| 2505 // We also do not include young regions in collection sets | |
| 2506 if (!r->isHumongous() && !r->is_young()) { | |
| 2507 add_region(r); | |
| 2508 } | |
| 2509 } | |
| 2510 return false; | |
| 2511 } | |
| 2512 jint marked_regions_added() { return _marked_regions_added; } | |
| 2513 int invokes() { return _invokes; } | |
| 2514 }; | |
| 2515 | |
| 2516 class ParKnownGarbageTask: public AbstractGangTask { | |
| 2517 CollectionSetChooser* _hrSorted; | |
| 2518 jint _chunk_size; | |
| 2519 G1CollectedHeap* _g1; | |
| 2520 public: | |
| 2521 ParKnownGarbageTask(CollectionSetChooser* hrSorted, jint chunk_size) : | |
| 2522 AbstractGangTask("ParKnownGarbageTask"), | |
| 2523 _hrSorted(hrSorted), _chunk_size(chunk_size), | |
| 2524 _g1(G1CollectedHeap::heap()) | |
| 2525 {} | |
| 2526 | |
| 2527 void work(int i) { | |
| 2528 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size, i); | |
| 2529 // Back to zero for the claim value. | |
| 355 | 2530 _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, i, |
| 2531 HeapRegion::InitialClaimValue); | |
| 342 | 2532 jint regions_added = parKnownGarbageCl.marked_regions_added(); |
| 2533 _hrSorted->incNumMarkedHeapRegions(regions_added); | |
| 2534 if (G1PrintParCleanupStats) { | |
| 2535 gclog_or_tty->print(" Thread %d called %d times, added %d regions to list.\n", | |
| 2536 i, parKnownGarbageCl.invokes(), regions_added); | |
| 2537 } | |
| 2538 } | |
| 2539 }; | |
| 2540 | |
| 2541 void | |
| 2542 G1CollectorPolicy_BestRegionsFirst:: | |
| 2543 record_concurrent_mark_cleanup_end(size_t freed_bytes, | |
| 2544 size_t max_live_bytes) { | |
| 2545 double start; | |
| 2546 if (G1PrintParCleanupStats) start = os::elapsedTime(); | |
| 2547 record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes); | |
| 2548 | |
| 2549 _collectionSetChooser->clearMarkedHeapRegions(); | |
| 2550 double clear_marked_end; | |
| 2551 if (G1PrintParCleanupStats) { | |
| 2552 clear_marked_end = os::elapsedTime(); | |
| 2553 gclog_or_tty->print_cr(" clear marked regions + work1: %8.3f ms.", | |
| 2554 (clear_marked_end - start)*1000.0); | |
| 2555 } | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
2556 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 2557 const size_t OverpartitionFactor = 4; |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2558 const size_t MinWorkUnit = 8; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2559 const size_t WorkUnit = |
| 342 | 2560 MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor), |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2561 MinWorkUnit); |
| 342 | 2562 _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(), |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2563 WorkUnit); |
| 342 | 2564 ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser, |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2565 (int) WorkUnit); |
| 342 | 2566 _g1->workers()->run_task(&parKnownGarbageTask); |
| 355 | 2567 |
| 2568 assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 2569 "sanity check"); | |
| 342 | 2570 } else { |
| 2571 KnownGarbageClosure knownGarbagecl(_collectionSetChooser); | |
| 2572 _g1->heap_region_iterate(&knownGarbagecl); | |
| 2573 } | |
| 2574 double known_garbage_end; | |
| 2575 if (G1PrintParCleanupStats) { | |
| 2576 known_garbage_end = os::elapsedTime(); | |
| 2577 gclog_or_tty->print_cr(" compute known garbage: %8.3f ms.", | |
| 2578 (known_garbage_end - clear_marked_end)*1000.0); | |
| 2579 } | |
| 2580 _collectionSetChooser->sortMarkedHeapRegions(); | |
| 2581 double sort_end; | |
| 2582 if (G1PrintParCleanupStats) { | |
| 2583 sort_end = os::elapsedTime(); | |
| 2584 gclog_or_tty->print_cr(" sorting: %8.3f ms.", | |
| 2585 (sort_end - known_garbage_end)*1000.0); | |
| 2586 } | |
| 2587 | |
| 2588 record_concurrent_mark_cleanup_end_work2(); | |
| 2589 double work2_end; | |
| 2590 if (G1PrintParCleanupStats) { | |
| 2591 work2_end = os::elapsedTime(); | |
| 2592 gclog_or_tty->print_cr(" work2: %8.3f ms.", | |
| 2593 (work2_end - sort_end)*1000.0); | |
| 2594 } | |
| 2595 } | |
| 2596 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2597 // Add the heap region at the head of the non-incremental collection set |
| 342 | 2598 void G1CollectorPolicy:: |
| 2599 add_to_collection_set(HeapRegion* hr) { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2600 assert(_inc_cset_build_state == Active, "Precondition"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2601 assert(!hr->is_young(), "non-incremental add of young region"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2602 |
| 1282 | 2603 if (G1PrintHeapRegions) { |
| 1388 | 2604 gclog_or_tty->print_cr("added region to cset " |
| 2605 "%d:["PTR_FORMAT", "PTR_FORMAT"], " | |
| 2606 "top "PTR_FORMAT", %s", | |
| 2607 hr->hrs_index(), hr->bottom(), hr->end(), | |
| 2608 hr->top(), hr->is_young() ? "YOUNG" : "NOT_YOUNG"); | |
| 342 | 2609 } |
| 2610 | |
| 2611 if (_g1->mark_in_progress()) | |
| 2612 _g1->concurrent_mark()->registerCSetRegion(hr); | |
| 2613 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2614 assert(!hr->in_collection_set(), "should not already be in the CSet"); |
| 342 | 2615 hr->set_in_collection_set(true); |
| 2616 hr->set_next_in_collection_set(_collection_set); | |
| 2617 _collection_set = hr; | |
| 2618 _collection_set_size++; | |
| 2619 _collection_set_bytes_used_before += hr->used(); | |
| 526 | 2620 _g1->register_region_with_in_cset_fast_test(hr); |
| 342 | 2621 } |
| 2622 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2623 // Initialize the per-collection-set information |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2624 void G1CollectorPolicy::start_incremental_cset_building() { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2625 assert(_inc_cset_build_state == Inactive, "Precondition"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2626 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2627 _inc_cset_head = NULL; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2628 _inc_cset_tail = NULL; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2629 _inc_cset_size = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2630 _inc_cset_bytes_used_before = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2631 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2632 if (in_young_gc_mode()) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2633 _inc_cset_young_index = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2634 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2635 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2636 _inc_cset_max_finger = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2637 _inc_cset_recorded_young_bytes = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2638 _inc_cset_recorded_rs_lengths = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2639 _inc_cset_predicted_elapsed_time_ms = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2640 _inc_cset_predicted_bytes_to_copy = 0; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2641 _inc_cset_build_state = Active; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2642 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2643 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2644 void G1CollectorPolicy::add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2645 // This routine is used when: |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2646 // * adding survivor regions to the incremental cset at the end of an |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2647 // evacuation pause, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2648 // * adding the current allocation region to the incremental cset |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2649 // when it is retired, and |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2650 // * updating existing policy information for a region in the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2651 // incremental cset via young list RSet sampling. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2652 // Therefore this routine may be called at a safepoint by the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2653 // VM thread, or in-between safepoints by mutator threads (when |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2654 // retiring the current allocation region) or a concurrent |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2655 // refine thread (RSet sampling). |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2656 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2657 double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, true); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2658 size_t used_bytes = hr->used(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2659 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2660 _inc_cset_recorded_rs_lengths += rs_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2661 _inc_cset_predicted_elapsed_time_ms += region_elapsed_time_ms; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2662 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2663 _inc_cset_bytes_used_before += used_bytes; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2664 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2665 // Cache the values we have added to the aggregated informtion |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2666 // in the heap region in case we have to remove this region from |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2667 // the incremental collection set, or it is updated by the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2668 // rset sampling code |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2669 hr->set_recorded_rs_length(rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2670 hr->set_predicted_elapsed_time_ms(region_elapsed_time_ms); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2671 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2672 #if PREDICTIONS_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2673 size_t bytes_to_copy = predict_bytes_to_copy(hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2674 _inc_cset_predicted_bytes_to_copy += bytes_to_copy; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2675 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2676 // Record the number of bytes used in this region |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2677 _inc_cset_recorded_young_bytes += used_bytes; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2678 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2679 // Cache the values we have added to the aggregated informtion |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2680 // in the heap region in case we have to remove this region from |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2681 // the incremental collection set, or it is updated by the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2682 // rset sampling code |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2683 hr->set_predicted_bytes_to_copy(bytes_to_copy); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2684 #endif // PREDICTIONS_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2685 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2686 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2687 void G1CollectorPolicy::remove_from_incremental_cset_info(HeapRegion* hr) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2688 // This routine is currently only called as part of the updating of |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2689 // existing policy information for regions in the incremental cset that |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2690 // is performed by the concurrent refine thread(s) as part of young list |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2691 // RSet sampling. Therefore we should not be at a safepoint. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2692 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2693 assert(!SafepointSynchronize::is_at_safepoint(), "should not be at safepoint"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2694 assert(hr->is_young(), "it should be"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2695 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2696 size_t used_bytes = hr->used(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2697 size_t old_rs_length = hr->recorded_rs_length(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2698 double old_elapsed_time_ms = hr->predicted_elapsed_time_ms(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2699 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2700 // Subtract the old recorded/predicted policy information for |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2701 // the given heap region from the collection set info. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2702 _inc_cset_recorded_rs_lengths -= old_rs_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2703 _inc_cset_predicted_elapsed_time_ms -= old_elapsed_time_ms; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2704 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2705 _inc_cset_bytes_used_before -= used_bytes; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2706 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2707 // Clear the values cached in the heap region |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2708 hr->set_recorded_rs_length(0); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2709 hr->set_predicted_elapsed_time_ms(0); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2710 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2711 #if PREDICTIONS_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2712 size_t old_predicted_bytes_to_copy = hr->predicted_bytes_to_copy(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2713 _inc_cset_predicted_bytes_to_copy -= old_predicted_bytes_to_copy; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2714 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2715 // Subtract the number of bytes used in this region |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2716 _inc_cset_recorded_young_bytes -= used_bytes; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2717 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2718 // Clear the values cached in the heap region |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2719 hr->set_predicted_bytes_to_copy(0); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2720 #endif // PREDICTIONS_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2721 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2722 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2723 void G1CollectorPolicy::update_incremental_cset_info(HeapRegion* hr, size_t new_rs_length) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2724 // Update the collection set information that is dependent on the new RS length |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2725 assert(hr->is_young(), "Precondition"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2726 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2727 remove_from_incremental_cset_info(hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2728 add_to_incremental_cset_info(hr, new_rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2729 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2730 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2731 void G1CollectorPolicy::add_region_to_incremental_cset_common(HeapRegion* hr) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2732 assert( hr->is_young(), "invariant"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2733 assert( hr->young_index_in_cset() == -1, "invariant" ); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2734 assert(_inc_cset_build_state == Active, "Precondition"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2735 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2736 // We need to clear and set the cached recorded/cached collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2737 // information in the heap region here (before the region gets added |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2738 // to the collection set). An individual heap region's cached values |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2739 // are calculated, aggregated with the policy collection set info, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2740 // and cached in the heap region here (initially) and (subsequently) |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2741 // by the Young List sampling code. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2742 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2743 size_t rs_length = hr->rem_set()->occupied(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2744 add_to_incremental_cset_info(hr, rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2745 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2746 HeapWord* hr_end = hr->end(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2747 _inc_cset_max_finger = MAX2(_inc_cset_max_finger, hr_end); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2748 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2749 assert(!hr->in_collection_set(), "invariant"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2750 hr->set_in_collection_set(true); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2751 assert( hr->next_in_collection_set() == NULL, "invariant"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2752 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2753 _inc_cset_size++; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2754 _g1->register_region_with_in_cset_fast_test(hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2755 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2756 hr->set_young_index_in_cset((int) _inc_cset_young_index); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2757 ++_inc_cset_young_index; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2758 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2759 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2760 // Add the region at the RHS of the incremental cset |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2761 void G1CollectorPolicy::add_region_to_incremental_cset_rhs(HeapRegion* hr) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2762 // We should only ever be appending survivors at the end of a pause |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2763 assert( hr->is_survivor(), "Logic"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2764 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2765 // Do the 'common' stuff |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2766 add_region_to_incremental_cset_common(hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2767 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2768 // Now add the region at the right hand side |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2769 if (_inc_cset_tail == NULL) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2770 assert(_inc_cset_head == NULL, "invariant"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2771 _inc_cset_head = hr; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2772 } else { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2773 _inc_cset_tail->set_next_in_collection_set(hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2774 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2775 _inc_cset_tail = hr; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2776 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2777 if (G1PrintHeapRegions) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2778 gclog_or_tty->print_cr(" added region to incremental cset (RHS) " |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2779 "%d:["PTR_FORMAT", "PTR_FORMAT"], " |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2780 "top "PTR_FORMAT", young %s", |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2781 hr->hrs_index(), hr->bottom(), hr->end(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2782 hr->top(), (hr->is_young()) ? "YES" : "NO"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2783 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2784 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2785 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2786 // Add the region to the LHS of the incremental cset |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2787 void G1CollectorPolicy::add_region_to_incremental_cset_lhs(HeapRegion* hr) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2788 // Survivors should be added to the RHS at the end of a pause |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2789 assert(!hr->is_survivor(), "Logic"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2790 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2791 // Do the 'common' stuff |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2792 add_region_to_incremental_cset_common(hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2793 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2794 // Add the region at the left hand side |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2795 hr->set_next_in_collection_set(_inc_cset_head); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2796 if (_inc_cset_head == NULL) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2797 assert(_inc_cset_tail == NULL, "Invariant"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2798 _inc_cset_tail = hr; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2799 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2800 _inc_cset_head = hr; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2801 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2802 if (G1PrintHeapRegions) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2803 gclog_or_tty->print_cr(" added region to incremental cset (LHS) " |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2804 "%d:["PTR_FORMAT", "PTR_FORMAT"], " |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2805 "top "PTR_FORMAT", young %s", |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2806 hr->hrs_index(), hr->bottom(), hr->end(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2807 hr->top(), (hr->is_young()) ? "YES" : "NO"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2808 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2809 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2810 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2811 #ifndef PRODUCT |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2812 void G1CollectorPolicy::print_collection_set(HeapRegion* list_head, outputStream* st) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2813 assert(list_head == inc_cset_head() || list_head == collection_set(), "must be"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2814 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2815 st->print_cr("\nCollection_set:"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2816 HeapRegion* csr = list_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2817 while (csr != NULL) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2818 HeapRegion* next = csr->next_in_collection_set(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2819 assert(csr->in_collection_set(), "bad CS"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2820 st->print_cr(" [%08x-%08x], t: %08x, P: %08x, N: %08x, C: %08x, " |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2821 "age: %4d, y: %d, surv: %d", |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2822 csr->bottom(), csr->end(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2823 csr->top(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2824 csr->prev_top_at_mark_start(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2825 csr->next_top_at_mark_start(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2826 csr->top_at_conc_mark_count(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2827 csr->age_in_surv_rate_group_cond(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2828 csr->is_young(), |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2829 csr->is_survivor()); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2830 csr = next; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2831 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2832 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2833 #endif // !PRODUCT |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2834 |
| 1707 | 2835 void |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2836 G1CollectorPolicy_BestRegionsFirst::choose_collection_set( |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2837 double target_pause_time_ms) { |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2838 // Set this here - in case we're not doing young collections. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2839 double non_young_start_time_sec = os::elapsedTime(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2840 |
| 342 | 2841 start_recording_regions(); |
| 2842 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2843 guarantee(target_pause_time_ms > 0.0, |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2844 err_msg("target_pause_time_ms = %1.6lf should be positive", |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2845 target_pause_time_ms)); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2846 guarantee(_collection_set == NULL, "Precondition"); |
| 342 | 2847 |
| 2848 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards); | |
| 2849 double predicted_pause_time_ms = base_time_ms; | |
| 2850 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2851 double time_remaining_ms = target_pause_time_ms - base_time_ms; |
| 342 | 2852 |
| 2853 // the 10% and 50% values are arbitrary... | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2854 if (time_remaining_ms < 0.10 * target_pause_time_ms) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2855 time_remaining_ms = 0.50 * target_pause_time_ms; |
| 342 | 2856 _within_target = false; |
| 2857 } else { | |
| 2858 _within_target = true; | |
| 2859 } | |
| 2860 | |
| 2861 // We figure out the number of bytes available for future to-space. | |
| 2862 // For new regions without marking information, we must assume the | |
| 2863 // worst-case of complete survival. If we have marking information for a | |
| 2864 // region, we can bound the amount of live data. We can add a number of | |
| 2865 // such regions, as long as the sum of the live data bounds does not | |
| 2866 // exceed the available evacuation space. | |
| 2867 size_t max_live_bytes = _g1->free_regions() * HeapRegion::GrainBytes; | |
| 2868 | |
| 2869 size_t expansion_bytes = | |
| 2870 _g1->expansion_regions() * HeapRegion::GrainBytes; | |
| 2871 | |
| 677 | 2872 _collection_set_bytes_used_before = 0; |
| 2873 _collection_set_size = 0; | |
| 342 | 2874 |
| 2875 // Adjust for expansion and slop. | |
| 2876 max_live_bytes = max_live_bytes + expansion_bytes; | |
| 2877 | |
| 2878 HeapRegion* hr; | |
| 2879 if (in_young_gc_mode()) { | |
| 2880 double young_start_time_sec = os::elapsedTime(); | |
| 2881 | |
| 2882 if (G1PolicyVerbose > 0) { | |
| 2883 gclog_or_tty->print_cr("Adding %d young regions to the CSet", | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2884 _g1->young_list()->length()); |
| 342 | 2885 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2886 |
| 342 | 2887 _young_cset_length = 0; |
| 2888 _last_young_gc_full = full_young_gcs() ? true : false; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2889 |
| 342 | 2890 if (_last_young_gc_full) |
| 2891 ++_full_young_pause_num; | |
| 2892 else | |
| 2893 ++_partial_young_pause_num; | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2894 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2895 // The young list is laid with the survivor regions from the previous |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2896 // pause are appended to the RHS of the young list, i.e. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2897 // [Newly Young Regions ++ Survivors from last pause]. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2898 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2899 hr = _g1->young_list()->first_survivor_region(); |
| 342 | 2900 while (hr != NULL) { |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2901 assert(hr->is_survivor(), "badly formed young list"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2902 hr->set_young(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2903 hr = hr->get_next_young_region(); |
| 342 | 2904 } |
| 2905 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2906 // Clear the fields that point to the survivor list - they are |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2907 // all young now. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2908 _g1->young_list()->clear_survivors(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2909 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2910 if (_g1->mark_in_progress()) |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2911 _g1->concurrent_mark()->register_collection_set_finger(_inc_cset_max_finger); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2912 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2913 _young_cset_length = _inc_cset_young_index; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2914 _collection_set = _inc_cset_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2915 _collection_set_size = _inc_cset_size; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2916 _collection_set_bytes_used_before = _inc_cset_bytes_used_before; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2917 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2918 // For young regions in the collection set, we assume the worst |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2919 // case of complete survival |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2920 max_live_bytes -= _inc_cset_size * HeapRegion::GrainBytes; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2921 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2922 time_remaining_ms -= _inc_cset_predicted_elapsed_time_ms; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2923 predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2924 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2925 // The number of recorded young regions is the incremental |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2926 // collection set's current size |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2927 set_recorded_young_regions(_inc_cset_size); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2928 set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2929 set_recorded_young_bytes(_inc_cset_recorded_young_bytes); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2930 #if PREDICTIONS_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2931 set_predicted_bytes_to_copy(_inc_cset_predicted_bytes_to_copy); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2932 #endif // PREDICTIONS_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2933 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2934 if (G1PolicyVerbose > 0) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2935 gclog_or_tty->print_cr(" Added " PTR_FORMAT " Young Regions to CS.", |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2936 _inc_cset_size); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2937 gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)", |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2938 max_live_bytes/K); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2939 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2940 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2941 assert(_inc_cset_size == _g1->young_list()->length(), "Invariant"); |
| 342 | 2942 |
| 2943 double young_end_time_sec = os::elapsedTime(); | |
| 2944 _recorded_young_cset_choice_time_ms = | |
| 2945 (young_end_time_sec - young_start_time_sec) * 1000.0; | |
| 2946 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2947 // We are doing young collections so reset this. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2948 non_young_start_time_sec = young_end_time_sec; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2949 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2950 // Note we can use either _collection_set_size or |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2951 // _young_cset_length here |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2952 if (_collection_set_size > 0 && _last_young_gc_full) { |
| 342 | 2953 // don't bother adding more regions... |
| 2954 goto choose_collection_set_end; | |
| 2955 } | |
| 2956 } | |
| 2957 | |
| 2958 if (!in_young_gc_mode() || !full_young_gcs()) { | |
| 2959 bool should_continue = true; | |
| 2960 NumberSeq seq; | |
| 2961 double avg_prediction = 100000000000000000.0; // something very large | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2962 |
| 342 | 2963 do { |
| 2964 hr = _collectionSetChooser->getNextMarkedRegion(time_remaining_ms, | |
| 2965 avg_prediction); | |
| 677 | 2966 if (hr != NULL) { |
| 342 | 2967 double predicted_time_ms = predict_region_elapsed_time_ms(hr, false); |
| 2968 time_remaining_ms -= predicted_time_ms; | |
| 2969 predicted_pause_time_ms += predicted_time_ms; | |
| 2970 add_to_collection_set(hr); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2971 record_non_young_cset_region(hr); |
| 342 | 2972 max_live_bytes -= MIN2(hr->max_live_bytes(), max_live_bytes); |
| 2973 if (G1PolicyVerbose > 0) { | |
| 2974 gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)", | |
| 2975 max_live_bytes/K); | |
| 2976 } | |
| 2977 seq.add(predicted_time_ms); | |
| 2978 avg_prediction = seq.avg() + seq.sd(); | |
| 2979 } | |
| 2980 should_continue = | |
| 2981 ( hr != NULL) && | |
| 2982 ( (adaptive_young_list_length()) ? time_remaining_ms > 0.0 | |
| 2983 : _collection_set_size < _young_list_fixed_length ); | |
| 2984 } while (should_continue); | |
| 2985 | |
| 2986 if (!adaptive_young_list_length() && | |
| 2987 _collection_set_size < _young_list_fixed_length) | |
| 2988 _should_revert_to_full_young_gcs = true; | |
| 2989 } | |
| 2990 | |
| 2991 choose_collection_set_end: | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2992 stop_incremental_cset_building(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2993 |
| 342 | 2994 count_CS_bytes_used(); |
| 2995 | |
| 2996 end_recording_regions(); | |
| 2997 | |
| 2998 double non_young_end_time_sec = os::elapsedTime(); | |
| 2999 _recorded_non_young_cset_choice_time_ms = | |
| 3000 (non_young_end_time_sec - non_young_start_time_sec) * 1000.0; | |
| 3001 } | |
| 3002 | |
| 3003 void G1CollectorPolicy_BestRegionsFirst::record_full_collection_end() { | |
| 3004 G1CollectorPolicy::record_full_collection_end(); | |
| 3005 _collectionSetChooser->updateAfterFullCollection(); | |
| 3006 } | |
| 3007 | |
| 3008 void G1CollectorPolicy_BestRegionsFirst:: | |
| 3009 expand_if_possible(size_t numRegions) { | |
| 3010 size_t expansion_bytes = numRegions * HeapRegion::GrainBytes; | |
| 3011 _g1->expand(expansion_bytes); | |
| 3012 } | |
| 3013 | |
| 3014 void G1CollectorPolicy_BestRegionsFirst:: | |
| 1707 | 3015 record_collection_pause_end() { |
| 3016 G1CollectorPolicy::record_collection_pause_end(); | |
| 342 | 3017 assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end."); |
| 3018 } |