Mon, 03 Aug 2009 12:59:30 -0700
6865703: G1: Parallelize hot card cache cleanup
Summary: Have the GC worker threads clear the hot card cache in parallel by having each worker thread claim a chunk of the card cache and process the cards in that chunk. The size of the chunks that each thread will claim is determined at VM initialization from the size of the card cache and the number of worker threads.
Reviewed-by: jmasa, tonyp
1 /*
2 * Copyright 2001-2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
25 #include "incls/_precompiled.incl"
26 #include "incls/_g1CollectorPolicy.cpp.incl"
28 #define PREDICTIONS_VERBOSE 0
30 // <NEW PREDICTION>
32 // Different defaults for different number of GC threads
33 // They were chosen by running GCOld and SPECjbb on debris with different
34 // numbers of GC threads and choosing them based on the results
36 // all the same
37 static double rs_length_diff_defaults[] = {
38 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
39 };
41 static double cost_per_card_ms_defaults[] = {
42 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015
43 };
45 static double cost_per_scan_only_region_ms_defaults[] = {
46 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
47 };
49 // all the same
50 static double fully_young_cards_per_entry_ratio_defaults[] = {
51 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
52 };
54 static double cost_per_entry_ms_defaults[] = {
55 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005
56 };
58 static double cost_per_byte_ms_defaults[] = {
59 0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009
60 };
62 // these should be pretty consistent
63 static double constant_other_time_ms_defaults[] = {
64 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0
65 };
68 static double young_other_cost_per_region_ms_defaults[] = {
69 0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1
70 };
72 static double non_young_other_cost_per_region_ms_defaults[] = {
73 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30
74 };
76 // </NEW PREDICTION>
78 G1CollectorPolicy::G1CollectorPolicy() :
79 _parallel_gc_threads((ParallelGCThreads > 0) ? ParallelGCThreads : 1),
80 _n_pauses(0),
81 _recent_CH_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
82 _recent_G1_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
83 _recent_evac_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
84 _recent_pause_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
85 _recent_rs_sizes(new TruncatedSeq(NumPrevPausesForHeuristics)),
86 _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
87 _all_pause_times_ms(new NumberSeq()),
88 _stop_world_start(0.0),
89 _all_stop_world_times_ms(new NumberSeq()),
90 _all_yield_times_ms(new NumberSeq()),
92 _all_mod_union_times_ms(new NumberSeq()),
94 _summary(new Summary()),
95 _abandoned_summary(new AbandonedSummary()),
97 _cur_clear_ct_time_ms(0.0),
99 _region_num_young(0),
100 _region_num_tenured(0),
101 _prev_region_num_young(0),
102 _prev_region_num_tenured(0),
104 _aux_num(10),
105 _all_aux_times_ms(new NumberSeq[_aux_num]),
106 _cur_aux_start_times_ms(new double[_aux_num]),
107 _cur_aux_times_ms(new double[_aux_num]),
108 _cur_aux_times_set(new bool[_aux_num]),
110 _concurrent_mark_init_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
111 _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
112 _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
114 // <NEW PREDICTION>
116 _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
117 _prev_collection_pause_end_ms(0.0),
118 _pending_card_diff_seq(new TruncatedSeq(TruncatedSeqLength)),
119 _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)),
120 _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
121 _cost_per_scan_only_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
122 _fully_young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),
123 _partially_young_cards_per_entry_ratio_seq(
124 new TruncatedSeq(TruncatedSeqLength)),
125 _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
126 _partially_young_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
127 _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
128 _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)),
129 _cost_per_scan_only_region_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)),
130 _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
131 _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
132 _non_young_other_cost_per_region_ms_seq(
133 new TruncatedSeq(TruncatedSeqLength)),
135 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
136 _scanned_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
137 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)),
139 _pause_time_target_ms((double) MaxGCPauseMillis),
141 // </NEW PREDICTION>
143 _in_young_gc_mode(false),
144 _full_young_gcs(true),
145 _full_young_pause_num(0),
146 _partial_young_pause_num(0),
148 _during_marking(false),
149 _in_marking_window(false),
150 _in_marking_window_im(false),
152 _known_garbage_ratio(0.0),
153 _known_garbage_bytes(0),
155 _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)),
156 _target_pause_time_ms(-1.0),
158 _recent_prev_end_times_for_all_gcs_sec(new TruncatedSeq(NumPrevPausesForHeuristics)),
160 _recent_CS_bytes_used_before(new TruncatedSeq(NumPrevPausesForHeuristics)),
161 _recent_CS_bytes_surviving(new TruncatedSeq(NumPrevPausesForHeuristics)),
163 _recent_avg_pause_time_ratio(0.0),
164 _num_markings(0),
165 _n_marks(0),
166 _n_pauses_at_mark_end(0),
168 _all_full_gc_times_ms(new NumberSeq()),
170 // G1PausesBtwnConcMark defaults to -1
171 // so the hack is to do the cast QQQ FIXME
172 _pauses_btwn_concurrent_mark((size_t)G1PausesBtwnConcMark),
173 _n_marks_since_last_pause(0),
174 _conc_mark_initiated(false),
175 _should_initiate_conc_mark(false),
176 _should_revert_to_full_young_gcs(false),
177 _last_full_young_gc(false),
179 _prev_collection_pause_used_at_end_bytes(0),
181 _collection_set(NULL),
182 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away
183 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list
184 #endif // _MSC_VER
186 _short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived",
187 G1YoungSurvRateNumRegionsSummary)),
188 _survivor_surv_rate_group(new SurvRateGroup(this, "Survivor",
189 G1YoungSurvRateNumRegionsSummary)),
190 // add here any more surv rate groups
191 _recorded_survivor_regions(0),
192 _recorded_survivor_head(NULL),
193 _recorded_survivor_tail(NULL),
194 _survivors_age_table(true)
196 {
197 _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime());
198 _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0;
200 _par_last_ext_root_scan_times_ms = new double[_parallel_gc_threads];
201 _par_last_mark_stack_scan_times_ms = new double[_parallel_gc_threads];
202 _par_last_scan_only_times_ms = new double[_parallel_gc_threads];
203 _par_last_scan_only_regions_scanned = new double[_parallel_gc_threads];
205 _par_last_update_rs_start_times_ms = new double[_parallel_gc_threads];
206 _par_last_update_rs_times_ms = new double[_parallel_gc_threads];
207 _par_last_update_rs_processed_buffers = new double[_parallel_gc_threads];
209 _par_last_scan_rs_start_times_ms = new double[_parallel_gc_threads];
210 _par_last_scan_rs_times_ms = new double[_parallel_gc_threads];
211 _par_last_scan_new_refs_times_ms = new double[_parallel_gc_threads];
213 _par_last_obj_copy_times_ms = new double[_parallel_gc_threads];
215 _par_last_termination_times_ms = new double[_parallel_gc_threads];
217 // start conservatively
218 _expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis;
220 // <NEW PREDICTION>
222 int index;
223 if (ParallelGCThreads == 0)
224 index = 0;
225 else if (ParallelGCThreads > 8)
226 index = 7;
227 else
228 index = ParallelGCThreads - 1;
230 _pending_card_diff_seq->add(0.0);
231 _rs_length_diff_seq->add(rs_length_diff_defaults[index]);
232 _cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]);
233 _cost_per_scan_only_region_ms_seq->add(
234 cost_per_scan_only_region_ms_defaults[index]);
235 _fully_young_cards_per_entry_ratio_seq->add(
236 fully_young_cards_per_entry_ratio_defaults[index]);
237 _cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]);
238 _cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]);
239 _constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]);
240 _young_other_cost_per_region_ms_seq->add(
241 young_other_cost_per_region_ms_defaults[index]);
242 _non_young_other_cost_per_region_ms_seq->add(
243 non_young_other_cost_per_region_ms_defaults[index]);
245 // </NEW PREDICTION>
247 double time_slice = (double) GCPauseIntervalMillis / 1000.0;
248 double max_gc_time = (double) MaxGCPauseMillis / 1000.0;
249 guarantee(max_gc_time < time_slice,
250 "Max GC time should not be greater than the time slice");
251 _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time);
252 _sigma = (double) G1ConfidencePercent / 100.0;
254 // start conservatively (around 50ms is about right)
255 _concurrent_mark_init_times_ms->add(0.05);
256 _concurrent_mark_remark_times_ms->add(0.05);
257 _concurrent_mark_cleanup_times_ms->add(0.20);
258 _tenuring_threshold = MaxTenuringThreshold;
260 if (G1UseSurvivorSpaces) {
261 // if G1FixedSurvivorSpaceSize is 0 which means the size is not
262 // fixed, then _max_survivor_regions will be calculated at
263 // calculate_young_list_target_config during initialization
264 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes;
265 } else {
266 _max_survivor_regions = 0;
267 }
269 initialize_all();
270 }
272 // Increment "i", mod "len"
273 static void inc_mod(int& i, int len) {
274 i++; if (i == len) i = 0;
275 }
277 void G1CollectorPolicy::initialize_flags() {
278 set_min_alignment(HeapRegion::GrainBytes);
279 set_max_alignment(GenRemSet::max_alignment_constraint(rem_set_name()));
280 if (SurvivorRatio < 1) {
281 vm_exit_during_initialization("Invalid survivor ratio specified");
282 }
283 CollectorPolicy::initialize_flags();
284 }
286 void G1CollectorPolicy::init() {
287 // Set aside an initial future to_space.
288 _g1 = G1CollectedHeap::heap();
289 size_t regions = Universe::heap()->capacity() / HeapRegion::GrainBytes;
291 assert(Heap_lock->owned_by_self(), "Locking discipline.");
293 if (G1SteadyStateUsed < 50) {
294 vm_exit_during_initialization("G1SteadyStateUsed must be at least 50%.");
295 }
297 initialize_gc_policy_counters();
299 if (G1Gen) {
300 _in_young_gc_mode = true;
302 if (G1YoungGenSize == 0) {
303 set_adaptive_young_list_length(true);
304 _young_list_fixed_length = 0;
305 } else {
306 set_adaptive_young_list_length(false);
307 _young_list_fixed_length = (G1YoungGenSize / HeapRegion::GrainBytes);
308 }
309 _free_regions_at_end_of_collection = _g1->free_regions();
310 _scan_only_regions_at_end_of_collection = 0;
311 calculate_young_list_min_length();
312 guarantee( _young_list_min_length == 0, "invariant, not enough info" );
313 calculate_young_list_target_config();
314 } else {
315 _young_list_fixed_length = 0;
316 _in_young_gc_mode = false;
317 }
318 }
320 // Create the jstat counters for the policy.
321 void G1CollectorPolicy::initialize_gc_policy_counters()
322 {
323 _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 2 + G1Gen);
324 }
326 void G1CollectorPolicy::calculate_young_list_min_length() {
327 _young_list_min_length = 0;
329 if (!adaptive_young_list_length())
330 return;
332 if (_alloc_rate_ms_seq->num() > 3) {
333 double now_sec = os::elapsedTime();
334 double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0;
335 double alloc_rate_ms = predict_alloc_rate_ms();
336 int min_regions = (int) ceil(alloc_rate_ms * when_ms);
337 int current_region_num = (int) _g1->young_list_length();
338 _young_list_min_length = min_regions + current_region_num;
339 }
340 }
342 void G1CollectorPolicy::calculate_young_list_target_config() {
343 if (adaptive_young_list_length()) {
344 size_t rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq);
345 calculate_young_list_target_config(rs_lengths);
346 } else {
347 if (full_young_gcs())
348 _young_list_target_length = _young_list_fixed_length;
349 else
350 _young_list_target_length = _young_list_fixed_length / 2;
351 _young_list_target_length = MAX2(_young_list_target_length, (size_t)1);
352 size_t so_length = calculate_optimal_so_length(_young_list_target_length);
353 guarantee( so_length < _young_list_target_length, "invariant" );
354 _young_list_so_prefix_length = so_length;
355 }
356 calculate_survivors_policy();
357 }
359 // This method calculate the optimal scan-only set for a fixed young
360 // gen size. I couldn't work out how to reuse the more elaborate one,
361 // i.e. calculate_young_list_target_config(rs_length), as the loops are
362 // fundamentally different (the other one finds a config for different
363 // S-O lengths, whereas here we need to do the opposite).
364 size_t G1CollectorPolicy::calculate_optimal_so_length(
365 size_t young_list_length) {
366 if (!G1UseScanOnlyPrefix)
367 return 0;
369 if (_all_pause_times_ms->num() < 3) {
370 // we won't use a scan-only set at the beginning to allow the rest
371 // of the predictors to warm up
372 return 0;
373 }
375 if (_cost_per_scan_only_region_ms_seq->num() < 3) {
376 // then, we'll only set the S-O set to 1 for a little bit of time,
377 // to get enough information on the scanning cost
378 return 1;
379 }
381 size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq);
382 size_t rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq);
383 size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff();
384 size_t scanned_cards;
385 if (full_young_gcs())
386 scanned_cards = predict_young_card_num(adj_rs_lengths);
387 else
388 scanned_cards = predict_non_young_card_num(adj_rs_lengths);
389 double base_time_ms = predict_base_elapsed_time_ms(pending_cards,
390 scanned_cards);
392 size_t so_length = 0;
393 double max_gc_eff = 0.0;
394 for (size_t i = 0; i < young_list_length; ++i) {
395 double gc_eff = 0.0;
396 double pause_time_ms = 0.0;
397 predict_gc_eff(young_list_length, i, base_time_ms,
398 &gc_eff, &pause_time_ms);
399 if (gc_eff > max_gc_eff) {
400 max_gc_eff = gc_eff;
401 so_length = i;
402 }
403 }
405 // set it to 95% of the optimal to make sure we sample the "area"
406 // around the optimal length to get up-to-date survival rate data
407 return so_length * 950 / 1000;
408 }
410 // This is a really cool piece of code! It finds the best
411 // target configuration (young length / scan-only prefix length) so
412 // that GC efficiency is maximized and that we also meet a pause
413 // time. It's a triple nested loop. These loops are explained below
414 // from the inside-out :-)
415 //
416 // (a) The innermost loop will try to find the optimal young length
417 // for a fixed S-O length. It uses a binary search to speed up the
418 // process. We assume that, for a fixed S-O length, as we add more
419 // young regions to the CSet, the GC efficiency will only go up (I'll
420 // skip the proof). So, using a binary search to optimize this process
421 // makes perfect sense.
422 //
423 // (b) The middle loop will fix the S-O length before calling the
424 // innermost one. It will vary it between two parameters, increasing
425 // it by a given increment.
426 //
427 // (c) The outermost loop will call the middle loop three times.
428 // (1) The first time it will explore all possible S-O length values
429 // from 0 to as large as it can get, using a coarse increment (to
430 // quickly "home in" to where the optimal seems to be).
431 // (2) The second time it will explore the values around the optimal
432 // that was found by the first iteration using a fine increment.
433 // (3) Once the optimal config has been determined by the second
434 // iteration, we'll redo the calculation, but setting the S-O length
435 // to 95% of the optimal to make sure we sample the "area"
436 // around the optimal length to get up-to-date survival rate data
437 //
438 // Termination conditions for the iterations are several: the pause
439 // time is over the limit, we do not have enough to-space, etc.
441 void G1CollectorPolicy::calculate_young_list_target_config(size_t rs_lengths) {
442 guarantee( adaptive_young_list_length(), "pre-condition" );
444 double start_time_sec = os::elapsedTime();
445 size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1MinReservePercent);
446 min_reserve_perc = MIN2((size_t) 50, min_reserve_perc);
447 size_t reserve_regions =
448 (size_t) ((double) min_reserve_perc * (double) _g1->n_regions() / 100.0);
450 if (full_young_gcs() && _free_regions_at_end_of_collection > 0) {
451 // we are in fully-young mode and there are free regions in the heap
453 double survivor_regions_evac_time =
454 predict_survivor_regions_evac_time();
456 size_t min_so_length = 0;
457 size_t max_so_length = 0;
459 if (G1UseScanOnlyPrefix) {
460 if (_all_pause_times_ms->num() < 3) {
461 // we won't use a scan-only set at the beginning to allow the rest
462 // of the predictors to warm up
463 min_so_length = 0;
464 max_so_length = 0;
465 } else if (_cost_per_scan_only_region_ms_seq->num() < 3) {
466 // then, we'll only set the S-O set to 1 for a little bit of time,
467 // to get enough information on the scanning cost
468 min_so_length = 1;
469 max_so_length = 1;
470 } else if (_in_marking_window || _last_full_young_gc) {
471 // no S-O prefix during a marking phase either, as at the end
472 // of the marking phase we'll have to use a very small young
473 // length target to fill up the rest of the CSet with
474 // non-young regions and, if we have lots of scan-only regions
475 // left-over, we will not be able to add any more non-young
476 // regions.
477 min_so_length = 0;
478 max_so_length = 0;
479 } else {
480 // this is the common case; we'll never reach the maximum, we
481 // one of the end conditions will fire well before that
482 // (hopefully!)
483 min_so_length = 0;
484 max_so_length = _free_regions_at_end_of_collection - 1;
485 }
486 } else {
487 // no S-O prefix, as the switch is not set, but we still need to
488 // do one iteration to calculate the best young target that
489 // meets the pause time; this way we reuse the same code instead
490 // of replicating it
491 min_so_length = 0;
492 max_so_length = 0;
493 }
495 double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0;
496 size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq);
497 size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff();
498 size_t scanned_cards;
499 if (full_young_gcs())
500 scanned_cards = predict_young_card_num(adj_rs_lengths);
501 else
502 scanned_cards = predict_non_young_card_num(adj_rs_lengths);
503 // calculate this once, so that we don't have to recalculate it in
504 // the innermost loop
505 double base_time_ms = predict_base_elapsed_time_ms(pending_cards, scanned_cards)
506 + survivor_regions_evac_time;
507 // the result
508 size_t final_young_length = 0;
509 size_t final_so_length = 0;
510 double final_gc_eff = 0.0;
511 // we'll also keep track of how many times we go into the inner loop
512 // this is for profiling reasons
513 size_t calculations = 0;
515 // this determines which of the three iterations the outer loop is in
516 typedef enum {
517 pass_type_coarse,
518 pass_type_fine,
519 pass_type_final
520 } pass_type_t;
522 // range of the outer loop's iteration
523 size_t from_so_length = min_so_length;
524 size_t to_so_length = max_so_length;
525 guarantee( from_so_length <= to_so_length, "invariant" );
527 // this will keep the S-O length that's found by the second
528 // iteration of the outer loop; we'll keep it just in case the third
529 // iteration fails to find something
530 size_t fine_so_length = 0;
532 // the increment step for the coarse (first) iteration
533 size_t so_coarse_increments = 5;
535 // the common case, we'll start with the coarse iteration
536 pass_type_t pass = pass_type_coarse;
537 size_t so_length_incr = so_coarse_increments;
539 if (from_so_length == to_so_length) {
540 // not point in doing the coarse iteration, we'll go directly into
541 // the fine one (we essentially trying to find the optimal young
542 // length for a fixed S-O length).
543 so_length_incr = 1;
544 pass = pass_type_final;
545 } else if (to_so_length - from_so_length < 3 * so_coarse_increments) {
546 // again, the range is too short so no point in foind the coarse
547 // iteration either
548 so_length_incr = 1;
549 pass = pass_type_fine;
550 }
552 bool done = false;
553 // this is the outermost loop
554 while (!done) {
555 #ifdef TRACE_CALC_YOUNG_CONFIG
556 // leave this in for debugging, just in case
557 gclog_or_tty->print_cr("searching between " SIZE_FORMAT " and " SIZE_FORMAT
558 ", incr " SIZE_FORMAT ", pass %s",
559 from_so_length, to_so_length, so_length_incr,
560 (pass == pass_type_coarse) ? "coarse" :
561 (pass == pass_type_fine) ? "fine" : "final");
562 #endif // TRACE_CALC_YOUNG_CONFIG
564 size_t so_length = from_so_length;
565 size_t init_free_regions =
566 MAX2((size_t)0,
567 _free_regions_at_end_of_collection +
568 _scan_only_regions_at_end_of_collection - reserve_regions);
570 // this determines whether a configuration was found
571 bool gc_eff_set = false;
572 // this is the middle loop
573 while (so_length <= to_so_length) {
574 // base time, which excludes region-related time; again we
575 // calculate it once to avoid recalculating it in the
576 // innermost loop
577 double base_time_with_so_ms =
578 base_time_ms + predict_scan_only_time_ms(so_length);
579 // it's already over the pause target, go around
580 if (base_time_with_so_ms > target_pause_time_ms)
581 break;
583 size_t starting_young_length = so_length+1;
585 // we make sure that the short young length that makes sense
586 // (one more than the S-O length) is feasible
587 size_t min_young_length = starting_young_length;
588 double min_gc_eff;
589 bool min_ok;
590 ++calculations;
591 min_ok = predict_gc_eff(min_young_length, so_length,
592 base_time_with_so_ms,
593 init_free_regions, target_pause_time_ms,
594 &min_gc_eff);
596 if (min_ok) {
597 // the shortest young length is indeed feasible; we'll know
598 // set up the max young length and we'll do a binary search
599 // between min_young_length and max_young_length
600 size_t max_young_length = _free_regions_at_end_of_collection - 1;
601 double max_gc_eff = 0.0;
602 bool max_ok = false;
604 // the innermost loop! (finally!)
605 while (max_young_length > min_young_length) {
606 // we'll make sure that min_young_length is always at a
607 // feasible config
608 guarantee( min_ok, "invariant" );
610 ++calculations;
611 max_ok = predict_gc_eff(max_young_length, so_length,
612 base_time_with_so_ms,
613 init_free_regions, target_pause_time_ms,
614 &max_gc_eff);
616 size_t diff = (max_young_length - min_young_length) / 2;
617 if (max_ok) {
618 min_young_length = max_young_length;
619 min_gc_eff = max_gc_eff;
620 min_ok = true;
621 }
622 max_young_length = min_young_length + diff;
623 }
625 // the innermost loop found a config
626 guarantee( min_ok, "invariant" );
627 if (min_gc_eff > final_gc_eff) {
628 // it's the best config so far, so we'll keep it
629 final_gc_eff = min_gc_eff;
630 final_young_length = min_young_length;
631 final_so_length = so_length;
632 gc_eff_set = true;
633 }
634 }
636 // incremental the fixed S-O length and go around
637 so_length += so_length_incr;
638 }
640 // this is the end of the outermost loop and we need to decide
641 // what to do during the next iteration
642 if (pass == pass_type_coarse) {
643 // we just did the coarse pass (first iteration)
645 if (!gc_eff_set)
646 // we didn't find a feasible config so we'll just bail out; of
647 // course, it might be the case that we missed it; but I'd say
648 // it's a bit unlikely
649 done = true;
650 else {
651 // We did find a feasible config with optimal GC eff during
652 // the first pass. So the second pass we'll only consider the
653 // S-O lengths around that config with a fine increment.
655 guarantee( so_length_incr == so_coarse_increments, "invariant" );
656 guarantee( final_so_length >= min_so_length, "invariant" );
658 #ifdef TRACE_CALC_YOUNG_CONFIG
659 // leave this in for debugging, just in case
660 gclog_or_tty->print_cr(" coarse pass: SO length " SIZE_FORMAT,
661 final_so_length);
662 #endif // TRACE_CALC_YOUNG_CONFIG
664 from_so_length =
665 (final_so_length - min_so_length > so_coarse_increments) ?
666 final_so_length - so_coarse_increments + 1 : min_so_length;
667 to_so_length =
668 (max_so_length - final_so_length > so_coarse_increments) ?
669 final_so_length + so_coarse_increments - 1 : max_so_length;
671 pass = pass_type_fine;
672 so_length_incr = 1;
673 }
674 } else if (pass == pass_type_fine) {
675 // we just finished the second pass
677 if (!gc_eff_set) {
678 // we didn't find a feasible config (yes, it's possible;
679 // notice that, sometimes, we go directly into the fine
680 // iteration and skip the coarse one) so we bail out
681 done = true;
682 } else {
683 // We did find a feasible config with optimal GC eff
684 guarantee( so_length_incr == 1, "invariant" );
686 if (final_so_length == 0) {
687 // The config is of an empty S-O set, so we'll just bail out
688 done = true;
689 } else {
690 // we'll go around once more, setting the S-O length to 95%
691 // of the optimal
692 size_t new_so_length = 950 * final_so_length / 1000;
694 #ifdef TRACE_CALC_YOUNG_CONFIG
695 // leave this in for debugging, just in case
696 gclog_or_tty->print_cr(" fine pass: SO length " SIZE_FORMAT
697 ", setting it to " SIZE_FORMAT,
698 final_so_length, new_so_length);
699 #endif // TRACE_CALC_YOUNG_CONFIG
701 from_so_length = new_so_length;
702 to_so_length = new_so_length;
703 fine_so_length = final_so_length;
705 pass = pass_type_final;
706 }
707 }
708 } else if (pass == pass_type_final) {
709 // we just finished the final (third) pass
711 if (!gc_eff_set)
712 // we didn't find a feasible config, so we'll just use the one
713 // we found during the second pass, which we saved
714 final_so_length = fine_so_length;
716 // and we're done!
717 done = true;
718 } else {
719 guarantee( false, "should never reach here" );
720 }
722 // we now go around the outermost loop
723 }
725 // we should have at least one region in the target young length
726 _young_list_target_length =
727 MAX2((size_t) 1, final_young_length + _recorded_survivor_regions);
728 if (final_so_length >= final_young_length)
729 // and we need to ensure that the S-O length is not greater than
730 // the target young length (this is being a bit careful)
731 final_so_length = 0;
732 _young_list_so_prefix_length = final_so_length;
733 guarantee( !_in_marking_window || !_last_full_young_gc ||
734 _young_list_so_prefix_length == 0, "invariant" );
736 // let's keep an eye of how long we spend on this calculation
737 // right now, I assume that we'll print it when we need it; we
738 // should really adde it to the breakdown of a pause
739 double end_time_sec = os::elapsedTime();
740 double elapsed_time_ms = (end_time_sec - start_time_sec) * 1000.0;
742 #ifdef TRACE_CALC_YOUNG_CONFIG
743 // leave this in for debugging, just in case
744 gclog_or_tty->print_cr("target = %1.1lf ms, young = " SIZE_FORMAT
745 ", SO = " SIZE_FORMAT ", "
746 "elapsed %1.2lf ms, calcs: " SIZE_FORMAT " (%s%s) "
747 SIZE_FORMAT SIZE_FORMAT,
748 target_pause_time_ms,
749 _young_list_target_length - _young_list_so_prefix_length,
750 _young_list_so_prefix_length,
751 elapsed_time_ms,
752 calculations,
753 full_young_gcs() ? "full" : "partial",
754 should_initiate_conc_mark() ? " i-m" : "",
755 _in_marking_window,
756 _in_marking_window_im);
757 #endif // TRACE_CALC_YOUNG_CONFIG
759 if (_young_list_target_length < _young_list_min_length) {
760 // bummer; this means that, if we do a pause when the optimal
761 // config dictates, we'll violate the pause spacing target (the
762 // min length was calculate based on the application's current
763 // alloc rate);
765 // so, we have to bite the bullet, and allocate the minimum
766 // number. We'll violate our target, but we just can't meet it.
768 size_t so_length = 0;
769 // a note further up explains why we do not want an S-O length
770 // during marking
771 if (!_in_marking_window && !_last_full_young_gc)
772 // but we can still try to see whether we can find an optimal
773 // S-O length
774 so_length = calculate_optimal_so_length(_young_list_min_length);
776 #ifdef TRACE_CALC_YOUNG_CONFIG
777 // leave this in for debugging, just in case
778 gclog_or_tty->print_cr("adjusted target length from "
779 SIZE_FORMAT " to " SIZE_FORMAT
780 ", SO " SIZE_FORMAT,
781 _young_list_target_length, _young_list_min_length,
782 so_length);
783 #endif // TRACE_CALC_YOUNG_CONFIG
785 _young_list_target_length =
786 MAX2(_young_list_min_length, (size_t)1);
787 _young_list_so_prefix_length = so_length;
788 }
789 } else {
790 // we are in a partially-young mode or we've run out of regions (due
791 // to evacuation failure)
793 #ifdef TRACE_CALC_YOUNG_CONFIG
794 // leave this in for debugging, just in case
795 gclog_or_tty->print_cr("(partial) setting target to " SIZE_FORMAT
796 ", SO " SIZE_FORMAT,
797 _young_list_min_length, 0);
798 #endif // TRACE_CALC_YOUNG_CONFIG
800 // we'll do the pause as soon as possible and with no S-O prefix
801 // (see above for the reasons behind the latter)
802 _young_list_target_length =
803 MAX2(_young_list_min_length, (size_t) 1);
804 _young_list_so_prefix_length = 0;
805 }
807 _rs_lengths_prediction = rs_lengths;
808 }
810 // This is used by: calculate_optimal_so_length(length). It returns
811 // the GC eff and predicted pause time for a particular config
812 void
813 G1CollectorPolicy::predict_gc_eff(size_t young_length,
814 size_t so_length,
815 double base_time_ms,
816 double* ret_gc_eff,
817 double* ret_pause_time_ms) {
818 double so_time_ms = predict_scan_only_time_ms(so_length);
819 double accum_surv_rate_adj = 0.0;
820 if (so_length > 0)
821 accum_surv_rate_adj = accum_yg_surv_rate_pred((int)(so_length - 1));
822 double accum_surv_rate =
823 accum_yg_surv_rate_pred((int)(young_length - 1)) - accum_surv_rate_adj;
824 size_t bytes_to_copy =
825 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);
826 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy);
827 double young_other_time_ms =
828 predict_young_other_time_ms(young_length - so_length);
829 double pause_time_ms =
830 base_time_ms + so_time_ms + copy_time_ms + young_other_time_ms;
831 size_t reclaimed_bytes =
832 (young_length - so_length) * HeapRegion::GrainBytes - bytes_to_copy;
833 double gc_eff = (double) reclaimed_bytes / pause_time_ms;
835 *ret_gc_eff = gc_eff;
836 *ret_pause_time_ms = pause_time_ms;
837 }
839 // This is used by: calculate_young_list_target_config(rs_length). It
840 // returns the GC eff of a particular config. It returns false if that
841 // config violates any of the end conditions of the search in the
842 // calling method, or true upon success. The end conditions were put
843 // here since it's called twice and it was best not to replicate them
844 // in the caller. Also, passing the parameteres avoids having to
845 // recalculate them in the innermost loop.
846 bool
847 G1CollectorPolicy::predict_gc_eff(size_t young_length,
848 size_t so_length,
849 double base_time_with_so_ms,
850 size_t init_free_regions,
851 double target_pause_time_ms,
852 double* ret_gc_eff) {
853 *ret_gc_eff = 0.0;
855 if (young_length >= init_free_regions)
856 // end condition 1: not enough space for the young regions
857 return false;
859 double accum_surv_rate_adj = 0.0;
860 if (so_length > 0)
861 accum_surv_rate_adj = accum_yg_surv_rate_pred((int)(so_length - 1));
862 double accum_surv_rate =
863 accum_yg_surv_rate_pred((int)(young_length - 1)) - accum_surv_rate_adj;
864 size_t bytes_to_copy =
865 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);
866 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy);
867 double young_other_time_ms =
868 predict_young_other_time_ms(young_length - so_length);
869 double pause_time_ms =
870 base_time_with_so_ms + copy_time_ms + young_other_time_ms;
872 if (pause_time_ms > target_pause_time_ms)
873 // end condition 2: over the target pause time
874 return false;
876 size_t reclaimed_bytes =
877 (young_length - so_length) * HeapRegion::GrainBytes - bytes_to_copy;
878 size_t free_bytes =
879 (init_free_regions - young_length) * HeapRegion::GrainBytes;
881 if ((2.0 + sigma()) * (double) bytes_to_copy > (double) free_bytes)
882 // end condition 3: out of to-space (conservatively)
883 return false;
885 // success!
886 double gc_eff = (double) reclaimed_bytes / pause_time_ms;
887 *ret_gc_eff = gc_eff;
889 return true;
890 }
892 double G1CollectorPolicy::predict_survivor_regions_evac_time() {
893 double survivor_regions_evac_time = 0.0;
894 for (HeapRegion * r = _recorded_survivor_head;
895 r != NULL && r != _recorded_survivor_tail->get_next_young_region();
896 r = r->get_next_young_region()) {
897 survivor_regions_evac_time += predict_region_elapsed_time_ms(r, true);
898 }
899 return survivor_regions_evac_time;
900 }
902 void G1CollectorPolicy::check_prediction_validity() {
903 guarantee( adaptive_young_list_length(), "should not call this otherwise" );
905 size_t rs_lengths = _g1->young_list_sampled_rs_lengths();
906 if (rs_lengths > _rs_lengths_prediction) {
907 // add 10% to avoid having to recalculate often
908 size_t rs_lengths_prediction = rs_lengths * 1100 / 1000;
909 calculate_young_list_target_config(rs_lengths_prediction);
910 }
911 }
913 HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size,
914 bool is_tlab,
915 bool* gc_overhead_limit_was_exceeded) {
916 guarantee(false, "Not using this policy feature yet.");
917 return NULL;
918 }
920 // This method controls how a collector handles one or more
921 // of its generations being fully allocated.
922 HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size,
923 bool is_tlab) {
924 guarantee(false, "Not using this policy feature yet.");
925 return NULL;
926 }
929 #ifndef PRODUCT
930 bool G1CollectorPolicy::verify_young_ages() {
931 HeapRegion* head = _g1->young_list_first_region();
932 return
933 verify_young_ages(head, _short_lived_surv_rate_group);
934 // also call verify_young_ages on any additional surv rate groups
935 }
937 bool
938 G1CollectorPolicy::verify_young_ages(HeapRegion* head,
939 SurvRateGroup *surv_rate_group) {
940 guarantee( surv_rate_group != NULL, "pre-condition" );
942 const char* name = surv_rate_group->name();
943 bool ret = true;
944 int prev_age = -1;
946 for (HeapRegion* curr = head;
947 curr != NULL;
948 curr = curr->get_next_young_region()) {
949 SurvRateGroup* group = curr->surv_rate_group();
950 if (group == NULL && !curr->is_survivor()) {
951 gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name);
952 ret = false;
953 }
955 if (surv_rate_group == group) {
956 int age = curr->age_in_surv_rate_group();
958 if (age < 0) {
959 gclog_or_tty->print_cr("## %s: encountered negative age", name);
960 ret = false;
961 }
963 if (age <= prev_age) {
964 gclog_or_tty->print_cr("## %s: region ages are not strictly increasing "
965 "(%d, %d)", name, age, prev_age);
966 ret = false;
967 }
968 prev_age = age;
969 }
970 }
972 return ret;
973 }
974 #endif // PRODUCT
976 void G1CollectorPolicy::record_full_collection_start() {
977 _cur_collection_start_sec = os::elapsedTime();
978 // Release the future to-space so that it is available for compaction into.
979 _g1->set_full_collection();
980 }
982 void G1CollectorPolicy::record_full_collection_end() {
983 // Consider this like a collection pause for the purposes of allocation
984 // since last pause.
985 double end_sec = os::elapsedTime();
986 double full_gc_time_sec = end_sec - _cur_collection_start_sec;
987 double full_gc_time_ms = full_gc_time_sec * 1000.0;
989 checkpoint_conc_overhead();
991 _all_full_gc_times_ms->add(full_gc_time_ms);
993 update_recent_gc_times(end_sec, full_gc_time_ms);
995 _g1->clear_full_collection();
997 // "Nuke" the heuristics that control the fully/partially young GC
998 // transitions and make sure we start with fully young GCs after the
999 // Full GC.
1000 set_full_young_gcs(true);
1001 _last_full_young_gc = false;
1002 _should_revert_to_full_young_gcs = false;
1003 _should_initiate_conc_mark = false;
1004 _known_garbage_bytes = 0;
1005 _known_garbage_ratio = 0.0;
1006 _in_marking_window = false;
1007 _in_marking_window_im = false;
1009 _short_lived_surv_rate_group->record_scan_only_prefix(0);
1010 _short_lived_surv_rate_group->start_adding_regions();
1011 // also call this on any additional surv rate groups
1013 record_survivor_regions(0, NULL, NULL);
1015 _prev_region_num_young = _region_num_young;
1016 _prev_region_num_tenured = _region_num_tenured;
1018 _free_regions_at_end_of_collection = _g1->free_regions();
1019 _scan_only_regions_at_end_of_collection = 0;
1020 // Reset survivors SurvRateGroup.
1021 _survivor_surv_rate_group->reset();
1022 calculate_young_list_min_length();
1023 calculate_young_list_target_config();
1024 }
1026 void G1CollectorPolicy::record_before_bytes(size_t bytes) {
1027 _bytes_in_to_space_before_gc += bytes;
1028 }
1030 void G1CollectorPolicy::record_after_bytes(size_t bytes) {
1031 _bytes_in_to_space_after_gc += bytes;
1032 }
1034 void G1CollectorPolicy::record_stop_world_start() {
1035 _stop_world_start = os::elapsedTime();
1036 }
1038 void G1CollectorPolicy::record_collection_pause_start(double start_time_sec,
1039 size_t start_used) {
1040 if (PrintGCDetails) {
1041 gclog_or_tty->stamp(PrintGCTimeStamps);
1042 gclog_or_tty->print("[GC pause");
1043 if (in_young_gc_mode())
1044 gclog_or_tty->print(" (%s)", full_young_gcs() ? "young" : "partial");
1045 }
1047 assert(_g1->used_regions() == _g1->recalculate_used_regions(),
1048 "sanity");
1049 assert(_g1->used() == _g1->recalculate_used(), "sanity");
1051 double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0;
1052 _all_stop_world_times_ms->add(s_w_t_ms);
1053 _stop_world_start = 0.0;
1055 _cur_collection_start_sec = start_time_sec;
1056 _cur_collection_pause_used_at_start_bytes = start_used;
1057 _cur_collection_pause_used_regions_at_start = _g1->used_regions();
1058 _pending_cards = _g1->pending_card_num();
1059 _max_pending_cards = _g1->max_pending_card_num();
1061 _bytes_in_to_space_before_gc = 0;
1062 _bytes_in_to_space_after_gc = 0;
1063 _bytes_in_collection_set_before_gc = 0;
1065 #ifdef DEBUG
1066 // initialise these to something well known so that we can spot
1067 // if they are not set properly
1069 for (int i = 0; i < _parallel_gc_threads; ++i) {
1070 _par_last_ext_root_scan_times_ms[i] = -666.0;
1071 _par_last_mark_stack_scan_times_ms[i] = -666.0;
1072 _par_last_scan_only_times_ms[i] = -666.0;
1073 _par_last_scan_only_regions_scanned[i] = -666.0;
1074 _par_last_update_rs_start_times_ms[i] = -666.0;
1075 _par_last_update_rs_times_ms[i] = -666.0;
1076 _par_last_update_rs_processed_buffers[i] = -666.0;
1077 _par_last_scan_rs_start_times_ms[i] = -666.0;
1078 _par_last_scan_rs_times_ms[i] = -666.0;
1079 _par_last_scan_new_refs_times_ms[i] = -666.0;
1080 _par_last_obj_copy_times_ms[i] = -666.0;
1081 _par_last_termination_times_ms[i] = -666.0;
1082 }
1083 #endif
1085 for (int i = 0; i < _aux_num; ++i) {
1086 _cur_aux_times_ms[i] = 0.0;
1087 _cur_aux_times_set[i] = false;
1088 }
1090 _satb_drain_time_set = false;
1091 _last_satb_drain_processed_buffers = -1;
1093 if (in_young_gc_mode())
1094 _last_young_gc_full = false;
1097 // do that for any other surv rate groups
1098 _short_lived_surv_rate_group->stop_adding_regions();
1099 size_t short_lived_so_length = _young_list_so_prefix_length;
1100 _short_lived_surv_rate_group->record_scan_only_prefix(short_lived_so_length);
1101 tag_scan_only(short_lived_so_length);
1103 if (G1UseSurvivorSpaces) {
1104 _survivors_age_table.clear();
1105 }
1107 assert( verify_young_ages(), "region age verification" );
1108 }
1110 void G1CollectorPolicy::tag_scan_only(size_t short_lived_scan_only_length) {
1111 // done in a way that it can be extended for other surv rate groups too...
1113 HeapRegion* head = _g1->young_list_first_region();
1114 bool finished_short_lived = (short_lived_scan_only_length == 0);
1116 if (finished_short_lived)
1117 return;
1119 for (HeapRegion* curr = head;
1120 curr != NULL;
1121 curr = curr->get_next_young_region()) {
1122 SurvRateGroup* surv_rate_group = curr->surv_rate_group();
1123 int age = curr->age_in_surv_rate_group();
1125 if (surv_rate_group == _short_lived_surv_rate_group) {
1126 if ((size_t)age < short_lived_scan_only_length)
1127 curr->set_scan_only();
1128 else
1129 finished_short_lived = true;
1130 }
1133 if (finished_short_lived)
1134 return;
1135 }
1137 guarantee( false, "we should never reach here" );
1138 }
1140 void G1CollectorPolicy::record_mark_closure_time(double mark_closure_time_ms) {
1141 _mark_closure_time_ms = mark_closure_time_ms;
1142 }
1144 void G1CollectorPolicy::record_concurrent_mark_init_start() {
1145 _mark_init_start_sec = os::elapsedTime();
1146 guarantee(!in_young_gc_mode(), "should not do be here in young GC mode");
1147 }
1149 void G1CollectorPolicy::record_concurrent_mark_init_end_pre(double
1150 mark_init_elapsed_time_ms) {
1151 _during_marking = true;
1152 _should_initiate_conc_mark = false;
1153 _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms;
1154 }
1156 void G1CollectorPolicy::record_concurrent_mark_init_end() {
1157 double end_time_sec = os::elapsedTime();
1158 double elapsed_time_ms = (end_time_sec - _mark_init_start_sec) * 1000.0;
1159 _concurrent_mark_init_times_ms->add(elapsed_time_ms);
1160 checkpoint_conc_overhead();
1161 record_concurrent_mark_init_end_pre(elapsed_time_ms);
1163 _mmu_tracker->add_pause(_mark_init_start_sec, end_time_sec, true);
1164 }
1166 void G1CollectorPolicy::record_concurrent_mark_remark_start() {
1167 _mark_remark_start_sec = os::elapsedTime();
1168 _during_marking = false;
1169 }
1171 void G1CollectorPolicy::record_concurrent_mark_remark_end() {
1172 double end_time_sec = os::elapsedTime();
1173 double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0;
1174 checkpoint_conc_overhead();
1175 _concurrent_mark_remark_times_ms->add(elapsed_time_ms);
1176 _cur_mark_stop_world_time_ms += elapsed_time_ms;
1177 _prev_collection_pause_end_ms += elapsed_time_ms;
1179 _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true);
1180 }
1182 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() {
1183 _mark_cleanup_start_sec = os::elapsedTime();
1184 }
1186 void
1187 G1CollectorPolicy::record_concurrent_mark_cleanup_end(size_t freed_bytes,
1188 size_t max_live_bytes) {
1189 record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes);
1190 record_concurrent_mark_cleanup_end_work2();
1191 }
1193 void
1194 G1CollectorPolicy::
1195 record_concurrent_mark_cleanup_end_work1(size_t freed_bytes,
1196 size_t max_live_bytes) {
1197 if (_n_marks < 2) _n_marks++;
1198 if (G1PolicyVerbose > 0)
1199 gclog_or_tty->print_cr("At end of marking, max_live is " SIZE_FORMAT " MB "
1200 " (of " SIZE_FORMAT " MB heap).",
1201 max_live_bytes/M, _g1->capacity()/M);
1202 }
1204 // The important thing about this is that it includes "os::elapsedTime".
1205 void G1CollectorPolicy::record_concurrent_mark_cleanup_end_work2() {
1206 checkpoint_conc_overhead();
1207 double end_time_sec = os::elapsedTime();
1208 double elapsed_time_ms = (end_time_sec - _mark_cleanup_start_sec)*1000.0;
1209 _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms);
1210 _cur_mark_stop_world_time_ms += elapsed_time_ms;
1211 _prev_collection_pause_end_ms += elapsed_time_ms;
1213 _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_time_sec, true);
1215 _num_markings++;
1217 // We did a marking, so reset the "since_last_mark" variables.
1218 double considerConcMarkCost = 1.0;
1219 // If there are available processors, concurrent activity is free...
1220 if (Threads::number_of_non_daemon_threads() * 2 <
1221 os::active_processor_count()) {
1222 considerConcMarkCost = 0.0;
1223 }
1224 _n_pauses_at_mark_end = _n_pauses;
1225 _n_marks_since_last_pause++;
1226 _conc_mark_initiated = false;
1227 }
1229 void
1230 G1CollectorPolicy::record_concurrent_mark_cleanup_completed() {
1231 if (in_young_gc_mode()) {
1232 _should_revert_to_full_young_gcs = false;
1233 _last_full_young_gc = true;
1234 _in_marking_window = false;
1235 if (adaptive_young_list_length())
1236 calculate_young_list_target_config();
1237 }
1238 }
1240 void G1CollectorPolicy::record_concurrent_pause() {
1241 if (_stop_world_start > 0.0) {
1242 double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0;
1243 _all_yield_times_ms->add(yield_ms);
1244 }
1245 }
1247 void G1CollectorPolicy::record_concurrent_pause_end() {
1248 }
1250 void G1CollectorPolicy::record_collection_pause_end_CH_strong_roots() {
1251 _cur_CH_strong_roots_end_sec = os::elapsedTime();
1252 _cur_CH_strong_roots_dur_ms =
1253 (_cur_CH_strong_roots_end_sec - _cur_collection_start_sec) * 1000.0;
1254 }
1256 void G1CollectorPolicy::record_collection_pause_end_G1_strong_roots() {
1257 _cur_G1_strong_roots_end_sec = os::elapsedTime();
1258 _cur_G1_strong_roots_dur_ms =
1259 (_cur_G1_strong_roots_end_sec - _cur_CH_strong_roots_end_sec) * 1000.0;
1260 }
1262 template<class T>
1263 T sum_of(T* sum_arr, int start, int n, int N) {
1264 T sum = (T)0;
1265 for (int i = 0; i < n; i++) {
1266 int j = (start + i) % N;
1267 sum += sum_arr[j];
1268 }
1269 return sum;
1270 }
1272 void G1CollectorPolicy::print_par_stats (int level,
1273 const char* str,
1274 double* data,
1275 bool summary) {
1276 double min = data[0], max = data[0];
1277 double total = 0.0;
1278 int j;
1279 for (j = 0; j < level; ++j)
1280 gclog_or_tty->print(" ");
1281 gclog_or_tty->print("[%s (ms):", str);
1282 for (uint i = 0; i < ParallelGCThreads; ++i) {
1283 double val = data[i];
1284 if (val < min)
1285 min = val;
1286 if (val > max)
1287 max = val;
1288 total += val;
1289 gclog_or_tty->print(" %3.1lf", val);
1290 }
1291 if (summary) {
1292 gclog_or_tty->print_cr("");
1293 double avg = total / (double) ParallelGCThreads;
1294 gclog_or_tty->print(" ");
1295 for (j = 0; j < level; ++j)
1296 gclog_or_tty->print(" ");
1297 gclog_or_tty->print("Avg: %5.1lf, Min: %5.1lf, Max: %5.1lf",
1298 avg, min, max);
1299 }
1300 gclog_or_tty->print_cr("]");
1301 }
1303 void G1CollectorPolicy::print_par_buffers (int level,
1304 const char* str,
1305 double* data,
1306 bool summary) {
1307 double min = data[0], max = data[0];
1308 double total = 0.0;
1309 int j;
1310 for (j = 0; j < level; ++j)
1311 gclog_or_tty->print(" ");
1312 gclog_or_tty->print("[%s :", str);
1313 for (uint i = 0; i < ParallelGCThreads; ++i) {
1314 double val = data[i];
1315 if (val < min)
1316 min = val;
1317 if (val > max)
1318 max = val;
1319 total += val;
1320 gclog_or_tty->print(" %d", (int) val);
1321 }
1322 if (summary) {
1323 gclog_or_tty->print_cr("");
1324 double avg = total / (double) ParallelGCThreads;
1325 gclog_or_tty->print(" ");
1326 for (j = 0; j < level; ++j)
1327 gclog_or_tty->print(" ");
1328 gclog_or_tty->print("Sum: %d, Avg: %d, Min: %d, Max: %d",
1329 (int)total, (int)avg, (int)min, (int)max);
1330 }
1331 gclog_or_tty->print_cr("]");
1332 }
1334 void G1CollectorPolicy::print_stats (int level,
1335 const char* str,
1336 double value) {
1337 for (int j = 0; j < level; ++j)
1338 gclog_or_tty->print(" ");
1339 gclog_or_tty->print_cr("[%s: %5.1lf ms]", str, value);
1340 }
1342 void G1CollectorPolicy::print_stats (int level,
1343 const char* str,
1344 int value) {
1345 for (int j = 0; j < level; ++j)
1346 gclog_or_tty->print(" ");
1347 gclog_or_tty->print_cr("[%s: %d]", str, value);
1348 }
1350 double G1CollectorPolicy::avg_value (double* data) {
1351 if (ParallelGCThreads > 0) {
1352 double ret = 0.0;
1353 for (uint i = 0; i < ParallelGCThreads; ++i)
1354 ret += data[i];
1355 return ret / (double) ParallelGCThreads;
1356 } else {
1357 return data[0];
1358 }
1359 }
1361 double G1CollectorPolicy::max_value (double* data) {
1362 if (ParallelGCThreads > 0) {
1363 double ret = data[0];
1364 for (uint i = 1; i < ParallelGCThreads; ++i)
1365 if (data[i] > ret)
1366 ret = data[i];
1367 return ret;
1368 } else {
1369 return data[0];
1370 }
1371 }
1373 double G1CollectorPolicy::sum_of_values (double* data) {
1374 if (ParallelGCThreads > 0) {
1375 double sum = 0.0;
1376 for (uint i = 0; i < ParallelGCThreads; i++)
1377 sum += data[i];
1378 return sum;
1379 } else {
1380 return data[0];
1381 }
1382 }
1384 double G1CollectorPolicy::max_sum (double* data1,
1385 double* data2) {
1386 double ret = data1[0] + data2[0];
1388 if (ParallelGCThreads > 0) {
1389 for (uint i = 1; i < ParallelGCThreads; ++i) {
1390 double data = data1[i] + data2[i];
1391 if (data > ret)
1392 ret = data;
1393 }
1394 }
1395 return ret;
1396 }
1398 // Anything below that is considered to be zero
1399 #define MIN_TIMER_GRANULARITY 0.0000001
1401 void G1CollectorPolicy::record_collection_pause_end(bool abandoned) {
1402 double end_time_sec = os::elapsedTime();
1403 double elapsed_ms = _last_pause_time_ms;
1404 bool parallel = ParallelGCThreads > 0;
1405 double evac_ms = (end_time_sec - _cur_G1_strong_roots_end_sec) * 1000.0;
1406 size_t rs_size =
1407 _cur_collection_pause_used_regions_at_start - collection_set_size();
1408 size_t cur_used_bytes = _g1->used();
1409 assert(cur_used_bytes == _g1->recalculate_used(), "It should!");
1410 bool last_pause_included_initial_mark = false;
1411 bool update_stats = !abandoned && !_g1->evacuation_failed();
1413 #ifndef PRODUCT
1414 if (G1YoungSurvRateVerbose) {
1415 gclog_or_tty->print_cr("");
1416 _short_lived_surv_rate_group->print();
1417 // do that for any other surv rate groups too
1418 }
1419 #endif // PRODUCT
1421 checkpoint_conc_overhead();
1423 if (in_young_gc_mode()) {
1424 last_pause_included_initial_mark = _should_initiate_conc_mark;
1425 if (last_pause_included_initial_mark)
1426 record_concurrent_mark_init_end_pre(0.0);
1428 size_t min_used_targ =
1429 (_g1->capacity() / 100) * (G1SteadyStateUsed - G1SteadyStateUsedDelta);
1431 if (cur_used_bytes > min_used_targ) {
1432 if (cur_used_bytes <= _prev_collection_pause_used_at_end_bytes) {
1433 } else if (!_g1->mark_in_progress() && !_last_full_young_gc) {
1434 _should_initiate_conc_mark = true;
1435 }
1436 }
1438 _prev_collection_pause_used_at_end_bytes = cur_used_bytes;
1439 }
1441 _mmu_tracker->add_pause(end_time_sec - elapsed_ms/1000.0,
1442 end_time_sec, false);
1444 guarantee(_cur_collection_pause_used_regions_at_start >=
1445 collection_set_size(),
1446 "Negative RS size?");
1448 // This assert is exempted when we're doing parallel collection pauses,
1449 // because the fragmentation caused by the parallel GC allocation buffers
1450 // can lead to more memory being used during collection than was used
1451 // before. Best leave this out until the fragmentation problem is fixed.
1452 // Pauses in which evacuation failed can also lead to negative
1453 // collections, since no space is reclaimed from a region containing an
1454 // object whose evacuation failed.
1455 // Further, we're now always doing parallel collection. But I'm still
1456 // leaving this here as a placeholder for a more precise assertion later.
1457 // (DLD, 10/05.)
1458 assert((true || parallel) // Always using GC LABs now.
1459 || _g1->evacuation_failed()
1460 || _cur_collection_pause_used_at_start_bytes >= cur_used_bytes,
1461 "Negative collection");
1463 size_t freed_bytes =
1464 _cur_collection_pause_used_at_start_bytes - cur_used_bytes;
1465 size_t surviving_bytes = _collection_set_bytes_used_before - freed_bytes;
1466 double survival_fraction =
1467 (double)surviving_bytes/
1468 (double)_collection_set_bytes_used_before;
1470 _n_pauses++;
1472 if (update_stats) {
1473 _recent_CH_strong_roots_times_ms->add(_cur_CH_strong_roots_dur_ms);
1474 _recent_G1_strong_roots_times_ms->add(_cur_G1_strong_roots_dur_ms);
1475 _recent_evac_times_ms->add(evac_ms);
1476 _recent_pause_times_ms->add(elapsed_ms);
1478 _recent_rs_sizes->add(rs_size);
1480 // We exempt parallel collection from this check because Alloc Buffer
1481 // fragmentation can produce negative collections. Same with evac
1482 // failure.
1483 // Further, we're now always doing parallel collection. But I'm still
1484 // leaving this here as a placeholder for a more precise assertion later.
1485 // (DLD, 10/05.
1486 assert((true || parallel)
1487 || _g1->evacuation_failed()
1488 || surviving_bytes <= _collection_set_bytes_used_before,
1489 "Or else negative collection!");
1490 _recent_CS_bytes_used_before->add(_collection_set_bytes_used_before);
1491 _recent_CS_bytes_surviving->add(surviving_bytes);
1493 // this is where we update the allocation rate of the application
1494 double app_time_ms =
1495 (_cur_collection_start_sec * 1000.0 - _prev_collection_pause_end_ms);
1496 if (app_time_ms < MIN_TIMER_GRANULARITY) {
1497 // This usually happens due to the timer not having the required
1498 // granularity. Some Linuxes are the usual culprits.
1499 // We'll just set it to something (arbitrarily) small.
1500 app_time_ms = 1.0;
1501 }
1502 size_t regions_allocated =
1503 (_region_num_young - _prev_region_num_young) +
1504 (_region_num_tenured - _prev_region_num_tenured);
1505 double alloc_rate_ms = (double) regions_allocated / app_time_ms;
1506 _alloc_rate_ms_seq->add(alloc_rate_ms);
1507 _prev_region_num_young = _region_num_young;
1508 _prev_region_num_tenured = _region_num_tenured;
1510 double interval_ms =
1511 (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0;
1512 update_recent_gc_times(end_time_sec, elapsed_ms);
1513 _recent_avg_pause_time_ratio = _recent_gc_times_ms->sum()/interval_ms;
1514 assert(recent_avg_pause_time_ratio() < 1.00, "All GC?");
1515 }
1517 if (G1PolicyVerbose > 1) {
1518 gclog_or_tty->print_cr(" Recording collection pause(%d)", _n_pauses);
1519 }
1521 PauseSummary* summary;
1522 if (abandoned) {
1523 summary = _abandoned_summary;
1524 } else {
1525 summary = _summary;
1526 }
1528 double ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms);
1529 double mark_stack_scan_time = avg_value(_par_last_mark_stack_scan_times_ms);
1530 double scan_only_time = avg_value(_par_last_scan_only_times_ms);
1531 double scan_only_regions_scanned =
1532 sum_of_values(_par_last_scan_only_regions_scanned);
1533 double update_rs_time = avg_value(_par_last_update_rs_times_ms);
1534 double update_rs_processed_buffers =
1535 sum_of_values(_par_last_update_rs_processed_buffers);
1536 double scan_rs_time = avg_value(_par_last_scan_rs_times_ms);
1537 double obj_copy_time = avg_value(_par_last_obj_copy_times_ms);
1538 double termination_time = avg_value(_par_last_termination_times_ms);
1540 double parallel_other_time = _cur_collection_par_time_ms -
1541 (update_rs_time + ext_root_scan_time + mark_stack_scan_time +
1542 scan_only_time + scan_rs_time + obj_copy_time + termination_time);
1543 if (update_stats) {
1544 MainBodySummary* body_summary = summary->main_body_summary();
1545 guarantee(body_summary != NULL, "should not be null!");
1547 if (_satb_drain_time_set)
1548 body_summary->record_satb_drain_time_ms(_cur_satb_drain_time_ms);
1549 else
1550 body_summary->record_satb_drain_time_ms(0.0);
1551 body_summary->record_ext_root_scan_time_ms(ext_root_scan_time);
1552 body_summary->record_mark_stack_scan_time_ms(mark_stack_scan_time);
1553 body_summary->record_scan_only_time_ms(scan_only_time);
1554 body_summary->record_update_rs_time_ms(update_rs_time);
1555 body_summary->record_scan_rs_time_ms(scan_rs_time);
1556 body_summary->record_obj_copy_time_ms(obj_copy_time);
1557 if (parallel) {
1558 body_summary->record_parallel_time_ms(_cur_collection_par_time_ms);
1559 body_summary->record_clear_ct_time_ms(_cur_clear_ct_time_ms);
1560 body_summary->record_termination_time_ms(termination_time);
1561 body_summary->record_parallel_other_time_ms(parallel_other_time);
1562 }
1563 body_summary->record_mark_closure_time_ms(_mark_closure_time_ms);
1564 }
1566 if (G1PolicyVerbose > 1) {
1567 gclog_or_tty->print_cr(" ET: %10.6f ms (avg: %10.6f ms)\n"
1568 " CH Strong: %10.6f ms (avg: %10.6f ms)\n"
1569 " G1 Strong: %10.6f ms (avg: %10.6f ms)\n"
1570 " Evac: %10.6f ms (avg: %10.6f ms)\n"
1571 " ET-RS: %10.6f ms (avg: %10.6f ms)\n"
1572 " |RS|: " SIZE_FORMAT,
1573 elapsed_ms, recent_avg_time_for_pauses_ms(),
1574 _cur_CH_strong_roots_dur_ms, recent_avg_time_for_CH_strong_ms(),
1575 _cur_G1_strong_roots_dur_ms, recent_avg_time_for_G1_strong_ms(),
1576 evac_ms, recent_avg_time_for_evac_ms(),
1577 scan_rs_time,
1578 recent_avg_time_for_pauses_ms() -
1579 recent_avg_time_for_G1_strong_ms(),
1580 rs_size);
1582 gclog_or_tty->print_cr(" Used at start: " SIZE_FORMAT"K"
1583 " At end " SIZE_FORMAT "K\n"
1584 " garbage : " SIZE_FORMAT "K"
1585 " of " SIZE_FORMAT "K\n"
1586 " survival : %6.2f%% (%6.2f%% avg)",
1587 _cur_collection_pause_used_at_start_bytes/K,
1588 _g1->used()/K, freed_bytes/K,
1589 _collection_set_bytes_used_before/K,
1590 survival_fraction*100.0,
1591 recent_avg_survival_fraction()*100.0);
1592 gclog_or_tty->print_cr(" Recent %% gc pause time: %6.2f",
1593 recent_avg_pause_time_ratio() * 100.0);
1594 }
1596 double other_time_ms = elapsed_ms;
1598 if (!abandoned) {
1599 if (_satb_drain_time_set)
1600 other_time_ms -= _cur_satb_drain_time_ms;
1602 if (parallel)
1603 other_time_ms -= _cur_collection_par_time_ms + _cur_clear_ct_time_ms;
1604 else
1605 other_time_ms -=
1606 update_rs_time +
1607 ext_root_scan_time + mark_stack_scan_time + scan_only_time +
1608 scan_rs_time + obj_copy_time;
1609 }
1611 if (PrintGCDetails) {
1612 gclog_or_tty->print_cr("%s%s, %1.8lf secs]",
1613 abandoned ? " (abandoned)" : "",
1614 (last_pause_included_initial_mark) ? " (initial-mark)" : "",
1615 elapsed_ms / 1000.0);
1617 if (!abandoned) {
1618 if (_satb_drain_time_set) {
1619 print_stats(1, "SATB Drain Time", _cur_satb_drain_time_ms);
1620 }
1621 if (_last_satb_drain_processed_buffers >= 0) {
1622 print_stats(2, "Processed Buffers", _last_satb_drain_processed_buffers);
1623 }
1624 if (parallel) {
1625 print_stats(1, "Parallel Time", _cur_collection_par_time_ms);
1626 print_par_stats(2, "Update RS (Start)", _par_last_update_rs_start_times_ms, false);
1627 print_par_stats(2, "Update RS", _par_last_update_rs_times_ms);
1628 print_par_buffers(3, "Processed Buffers",
1629 _par_last_update_rs_processed_buffers, true);
1630 print_par_stats(2, "Ext Root Scanning", _par_last_ext_root_scan_times_ms);
1631 print_par_stats(2, "Mark Stack Scanning", _par_last_mark_stack_scan_times_ms);
1632 print_par_stats(2, "Scan-Only Scanning", _par_last_scan_only_times_ms);
1633 print_par_buffers(3, "Scan-Only Regions",
1634 _par_last_scan_only_regions_scanned, true);
1635 print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms);
1636 print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms);
1637 print_par_stats(2, "Termination", _par_last_termination_times_ms);
1638 print_stats(2, "Other", parallel_other_time);
1639 print_stats(1, "Clear CT", _cur_clear_ct_time_ms);
1640 } else {
1641 print_stats(1, "Update RS", update_rs_time);
1642 print_stats(2, "Processed Buffers",
1643 (int)update_rs_processed_buffers);
1644 print_stats(1, "Ext Root Scanning", ext_root_scan_time);
1645 print_stats(1, "Mark Stack Scanning", mark_stack_scan_time);
1646 print_stats(1, "Scan-Only Scanning", scan_only_time);
1647 print_stats(1, "Scan RS", scan_rs_time);
1648 print_stats(1, "Object Copying", obj_copy_time);
1649 }
1650 }
1651 print_stats(1, "Other", other_time_ms);
1652 for (int i = 0; i < _aux_num; ++i) {
1653 if (_cur_aux_times_set[i]) {
1654 char buffer[96];
1655 sprintf(buffer, "Aux%d", i);
1656 print_stats(1, buffer, _cur_aux_times_ms[i]);
1657 }
1658 }
1659 }
1660 if (PrintGCDetails)
1661 gclog_or_tty->print(" [");
1662 if (PrintGC || PrintGCDetails)
1663 _g1->print_size_transition(gclog_or_tty,
1664 _cur_collection_pause_used_at_start_bytes,
1665 _g1->used(), _g1->capacity());
1666 if (PrintGCDetails)
1667 gclog_or_tty->print_cr("]");
1669 _all_pause_times_ms->add(elapsed_ms);
1670 if (update_stats) {
1671 summary->record_total_time_ms(elapsed_ms);
1672 summary->record_other_time_ms(other_time_ms);
1673 }
1674 for (int i = 0; i < _aux_num; ++i)
1675 if (_cur_aux_times_set[i])
1676 _all_aux_times_ms[i].add(_cur_aux_times_ms[i]);
1678 // Reset marks-between-pauses counter.
1679 _n_marks_since_last_pause = 0;
1681 // Update the efficiency-since-mark vars.
1682 double proc_ms = elapsed_ms * (double) _parallel_gc_threads;
1683 if (elapsed_ms < MIN_TIMER_GRANULARITY) {
1684 // This usually happens due to the timer not having the required
1685 // granularity. Some Linuxes are the usual culprits.
1686 // We'll just set it to something (arbitrarily) small.
1687 proc_ms = 1.0;
1688 }
1689 double cur_efficiency = (double) freed_bytes / proc_ms;
1691 bool new_in_marking_window = _in_marking_window;
1692 bool new_in_marking_window_im = false;
1693 if (_should_initiate_conc_mark) {
1694 new_in_marking_window = true;
1695 new_in_marking_window_im = true;
1696 }
1698 if (in_young_gc_mode()) {
1699 if (_last_full_young_gc) {
1700 set_full_young_gcs(false);
1701 _last_full_young_gc = false;
1702 }
1704 if ( !_last_young_gc_full ) {
1705 if ( _should_revert_to_full_young_gcs ||
1706 _known_garbage_ratio < 0.05 ||
1707 (adaptive_young_list_length() &&
1708 (get_gc_eff_factor() * cur_efficiency < predict_young_gc_eff())) ) {
1709 set_full_young_gcs(true);
1710 }
1711 }
1712 _should_revert_to_full_young_gcs = false;
1714 if (_last_young_gc_full && !_during_marking)
1715 _young_gc_eff_seq->add(cur_efficiency);
1716 }
1718 _short_lived_surv_rate_group->start_adding_regions();
1719 // do that for any other surv rate groupsx
1721 // <NEW PREDICTION>
1723 if (update_stats) {
1724 double pause_time_ms = elapsed_ms;
1726 size_t diff = 0;
1727 if (_max_pending_cards >= _pending_cards)
1728 diff = _max_pending_cards - _pending_cards;
1729 _pending_card_diff_seq->add((double) diff);
1731 double cost_per_card_ms = 0.0;
1732 if (_pending_cards > 0) {
1733 cost_per_card_ms = update_rs_time / (double) _pending_cards;
1734 _cost_per_card_ms_seq->add(cost_per_card_ms);
1735 }
1737 double cost_per_scan_only_region_ms = 0.0;
1738 if (scan_only_regions_scanned > 0.0) {
1739 cost_per_scan_only_region_ms =
1740 scan_only_time / scan_only_regions_scanned;
1741 if (_in_marking_window_im)
1742 _cost_per_scan_only_region_ms_during_cm_seq->add(cost_per_scan_only_region_ms);
1743 else
1744 _cost_per_scan_only_region_ms_seq->add(cost_per_scan_only_region_ms);
1745 }
1747 size_t cards_scanned = _g1->cards_scanned();
1749 double cost_per_entry_ms = 0.0;
1750 if (cards_scanned > 10) {
1751 cost_per_entry_ms = scan_rs_time / (double) cards_scanned;
1752 if (_last_young_gc_full)
1753 _cost_per_entry_ms_seq->add(cost_per_entry_ms);
1754 else
1755 _partially_young_cost_per_entry_ms_seq->add(cost_per_entry_ms);
1756 }
1758 if (_max_rs_lengths > 0) {
1759 double cards_per_entry_ratio =
1760 (double) cards_scanned / (double) _max_rs_lengths;
1761 if (_last_young_gc_full)
1762 _fully_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio);
1763 else
1764 _partially_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio);
1765 }
1767 size_t rs_length_diff = _max_rs_lengths - _recorded_rs_lengths;
1768 if (rs_length_diff >= 0)
1769 _rs_length_diff_seq->add((double) rs_length_diff);
1771 size_t copied_bytes = surviving_bytes;
1772 double cost_per_byte_ms = 0.0;
1773 if (copied_bytes > 0) {
1774 cost_per_byte_ms = obj_copy_time / (double) copied_bytes;
1775 if (_in_marking_window)
1776 _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms);
1777 else
1778 _cost_per_byte_ms_seq->add(cost_per_byte_ms);
1779 }
1781 double all_other_time_ms = pause_time_ms -
1782 (update_rs_time + scan_only_time + scan_rs_time + obj_copy_time +
1783 _mark_closure_time_ms + termination_time);
1785 double young_other_time_ms = 0.0;
1786 if (_recorded_young_regions > 0) {
1787 young_other_time_ms =
1788 _recorded_young_cset_choice_time_ms +
1789 _recorded_young_free_cset_time_ms;
1790 _young_other_cost_per_region_ms_seq->add(young_other_time_ms /
1791 (double) _recorded_young_regions);
1792 }
1793 double non_young_other_time_ms = 0.0;
1794 if (_recorded_non_young_regions > 0) {
1795 non_young_other_time_ms =
1796 _recorded_non_young_cset_choice_time_ms +
1797 _recorded_non_young_free_cset_time_ms;
1799 _non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms /
1800 (double) _recorded_non_young_regions);
1801 }
1803 double constant_other_time_ms = all_other_time_ms -
1804 (young_other_time_ms + non_young_other_time_ms);
1805 _constant_other_time_ms_seq->add(constant_other_time_ms);
1807 double survival_ratio = 0.0;
1808 if (_bytes_in_collection_set_before_gc > 0) {
1809 survival_ratio = (double) bytes_in_to_space_during_gc() /
1810 (double) _bytes_in_collection_set_before_gc;
1811 }
1813 _pending_cards_seq->add((double) _pending_cards);
1814 _scanned_cards_seq->add((double) cards_scanned);
1815 _rs_lengths_seq->add((double) _max_rs_lengths);
1817 double expensive_region_limit_ms =
1818 (double) MaxGCPauseMillis - predict_constant_other_time_ms();
1819 if (expensive_region_limit_ms < 0.0) {
1820 // this means that the other time was predicted to be longer than
1821 // than the max pause time
1822 expensive_region_limit_ms = (double) MaxGCPauseMillis;
1823 }
1824 _expensive_region_limit_ms = expensive_region_limit_ms;
1826 if (PREDICTIONS_VERBOSE) {
1827 gclog_or_tty->print_cr("");
1828 gclog_or_tty->print_cr("PREDICTIONS %1.4lf %d "
1829 "REGIONS %d %d %d %d "
1830 "PENDING_CARDS %d %d "
1831 "CARDS_SCANNED %d %d "
1832 "RS_LENGTHS %d %d "
1833 "SCAN_ONLY_SCAN %1.6lf %1.6lf "
1834 "RS_UPDATE %1.6lf %1.6lf RS_SCAN %1.6lf %1.6lf "
1835 "SURVIVAL_RATIO %1.6lf %1.6lf "
1836 "OBJECT_COPY %1.6lf %1.6lf OTHER_CONSTANT %1.6lf %1.6lf "
1837 "OTHER_YOUNG %1.6lf %1.6lf "
1838 "OTHER_NON_YOUNG %1.6lf %1.6lf "
1839 "VTIME_DIFF %1.6lf TERMINATION %1.6lf "
1840 "ELAPSED %1.6lf %1.6lf ",
1841 _cur_collection_start_sec,
1842 (!_last_young_gc_full) ? 2 :
1843 (last_pause_included_initial_mark) ? 1 : 0,
1844 _recorded_region_num,
1845 _recorded_young_regions,
1846 _recorded_scan_only_regions,
1847 _recorded_non_young_regions,
1848 _predicted_pending_cards, _pending_cards,
1849 _predicted_cards_scanned, cards_scanned,
1850 _predicted_rs_lengths, _max_rs_lengths,
1851 _predicted_scan_only_scan_time_ms, scan_only_time,
1852 _predicted_rs_update_time_ms, update_rs_time,
1853 _predicted_rs_scan_time_ms, scan_rs_time,
1854 _predicted_survival_ratio, survival_ratio,
1855 _predicted_object_copy_time_ms, obj_copy_time,
1856 _predicted_constant_other_time_ms, constant_other_time_ms,
1857 _predicted_young_other_time_ms, young_other_time_ms,
1858 _predicted_non_young_other_time_ms,
1859 non_young_other_time_ms,
1860 _vtime_diff_ms, termination_time,
1861 _predicted_pause_time_ms, elapsed_ms);
1862 }
1864 if (G1PolicyVerbose > 0) {
1865 gclog_or_tty->print_cr("Pause Time, predicted: %1.4lfms (predicted %s), actual: %1.4lfms",
1866 _predicted_pause_time_ms,
1867 (_within_target) ? "within" : "outside",
1868 elapsed_ms);
1869 }
1871 }
1873 _in_marking_window = new_in_marking_window;
1874 _in_marking_window_im = new_in_marking_window_im;
1875 _free_regions_at_end_of_collection = _g1->free_regions();
1876 _scan_only_regions_at_end_of_collection = _g1->young_list_length();
1877 calculate_young_list_min_length();
1878 calculate_young_list_target_config();
1880 // </NEW PREDICTION>
1882 _target_pause_time_ms = -1.0;
1883 }
1885 // <NEW PREDICTION>
1887 double
1888 G1CollectorPolicy::
1889 predict_young_collection_elapsed_time_ms(size_t adjustment) {
1890 guarantee( adjustment == 0 || adjustment == 1, "invariant" );
1892 G1CollectedHeap* g1h = G1CollectedHeap::heap();
1893 size_t young_num = g1h->young_list_length();
1894 if (young_num == 0)
1895 return 0.0;
1897 young_num += adjustment;
1898 size_t pending_cards = predict_pending_cards();
1899 size_t rs_lengths = g1h->young_list_sampled_rs_lengths() +
1900 predict_rs_length_diff();
1901 size_t card_num;
1902 if (full_young_gcs())
1903 card_num = predict_young_card_num(rs_lengths);
1904 else
1905 card_num = predict_non_young_card_num(rs_lengths);
1906 size_t young_byte_size = young_num * HeapRegion::GrainBytes;
1907 double accum_yg_surv_rate =
1908 _short_lived_surv_rate_group->accum_surv_rate(adjustment);
1910 size_t bytes_to_copy =
1911 (size_t) (accum_yg_surv_rate * (double) HeapRegion::GrainBytes);
1913 return
1914 predict_rs_update_time_ms(pending_cards) +
1915 predict_rs_scan_time_ms(card_num) +
1916 predict_object_copy_time_ms(bytes_to_copy) +
1917 predict_young_other_time_ms(young_num) +
1918 predict_constant_other_time_ms();
1919 }
1921 double
1922 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) {
1923 size_t rs_length = predict_rs_length_diff();
1924 size_t card_num;
1925 if (full_young_gcs())
1926 card_num = predict_young_card_num(rs_length);
1927 else
1928 card_num = predict_non_young_card_num(rs_length);
1929 return predict_base_elapsed_time_ms(pending_cards, card_num);
1930 }
1932 double
1933 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards,
1934 size_t scanned_cards) {
1935 return
1936 predict_rs_update_time_ms(pending_cards) +
1937 predict_rs_scan_time_ms(scanned_cards) +
1938 predict_constant_other_time_ms();
1939 }
1941 double
1942 G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
1943 bool young) {
1944 size_t rs_length = hr->rem_set()->occupied();
1945 size_t card_num;
1946 if (full_young_gcs())
1947 card_num = predict_young_card_num(rs_length);
1948 else
1949 card_num = predict_non_young_card_num(rs_length);
1950 size_t bytes_to_copy = predict_bytes_to_copy(hr);
1952 double region_elapsed_time_ms =
1953 predict_rs_scan_time_ms(card_num) +
1954 predict_object_copy_time_ms(bytes_to_copy);
1956 if (young)
1957 region_elapsed_time_ms += predict_young_other_time_ms(1);
1958 else
1959 region_elapsed_time_ms += predict_non_young_other_time_ms(1);
1961 return region_elapsed_time_ms;
1962 }
1964 size_t
1965 G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) {
1966 size_t bytes_to_copy;
1967 if (hr->is_marked())
1968 bytes_to_copy = hr->max_live_bytes();
1969 else {
1970 guarantee( hr->is_young() && hr->age_in_surv_rate_group() != -1,
1971 "invariant" );
1972 int age = hr->age_in_surv_rate_group();
1973 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group());
1974 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate);
1975 }
1977 return bytes_to_copy;
1978 }
1980 void
1981 G1CollectorPolicy::start_recording_regions() {
1982 _recorded_rs_lengths = 0;
1983 _recorded_scan_only_regions = 0;
1984 _recorded_young_regions = 0;
1985 _recorded_non_young_regions = 0;
1987 #if PREDICTIONS_VERBOSE
1988 _predicted_rs_lengths = 0;
1989 _predicted_cards_scanned = 0;
1991 _recorded_marked_bytes = 0;
1992 _recorded_young_bytes = 0;
1993 _predicted_bytes_to_copy = 0;
1994 #endif // PREDICTIONS_VERBOSE
1995 }
1997 void
1998 G1CollectorPolicy::record_cset_region(HeapRegion* hr, bool young) {
1999 if (young) {
2000 ++_recorded_young_regions;
2001 } else {
2002 ++_recorded_non_young_regions;
2003 }
2004 #if PREDICTIONS_VERBOSE
2005 if (young) {
2006 _recorded_young_bytes += hr->used();
2007 } else {
2008 _recorded_marked_bytes += hr->max_live_bytes();
2009 }
2010 _predicted_bytes_to_copy += predict_bytes_to_copy(hr);
2011 #endif // PREDICTIONS_VERBOSE
2013 size_t rs_length = hr->rem_set()->occupied();
2014 _recorded_rs_lengths += rs_length;
2015 }
2017 void
2018 G1CollectorPolicy::record_scan_only_regions(size_t scan_only_length) {
2019 _recorded_scan_only_regions = scan_only_length;
2020 }
2022 void
2023 G1CollectorPolicy::end_recording_regions() {
2024 #if PREDICTIONS_VERBOSE
2025 _predicted_pending_cards = predict_pending_cards();
2026 _predicted_rs_lengths = _recorded_rs_lengths + predict_rs_length_diff();
2027 if (full_young_gcs())
2028 _predicted_cards_scanned += predict_young_card_num(_predicted_rs_lengths);
2029 else
2030 _predicted_cards_scanned +=
2031 predict_non_young_card_num(_predicted_rs_lengths);
2032 _recorded_region_num = _recorded_young_regions + _recorded_non_young_regions;
2034 _predicted_scan_only_scan_time_ms =
2035 predict_scan_only_time_ms(_recorded_scan_only_regions);
2036 _predicted_rs_update_time_ms =
2037 predict_rs_update_time_ms(_g1->pending_card_num());
2038 _predicted_rs_scan_time_ms =
2039 predict_rs_scan_time_ms(_predicted_cards_scanned);
2040 _predicted_object_copy_time_ms =
2041 predict_object_copy_time_ms(_predicted_bytes_to_copy);
2042 _predicted_constant_other_time_ms =
2043 predict_constant_other_time_ms();
2044 _predicted_young_other_time_ms =
2045 predict_young_other_time_ms(_recorded_young_regions);
2046 _predicted_non_young_other_time_ms =
2047 predict_non_young_other_time_ms(_recorded_non_young_regions);
2049 _predicted_pause_time_ms =
2050 _predicted_scan_only_scan_time_ms +
2051 _predicted_rs_update_time_ms +
2052 _predicted_rs_scan_time_ms +
2053 _predicted_object_copy_time_ms +
2054 _predicted_constant_other_time_ms +
2055 _predicted_young_other_time_ms +
2056 _predicted_non_young_other_time_ms;
2057 #endif // PREDICTIONS_VERBOSE
2058 }
2060 void G1CollectorPolicy::check_if_region_is_too_expensive(double
2061 predicted_time_ms) {
2062 // I don't think we need to do this when in young GC mode since
2063 // marking will be initiated next time we hit the soft limit anyway...
2064 if (predicted_time_ms > _expensive_region_limit_ms) {
2065 if (!in_young_gc_mode()) {
2066 set_full_young_gcs(true);
2067 _should_initiate_conc_mark = true;
2068 } else
2069 // no point in doing another partial one
2070 _should_revert_to_full_young_gcs = true;
2071 }
2072 }
2074 // </NEW PREDICTION>
2077 void G1CollectorPolicy::update_recent_gc_times(double end_time_sec,
2078 double elapsed_ms) {
2079 _recent_gc_times_ms->add(elapsed_ms);
2080 _recent_prev_end_times_for_all_gcs_sec->add(end_time_sec);
2081 _prev_collection_pause_end_ms = end_time_sec * 1000.0;
2082 }
2084 double G1CollectorPolicy::recent_avg_time_for_pauses_ms() {
2085 if (_recent_pause_times_ms->num() == 0) return (double) MaxGCPauseMillis;
2086 else return _recent_pause_times_ms->avg();
2087 }
2089 double G1CollectorPolicy::recent_avg_time_for_CH_strong_ms() {
2090 if (_recent_CH_strong_roots_times_ms->num() == 0)
2091 return (double)MaxGCPauseMillis/3.0;
2092 else return _recent_CH_strong_roots_times_ms->avg();
2093 }
2095 double G1CollectorPolicy::recent_avg_time_for_G1_strong_ms() {
2096 if (_recent_G1_strong_roots_times_ms->num() == 0)
2097 return (double)MaxGCPauseMillis/3.0;
2098 else return _recent_G1_strong_roots_times_ms->avg();
2099 }
2101 double G1CollectorPolicy::recent_avg_time_for_evac_ms() {
2102 if (_recent_evac_times_ms->num() == 0) return (double)MaxGCPauseMillis/3.0;
2103 else return _recent_evac_times_ms->avg();
2104 }
2106 int G1CollectorPolicy::number_of_recent_gcs() {
2107 assert(_recent_CH_strong_roots_times_ms->num() ==
2108 _recent_G1_strong_roots_times_ms->num(), "Sequence out of sync");
2109 assert(_recent_G1_strong_roots_times_ms->num() ==
2110 _recent_evac_times_ms->num(), "Sequence out of sync");
2111 assert(_recent_evac_times_ms->num() ==
2112 _recent_pause_times_ms->num(), "Sequence out of sync");
2113 assert(_recent_pause_times_ms->num() ==
2114 _recent_CS_bytes_used_before->num(), "Sequence out of sync");
2115 assert(_recent_CS_bytes_used_before->num() ==
2116 _recent_CS_bytes_surviving->num(), "Sequence out of sync");
2117 return _recent_pause_times_ms->num();
2118 }
2120 double G1CollectorPolicy::recent_avg_survival_fraction() {
2121 return recent_avg_survival_fraction_work(_recent_CS_bytes_surviving,
2122 _recent_CS_bytes_used_before);
2123 }
2125 double G1CollectorPolicy::last_survival_fraction() {
2126 return last_survival_fraction_work(_recent_CS_bytes_surviving,
2127 _recent_CS_bytes_used_before);
2128 }
2130 double
2131 G1CollectorPolicy::recent_avg_survival_fraction_work(TruncatedSeq* surviving,
2132 TruncatedSeq* before) {
2133 assert(surviving->num() == before->num(), "Sequence out of sync");
2134 if (before->sum() > 0.0) {
2135 double recent_survival_rate = surviving->sum() / before->sum();
2136 // We exempt parallel collection from this check because Alloc Buffer
2137 // fragmentation can produce negative collections.
2138 // Further, we're now always doing parallel collection. But I'm still
2139 // leaving this here as a placeholder for a more precise assertion later.
2140 // (DLD, 10/05.)
2141 assert((true || ParallelGCThreads > 0) ||
2142 _g1->evacuation_failed() ||
2143 recent_survival_rate <= 1.0, "Or bad frac");
2144 return recent_survival_rate;
2145 } else {
2146 return 1.0; // Be conservative.
2147 }
2148 }
2150 double
2151 G1CollectorPolicy::last_survival_fraction_work(TruncatedSeq* surviving,
2152 TruncatedSeq* before) {
2153 assert(surviving->num() == before->num(), "Sequence out of sync");
2154 if (surviving->num() > 0 && before->last() > 0.0) {
2155 double last_survival_rate = surviving->last() / before->last();
2156 // We exempt parallel collection from this check because Alloc Buffer
2157 // fragmentation can produce negative collections.
2158 // Further, we're now always doing parallel collection. But I'm still
2159 // leaving this here as a placeholder for a more precise assertion later.
2160 // (DLD, 10/05.)
2161 assert((true || ParallelGCThreads > 0) ||
2162 last_survival_rate <= 1.0, "Or bad frac");
2163 return last_survival_rate;
2164 } else {
2165 return 1.0;
2166 }
2167 }
2169 static const int survival_min_obs = 5;
2170 static double survival_min_obs_limits[] = { 0.9, 0.7, 0.5, 0.3, 0.1 };
2171 static const double min_survival_rate = 0.1;
2173 double
2174 G1CollectorPolicy::conservative_avg_survival_fraction_work(double avg,
2175 double latest) {
2176 double res = avg;
2177 if (number_of_recent_gcs() < survival_min_obs) {
2178 res = MAX2(res, survival_min_obs_limits[number_of_recent_gcs()]);
2179 }
2180 res = MAX2(res, latest);
2181 res = MAX2(res, min_survival_rate);
2182 // In the parallel case, LAB fragmentation can produce "negative
2183 // collections"; so can evac failure. Cap at 1.0
2184 res = MIN2(res, 1.0);
2185 return res;
2186 }
2188 size_t G1CollectorPolicy::expansion_amount() {
2189 if ((int)(recent_avg_pause_time_ratio() * 100.0) > G1GCPercent) {
2190 // We will double the existing space, or take
2191 // G1ExpandByPercentOfAvailable % of the available expansion
2192 // space, whichever is smaller, bounded below by a minimum
2193 // expansion (unless that's all that's left.)
2194 const size_t min_expand_bytes = 1*M;
2195 size_t reserved_bytes = _g1->g1_reserved_obj_bytes();
2196 size_t committed_bytes = _g1->capacity();
2197 size_t uncommitted_bytes = reserved_bytes - committed_bytes;
2198 size_t expand_bytes;
2199 size_t expand_bytes_via_pct =
2200 uncommitted_bytes * G1ExpandByPercentOfAvailable / 100;
2201 expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes);
2202 expand_bytes = MAX2(expand_bytes, min_expand_bytes);
2203 expand_bytes = MIN2(expand_bytes, uncommitted_bytes);
2204 if (G1PolicyVerbose > 1) {
2205 gclog_or_tty->print("Decided to expand: ratio = %5.2f, "
2206 "committed = %d%s, uncommited = %d%s, via pct = %d%s.\n"
2207 " Answer = %d.\n",
2208 recent_avg_pause_time_ratio(),
2209 byte_size_in_proper_unit(committed_bytes),
2210 proper_unit_for_byte_size(committed_bytes),
2211 byte_size_in_proper_unit(uncommitted_bytes),
2212 proper_unit_for_byte_size(uncommitted_bytes),
2213 byte_size_in_proper_unit(expand_bytes_via_pct),
2214 proper_unit_for_byte_size(expand_bytes_via_pct),
2215 byte_size_in_proper_unit(expand_bytes),
2216 proper_unit_for_byte_size(expand_bytes));
2217 }
2218 return expand_bytes;
2219 } else {
2220 return 0;
2221 }
2222 }
2224 void G1CollectorPolicy::note_start_of_mark_thread() {
2225 _mark_thread_startup_sec = os::elapsedTime();
2226 }
2228 class CountCSClosure: public HeapRegionClosure {
2229 G1CollectorPolicy* _g1_policy;
2230 public:
2231 CountCSClosure(G1CollectorPolicy* g1_policy) :
2232 _g1_policy(g1_policy) {}
2233 bool doHeapRegion(HeapRegion* r) {
2234 _g1_policy->_bytes_in_collection_set_before_gc += r->used();
2235 return false;
2236 }
2237 };
2239 void G1CollectorPolicy::count_CS_bytes_used() {
2240 CountCSClosure cs_closure(this);
2241 _g1->collection_set_iterate(&cs_closure);
2242 }
2244 static void print_indent(int level) {
2245 for (int j = 0; j < level+1; ++j)
2246 gclog_or_tty->print(" ");
2247 }
2249 void G1CollectorPolicy::print_summary (int level,
2250 const char* str,
2251 NumberSeq* seq) const {
2252 double sum = seq->sum();
2253 print_indent(level);
2254 gclog_or_tty->print_cr("%-24s = %8.2lf s (avg = %8.2lf ms)",
2255 str, sum / 1000.0, seq->avg());
2256 }
2258 void G1CollectorPolicy::print_summary_sd (int level,
2259 const char* str,
2260 NumberSeq* seq) const {
2261 print_summary(level, str, seq);
2262 print_indent(level + 5);
2263 gclog_or_tty->print_cr("(num = %5d, std dev = %8.2lf ms, max = %8.2lf ms)",
2264 seq->num(), seq->sd(), seq->maximum());
2265 }
2267 void G1CollectorPolicy::check_other_times(int level,
2268 NumberSeq* other_times_ms,
2269 NumberSeq* calc_other_times_ms) const {
2270 bool should_print = false;
2272 double max_sum = MAX2(fabs(other_times_ms->sum()),
2273 fabs(calc_other_times_ms->sum()));
2274 double min_sum = MIN2(fabs(other_times_ms->sum()),
2275 fabs(calc_other_times_ms->sum()));
2276 double sum_ratio = max_sum / min_sum;
2277 if (sum_ratio > 1.1) {
2278 should_print = true;
2279 print_indent(level + 1);
2280 gclog_or_tty->print_cr("## CALCULATED OTHER SUM DOESN'T MATCH RECORDED ###");
2281 }
2283 double max_avg = MAX2(fabs(other_times_ms->avg()),
2284 fabs(calc_other_times_ms->avg()));
2285 double min_avg = MIN2(fabs(other_times_ms->avg()),
2286 fabs(calc_other_times_ms->avg()));
2287 double avg_ratio = max_avg / min_avg;
2288 if (avg_ratio > 1.1) {
2289 should_print = true;
2290 print_indent(level + 1);
2291 gclog_or_tty->print_cr("## CALCULATED OTHER AVG DOESN'T MATCH RECORDED ###");
2292 }
2294 if (other_times_ms->sum() < -0.01) {
2295 print_indent(level + 1);
2296 gclog_or_tty->print_cr("## RECORDED OTHER SUM IS NEGATIVE ###");
2297 }
2299 if (other_times_ms->avg() < -0.01) {
2300 print_indent(level + 1);
2301 gclog_or_tty->print_cr("## RECORDED OTHER AVG IS NEGATIVE ###");
2302 }
2304 if (calc_other_times_ms->sum() < -0.01) {
2305 should_print = true;
2306 print_indent(level + 1);
2307 gclog_or_tty->print_cr("## CALCULATED OTHER SUM IS NEGATIVE ###");
2308 }
2310 if (calc_other_times_ms->avg() < -0.01) {
2311 should_print = true;
2312 print_indent(level + 1);
2313 gclog_or_tty->print_cr("## CALCULATED OTHER AVG IS NEGATIVE ###");
2314 }
2316 if (should_print)
2317 print_summary(level, "Other(Calc)", calc_other_times_ms);
2318 }
2320 void G1CollectorPolicy::print_summary(PauseSummary* summary) const {
2321 bool parallel = ParallelGCThreads > 0;
2322 MainBodySummary* body_summary = summary->main_body_summary();
2323 if (summary->get_total_seq()->num() > 0) {
2324 print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq());
2325 if (body_summary != NULL) {
2326 print_summary(1, "SATB Drain", body_summary->get_satb_drain_seq());
2327 if (parallel) {
2328 print_summary(1, "Parallel Time", body_summary->get_parallel_seq());
2329 print_summary(2, "Update RS", body_summary->get_update_rs_seq());
2330 print_summary(2, "Ext Root Scanning",
2331 body_summary->get_ext_root_scan_seq());
2332 print_summary(2, "Mark Stack Scanning",
2333 body_summary->get_mark_stack_scan_seq());
2334 print_summary(2, "Scan-Only Scanning",
2335 body_summary->get_scan_only_seq());
2336 print_summary(2, "Scan RS", body_summary->get_scan_rs_seq());
2337 print_summary(2, "Object Copy", body_summary->get_obj_copy_seq());
2338 print_summary(2, "Termination", body_summary->get_termination_seq());
2339 print_summary(2, "Other", body_summary->get_parallel_other_seq());
2340 {
2341 NumberSeq* other_parts[] = {
2342 body_summary->get_update_rs_seq(),
2343 body_summary->get_ext_root_scan_seq(),
2344 body_summary->get_mark_stack_scan_seq(),
2345 body_summary->get_scan_only_seq(),
2346 body_summary->get_scan_rs_seq(),
2347 body_summary->get_obj_copy_seq(),
2348 body_summary->get_termination_seq()
2349 };
2350 NumberSeq calc_other_times_ms(body_summary->get_parallel_seq(),
2351 7, other_parts);
2352 check_other_times(2, body_summary->get_parallel_other_seq(),
2353 &calc_other_times_ms);
2354 }
2355 print_summary(1, "Mark Closure", body_summary->get_mark_closure_seq());
2356 print_summary(1, "Clear CT", body_summary->get_clear_ct_seq());
2357 } else {
2358 print_summary(1, "Update RS", body_summary->get_update_rs_seq());
2359 print_summary(1, "Ext Root Scanning",
2360 body_summary->get_ext_root_scan_seq());
2361 print_summary(1, "Mark Stack Scanning",
2362 body_summary->get_mark_stack_scan_seq());
2363 print_summary(1, "Scan-Only Scanning",
2364 body_summary->get_scan_only_seq());
2365 print_summary(1, "Scan RS", body_summary->get_scan_rs_seq());
2366 print_summary(1, "Object Copy", body_summary->get_obj_copy_seq());
2367 }
2368 }
2369 print_summary(1, "Other", summary->get_other_seq());
2370 {
2371 NumberSeq calc_other_times_ms;
2372 if (body_summary != NULL) {
2373 // not abandoned
2374 if (parallel) {
2375 // parallel
2376 NumberSeq* other_parts[] = {
2377 body_summary->get_satb_drain_seq(),
2378 body_summary->get_parallel_seq(),
2379 body_summary->get_clear_ct_seq()
2380 };
2381 calc_other_times_ms = NumberSeq(summary->get_total_seq(),
2382 3, other_parts);
2383 } else {
2384 // serial
2385 NumberSeq* other_parts[] = {
2386 body_summary->get_satb_drain_seq(),
2387 body_summary->get_update_rs_seq(),
2388 body_summary->get_ext_root_scan_seq(),
2389 body_summary->get_mark_stack_scan_seq(),
2390 body_summary->get_scan_only_seq(),
2391 body_summary->get_scan_rs_seq(),
2392 body_summary->get_obj_copy_seq()
2393 };
2394 calc_other_times_ms = NumberSeq(summary->get_total_seq(),
2395 7, other_parts);
2396 }
2397 } else {
2398 // abandoned
2399 calc_other_times_ms = NumberSeq();
2400 }
2401 check_other_times(1, summary->get_other_seq(), &calc_other_times_ms);
2402 }
2403 } else {
2404 print_indent(0);
2405 gclog_or_tty->print_cr("none");
2406 }
2407 gclog_or_tty->print_cr("");
2408 }
2410 void
2411 G1CollectorPolicy::print_abandoned_summary(PauseSummary* summary) const {
2412 bool printed = false;
2413 if (summary->get_total_seq()->num() > 0) {
2414 printed = true;
2415 print_summary(summary);
2416 }
2417 if (!printed) {
2418 print_indent(0);
2419 gclog_or_tty->print_cr("none");
2420 gclog_or_tty->print_cr("");
2421 }
2422 }
2424 void G1CollectorPolicy::print_tracing_info() const {
2425 if (TraceGen0Time) {
2426 gclog_or_tty->print_cr("ALL PAUSES");
2427 print_summary_sd(0, "Total", _all_pause_times_ms);
2428 gclog_or_tty->print_cr("");
2429 gclog_or_tty->print_cr("");
2430 gclog_or_tty->print_cr(" Full Young GC Pauses: %8d", _full_young_pause_num);
2431 gclog_or_tty->print_cr(" Partial Young GC Pauses: %8d", _partial_young_pause_num);
2432 gclog_or_tty->print_cr("");
2434 gclog_or_tty->print_cr("EVACUATION PAUSES");
2435 print_summary(_summary);
2437 gclog_or_tty->print_cr("ABANDONED PAUSES");
2438 print_abandoned_summary(_abandoned_summary);
2440 gclog_or_tty->print_cr("MISC");
2441 print_summary_sd(0, "Stop World", _all_stop_world_times_ms);
2442 print_summary_sd(0, "Yields", _all_yield_times_ms);
2443 for (int i = 0; i < _aux_num; ++i) {
2444 if (_all_aux_times_ms[i].num() > 0) {
2445 char buffer[96];
2446 sprintf(buffer, "Aux%d", i);
2447 print_summary_sd(0, buffer, &_all_aux_times_ms[i]);
2448 }
2449 }
2451 size_t all_region_num = _region_num_young + _region_num_tenured;
2452 gclog_or_tty->print_cr(" New Regions %8d, Young %8d (%6.2lf%%), "
2453 "Tenured %8d (%6.2lf%%)",
2454 all_region_num,
2455 _region_num_young,
2456 (double) _region_num_young / (double) all_region_num * 100.0,
2457 _region_num_tenured,
2458 (double) _region_num_tenured / (double) all_region_num * 100.0);
2459 }
2460 if (TraceGen1Time) {
2461 if (_all_full_gc_times_ms->num() > 0) {
2462 gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s",
2463 _all_full_gc_times_ms->num(),
2464 _all_full_gc_times_ms->sum() / 1000.0);
2465 gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times_ms->avg());
2466 gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]",
2467 _all_full_gc_times_ms->sd(),
2468 _all_full_gc_times_ms->maximum());
2469 }
2470 }
2471 }
2473 void G1CollectorPolicy::print_yg_surv_rate_info() const {
2474 #ifndef PRODUCT
2475 _short_lived_surv_rate_group->print_surv_rate_summary();
2476 // add this call for any other surv rate groups
2477 #endif // PRODUCT
2478 }
2480 bool
2481 G1CollectorPolicy::should_add_next_region_to_young_list() {
2482 assert(in_young_gc_mode(), "should be in young GC mode");
2483 bool ret;
2484 size_t young_list_length = _g1->young_list_length();
2485 size_t young_list_max_length = _young_list_target_length;
2486 if (G1FixedEdenSize) {
2487 young_list_max_length -= _max_survivor_regions;
2488 }
2489 if (young_list_length < young_list_max_length) {
2490 ret = true;
2491 ++_region_num_young;
2492 } else {
2493 ret = false;
2494 ++_region_num_tenured;
2495 }
2497 return ret;
2498 }
2500 #ifndef PRODUCT
2501 // for debugging, bit of a hack...
2502 static char*
2503 region_num_to_mbs(int length) {
2504 static char buffer[64];
2505 double bytes = (double) (length * HeapRegion::GrainBytes);
2506 double mbs = bytes / (double) (1024 * 1024);
2507 sprintf(buffer, "%7.2lfMB", mbs);
2508 return buffer;
2509 }
2510 #endif // PRODUCT
2512 void
2513 G1CollectorPolicy::checkpoint_conc_overhead() {
2514 double conc_overhead = 0.0;
2515 if (G1AccountConcurrentOverhead)
2516 conc_overhead = COTracker::totalPredConcOverhead();
2517 _mmu_tracker->update_conc_overhead(conc_overhead);
2518 #if 0
2519 gclog_or_tty->print(" CO %1.4lf TARGET %1.4lf",
2520 conc_overhead, _mmu_tracker->max_gc_time());
2521 #endif
2522 }
2525 size_t G1CollectorPolicy::max_regions(int purpose) {
2526 switch (purpose) {
2527 case GCAllocForSurvived:
2528 return _max_survivor_regions;
2529 case GCAllocForTenured:
2530 return REGIONS_UNLIMITED;
2531 default:
2532 ShouldNotReachHere();
2533 return REGIONS_UNLIMITED;
2534 };
2535 }
2537 // Calculates survivor space parameters.
2538 void G1CollectorPolicy::calculate_survivors_policy()
2539 {
2540 if (!G1UseSurvivorSpaces) {
2541 return;
2542 }
2543 if (G1FixedSurvivorSpaceSize == 0) {
2544 _max_survivor_regions = _young_list_target_length / SurvivorRatio;
2545 } else {
2546 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes;
2547 }
2549 if (G1FixedTenuringThreshold) {
2550 _tenuring_threshold = MaxTenuringThreshold;
2551 } else {
2552 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold(
2553 HeapRegion::GrainWords * _max_survivor_regions);
2554 }
2555 }
2557 bool
2558 G1CollectorPolicy_BestRegionsFirst::should_do_collection_pause(size_t
2559 word_size) {
2560 assert(_g1->regions_accounted_for(), "Region leakage!");
2561 // Initiate a pause when we reach the steady-state "used" target.
2562 size_t used_hard = (_g1->capacity() / 100) * G1SteadyStateUsed;
2563 size_t used_soft =
2564 MAX2((_g1->capacity() / 100) * (G1SteadyStateUsed - G1SteadyStateUsedDelta),
2565 used_hard/2);
2566 size_t used = _g1->used();
2568 double max_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0;
2570 size_t young_list_length = _g1->young_list_length();
2571 size_t young_list_max_length = _young_list_target_length;
2572 if (G1FixedEdenSize) {
2573 young_list_max_length -= _max_survivor_regions;
2574 }
2575 bool reached_target_length = young_list_length >= young_list_max_length;
2577 if (in_young_gc_mode()) {
2578 if (reached_target_length) {
2579 assert( young_list_length > 0 && _g1->young_list_length() > 0,
2580 "invariant" );
2581 _target_pause_time_ms = max_pause_time_ms;
2582 return true;
2583 }
2584 } else {
2585 guarantee( false, "should not reach here" );
2586 }
2588 return false;
2589 }
2591 #ifndef PRODUCT
2592 class HRSortIndexIsOKClosure: public HeapRegionClosure {
2593 CollectionSetChooser* _chooser;
2594 public:
2595 HRSortIndexIsOKClosure(CollectionSetChooser* chooser) :
2596 _chooser(chooser) {}
2598 bool doHeapRegion(HeapRegion* r) {
2599 if (!r->continuesHumongous()) {
2600 assert(_chooser->regionProperlyOrdered(r), "Ought to be.");
2601 }
2602 return false;
2603 }
2604 };
2606 bool G1CollectorPolicy_BestRegionsFirst::assertMarkedBytesDataOK() {
2607 HRSortIndexIsOKClosure cl(_collectionSetChooser);
2608 _g1->heap_region_iterate(&cl);
2609 return true;
2610 }
2611 #endif
2613 void
2614 G1CollectorPolicy_BestRegionsFirst::
2615 record_collection_pause_start(double start_time_sec, size_t start_used) {
2616 G1CollectorPolicy::record_collection_pause_start(start_time_sec, start_used);
2617 }
2619 class NextNonCSElemFinder: public HeapRegionClosure {
2620 HeapRegion* _res;
2621 public:
2622 NextNonCSElemFinder(): _res(NULL) {}
2623 bool doHeapRegion(HeapRegion* r) {
2624 if (!r->in_collection_set()) {
2625 _res = r;
2626 return true;
2627 } else {
2628 return false;
2629 }
2630 }
2631 HeapRegion* res() { return _res; }
2632 };
2634 class KnownGarbageClosure: public HeapRegionClosure {
2635 CollectionSetChooser* _hrSorted;
2637 public:
2638 KnownGarbageClosure(CollectionSetChooser* hrSorted) :
2639 _hrSorted(hrSorted)
2640 {}
2642 bool doHeapRegion(HeapRegion* r) {
2643 // We only include humongous regions in collection
2644 // sets when concurrent mark shows that their contained object is
2645 // unreachable.
2647 // Do we have any marking information for this region?
2648 if (r->is_marked()) {
2649 // We don't include humongous regions in collection
2650 // sets because we collect them immediately at the end of a marking
2651 // cycle. We also don't include young regions because we *must*
2652 // include them in the next collection pause.
2653 if (!r->isHumongous() && !r->is_young()) {
2654 _hrSorted->addMarkedHeapRegion(r);
2655 }
2656 }
2657 return false;
2658 }
2659 };
2661 class ParKnownGarbageHRClosure: public HeapRegionClosure {
2662 CollectionSetChooser* _hrSorted;
2663 jint _marked_regions_added;
2664 jint _chunk_size;
2665 jint _cur_chunk_idx;
2666 jint _cur_chunk_end; // Cur chunk [_cur_chunk_idx, _cur_chunk_end)
2667 int _worker;
2668 int _invokes;
2670 void get_new_chunk() {
2671 _cur_chunk_idx = _hrSorted->getParMarkedHeapRegionChunk(_chunk_size);
2672 _cur_chunk_end = _cur_chunk_idx + _chunk_size;
2673 }
2674 void add_region(HeapRegion* r) {
2675 if (_cur_chunk_idx == _cur_chunk_end) {
2676 get_new_chunk();
2677 }
2678 assert(_cur_chunk_idx < _cur_chunk_end, "postcondition");
2679 _hrSorted->setMarkedHeapRegion(_cur_chunk_idx, r);
2680 _marked_regions_added++;
2681 _cur_chunk_idx++;
2682 }
2684 public:
2685 ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted,
2686 jint chunk_size,
2687 int worker) :
2688 _hrSorted(hrSorted), _chunk_size(chunk_size), _worker(worker),
2689 _marked_regions_added(0), _cur_chunk_idx(0), _cur_chunk_end(0),
2690 _invokes(0)
2691 {}
2693 bool doHeapRegion(HeapRegion* r) {
2694 // We only include humongous regions in collection
2695 // sets when concurrent mark shows that their contained object is
2696 // unreachable.
2697 _invokes++;
2699 // Do we have any marking information for this region?
2700 if (r->is_marked()) {
2701 // We don't include humongous regions in collection
2702 // sets because we collect them immediately at the end of a marking
2703 // cycle.
2704 // We also do not include young regions in collection sets
2705 if (!r->isHumongous() && !r->is_young()) {
2706 add_region(r);
2707 }
2708 }
2709 return false;
2710 }
2711 jint marked_regions_added() { return _marked_regions_added; }
2712 int invokes() { return _invokes; }
2713 };
2715 class ParKnownGarbageTask: public AbstractGangTask {
2716 CollectionSetChooser* _hrSorted;
2717 jint _chunk_size;
2718 G1CollectedHeap* _g1;
2719 public:
2720 ParKnownGarbageTask(CollectionSetChooser* hrSorted, jint chunk_size) :
2721 AbstractGangTask("ParKnownGarbageTask"),
2722 _hrSorted(hrSorted), _chunk_size(chunk_size),
2723 _g1(G1CollectedHeap::heap())
2724 {}
2726 void work(int i) {
2727 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size, i);
2728 // Back to zero for the claim value.
2729 _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, i,
2730 HeapRegion::InitialClaimValue);
2731 jint regions_added = parKnownGarbageCl.marked_regions_added();
2732 _hrSorted->incNumMarkedHeapRegions(regions_added);
2733 if (G1PrintParCleanupStats) {
2734 gclog_or_tty->print(" Thread %d called %d times, added %d regions to list.\n",
2735 i, parKnownGarbageCl.invokes(), regions_added);
2736 }
2737 }
2738 };
2740 void
2741 G1CollectorPolicy_BestRegionsFirst::
2742 record_concurrent_mark_cleanup_end(size_t freed_bytes,
2743 size_t max_live_bytes) {
2744 double start;
2745 if (G1PrintParCleanupStats) start = os::elapsedTime();
2746 record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes);
2748 _collectionSetChooser->clearMarkedHeapRegions();
2749 double clear_marked_end;
2750 if (G1PrintParCleanupStats) {
2751 clear_marked_end = os::elapsedTime();
2752 gclog_or_tty->print_cr(" clear marked regions + work1: %8.3f ms.",
2753 (clear_marked_end - start)*1000.0);
2754 }
2755 if (ParallelGCThreads > 0) {
2756 const size_t OverpartitionFactor = 4;
2757 const size_t MinChunkSize = 8;
2758 const size_t ChunkSize =
2759 MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor),
2760 MinChunkSize);
2761 _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(),
2762 ChunkSize);
2763 ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser,
2764 (int) ChunkSize);
2765 _g1->workers()->run_task(&parKnownGarbageTask);
2767 assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
2768 "sanity check");
2769 } else {
2770 KnownGarbageClosure knownGarbagecl(_collectionSetChooser);
2771 _g1->heap_region_iterate(&knownGarbagecl);
2772 }
2773 double known_garbage_end;
2774 if (G1PrintParCleanupStats) {
2775 known_garbage_end = os::elapsedTime();
2776 gclog_or_tty->print_cr(" compute known garbage: %8.3f ms.",
2777 (known_garbage_end - clear_marked_end)*1000.0);
2778 }
2779 _collectionSetChooser->sortMarkedHeapRegions();
2780 double sort_end;
2781 if (G1PrintParCleanupStats) {
2782 sort_end = os::elapsedTime();
2783 gclog_or_tty->print_cr(" sorting: %8.3f ms.",
2784 (sort_end - known_garbage_end)*1000.0);
2785 }
2787 record_concurrent_mark_cleanup_end_work2();
2788 double work2_end;
2789 if (G1PrintParCleanupStats) {
2790 work2_end = os::elapsedTime();
2791 gclog_or_tty->print_cr(" work2: %8.3f ms.",
2792 (work2_end - sort_end)*1000.0);
2793 }
2794 }
2796 // Add the heap region to the collection set and return the conservative
2797 // estimate of the number of live bytes.
2798 void G1CollectorPolicy::
2799 add_to_collection_set(HeapRegion* hr) {
2800 if (G1PrintRegions) {
2801 gclog_or_tty->print_cr("added region to cset %d:["PTR_FORMAT", "PTR_FORMAT"], "
2802 "top "PTR_FORMAT", young %s",
2803 hr->hrs_index(), hr->bottom(), hr->end(),
2804 hr->top(), (hr->is_young()) ? "YES" : "NO");
2805 }
2807 if (_g1->mark_in_progress())
2808 _g1->concurrent_mark()->registerCSetRegion(hr);
2810 assert(!hr->in_collection_set(),
2811 "should not already be in the CSet");
2812 hr->set_in_collection_set(true);
2813 hr->set_next_in_collection_set(_collection_set);
2814 _collection_set = hr;
2815 _collection_set_size++;
2816 _collection_set_bytes_used_before += hr->used();
2817 _g1->register_region_with_in_cset_fast_test(hr);
2818 }
2820 void
2821 G1CollectorPolicy_BestRegionsFirst::
2822 choose_collection_set() {
2823 double non_young_start_time_sec;
2824 start_recording_regions();
2826 guarantee(_target_pause_time_ms > -1.0,
2827 "_target_pause_time_ms should have been set!");
2828 assert(_collection_set == NULL, "Precondition");
2830 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards);
2831 double predicted_pause_time_ms = base_time_ms;
2833 double target_time_ms = _target_pause_time_ms;
2834 double time_remaining_ms = target_time_ms - base_time_ms;
2836 // the 10% and 50% values are arbitrary...
2837 if (time_remaining_ms < 0.10*target_time_ms) {
2838 time_remaining_ms = 0.50 * target_time_ms;
2839 _within_target = false;
2840 } else {
2841 _within_target = true;
2842 }
2844 // We figure out the number of bytes available for future to-space.
2845 // For new regions without marking information, we must assume the
2846 // worst-case of complete survival. If we have marking information for a
2847 // region, we can bound the amount of live data. We can add a number of
2848 // such regions, as long as the sum of the live data bounds does not
2849 // exceed the available evacuation space.
2850 size_t max_live_bytes = _g1->free_regions() * HeapRegion::GrainBytes;
2852 size_t expansion_bytes =
2853 _g1->expansion_regions() * HeapRegion::GrainBytes;
2855 _collection_set_bytes_used_before = 0;
2856 _collection_set_size = 0;
2858 // Adjust for expansion and slop.
2859 max_live_bytes = max_live_bytes + expansion_bytes;
2861 assert(_g1->regions_accounted_for(), "Region leakage!");
2863 HeapRegion* hr;
2864 if (in_young_gc_mode()) {
2865 double young_start_time_sec = os::elapsedTime();
2867 if (G1PolicyVerbose > 0) {
2868 gclog_or_tty->print_cr("Adding %d young regions to the CSet",
2869 _g1->young_list_length());
2870 }
2871 _young_cset_length = 0;
2872 _last_young_gc_full = full_young_gcs() ? true : false;
2873 if (_last_young_gc_full)
2874 ++_full_young_pause_num;
2875 else
2876 ++_partial_young_pause_num;
2877 hr = _g1->pop_region_from_young_list();
2878 while (hr != NULL) {
2880 assert( hr->young_index_in_cset() == -1, "invariant" );
2881 assert( hr->age_in_surv_rate_group() != -1, "invariant" );
2882 hr->set_young_index_in_cset((int) _young_cset_length);
2884 ++_young_cset_length;
2885 double predicted_time_ms = predict_region_elapsed_time_ms(hr, true);
2886 time_remaining_ms -= predicted_time_ms;
2887 predicted_pause_time_ms += predicted_time_ms;
2888 assert(!hr->in_collection_set(), "invariant");
2889 add_to_collection_set(hr);
2890 record_cset_region(hr, true);
2891 max_live_bytes -= MIN2(hr->max_live_bytes(), max_live_bytes);
2892 if (G1PolicyVerbose > 0) {
2893 gclog_or_tty->print_cr(" Added [" PTR_FORMAT ", " PTR_FORMAT") to CS.",
2894 hr->bottom(), hr->end());
2895 gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)",
2896 max_live_bytes/K);
2897 }
2898 hr = _g1->pop_region_from_young_list();
2899 }
2901 record_scan_only_regions(_g1->young_list_scan_only_length());
2903 double young_end_time_sec = os::elapsedTime();
2904 _recorded_young_cset_choice_time_ms =
2905 (young_end_time_sec - young_start_time_sec) * 1000.0;
2907 non_young_start_time_sec = os::elapsedTime();
2909 if (_young_cset_length > 0 && _last_young_gc_full) {
2910 // don't bother adding more regions...
2911 goto choose_collection_set_end;
2912 }
2913 }
2915 if (!in_young_gc_mode() || !full_young_gcs()) {
2916 bool should_continue = true;
2917 NumberSeq seq;
2918 double avg_prediction = 100000000000000000.0; // something very large
2919 do {
2920 hr = _collectionSetChooser->getNextMarkedRegion(time_remaining_ms,
2921 avg_prediction);
2922 if (hr != NULL) {
2923 double predicted_time_ms = predict_region_elapsed_time_ms(hr, false);
2924 time_remaining_ms -= predicted_time_ms;
2925 predicted_pause_time_ms += predicted_time_ms;
2926 add_to_collection_set(hr);
2927 record_cset_region(hr, false);
2928 max_live_bytes -= MIN2(hr->max_live_bytes(), max_live_bytes);
2929 if (G1PolicyVerbose > 0) {
2930 gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)",
2931 max_live_bytes/K);
2932 }
2933 seq.add(predicted_time_ms);
2934 avg_prediction = seq.avg() + seq.sd();
2935 }
2936 should_continue =
2937 ( hr != NULL) &&
2938 ( (adaptive_young_list_length()) ? time_remaining_ms > 0.0
2939 : _collection_set_size < _young_list_fixed_length );
2940 } while (should_continue);
2942 if (!adaptive_young_list_length() &&
2943 _collection_set_size < _young_list_fixed_length)
2944 _should_revert_to_full_young_gcs = true;
2945 }
2947 choose_collection_set_end:
2948 count_CS_bytes_used();
2950 end_recording_regions();
2952 double non_young_end_time_sec = os::elapsedTime();
2953 _recorded_non_young_cset_choice_time_ms =
2954 (non_young_end_time_sec - non_young_start_time_sec) * 1000.0;
2955 }
2957 void G1CollectorPolicy_BestRegionsFirst::record_full_collection_end() {
2958 G1CollectorPolicy::record_full_collection_end();
2959 _collectionSetChooser->updateAfterFullCollection();
2960 }
2962 void G1CollectorPolicy_BestRegionsFirst::
2963 expand_if_possible(size_t numRegions) {
2964 size_t expansion_bytes = numRegions * HeapRegion::GrainBytes;
2965 _g1->expand(expansion_bytes);
2966 }
2968 void G1CollectorPolicy_BestRegionsFirst::
2969 record_collection_pause_end(bool abandoned) {
2970 G1CollectorPolicy::record_collection_pause_end(abandoned);
2971 assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end.");
2972 }
2974 // Local Variables: ***
2975 // c-indentation-style: gnu ***
2976 // End: ***