Wed, 19 Jan 2011 19:30:42 -0500
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
1 /*
2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
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"
38 #define PREDICTIONS_VERBOSE 0
40 // <NEW PREDICTION>
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
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 };
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 };
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 };
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 };
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 };
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 };
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 };
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 };
82 // </NEW PREDICTION>
84 G1CollectorPolicy::G1CollectorPolicy() :
85 _parallel_gc_threads(G1CollectedHeap::use_parallel_gc_threads()
86 ? ParallelGCThreads : 1),
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()),
101 _all_mod_union_times_ms(new NumberSeq()),
103 _summary(new Summary()),
105 #ifndef PRODUCT
106 _cur_clear_ct_time_ms(0.0),
107 _min_clear_cc_time_ms(-1.0),
108 _max_clear_cc_time_ms(-1.0),
109 _cur_clear_cc_time_ms(0.0),
110 _cum_clear_cc_time_ms(0.0),
111 _num_cc_clears(0L),
112 #endif
114 _region_num_young(0),
115 _region_num_tenured(0),
116 _prev_region_num_young(0),
117 _prev_region_num_tenured(0),
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]),
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)),
129 // <NEW PREDICTION>
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)),
148 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
149 _scanned_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
150 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)),
152 _pause_time_target_ms((double) MaxGCPauseMillis),
154 // </NEW PREDICTION>
156 _in_young_gc_mode(false),
157 _full_young_gcs(true),
158 _full_young_pause_num(0),
159 _partial_young_pause_num(0),
161 _during_marking(false),
162 _in_marking_window(false),
163 _in_marking_window_im(false),
165 _known_garbage_ratio(0.0),
166 _known_garbage_bytes(0),
168 _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)),
170 _recent_prev_end_times_for_all_gcs_sec(new TruncatedSeq(NumPrevPausesForHeuristics)),
172 _recent_CS_bytes_used_before(new TruncatedSeq(NumPrevPausesForHeuristics)),
173 _recent_CS_bytes_surviving(new TruncatedSeq(NumPrevPausesForHeuristics)),
175 _recent_avg_pause_time_ratio(0.0),
176 _num_markings(0),
177 _n_marks(0),
178 _n_pauses_at_mark_end(0),
180 _all_full_gc_times_ms(new NumberSeq()),
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),
186 _initiate_conc_mark_if_possible(false),
187 _during_initial_mark_pause(false),
188 _should_revert_to_full_young_gcs(false),
189 _last_full_young_gc(false),
191 _prev_collection_pause_used_at_end_bytes(0),
193 _collection_set(NULL),
194 _collection_set_size(0),
195 _collection_set_bytes_used_before(0),
197 // Incremental CSet attributes
198 _inc_cset_build_state(Inactive),
199 _inc_cset_head(NULL),
200 _inc_cset_tail(NULL),
201 _inc_cset_size(0),
202 _inc_cset_young_index(0),
203 _inc_cset_bytes_used_before(0),
204 _inc_cset_max_finger(NULL),
205 _inc_cset_recorded_young_bytes(0),
206 _inc_cset_recorded_rs_lengths(0),
207 _inc_cset_predicted_elapsed_time_ms(0.0),
208 _inc_cset_predicted_bytes_to_copy(0),
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
214 _short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived",
215 G1YoungSurvRateNumRegionsSummary)),
216 _survivor_surv_rate_group(new SurvRateGroup(this, "Survivor",
217 G1YoungSurvRateNumRegionsSummary)),
218 // add here any more surv rate groups
219 _recorded_survivor_regions(0),
220 _recorded_survivor_head(NULL),
221 _recorded_survivor_tail(NULL),
222 _survivors_age_table(true),
224 _gc_overhead_perc(0.0)
226 {
227 // Set up the region size and associated fields. Given that the
228 // policy is created before the heap, we have to set this up here,
229 // so it's done as soon as possible.
230 HeapRegion::setup_heap_region_size(Arguments::min_heap_size());
231 HeapRegionRemSet::setup_remset_size();
233 // Verify PLAB sizes
234 const uint region_size = HeapRegion::GrainWords;
235 if (YoungPLABSize > region_size || OldPLABSize > region_size) {
236 char buffer[128];
237 jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most %u",
238 OldPLABSize > region_size ? "Old" : "Young", region_size);
239 vm_exit_during_initialization(buffer);
240 }
242 _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime());
243 _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0;
245 _par_last_gc_worker_start_times_ms = new double[_parallel_gc_threads];
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];
249 _par_last_update_rs_times_ms = new double[_parallel_gc_threads];
250 _par_last_update_rs_processed_buffers = new double[_parallel_gc_threads];
252 _par_last_scan_rs_times_ms = new double[_parallel_gc_threads];
254 _par_last_obj_copy_times_ms = new double[_parallel_gc_threads];
256 _par_last_termination_times_ms = new double[_parallel_gc_threads];
257 _par_last_termination_attempts = new double[_parallel_gc_threads];
258 _par_last_gc_worker_end_times_ms = new double[_parallel_gc_threads];
260 // start conservatively
261 _expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis;
263 // <NEW PREDICTION>
265 int index;
266 if (ParallelGCThreads == 0)
267 index = 0;
268 else if (ParallelGCThreads > 8)
269 index = 7;
270 else
271 index = ParallelGCThreads - 1;
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]);
286 // </NEW PREDICTION>
288 // Below, we might need to calculate the pause time target based on
289 // the pause interval. When we do so we are going to give G1 maximum
290 // flexibility and allow it to do pauses when it needs to. So, we'll
291 // arrange that the pause interval to be pause time target + 1 to
292 // ensure that a) the pause time target is maximized with respect to
293 // the pause interval and b) we maintain the invariant that pause
294 // time target < pause interval. If the user does not want this
295 // maximum flexibility, they will have to set the pause interval
296 // explicitly.
298 // First make sure that, if either parameter is set, its value is
299 // reasonable.
300 if (!FLAG_IS_DEFAULT(MaxGCPauseMillis)) {
301 if (MaxGCPauseMillis < 1) {
302 vm_exit_during_initialization("MaxGCPauseMillis should be "
303 "greater than 0");
304 }
305 }
306 if (!FLAG_IS_DEFAULT(GCPauseIntervalMillis)) {
307 if (GCPauseIntervalMillis < 1) {
308 vm_exit_during_initialization("GCPauseIntervalMillis should be "
309 "greater than 0");
310 }
311 }
313 // Then, if the pause time target parameter was not set, set it to
314 // the default value.
315 if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) {
316 if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) {
317 // The default pause time target in G1 is 200ms
318 FLAG_SET_DEFAULT(MaxGCPauseMillis, 200);
319 } else {
320 // We do not allow the pause interval to be set without the
321 // pause time target
322 vm_exit_during_initialization("GCPauseIntervalMillis cannot be set "
323 "without setting MaxGCPauseMillis");
324 }
325 }
327 // Then, if the interval parameter was not set, set it according to
328 // the pause time target (this will also deal with the case when the
329 // pause time target is the default value).
330 if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) {
331 FLAG_SET_DEFAULT(GCPauseIntervalMillis, MaxGCPauseMillis + 1);
332 }
334 // Finally, make sure that the two parameters are consistent.
335 if (MaxGCPauseMillis >= GCPauseIntervalMillis) {
336 char buffer[256];
337 jio_snprintf(buffer, 256,
338 "MaxGCPauseMillis (%u) should be less than "
339 "GCPauseIntervalMillis (%u)",
340 MaxGCPauseMillis, GCPauseIntervalMillis);
341 vm_exit_during_initialization(buffer);
342 }
344 double max_gc_time = (double) MaxGCPauseMillis / 1000.0;
345 double time_slice = (double) GCPauseIntervalMillis / 1000.0;
346 _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time);
347 _sigma = (double) G1ConfidencePercent / 100.0;
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;
355 // if G1FixedSurvivorSpaceSize is 0 which means the size is not
356 // fixed, then _max_survivor_regions will be calculated at
357 // calculate_young_list_target_length during initialization
358 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes;
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));
365 initialize_all();
366 }
368 // Increment "i", mod "len"
369 static void inc_mod(int& i, int len) {
370 i++; if (i == len) i = 0;
371 }
373 void G1CollectorPolicy::initialize_flags() {
374 set_min_alignment(HeapRegion::GrainBytes);
375 set_max_alignment(GenRemSet::max_alignment_constraint(rem_set_name()));
376 if (SurvivorRatio < 1) {
377 vm_exit_during_initialization("Invalid survivor ratio specified");
378 }
379 CollectorPolicy::initialize_flags();
380 }
382 // The easiest way to deal with the parsing of the NewSize /
383 // MaxNewSize / etc. parameteres is to re-use the code in the
384 // TwoGenerationCollectorPolicy class. This is similar to what
385 // ParallelScavenge does with its GenerationSizer class (see
386 // ParallelScavengeHeap::initialize()). We might change this in the
387 // future, but it's a good start.
388 class G1YoungGenSizer : public TwoGenerationCollectorPolicy {
389 size_t size_to_region_num(size_t byte_size) {
390 return MAX2((size_t) 1, byte_size / HeapRegion::GrainBytes);
391 }
393 public:
394 G1YoungGenSizer() {
395 initialize_flags();
396 initialize_size_info();
397 }
399 size_t min_young_region_num() {
400 return size_to_region_num(_min_gen0_size);
401 }
402 size_t initial_young_region_num() {
403 return size_to_region_num(_initial_gen0_size);
404 }
405 size_t max_young_region_num() {
406 return size_to_region_num(_max_gen0_size);
407 }
408 };
410 void G1CollectorPolicy::init() {
411 // Set aside an initial future to_space.
412 _g1 = G1CollectedHeap::heap();
414 assert(Heap_lock->owned_by_self(), "Locking discipline.");
416 initialize_gc_policy_counters();
418 if (G1Gen) {
419 _in_young_gc_mode = true;
421 G1YoungGenSizer sizer;
422 size_t initial_region_num = sizer.initial_young_region_num();
424 if (UseAdaptiveSizePolicy) {
425 set_adaptive_young_list_length(true);
426 _young_list_fixed_length = 0;
427 } else {
428 set_adaptive_young_list_length(false);
429 _young_list_fixed_length = initial_region_num;
430 }
431 _free_regions_at_end_of_collection = _g1->free_regions();
432 calculate_young_list_min_length();
433 guarantee( _young_list_min_length == 0, "invariant, not enough info" );
434 calculate_young_list_target_length();
435 } else {
436 _young_list_fixed_length = 0;
437 _in_young_gc_mode = false;
438 }
440 // We may immediately start allocating regions and placing them on the
441 // collection set list. Initialize the per-collection set info
442 start_incremental_cset_building();
443 }
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 }
451 void G1CollectorPolicy::calculate_young_list_min_length() {
452 _young_list_min_length = 0;
454 if (!adaptive_young_list_length())
455 return;
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();
461 size_t min_regions = (size_t) ceil(alloc_rate_ms * when_ms);
462 size_t current_region_num = _g1->young_list()->length();
463 _young_list_min_length = min_regions + current_region_num;
464 }
465 }
467 void G1CollectorPolicy::calculate_young_list_target_length() {
468 if (adaptive_young_list_length()) {
469 size_t rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq);
470 calculate_young_list_target_length(rs_lengths);
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 }
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);
482 calculate_max_gc_locker_expansion();
483 calculate_survivors_policy();
484 }
486 void G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths) {
487 guarantee( adaptive_young_list_length(), "pre-condition" );
488 guarantee( !_in_marking_window || !_last_full_young_gc, "invariant" );
490 double start_time_sec = os::elapsedTime();
491 size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1ReservePercent);
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);
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
499 double survivor_regions_evac_time =
500 predict_survivor_regions_evac_time();
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();
505 size_t scanned_cards = predict_young_card_num(adj_rs_lengths);
506 double base_time_ms = predict_base_elapsed_time_ms(pending_cards, scanned_cards)
507 + survivor_regions_evac_time;
509 // the result
510 size_t final_young_length = 0;
512 size_t init_free_regions =
513 MAX2((size_t)0, _free_regions_at_end_of_collection - reserve_regions);
515 // if we're still under the pause target...
516 if (base_time_ms <= target_pause_time_ms) {
517 // We make sure that the shortest young length that makes sense
518 // fits within the target pause time.
519 size_t min_young_length = 1;
521 if (predict_will_fit(min_young_length, base_time_ms,
522 init_free_regions, target_pause_time_ms)) {
523 // The shortest young length will fit within the target pause time;
524 // we'll now check whether the absolute maximum number of young
525 // regions will fit in the target pause time. If not, we'll do
526 // a binary search between min_young_length and max_young_length
527 size_t abs_max_young_length = _free_regions_at_end_of_collection - 1;
528 size_t max_young_length = abs_max_young_length;
530 if (max_young_length > min_young_length) {
531 // Let's check if the initial max young length will fit within the
532 // target pause. If so then there is no need to search for a maximal
533 // young length - we'll return the initial maximum
535 if (predict_will_fit(max_young_length, base_time_ms,
536 init_free_regions, target_pause_time_ms)) {
537 // The maximum young length will satisfy the target pause time.
538 // We are done so set min young length to this maximum length.
539 // The code after the loop will then set final_young_length using
540 // the value cached in the minimum length.
541 min_young_length = max_young_length;
542 } else {
543 // The maximum possible number of young regions will not fit within
544 // the target pause time so let's search....
546 size_t diff = (max_young_length - min_young_length) / 2;
547 max_young_length = min_young_length + diff;
549 while (max_young_length > min_young_length) {
550 if (predict_will_fit(max_young_length, base_time_ms,
551 init_free_regions, target_pause_time_ms)) {
553 // The current max young length will fit within the target
554 // pause time. Note we do not exit the loop here. By setting
555 // min = max, and then increasing the max below means that
556 // we will continue searching for an upper bound in the
557 // range [max..max+diff]
558 min_young_length = max_young_length;
559 }
560 diff = (max_young_length - min_young_length) / 2;
561 max_young_length = min_young_length + diff;
562 }
563 // the above loop found a maximal young length that will fit
564 // within the target pause time.
565 }
566 assert(min_young_length <= abs_max_young_length, "just checking");
567 }
568 final_young_length = min_young_length;
569 }
570 }
571 // and we're done!
573 // we should have at least one region in the target young length
574 _young_list_target_length =
575 final_young_length + _recorded_survivor_regions;
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;
583 #ifdef TRACE_CALC_YOUNG_LENGTH
584 // leave this in for debugging, just in case
585 gclog_or_tty->print_cr("target = %1.1lf ms, young = " SIZE_FORMAT ", "
586 "elapsed %1.2lf ms, (%s%s) " SIZE_FORMAT SIZE_FORMAT,
587 target_pause_time_ms,
588 _young_list_target_length
589 elapsed_time_ms,
590 full_young_gcs() ? "full" : "partial",
591 during_initial_mark_pause() ? " i-m" : "",
592 _in_marking_window,
593 _in_marking_window_im);
594 #endif // TRACE_CALC_YOUNG_LENGTH
596 if (_young_list_target_length < _young_list_min_length) {
597 // bummer; this means that, if we do a pause when the maximal
598 // length dictates, we'll violate the pause spacing target (the
599 // min length was calculate based on the application's current
600 // alloc rate);
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.
605 #ifdef TRACE_CALC_YOUNG_LENGTH
606 // leave this in for debugging, just in case
607 gclog_or_tty->print_cr("adjusted target length from "
608 SIZE_FORMAT " to " SIZE_FORMAT,
609 _young_list_target_length, _young_list_min_length);
610 #endif // TRACE_CALC_YOUNG_LENGTH
612 _young_list_target_length = _young_list_min_length;
613 }
614 } else {
615 // we are in a partially-young mode or we've run out of regions (due
616 // to evacuation failure)
618 #ifdef TRACE_CALC_YOUNG_LENGTH
619 // leave this in for debugging, just in case
620 gclog_or_tty->print_cr("(partial) setting target to " SIZE_FORMAT
621 _young_list_min_length);
622 #endif // TRACE_CALC_YOUNG_LENGTH
623 // we'll do the pause as soon as possible by choosing the minimum
624 _young_list_target_length = _young_list_min_length;
625 }
627 _rs_lengths_prediction = rs_lengths;
628 }
630 // This is used by: calculate_young_list_target_length(rs_length). It
631 // returns true iff:
632 // the predicted pause time for the given young list will not overflow
633 // the target pause time
634 // and:
635 // the predicted amount of surviving data will not overflow the
636 // the amount of free space available for survivor regions.
637 //
638 bool
639 G1CollectorPolicy::predict_will_fit(size_t young_length,
640 double base_time_ms,
641 size_t init_free_regions,
642 double target_pause_time_ms) {
644 if (young_length >= init_free_regions)
645 // end condition 1: not enough space for the young regions
646 return false;
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;
652 size_t bytes_to_copy =
653 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);
655 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy);
657 double young_other_time_ms =
658 predict_young_other_time_ms(young_length);
660 double pause_time_ms =
661 base_time_ms + copy_time_ms + young_other_time_ms;
663 if (pause_time_ms > target_pause_time_ms)
664 // end condition 2: over the target pause time
665 return false;
667 size_t free_bytes =
668 (init_free_regions - young_length) * HeapRegion::GrainBytes;
670 if ((2.0 + sigma()) * (double) bytes_to_copy > (double) free_bytes)
671 // end condition 3: out of to-space (conservatively)
672 return false;
674 // success!
675 return true;
676 }
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 }
688 void G1CollectorPolicy::check_prediction_validity() {
689 guarantee( adaptive_young_list_length(), "should not call this otherwise" );
691 size_t rs_lengths = _g1->young_list()->sampled_rs_lengths();
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;
695 calculate_young_list_target_length(rs_lengths_prediction);
696 }
697 }
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 }
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 }
715 #ifndef PRODUCT
716 bool G1CollectorPolicy::verify_young_ages() {
717 HeapRegion* head = _g1->young_list()->first_region();
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 }
723 bool
724 G1CollectorPolicy::verify_young_ages(HeapRegion* head,
725 SurvRateGroup *surv_rate_group) {
726 guarantee( surv_rate_group != NULL, "pre-condition" );
728 const char* name = surv_rate_group->name();
729 bool ret = true;
730 int prev_age = -1;
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 }
741 if (surv_rate_group == group) {
742 int age = curr->age_in_surv_rate_group();
744 if (age < 0) {
745 gclog_or_tty->print_cr("## %s: encountered negative age", name);
746 ret = false;
747 }
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 }
758 return ret;
759 }
760 #endif // PRODUCT
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 }
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;
775 _all_full_gc_times_ms->add(full_gc_time_ms);
777 update_recent_gc_times(end_sec, full_gc_time_ms);
779 _g1->clear_full_collection();
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;
787 clear_initiate_conc_mark_if_possible();
788 clear_during_initial_mark_pause();
789 _known_garbage_bytes = 0;
790 _known_garbage_ratio = 0.0;
791 _in_marking_window = false;
792 _in_marking_window_im = false;
794 _short_lived_surv_rate_group->start_adding_regions();
795 // also call this on any additional surv rate groups
797 record_survivor_regions(0, NULL, NULL);
799 _prev_region_num_young = _region_num_young;
800 _prev_region_num_tenured = _region_num_tenured;
802 _free_regions_at_end_of_collection = _g1->free_regions();
803 // Reset survivors SurvRateGroup.
804 _survivor_surv_rate_group->reset();
805 calculate_young_list_min_length();
806 calculate_young_list_target_length();
807 }
809 void G1CollectorPolicy::record_before_bytes(size_t bytes) {
810 _bytes_in_to_space_before_gc += bytes;
811 }
813 void G1CollectorPolicy::record_after_bytes(size_t bytes) {
814 _bytes_in_to_space_after_gc += bytes;
815 }
817 void G1CollectorPolicy::record_stop_world_start() {
818 _stop_world_start = os::elapsedTime();
819 }
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 }
830 assert(_g1->used() == _g1->recalculate_used(),
831 err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT,
832 _g1->used(), _g1->recalculate_used()));
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;
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();
844 _bytes_in_to_space_before_gc = 0;
845 _bytes_in_to_space_after_gc = 0;
846 _bytes_in_collection_set_before_gc = 0;
848 #ifdef DEBUG
849 // initialise these to something well known so that we can spot
850 // if they are not set properly
852 for (int i = 0; i < _parallel_gc_threads; ++i) {
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;
863 }
864 #endif
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 }
871 _satb_drain_time_set = false;
872 _last_satb_drain_processed_buffers = -1;
874 if (in_young_gc_mode())
875 _last_young_gc_full = false;
877 // do that for any other surv rate groups
878 _short_lived_surv_rate_group->stop_adding_regions();
879 _survivors_age_table.clear();
881 assert( verify_young_ages(), "region age verification" );
882 }
884 void G1CollectorPolicy::record_mark_closure_time(double mark_closure_time_ms) {
885 _mark_closure_time_ms = mark_closure_time_ms;
886 }
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 }
893 void G1CollectorPolicy::record_concurrent_mark_init_end_pre(double
894 mark_init_elapsed_time_ms) {
895 _during_marking = true;
896 assert(!initiate_conc_mark_if_possible(), "we should have cleared it by now");
897 clear_during_initial_mark_pause();
898 _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms;
899 }
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);
907 _mmu_tracker->add_pause(_mark_init_start_sec, end_time_sec, true);
908 }
910 void G1CollectorPolicy::record_concurrent_mark_remark_start() {
911 _mark_remark_start_sec = os::elapsedTime();
912 _during_marking = false;
913 }
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;
922 _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true);
923 }
925 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() {
926 _mark_cleanup_start_sec = os::elapsedTime();
927 }
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 }
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 }
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;
955 _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_time_sec, true);
957 _num_markings++;
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 }
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())
977 calculate_young_list_target_length();
978 }
979 }
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 }
988 void G1CollectorPolicy::record_concurrent_pause_end() {
989 }
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 }
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 }
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 }
1013 void G1CollectorPolicy::print_par_stats(int level,
1014 const char* str,
1015 double* data,
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 }
1044 void G1CollectorPolicy::print_par_sizes(int level,
1045 const char* str,
1046 double* data,
1047 bool summary) {
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 }
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 }
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 }
1091 double G1CollectorPolicy::avg_value (double* data) {
1092 if (G1CollectedHeap::use_parallel_gc_threads()) {
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 }
1102 double G1CollectorPolicy::max_value (double* data) {
1103 if (G1CollectedHeap::use_parallel_gc_threads()) {
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 }
1114 double G1CollectorPolicy::sum_of_values (double* data) {
1115 if (G1CollectedHeap::use_parallel_gc_threads()) {
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 }
1125 double G1CollectorPolicy::max_sum (double* data1,
1126 double* data2) {
1127 double ret = data1[0] + data2[0];
1129 if (G1CollectedHeap::use_parallel_gc_threads()) {
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 }
1139 // Anything below that is considered to be zero
1140 #define MIN_TIMER_GRANULARITY 0.0000001
1142 void G1CollectorPolicy::record_collection_pause_end() {
1143 double end_time_sec = os::elapsedTime();
1144 double elapsed_ms = _last_pause_time_ms;
1145 bool parallel = G1CollectedHeap::use_parallel_gc_threads();
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;
1152 bool update_stats = !_g1->evacuation_failed();
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
1162 if (in_young_gc_mode()) {
1163 last_pause_included_initial_mark = during_initial_mark_pause();
1164 if (last_pause_included_initial_mark)
1165 record_concurrent_mark_init_end_pre(0.0);
1167 size_t min_used_targ =
1168 (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent;
1171 if (!_g1->mark_in_progress() && !_last_full_young_gc) {
1172 assert(!last_pause_included_initial_mark, "invariant");
1173 if (cur_used_bytes > min_used_targ &&
1174 cur_used_bytes > _prev_collection_pause_used_at_end_bytes) {
1175 assert(!during_initial_mark_pause(), "we should not see this here");
1177 // Note: this might have already been set, if during the last
1178 // pause we decided to start a cycle but at the beginning of
1179 // this pause we decided to postpone it. That's OK.
1180 set_initiate_conc_mark_if_possible();
1181 }
1182 }
1184 _prev_collection_pause_used_at_end_bytes = cur_used_bytes;
1185 }
1187 _mmu_tracker->add_pause(end_time_sec - elapsed_ms/1000.0,
1188 end_time_sec, false);
1190 guarantee(_cur_collection_pause_used_regions_at_start >=
1191 collection_set_size(),
1192 "Negative RS size?");
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");
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;
1213 double survival_fraction =
1214 (double)surviving_bytes/
1215 (double)_collection_set_bytes_used_before;
1217 _n_pauses++;
1219 if (update_stats) {
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);
1225 _recent_rs_sizes->add(rs_size);
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);
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;
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;
1261 if (recent_avg_pause_time_ratio() < 0.0 ||
1262 (recent_avg_pause_time_ratio() - 1.0 > 0.0)) {
1263 #ifndef PRODUCT
1264 // Dump info to allow post-facto debugging
1265 gclog_or_tty->print_cr("recent_avg_pause_time_ratio() out of bounds");
1266 gclog_or_tty->print_cr("-------------------------------------------");
1267 gclog_or_tty->print_cr("Recent GC Times (ms):");
1268 _recent_gc_times_ms->dump();
1269 gclog_or_tty->print_cr("(End Time=%3.3f) Recent GC End Times (s):", end_time_sec);
1270 _recent_prev_end_times_for_all_gcs_sec->dump();
1271 gclog_or_tty->print_cr("GC = %3.3f, Interval = %3.3f, Ratio = %3.3f",
1272 _recent_gc_times_ms->sum(), interval_ms, recent_avg_pause_time_ratio());
1273 // In debug mode, terminate the JVM if the user wants to debug at this point.
1274 assert(!G1FailOnFPError, "Debugging data for CR 6898948 has been dumped above");
1275 #endif // !PRODUCT
1276 // Clip ratio between 0.0 and 1.0, and continue. This will be fixed in
1277 // CR 6902692 by redoing the manner in which the ratio is incrementally computed.
1278 if (_recent_avg_pause_time_ratio < 0.0) {
1279 _recent_avg_pause_time_ratio = 0.0;
1280 } else {
1281 assert(_recent_avg_pause_time_ratio - 1.0 > 0.0, "Ctl-point invariant");
1282 _recent_avg_pause_time_ratio = 1.0;
1283 }
1284 }
1285 }
1287 if (G1PolicyVerbose > 1) {
1288 gclog_or_tty->print_cr(" Recording collection pause(%d)", _n_pauses);
1289 }
1291 PauseSummary* summary = _summary;
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);
1302 double parallel_other_time = _cur_collection_par_time_ms -
1303 (update_rs_time + ext_root_scan_time + mark_stack_scan_time +
1304 scan_rs_time + obj_copy_time + termination_time);
1305 if (update_stats) {
1306 MainBodySummary* body_summary = summary->main_body_summary();
1307 guarantee(body_summary != NULL, "should not be null!");
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 }
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);
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 }
1357 double other_time_ms = elapsed_ms;
1359 if (_satb_drain_time_set) {
1360 other_time_ms -= _cur_satb_drain_time_ms;
1361 }
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;
1370 }
1372 if (PrintGCDetails) {
1373 gclog_or_tty->print_cr("%s, %1.8lf secs]",
1374 (last_pause_included_initial_mark) ? " (initial-mark)" : "",
1375 elapsed_ms / 1000.0);
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);
1411 }
1412 #ifndef PRODUCT
1413 print_stats(1, "Cur Clear CC", _cur_clear_cc_time_ms);
1414 print_stats(1, "Cum Clear CC", _cum_clear_cc_time_ms);
1415 print_stats(1, "Min Clear CC", _min_clear_cc_time_ms);
1416 print_stats(1, "Max Clear CC", _max_clear_cc_time_ms);
1417 if (_num_cc_clears > 0) {
1418 print_stats(1, "Avg Clear CC", _cum_clear_cc_time_ms / ((double)_num_cc_clears));
1419 }
1420 #endif
1421 print_stats(1, "Other", other_time_ms);
1422 print_stats(2, "Choose CSet", _recorded_young_cset_choice_time_ms);
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("]");
1441 _all_pause_times_ms->add(elapsed_ms);
1442 if (update_stats) {
1443 summary->record_total_time_ms(elapsed_ms);
1444 summary->record_other_time_ms(other_time_ms);
1445 }
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]);
1450 // Reset marks-between-pauses counter.
1451 _n_marks_since_last_pause = 0;
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;
1463 bool new_in_marking_window = _in_marking_window;
1464 bool new_in_marking_window_im = false;
1465 if (during_initial_mark_pause()) {
1466 new_in_marking_window = true;
1467 new_in_marking_window_im = true;
1468 }
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 }
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;
1486 if (_last_young_gc_full && !_during_marking)
1487 _young_gc_eff_seq->add(cur_efficiency);
1488 }
1490 _short_lived_surv_rate_group->start_adding_regions();
1491 // do that for any other surv rate groupsx
1493 // <NEW PREDICTION>
1495 if (update_stats) {
1496 double pause_time_ms = elapsed_ms;
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);
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 }
1509 size_t cards_scanned = _g1->cards_scanned();
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 }
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 }
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);
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 }
1543 double all_other_time_ms = pause_time_ms -
1544 (update_rs_time + scan_rs_time + obj_copy_time +
1545 _mark_closure_time_ms + termination_time);
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;
1561 _non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms /
1562 (double) _recorded_non_young_regions);
1563 }
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);
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 }
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);
1579 double expensive_region_limit_ms =
1580 (double) MaxGCPauseMillis - predict_constant_other_time_ms();
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
1584 expensive_region_limit_ms = (double) MaxGCPauseMillis;
1585 }
1586 _expensive_region_limit_ms = expensive_region_limit_ms;
1588 if (PREDICTIONS_VERBOSE) {
1589 gclog_or_tty->print_cr("");
1590 gclog_or_tty->print_cr("PREDICTIONS %1.4lf %d "
1591 "REGIONS %d %d %d "
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 }
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 }
1630 }
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();
1636 calculate_young_list_target_length();
1638 // Note that _mmu_tracker->max_gc_time() returns the time in seconds.
1639 double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0;
1640 adjust_concurrent_refinement(update_rs_time, update_rs_processed_buffers, update_rs_time_goal_ms);
1641 // </NEW PREDICTION>
1642 }
1644 // <NEW PREDICTION>
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();
1652 if (G1UseAdaptiveConcRefinement) {
1653 const int k_gy = 3, k_gr = 6;
1654 const double inc_k = 1.1, dec_k = 0.9;
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();
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 }
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 }
1687 double
1688 G1CollectorPolicy::
1689 predict_young_collection_elapsed_time_ms(size_t adjustment) {
1690 guarantee( adjustment == 0 || adjustment == 1, "invariant" );
1692 G1CollectedHeap* g1h = G1CollectedHeap::heap();
1693 size_t young_num = g1h->young_list()->length();
1694 if (young_num == 0)
1695 return 0.0;
1697 young_num += adjustment;
1698 size_t pending_cards = predict_pending_cards();
1699 size_t rs_lengths = g1h->young_list()->sampled_rs_lengths() +
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);
1710 size_t bytes_to_copy =
1711 (size_t) (accum_yg_surv_rate * (double) HeapRegion::GrainBytes);
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 }
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 }
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 }
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);
1752 double region_elapsed_time_ms =
1753 predict_rs_scan_time_ms(card_num) +
1754 predict_object_copy_time_ms(bytes_to_copy);
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);
1761 return region_elapsed_time_ms;
1762 }
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();
1773 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group());
1774 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate);
1775 }
1777 return bytes_to_copy;
1778 }
1780 void
1781 G1CollectorPolicy::start_recording_regions() {
1782 _recorded_rs_lengths = 0;
1783 _recorded_young_regions = 0;
1784 _recorded_non_young_regions = 0;
1786 #if PREDICTIONS_VERBOSE
1787 _recorded_marked_bytes = 0;
1788 _recorded_young_bytes = 0;
1789 _predicted_bytes_to_copy = 0;
1790 _predicted_rs_lengths = 0;
1791 _predicted_cards_scanned = 0;
1792 #endif // PREDICTIONS_VERBOSE
1793 }
1795 void
1796 G1CollectorPolicy::record_cset_region_info(HeapRegion* hr, bool young) {
1797 #if PREDICTIONS_VERBOSE
1798 if (!young) {
1799 _recorded_marked_bytes += hr->max_live_bytes();
1800 }
1801 _predicted_bytes_to_copy += predict_bytes_to_copy(hr);
1802 #endif // PREDICTIONS_VERBOSE
1804 size_t rs_length = hr->rem_set()->occupied();
1805 _recorded_rs_lengths += rs_length;
1806 }
1808 void
1809 G1CollectorPolicy::record_non_young_cset_region(HeapRegion* hr) {
1810 assert(!hr->is_young(), "should not call this");
1811 ++_recorded_non_young_regions;
1812 record_cset_region_info(hr, false);
1813 }
1815 void
1816 G1CollectorPolicy::set_recorded_young_regions(size_t n_regions) {
1817 _recorded_young_regions = n_regions;
1818 }
1820 void G1CollectorPolicy::set_recorded_young_bytes(size_t bytes) {
1821 #if PREDICTIONS_VERBOSE
1822 _recorded_young_bytes = bytes;
1823 #endif // PREDICTIONS_VERBOSE
1824 }
1826 void G1CollectorPolicy::set_recorded_rs_lengths(size_t rs_lengths) {
1827 _recorded_rs_lengths = rs_lengths;
1828 }
1830 void G1CollectorPolicy::set_predicted_bytes_to_copy(size_t bytes) {
1831 _predicted_bytes_to_copy = bytes;
1832 }
1834 void
1835 G1CollectorPolicy::end_recording_regions() {
1836 // The _predicted_pause_time_ms field is referenced in code
1837 // not under PREDICTIONS_VERBOSE. Let's initialize it.
1838 _predicted_pause_time_ms = -1.0;
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;
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);
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 }
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);
1880 // We might want to do something different here. However,
1881 // right now we don't support the non-generational G1 mode
1882 // (and in fact we are planning to remove the associated code,
1883 // see CR 6814390). So, let's leave it as is and this will be
1884 // removed some time in the future
1885 ShouldNotReachHere();
1886 set_during_initial_mark_pause();
1887 } else
1888 // no point in doing another partial one
1889 _should_revert_to_full_young_gcs = true;
1890 }
1891 }
1893 // </NEW PREDICTION>
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 }
1903 double G1CollectorPolicy::recent_avg_time_for_pauses_ms() {
1904 if (_recent_pause_times_ms->num() == 0) return (double) MaxGCPauseMillis;
1905 else return _recent_pause_times_ms->avg();
1906 }
1908 double G1CollectorPolicy::recent_avg_time_for_CH_strong_ms() {
1909 if (_recent_CH_strong_roots_times_ms->num() == 0)
1910 return (double)MaxGCPauseMillis/3.0;
1911 else return _recent_CH_strong_roots_times_ms->avg();
1912 }
1914 double G1CollectorPolicy::recent_avg_time_for_G1_strong_ms() {
1915 if (_recent_G1_strong_roots_times_ms->num() == 0)
1916 return (double)MaxGCPauseMillis/3.0;
1917 else return _recent_G1_strong_roots_times_ms->avg();
1918 }
1920 double G1CollectorPolicy::recent_avg_time_for_evac_ms() {
1921 if (_recent_evac_times_ms->num() == 0) return (double)MaxGCPauseMillis/3.0;
1922 else return _recent_evac_times_ms->avg();
1923 }
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 }
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 }
1944 double G1CollectorPolicy::last_survival_fraction() {
1945 return last_survival_fraction_work(_recent_CS_bytes_surviving,
1946 _recent_CS_bytes_used_before);
1947 }
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.)
1960 assert((true || G1CollectedHeap::use_parallel_gc_threads()) ||
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 }
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.)
1980 assert((true || G1CollectedHeap::use_parallel_gc_threads()) ||
1981 last_survival_rate <= 1.0, "Or bad frac");
1982 return last_survival_rate;
1983 } else {
1984 return 1.0;
1985 }
1986 }
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;
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 }
2007 size_t G1CollectorPolicy::expansion_amount() {
2008 if ((recent_avg_pause_time_ratio() * 100.0) > _gc_overhead_perc) {
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.)
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 =
2019 uncommitted_bytes * G1ExpandByPercentOfAvailable / 100;
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 }
2043 void G1CollectorPolicy::note_start_of_mark_thread() {
2044 _mark_thread_startup_sec = os::elapsedTime();
2045 }
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 };
2058 void G1CollectorPolicy::count_CS_bytes_used() {
2059 CountCSClosure cs_closure(this);
2060 _g1->collection_set_iterate(&cs_closure);
2061 }
2063 static void print_indent(int level) {
2064 for (int j = 0; j < level+1; ++j)
2065 gclog_or_tty->print(" ");
2066 }
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 }
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 }
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;
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 }
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 }
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 }
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 }
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 }
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 }
2135 if (should_print)
2136 print_summary(level, "Other(Calc)", calc_other_times_ms);
2137 }
2139 void G1CollectorPolicy::print_summary(PauseSummary* summary) const {
2140 bool parallel = G1CollectedHeap::use_parallel_gc_threads();
2141 MainBodySummary* body_summary = summary->main_body_summary();
2142 if (summary->get_total_seq()->num() > 0) {
2143 print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq());
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(),
2167 6, other_parts);
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 {
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);
2210 }
2211 }
2212 } else {
2213 print_indent(0);
2214 gclog_or_tty->print_cr("none");
2215 }
2216 gclog_or_tty->print_cr("");
2217 }
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("");
2229 gclog_or_tty->print_cr("EVACUATION PAUSES");
2230 print_summary(_summary);
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 }
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 }
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 }
2272 void
2273 G1CollectorPolicy::update_region_num(bool young) {
2274 if (young) {
2275 ++_region_num_young;
2276 } else {
2277 ++_region_num_tenured;
2278 }
2279 }
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
2293 size_t G1CollectorPolicy::max_regions(int purpose) {
2294 switch (purpose) {
2295 case GCAllocForSurvived:
2296 return _max_survivor_regions;
2297 case GCAllocForTenured:
2298 return REGIONS_UNLIMITED;
2299 default:
2300 ShouldNotReachHere();
2301 return REGIONS_UNLIMITED;
2302 };
2303 }
2305 void G1CollectorPolicy::calculate_max_gc_locker_expansion() {
2306 size_t expansion_region_num = 0;
2307 if (GCLockerEdenExpansionPercent > 0) {
2308 double perc = (double) GCLockerEdenExpansionPercent / 100.0;
2309 double expansion_region_num_d = perc * (double) _young_list_target_length;
2310 // We use ceiling so that if expansion_region_num_d is > 0.0 (but
2311 // less than 1.0) we'll get 1.
2312 expansion_region_num = (size_t) ceil(expansion_region_num_d);
2313 } else {
2314 assert(expansion_region_num == 0, "sanity");
2315 }
2316 _young_list_max_length = _young_list_target_length + expansion_region_num;
2317 assert(_young_list_target_length <= _young_list_max_length, "post-condition");
2318 }
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 {
2326 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes;
2327 }
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 }
2337 #ifndef PRODUCT
2338 class HRSortIndexIsOKClosure: public HeapRegionClosure {
2339 CollectionSetChooser* _chooser;
2340 public:
2341 HRSortIndexIsOKClosure(CollectionSetChooser* chooser) :
2342 _chooser(chooser) {}
2344 bool doHeapRegion(HeapRegion* r) {
2345 if (!r->continuesHumongous()) {
2346 assert(_chooser->regionProperlyOrdered(r), "Ought to be.");
2347 }
2348 return false;
2349 }
2350 };
2352 bool G1CollectorPolicy_BestRegionsFirst::assertMarkedBytesDataOK() {
2353 HRSortIndexIsOKClosure cl(_collectionSetChooser);
2354 _g1->heap_region_iterate(&cl);
2355 return true;
2356 }
2357 #endif
2359 bool
2360 G1CollectorPolicy::force_initial_mark_if_outside_cycle() {
2361 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle();
2362 if (!during_cycle) {
2363 set_initiate_conc_mark_if_possible();
2364 return true;
2365 } else {
2366 return false;
2367 }
2368 }
2370 void
2371 G1CollectorPolicy::decide_on_conc_mark_initiation() {
2372 // We are about to decide on whether this pause will be an
2373 // initial-mark pause.
2375 // First, during_initial_mark_pause() should not be already set. We
2376 // will set it here if we have to. However, it should be cleared by
2377 // the end of the pause (it's only set for the duration of an
2378 // initial-mark pause).
2379 assert(!during_initial_mark_pause(), "pre-condition");
2381 if (initiate_conc_mark_if_possible()) {
2382 // We had noticed on a previous pause that the heap occupancy has
2383 // gone over the initiating threshold and we should start a
2384 // concurrent marking cycle. So we might initiate one.
2386 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle();
2387 if (!during_cycle) {
2388 // The concurrent marking thread is not "during a cycle", i.e.,
2389 // it has completed the last one. So we can go ahead and
2390 // initiate a new cycle.
2392 set_during_initial_mark_pause();
2394 // And we can now clear initiate_conc_mark_if_possible() as
2395 // we've already acted on it.
2396 clear_initiate_conc_mark_if_possible();
2397 } else {
2398 // The concurrent marking thread is still finishing up the
2399 // previous cycle. If we start one right now the two cycles
2400 // overlap. In particular, the concurrent marking thread might
2401 // be in the process of clearing the next marking bitmap (which
2402 // we will use for the next cycle if we start one). Starting a
2403 // cycle now will be bad given that parts of the marking
2404 // information might get cleared by the marking thread. And we
2405 // cannot wait for the marking thread to finish the cycle as it
2406 // periodically yields while clearing the next marking bitmap
2407 // and, if it's in a yield point, it's waiting for us to
2408 // finish. So, at this point we will not start a cycle and we'll
2409 // let the concurrent marking thread complete the last one.
2410 }
2411 }
2412 }
2414 void
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 }
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 };
2435 class KnownGarbageClosure: public HeapRegionClosure {
2436 CollectionSetChooser* _hrSorted;
2438 public:
2439 KnownGarbageClosure(CollectionSetChooser* hrSorted) :
2440 _hrSorted(hrSorted)
2441 {}
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.
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 };
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;
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 }
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 {}
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++;
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 };
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 {}
2527 void work(int i) {
2528 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size, i);
2529 // Back to zero for the claim value.
2530 _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, i,
2531 HeapRegion::InitialClaimValue);
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 };
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);
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 }
2556 if (G1CollectedHeap::use_parallel_gc_threads()) {
2557 const size_t OverpartitionFactor = 4;
2558 const size_t MinWorkUnit = 8;
2559 const size_t WorkUnit =
2560 MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor),
2561 MinWorkUnit);
2562 _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(),
2563 WorkUnit);
2564 ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser,
2565 (int) WorkUnit);
2566 _g1->workers()->run_task(&parKnownGarbageTask);
2568 assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
2569 "sanity check");
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 }
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 }
2597 // Add the heap region at the head of the non-incremental collection set
2598 void G1CollectorPolicy::
2599 add_to_collection_set(HeapRegion* hr) {
2600 assert(_inc_cset_build_state == Active, "Precondition");
2601 assert(!hr->is_young(), "non-incremental add of young region");
2603 if (G1PrintHeapRegions) {
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");
2609 }
2611 if (_g1->mark_in_progress())
2612 _g1->concurrent_mark()->registerCSetRegion(hr);
2614 assert(!hr->in_collection_set(), "should not already be in the CSet");
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();
2620 _g1->register_region_with_in_cset_fast_test(hr);
2621 }
2623 // Initialize the per-collection-set information
2624 void G1CollectorPolicy::start_incremental_cset_building() {
2625 assert(_inc_cset_build_state == Inactive, "Precondition");
2627 _inc_cset_head = NULL;
2628 _inc_cset_tail = NULL;
2629 _inc_cset_size = 0;
2630 _inc_cset_bytes_used_before = 0;
2632 if (in_young_gc_mode()) {
2633 _inc_cset_young_index = 0;
2634 }
2636 _inc_cset_max_finger = 0;
2637 _inc_cset_recorded_young_bytes = 0;
2638 _inc_cset_recorded_rs_lengths = 0;
2639 _inc_cset_predicted_elapsed_time_ms = 0;
2640 _inc_cset_predicted_bytes_to_copy = 0;
2641 _inc_cset_build_state = Active;
2642 }
2644 void G1CollectorPolicy::add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length) {
2645 // This routine is used when:
2646 // * adding survivor regions to the incremental cset at the end of an
2647 // evacuation pause,
2648 // * adding the current allocation region to the incremental cset
2649 // when it is retired, and
2650 // * updating existing policy information for a region in the
2651 // incremental cset via young list RSet sampling.
2652 // Therefore this routine may be called at a safepoint by the
2653 // VM thread, or in-between safepoints by mutator threads (when
2654 // retiring the current allocation region) or a concurrent
2655 // refine thread (RSet sampling).
2657 double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, true);
2658 size_t used_bytes = hr->used();
2660 _inc_cset_recorded_rs_lengths += rs_length;
2661 _inc_cset_predicted_elapsed_time_ms += region_elapsed_time_ms;
2663 _inc_cset_bytes_used_before += used_bytes;
2665 // Cache the values we have added to the aggregated informtion
2666 // in the heap region in case we have to remove this region from
2667 // the incremental collection set, or it is updated by the
2668 // rset sampling code
2669 hr->set_recorded_rs_length(rs_length);
2670 hr->set_predicted_elapsed_time_ms(region_elapsed_time_ms);
2672 #if PREDICTIONS_VERBOSE
2673 size_t bytes_to_copy = predict_bytes_to_copy(hr);
2674 _inc_cset_predicted_bytes_to_copy += bytes_to_copy;
2676 // Record the number of bytes used in this region
2677 _inc_cset_recorded_young_bytes += used_bytes;
2679 // Cache the values we have added to the aggregated informtion
2680 // in the heap region in case we have to remove this region from
2681 // the incremental collection set, or it is updated by the
2682 // rset sampling code
2683 hr->set_predicted_bytes_to_copy(bytes_to_copy);
2684 #endif // PREDICTIONS_VERBOSE
2685 }
2687 void G1CollectorPolicy::remove_from_incremental_cset_info(HeapRegion* hr) {
2688 // This routine is currently only called as part of the updating of
2689 // existing policy information for regions in the incremental cset that
2690 // is performed by the concurrent refine thread(s) as part of young list
2691 // RSet sampling. Therefore we should not be at a safepoint.
2693 assert(!SafepointSynchronize::is_at_safepoint(), "should not be at safepoint");
2694 assert(hr->is_young(), "it should be");
2696 size_t used_bytes = hr->used();
2697 size_t old_rs_length = hr->recorded_rs_length();
2698 double old_elapsed_time_ms = hr->predicted_elapsed_time_ms();
2700 // Subtract the old recorded/predicted policy information for
2701 // the given heap region from the collection set info.
2702 _inc_cset_recorded_rs_lengths -= old_rs_length;
2703 _inc_cset_predicted_elapsed_time_ms -= old_elapsed_time_ms;
2705 _inc_cset_bytes_used_before -= used_bytes;
2707 // Clear the values cached in the heap region
2708 hr->set_recorded_rs_length(0);
2709 hr->set_predicted_elapsed_time_ms(0);
2711 #if PREDICTIONS_VERBOSE
2712 size_t old_predicted_bytes_to_copy = hr->predicted_bytes_to_copy();
2713 _inc_cset_predicted_bytes_to_copy -= old_predicted_bytes_to_copy;
2715 // Subtract the number of bytes used in this region
2716 _inc_cset_recorded_young_bytes -= used_bytes;
2718 // Clear the values cached in the heap region
2719 hr->set_predicted_bytes_to_copy(0);
2720 #endif // PREDICTIONS_VERBOSE
2721 }
2723 void G1CollectorPolicy::update_incremental_cset_info(HeapRegion* hr, size_t new_rs_length) {
2724 // Update the collection set information that is dependent on the new RS length
2725 assert(hr->is_young(), "Precondition");
2727 remove_from_incremental_cset_info(hr);
2728 add_to_incremental_cset_info(hr, new_rs_length);
2729 }
2731 void G1CollectorPolicy::add_region_to_incremental_cset_common(HeapRegion* hr) {
2732 assert( hr->is_young(), "invariant");
2733 assert( hr->young_index_in_cset() == -1, "invariant" );
2734 assert(_inc_cset_build_state == Active, "Precondition");
2736 // We need to clear and set the cached recorded/cached collection set
2737 // information in the heap region here (before the region gets added
2738 // to the collection set). An individual heap region's cached values
2739 // are calculated, aggregated with the policy collection set info,
2740 // and cached in the heap region here (initially) and (subsequently)
2741 // by the Young List sampling code.
2743 size_t rs_length = hr->rem_set()->occupied();
2744 add_to_incremental_cset_info(hr, rs_length);
2746 HeapWord* hr_end = hr->end();
2747 _inc_cset_max_finger = MAX2(_inc_cset_max_finger, hr_end);
2749 assert(!hr->in_collection_set(), "invariant");
2750 hr->set_in_collection_set(true);
2751 assert( hr->next_in_collection_set() == NULL, "invariant");
2753 _inc_cset_size++;
2754 _g1->register_region_with_in_cset_fast_test(hr);
2756 hr->set_young_index_in_cset((int) _inc_cset_young_index);
2757 ++_inc_cset_young_index;
2758 }
2760 // Add the region at the RHS of the incremental cset
2761 void G1CollectorPolicy::add_region_to_incremental_cset_rhs(HeapRegion* hr) {
2762 // We should only ever be appending survivors at the end of a pause
2763 assert( hr->is_survivor(), "Logic");
2765 // Do the 'common' stuff
2766 add_region_to_incremental_cset_common(hr);
2768 // Now add the region at the right hand side
2769 if (_inc_cset_tail == NULL) {
2770 assert(_inc_cset_head == NULL, "invariant");
2771 _inc_cset_head = hr;
2772 } else {
2773 _inc_cset_tail->set_next_in_collection_set(hr);
2774 }
2775 _inc_cset_tail = hr;
2777 if (G1PrintHeapRegions) {
2778 gclog_or_tty->print_cr(" added region to incremental cset (RHS) "
2779 "%d:["PTR_FORMAT", "PTR_FORMAT"], "
2780 "top "PTR_FORMAT", young %s",
2781 hr->hrs_index(), hr->bottom(), hr->end(),
2782 hr->top(), (hr->is_young()) ? "YES" : "NO");
2783 }
2784 }
2786 // Add the region to the LHS of the incremental cset
2787 void G1CollectorPolicy::add_region_to_incremental_cset_lhs(HeapRegion* hr) {
2788 // Survivors should be added to the RHS at the end of a pause
2789 assert(!hr->is_survivor(), "Logic");
2791 // Do the 'common' stuff
2792 add_region_to_incremental_cset_common(hr);
2794 // Add the region at the left hand side
2795 hr->set_next_in_collection_set(_inc_cset_head);
2796 if (_inc_cset_head == NULL) {
2797 assert(_inc_cset_tail == NULL, "Invariant");
2798 _inc_cset_tail = hr;
2799 }
2800 _inc_cset_head = hr;
2802 if (G1PrintHeapRegions) {
2803 gclog_or_tty->print_cr(" added region to incremental cset (LHS) "
2804 "%d:["PTR_FORMAT", "PTR_FORMAT"], "
2805 "top "PTR_FORMAT", young %s",
2806 hr->hrs_index(), hr->bottom(), hr->end(),
2807 hr->top(), (hr->is_young()) ? "YES" : "NO");
2808 }
2809 }
2811 #ifndef PRODUCT
2812 void G1CollectorPolicy::print_collection_set(HeapRegion* list_head, outputStream* st) {
2813 assert(list_head == inc_cset_head() || list_head == collection_set(), "must be");
2815 st->print_cr("\nCollection_set:");
2816 HeapRegion* csr = list_head;
2817 while (csr != NULL) {
2818 HeapRegion* next = csr->next_in_collection_set();
2819 assert(csr->in_collection_set(), "bad CS");
2820 st->print_cr(" [%08x-%08x], t: %08x, P: %08x, N: %08x, C: %08x, "
2821 "age: %4d, y: %d, surv: %d",
2822 csr->bottom(), csr->end(),
2823 csr->top(),
2824 csr->prev_top_at_mark_start(),
2825 csr->next_top_at_mark_start(),
2826 csr->top_at_conc_mark_count(),
2827 csr->age_in_surv_rate_group_cond(),
2828 csr->is_young(),
2829 csr->is_survivor());
2830 csr = next;
2831 }
2832 }
2833 #endif // !PRODUCT
2835 void
2836 G1CollectorPolicy_BestRegionsFirst::choose_collection_set(
2837 double target_pause_time_ms) {
2838 // Set this here - in case we're not doing young collections.
2839 double non_young_start_time_sec = os::elapsedTime();
2841 start_recording_regions();
2843 guarantee(target_pause_time_ms > 0.0,
2844 err_msg("target_pause_time_ms = %1.6lf should be positive",
2845 target_pause_time_ms));
2846 guarantee(_collection_set == NULL, "Precondition");
2848 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards);
2849 double predicted_pause_time_ms = base_time_ms;
2851 double time_remaining_ms = target_pause_time_ms - base_time_ms;
2853 // the 10% and 50% values are arbitrary...
2854 if (time_remaining_ms < 0.10 * target_pause_time_ms) {
2855 time_remaining_ms = 0.50 * target_pause_time_ms;
2856 _within_target = false;
2857 } else {
2858 _within_target = true;
2859 }
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;
2869 size_t expansion_bytes =
2870 _g1->expansion_regions() * HeapRegion::GrainBytes;
2872 _collection_set_bytes_used_before = 0;
2873 _collection_set_size = 0;
2875 // Adjust for expansion and slop.
2876 max_live_bytes = max_live_bytes + expansion_bytes;
2878 HeapRegion* hr;
2879 if (in_young_gc_mode()) {
2880 double young_start_time_sec = os::elapsedTime();
2882 if (G1PolicyVerbose > 0) {
2883 gclog_or_tty->print_cr("Adding %d young regions to the CSet",
2884 _g1->young_list()->length());
2885 }
2887 _young_cset_length = 0;
2888 _last_young_gc_full = full_young_gcs() ? true : false;
2890 if (_last_young_gc_full)
2891 ++_full_young_pause_num;
2892 else
2893 ++_partial_young_pause_num;
2895 // The young list is laid with the survivor regions from the previous
2896 // pause are appended to the RHS of the young list, i.e.
2897 // [Newly Young Regions ++ Survivors from last pause].
2899 hr = _g1->young_list()->first_survivor_region();
2900 while (hr != NULL) {
2901 assert(hr->is_survivor(), "badly formed young list");
2902 hr->set_young();
2903 hr = hr->get_next_young_region();
2904 }
2906 // Clear the fields that point to the survivor list - they are
2907 // all young now.
2908 _g1->young_list()->clear_survivors();
2910 if (_g1->mark_in_progress())
2911 _g1->concurrent_mark()->register_collection_set_finger(_inc_cset_max_finger);
2913 _young_cset_length = _inc_cset_young_index;
2914 _collection_set = _inc_cset_head;
2915 _collection_set_size = _inc_cset_size;
2916 _collection_set_bytes_used_before = _inc_cset_bytes_used_before;
2918 // For young regions in the collection set, we assume the worst
2919 // case of complete survival
2920 max_live_bytes -= _inc_cset_size * HeapRegion::GrainBytes;
2922 time_remaining_ms -= _inc_cset_predicted_elapsed_time_ms;
2923 predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms;
2925 // The number of recorded young regions is the incremental
2926 // collection set's current size
2927 set_recorded_young_regions(_inc_cset_size);
2928 set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths);
2929 set_recorded_young_bytes(_inc_cset_recorded_young_bytes);
2930 #if PREDICTIONS_VERBOSE
2931 set_predicted_bytes_to_copy(_inc_cset_predicted_bytes_to_copy);
2932 #endif // PREDICTIONS_VERBOSE
2934 if (G1PolicyVerbose > 0) {
2935 gclog_or_tty->print_cr(" Added " PTR_FORMAT " Young Regions to CS.",
2936 _inc_cset_size);
2937 gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)",
2938 max_live_bytes/K);
2939 }
2941 assert(_inc_cset_size == _g1->young_list()->length(), "Invariant");
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;
2947 // We are doing young collections so reset this.
2948 non_young_start_time_sec = young_end_time_sec;
2950 // Note we can use either _collection_set_size or
2951 // _young_cset_length here
2952 if (_collection_set_size > 0 && _last_young_gc_full) {
2953 // don't bother adding more regions...
2954 goto choose_collection_set_end;
2955 }
2956 }
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
2963 do {
2964 hr = _collectionSetChooser->getNextMarkedRegion(time_remaining_ms,
2965 avg_prediction);
2966 if (hr != NULL) {
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);
2971 record_non_young_cset_region(hr);
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);
2986 if (!adaptive_young_list_length() &&
2987 _collection_set_size < _young_list_fixed_length)
2988 _should_revert_to_full_young_gcs = true;
2989 }
2991 choose_collection_set_end:
2992 stop_incremental_cset_building();
2994 count_CS_bytes_used();
2996 end_recording_regions();
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 }
3003 void G1CollectorPolicy_BestRegionsFirst::record_full_collection_end() {
3004 G1CollectorPolicy::record_full_collection_end();
3005 _collectionSetChooser->updateAfterFullCollection();
3006 }
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 }
3014 void G1CollectorPolicy_BestRegionsFirst::
3015 record_collection_pause_end() {
3016 G1CollectorPolicy::record_collection_pause_end();
3017 assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end.");
3018 }