1 /*
2 * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/g1/concurrentG1Refine.hpp"
27 #include "gc/g1/concurrentMarkThread.inline.hpp"
28 #include "gc/g1/g1Analytics.hpp"
29 #include "gc/g1/g1CollectedHeap.inline.hpp"
30 #include "gc/g1/g1CollectionSet.hpp"
31 #include "gc/g1/g1ConcurrentMark.hpp"
32 #include "gc/g1/g1DefaultPolicy.hpp"
33 #include "gc/g1/g1HotCardCache.hpp"
34 #include "gc/g1/g1IHOPControl.hpp"
35 #include "gc/g1/g1GCPhaseTimes.hpp"
36 #include "gc/g1/g1Policy.hpp"
37 #include "gc/g1/g1SurvivorRegions.hpp"
38 #include "gc/g1/g1YoungGenSizer.hpp"
39 #include "gc/g1/heapRegion.inline.hpp"
40 #include "gc/g1/heapRegionRemSet.hpp"
41 #include "gc/shared/gcPolicyCounters.hpp"
42 #include "logging/logStream.hpp"
43 #include "runtime/arguments.hpp"
44 #include "runtime/java.hpp"
45 #include "runtime/mutexLocker.hpp"
46 #include "utilities/debug.hpp"
47 #include "utilities/growableArray.hpp"
48 #include "utilities/pair.hpp"
49
50 G1DefaultPolicy::G1DefaultPolicy() :
51 _predictor(G1ConfidencePercent / 100.0),
52 _analytics(new G1Analytics(&_predictor)),
53 _mmu_tracker(new G1MMUTrackerQueue(GCPauseIntervalMillis / 1000.0, MaxGCPauseMillis / 1000.0)),
54 _ihop_control(create_ihop_control(&_predictor)),
55 _policy_counters(new GCPolicyCounters("GarbageFirst", 1, 3)),
56 _young_list_fixed_length(0),
57 _short_lived_surv_rate_group(new SurvRateGroup()),
58 _survivor_surv_rate_group(new SurvRateGroup()),
59 _reserve_factor((double) G1ReservePercent / 100.0),
60 _reserve_regions(0),
61 _rs_lengths_prediction(0),
62 _bytes_allocated_in_old_since_last_gc(0),
63 _initial_mark_to_mixed(),
64 _collection_set(NULL),
65 _g1(NULL),
66 _phase_times(new G1GCPhaseTimes(ParallelGCThreads)),
67 _tenuring_threshold(MaxTenuringThreshold),
68 _max_survivor_regions(0),
69 _survivors_age_table(true) { }
70
71 G1DefaultPolicy::~G1DefaultPolicy() {
72 delete _ihop_control;
73 }
74
75 G1CollectorState* G1DefaultPolicy::collector_state() const { return _g1->collector_state(); }
76
77 void G1DefaultPolicy::init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) {
78 _g1 = g1h;
79 _collection_set = collection_set;
80
81 assert(Heap_lock->owned_by_self(), "Locking discipline.");
82
83 if (!adaptive_young_list_length()) {
84 _young_list_fixed_length = _young_gen_sizer.min_desired_young_length();
85 }
86 _young_gen_sizer.adjust_max_new_size(_g1->max_regions());
87
88 _free_regions_at_end_of_collection = _g1->num_free_regions();
89
90 update_young_list_max_and_target_length();
91 // We may immediately start allocating regions and placing them on the
92 // collection set list. Initialize the per-collection set info
93 _collection_set->start_incremental_building();
94 }
95
96 void G1DefaultPolicy::note_gc_start() {
97 phase_times()->note_gc_start();
98 }
99
100 class G1YoungLengthPredictor VALUE_OBJ_CLASS_SPEC {
101 const bool _during_cm;
102 const double _base_time_ms;
103 const double _base_free_regions;
104 const double _target_pause_time_ms;
105 const G1DefaultPolicy* const _policy;
106
107 public:
108 G1YoungLengthPredictor(bool during_cm,
109 double base_time_ms,
110 double base_free_regions,
111 double target_pause_time_ms,
112 const G1DefaultPolicy* policy) :
113 _during_cm(during_cm),
114 _base_time_ms(base_time_ms),
115 _base_free_regions(base_free_regions),
116 _target_pause_time_ms(target_pause_time_ms),
117 _policy(policy) {}
118
119 bool will_fit(uint young_length) const {
120 if (young_length >= _base_free_regions) {
121 // end condition 1: not enough space for the young regions
122 return false;
123 }
124
125 const double accum_surv_rate = _policy->accum_yg_surv_rate_pred((int) young_length - 1);
126 const size_t bytes_to_copy =
127 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);
128 const double copy_time_ms =
129 _policy->analytics()->predict_object_copy_time_ms(bytes_to_copy, _during_cm);
130 const double young_other_time_ms = _policy->analytics()->predict_young_other_time_ms(young_length);
131 const double pause_time_ms = _base_time_ms + copy_time_ms + young_other_time_ms;
132 if (pause_time_ms > _target_pause_time_ms) {
133 // end condition 2: prediction is over the target pause time
134 return false;
135 }
136
137 const size_t free_bytes = (_base_free_regions - young_length) * HeapRegion::GrainBytes;
138
139 // When copying, we will likely need more bytes free than is live in the region.
140 // Add some safety margin to factor in the confidence of our guess, and the
141 // natural expected waste.
142 // (100.0 / G1ConfidencePercent) is a scale factor that expresses the uncertainty
143 // of the calculation: the lower the confidence, the more headroom.
144 // (100 + TargetPLABWastePct) represents the increase in expected bytes during
145 // copying due to anticipated waste in the PLABs.
146 const double safety_factor = (100.0 / G1ConfidencePercent) * (100 + TargetPLABWastePct) / 100.0;
147 const size_t expected_bytes_to_copy = (size_t)(safety_factor * bytes_to_copy);
148
149 if (expected_bytes_to_copy > free_bytes) {
150 // end condition 3: out-of-space
151 return false;
152 }
153
154 // success!
155 return true;
156 }
157 };
158
159 void G1DefaultPolicy::record_new_heap_size(uint new_number_of_regions) {
160 // re-calculate the necessary reserve
161 double reserve_regions_d = (double) new_number_of_regions * _reserve_factor;
162 // We use ceiling so that if reserve_regions_d is > 0.0 (but
163 // smaller than 1.0) we'll get 1.
164 _reserve_regions = (uint) ceil(reserve_regions_d);
165
166 _young_gen_sizer.heap_size_changed(new_number_of_regions);
167
168 _ihop_control->update_target_occupancy(new_number_of_regions * HeapRegion::GrainBytes);
169 }
170
171 uint G1DefaultPolicy::calculate_young_list_desired_min_length(uint base_min_length) const {
172 uint desired_min_length = 0;
173 if (adaptive_young_list_length()) {
174 if (_analytics->num_alloc_rate_ms() > 3) {
175 double now_sec = os::elapsedTime();
176 double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0;
177 double alloc_rate_ms = _analytics->predict_alloc_rate_ms();
178 desired_min_length = (uint) ceil(alloc_rate_ms * when_ms);
179 } else {
180 // otherwise we don't have enough info to make the prediction
181 }
182 }
183 desired_min_length += base_min_length;
184 // make sure we don't go below any user-defined minimum bound
185 return MAX2(_young_gen_sizer.min_desired_young_length(), desired_min_length);
186 }
187
188 uint G1DefaultPolicy::calculate_young_list_desired_max_length() const {
189 // Here, we might want to also take into account any additional
190 // constraints (i.e., user-defined minimum bound). Currently, we
191 // effectively don't set this bound.
192 return _young_gen_sizer.max_desired_young_length();
193 }
194
195 uint G1DefaultPolicy::update_young_list_max_and_target_length() {
196 return update_young_list_max_and_target_length(_analytics->predict_rs_lengths());
197 }
198
199 uint G1DefaultPolicy::update_young_list_max_and_target_length(size_t rs_lengths) {
200 uint unbounded_target_length = update_young_list_target_length(rs_lengths);
201 update_max_gc_locker_expansion();
202 return unbounded_target_length;
203 }
204
205 uint G1DefaultPolicy::update_young_list_target_length(size_t rs_lengths) {
206 YoungTargetLengths young_lengths = young_list_target_lengths(rs_lengths);
207 _young_list_target_length = young_lengths.first;
208 return young_lengths.second;
209 }
210
211 G1DefaultPolicy::YoungTargetLengths G1DefaultPolicy::young_list_target_lengths(size_t rs_lengths) const {
212 YoungTargetLengths result;
213
214 // Calculate the absolute and desired min bounds first.
215
216 // This is how many young regions we already have (currently: the survivors).
217 const uint base_min_length = _g1->survivor_regions_count();
218 uint desired_min_length = calculate_young_list_desired_min_length(base_min_length);
219 // This is the absolute minimum young length. Ensure that we
220 // will at least have one eden region available for allocation.
221 uint absolute_min_length = base_min_length + MAX2(_g1->eden_regions_count(), (uint)1);
222 // If we shrank the young list target it should not shrink below the current size.
223 desired_min_length = MAX2(desired_min_length, absolute_min_length);
224 // Calculate the absolute and desired max bounds.
225
226 uint desired_max_length = calculate_young_list_desired_max_length();
227
228 uint young_list_target_length = 0;
229 if (adaptive_young_list_length()) {
230 if (collector_state()->gcs_are_young()) {
231 young_list_target_length =
232 calculate_young_list_target_length(rs_lengths,
233 base_min_length,
234 desired_min_length,
235 desired_max_length);
236 } else {
237 // Don't calculate anything and let the code below bound it to
238 // the desired_min_length, i.e., do the next GC as soon as
239 // possible to maximize how many old regions we can add to it.
240 }
241 } else {
242 // The user asked for a fixed young gen so we'll fix the young gen
243 // whether the next GC is young or mixed.
244 young_list_target_length = _young_list_fixed_length;
245 }
246
247 result.second = young_list_target_length;
248
249 // We will try our best not to "eat" into the reserve.
250 uint absolute_max_length = 0;
251 if (_free_regions_at_end_of_collection > _reserve_regions) {
252 absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions;
253 }
254 if (desired_max_length > absolute_max_length) {
255 desired_max_length = absolute_max_length;
256 }
257
258 // Make sure we don't go over the desired max length, nor under the
259 // desired min length. In case they clash, desired_min_length wins
260 // which is why that test is second.
261 if (young_list_target_length > desired_max_length) {
262 young_list_target_length = desired_max_length;
263 }
264 if (young_list_target_length < desired_min_length) {
265 young_list_target_length = desired_min_length;
266 }
267
268 assert(young_list_target_length > base_min_length,
269 "we should be able to allocate at least one eden region");
270 assert(young_list_target_length >= absolute_min_length, "post-condition");
271
272 result.first = young_list_target_length;
273 return result;
274 }
275
276 uint
277 G1DefaultPolicy::calculate_young_list_target_length(size_t rs_lengths,
278 uint base_min_length,
279 uint desired_min_length,
280 uint desired_max_length) const {
281 assert(adaptive_young_list_length(), "pre-condition");
282 assert(collector_state()->gcs_are_young(), "only call this for young GCs");
283
284 // In case some edge-condition makes the desired max length too small...
285 if (desired_max_length <= desired_min_length) {
286 return desired_min_length;
287 }
288
289 // We'll adjust min_young_length and max_young_length not to include
290 // the already allocated young regions (i.e., so they reflect the
291 // min and max eden regions we'll allocate). The base_min_length
292 // will be reflected in the predictions by the
293 // survivor_regions_evac_time prediction.
294 assert(desired_min_length > base_min_length, "invariant");
295 uint min_young_length = desired_min_length - base_min_length;
296 assert(desired_max_length > base_min_length, "invariant");
297 uint max_young_length = desired_max_length - base_min_length;
298
299 const double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0;
300 const double survivor_regions_evac_time = predict_survivor_regions_evac_time();
301 const size_t pending_cards = _analytics->predict_pending_cards();
302 const size_t adj_rs_lengths = rs_lengths + _analytics->predict_rs_length_diff();
303 const size_t scanned_cards = _analytics->predict_card_num(adj_rs_lengths, /* gcs_are_young */ true);
304 const double base_time_ms =
305 predict_base_elapsed_time_ms(pending_cards, scanned_cards) +
306 survivor_regions_evac_time;
307 const uint available_free_regions = _free_regions_at_end_of_collection;
308 const uint base_free_regions =
309 available_free_regions > _reserve_regions ? available_free_regions - _reserve_regions : 0;
310
311 // Here, we will make sure that the shortest young length that
312 // makes sense fits within the target pause time.
313
314 G1YoungLengthPredictor p(collector_state()->during_concurrent_mark(),
315 base_time_ms,
316 base_free_regions,
317 target_pause_time_ms,
318 this);
319 if (p.will_fit(min_young_length)) {
320 // The shortest young length will fit into the target pause time;
321 // we'll now check whether the absolute maximum number of young
322 // regions will fit in the target pause time. If not, we'll do
323 // a binary search between min_young_length and max_young_length.
324 if (p.will_fit(max_young_length)) {
325 // The maximum young length will fit into the target pause time.
326 // We are done so set min young length to the maximum length (as
327 // the result is assumed to be returned in min_young_length).
328 min_young_length = max_young_length;
329 } else {
330 // The maximum possible number of young regions will not fit within
331 // the target pause time so we'll search for the optimal
332 // length. The loop invariants are:
333 //
334 // min_young_length < max_young_length
335 // min_young_length is known to fit into the target pause time
336 // max_young_length is known not to fit into the target pause time
337 //
338 // Going into the loop we know the above hold as we've just
339 // checked them. Every time around the loop we check whether
340 // the middle value between min_young_length and
341 // max_young_length fits into the target pause time. If it
342 // does, it becomes the new min. If it doesn't, it becomes
343 // the new max. This way we maintain the loop invariants.
344
345 assert(min_young_length < max_young_length, "invariant");
346 uint diff = (max_young_length - min_young_length) / 2;
347 while (diff > 0) {
348 uint young_length = min_young_length + diff;
349 if (p.will_fit(young_length)) {
350 min_young_length = young_length;
351 } else {
352 max_young_length = young_length;
353 }
354 assert(min_young_length < max_young_length, "invariant");
355 diff = (max_young_length - min_young_length) / 2;
356 }
357 // The results is min_young_length which, according to the
358 // loop invariants, should fit within the target pause time.
359
360 // These are the post-conditions of the binary search above:
361 assert(min_young_length < max_young_length,
362 "otherwise we should have discovered that max_young_length "
363 "fits into the pause target and not done the binary search");
364 assert(p.will_fit(min_young_length),
365 "min_young_length, the result of the binary search, should "
366 "fit into the pause target");
367 assert(!p.will_fit(min_young_length + 1),
368 "min_young_length, the result of the binary search, should be "
369 "optimal, so no larger length should fit into the pause target");
370 }
371 } else {
372 // Even the minimum length doesn't fit into the pause time
373 // target, return it as the result nevertheless.
374 }
375 return base_min_length + min_young_length;
376 }
377
378 double G1DefaultPolicy::predict_survivor_regions_evac_time() const {
379 double survivor_regions_evac_time = 0.0;
380 const GrowableArray<HeapRegion*>* survivor_regions = _g1->survivor()->regions();
381
382 for (GrowableArrayIterator<HeapRegion*> it = survivor_regions->begin();
383 it != survivor_regions->end();
384 ++it) {
385 survivor_regions_evac_time += predict_region_elapsed_time_ms(*it, collector_state()->gcs_are_young());
386 }
387 return survivor_regions_evac_time;
388 }
389
390 void G1DefaultPolicy::revise_young_list_target_length_if_necessary(size_t rs_lengths) {
391 guarantee( adaptive_young_list_length(), "should not call this otherwise" );
392
393 if (rs_lengths > _rs_lengths_prediction) {
394 // add 10% to avoid having to recalculate often
395 size_t rs_lengths_prediction = rs_lengths * 1100 / 1000;
396 update_rs_lengths_prediction(rs_lengths_prediction);
397
398 update_young_list_max_and_target_length(rs_lengths_prediction);
399 }
400 }
401
402 void G1DefaultPolicy::update_rs_lengths_prediction() {
403 update_rs_lengths_prediction(_analytics->predict_rs_lengths());
404 }
405
406 void G1DefaultPolicy::update_rs_lengths_prediction(size_t prediction) {
407 if (collector_state()->gcs_are_young() && adaptive_young_list_length()) {
408 _rs_lengths_prediction = prediction;
409 }
410 }
411
412 void G1DefaultPolicy::record_full_collection_start() {
413 _full_collection_start_sec = os::elapsedTime();
414 // Release the future to-space so that it is available for compaction into.
415 collector_state()->set_full_collection(true);
416 }
417
418 void G1DefaultPolicy::record_full_collection_end() {
419 // Consider this like a collection pause for the purposes of allocation
420 // since last pause.
421 double end_sec = os::elapsedTime();
422 double full_gc_time_sec = end_sec - _full_collection_start_sec;
423 double full_gc_time_ms = full_gc_time_sec * 1000.0;
424
425 _analytics->update_recent_gc_times(end_sec, full_gc_time_ms);
426
427 collector_state()->set_full_collection(false);
428
429 // "Nuke" the heuristics that control the young/mixed GC
430 // transitions and make sure we start with young GCs after the Full GC.
431 collector_state()->set_gcs_are_young(true);
432 collector_state()->set_last_young_gc(false);
433 collector_state()->set_initiate_conc_mark_if_possible(need_to_start_conc_mark("end of Full GC", 0));
434 collector_state()->set_during_initial_mark_pause(false);
435 collector_state()->set_in_marking_window(false);
436 collector_state()->set_in_marking_window_im(false);
437
438 _short_lived_surv_rate_group->start_adding_regions();
439 // also call this on any additional surv rate groups
440
441 _free_regions_at_end_of_collection = _g1->num_free_regions();
442 // Reset survivors SurvRateGroup.
443 _survivor_surv_rate_group->reset();
444 update_young_list_max_and_target_length();
445 update_rs_lengths_prediction();
446 cset_chooser()->clear();
447
448 _bytes_allocated_in_old_since_last_gc = 0;
449
450 record_pause(FullGC, _full_collection_start_sec, end_sec);
451 }
452
453 void G1DefaultPolicy::record_collection_pause_start(double start_time_sec) {
454 // We only need to do this here as the policy will only be applied
455 // to the GC we're about to start. so, no point is calculating this
456 // every time we calculate / recalculate the target young length.
457 update_survivors_policy();
458
459 assert(_g1->used() == _g1->recalculate_used(),
460 "sanity, used: " SIZE_FORMAT " recalculate_used: " SIZE_FORMAT,
461 _g1->used(), _g1->recalculate_used());
462
463 phase_times()->record_cur_collection_start_sec(start_time_sec);
464 _pending_cards = _g1->pending_card_num();
465
466 _collection_set->reset_bytes_used_before();
467 _bytes_copied_during_gc = 0;
468
469 collector_state()->set_last_gc_was_young(false);
470
471 // do that for any other surv rate groups
472 _short_lived_surv_rate_group->stop_adding_regions();
473 _survivors_age_table.clear();
474
475 assert(_g1->collection_set()->verify_young_ages(), "region age verification failed");
476 }
477
478 void G1DefaultPolicy::record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) {
479 collector_state()->set_during_marking(true);
480 assert(!collector_state()->initiate_conc_mark_if_possible(), "we should have cleared it by now");
481 collector_state()->set_during_initial_mark_pause(false);
482 }
483
484 void G1DefaultPolicy::record_concurrent_mark_remark_start() {
485 _mark_remark_start_sec = os::elapsedTime();
486 collector_state()->set_during_marking(false);
487 }
488
489 void G1DefaultPolicy::record_concurrent_mark_remark_end() {
490 double end_time_sec = os::elapsedTime();
491 double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0;
492 _analytics->report_concurrent_mark_remark_times_ms(elapsed_time_ms);
493 _analytics->append_prev_collection_pause_end_ms(elapsed_time_ms);
494
495 record_pause(Remark, _mark_remark_start_sec, end_time_sec);
496 }
497
498 void G1DefaultPolicy::record_concurrent_mark_cleanup_start() {
499 _mark_cleanup_start_sec = os::elapsedTime();
500 }
501
502 void G1DefaultPolicy::record_concurrent_mark_cleanup_completed() {
503 bool should_continue_with_reclaim = next_gc_should_be_mixed("request last young-only gc",
504 "skip last young-only gc");
505 collector_state()->set_last_young_gc(should_continue_with_reclaim);
506 // We skip the marking phase.
507 if (!should_continue_with_reclaim) {
508 abort_time_to_mixed_tracking();
509 }
510 collector_state()->set_in_marking_window(false);
511 }
512
513 double G1DefaultPolicy::average_time_ms(G1GCPhaseTimes::GCParPhases phase) const {
514 return phase_times()->average_time_ms(phase);
515 }
516
517 double G1DefaultPolicy::young_other_time_ms() const {
518 return phase_times()->young_cset_choice_time_ms() +
519 phase_times()->average_time_ms(G1GCPhaseTimes::YoungFreeCSet);
520 }
521
522 double G1DefaultPolicy::non_young_other_time_ms() const {
523 return phase_times()->non_young_cset_choice_time_ms() +
524 phase_times()->average_time_ms(G1GCPhaseTimes::NonYoungFreeCSet);
525 }
526
527 double G1DefaultPolicy::other_time_ms(double pause_time_ms) const {
528 return pause_time_ms - phase_times()->cur_collection_par_time_ms();
529 }
530
531 double G1DefaultPolicy::constant_other_time_ms(double pause_time_ms) const {
532 return other_time_ms(pause_time_ms) - phase_times()->total_free_cset_time_ms();
533 }
534
535 CollectionSetChooser* G1DefaultPolicy::cset_chooser() const {
536 return _collection_set->cset_chooser();
537 }
538
539 bool G1DefaultPolicy::about_to_start_mixed_phase() const {
540 return _g1->concurrent_mark()->cmThread()->during_cycle() || collector_state()->last_young_gc();
541 }
542
543 bool G1DefaultPolicy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) {
544 if (about_to_start_mixed_phase()) {
545 return false;
546 }
547
548 size_t marking_initiating_used_threshold = _ihop_control->get_conc_mark_start_threshold();
549
550 size_t cur_used_bytes = _g1->non_young_capacity_bytes();
551 size_t alloc_byte_size = alloc_word_size * HeapWordSize;
552 size_t marking_request_bytes = cur_used_bytes + alloc_byte_size;
553
554 bool result = false;
555 if (marking_request_bytes > marking_initiating_used_threshold) {
556 result = collector_state()->gcs_are_young() && !collector_state()->last_young_gc();
557 log_debug(gc, ergo, ihop)("%s occupancy: " SIZE_FORMAT "B allocation request: " SIZE_FORMAT "B threshold: " SIZE_FORMAT "B (%1.2f) source: %s",
558 result ? "Request concurrent cycle initiation (occupancy higher than threshold)" : "Do not request concurrent cycle initiation (still doing mixed collections)",
559 cur_used_bytes, alloc_byte_size, marking_initiating_used_threshold, (double) marking_initiating_used_threshold / _g1->capacity() * 100, source);
560 }
561
562 return result;
563 }
564
565 // Anything below that is considered to be zero
566 #define MIN_TIMER_GRANULARITY 0.0000001
567
568 void G1DefaultPolicy::record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc) {
569 double end_time_sec = os::elapsedTime();
570
571 size_t cur_used_bytes = _g1->used();
572 assert(cur_used_bytes == _g1->recalculate_used(), "It should!");
573 bool last_pause_included_initial_mark = false;
574 bool update_stats = !_g1->evacuation_failed();
575
576 record_pause(young_gc_pause_kind(), end_time_sec - pause_time_ms / 1000.0, end_time_sec);
577
578 last_pause_included_initial_mark = collector_state()->during_initial_mark_pause();
579 if (last_pause_included_initial_mark) {
580 record_concurrent_mark_init_end(0.0);
581 } else {
582 maybe_start_marking();
583 }
584
585 double app_time_ms = (phase_times()->cur_collection_start_sec() * 1000.0 - _analytics->prev_collection_pause_end_ms());
586 if (app_time_ms < MIN_TIMER_GRANULARITY) {
587 // This usually happens due to the timer not having the required
588 // granularity. Some Linuxes are the usual culprits.
589 // We'll just set it to something (arbitrarily) small.
590 app_time_ms = 1.0;
591 }
592
593 if (update_stats) {
594 // We maintain the invariant that all objects allocated by mutator
595 // threads will be allocated out of eden regions. So, we can use
596 // the eden region number allocated since the previous GC to
597 // calculate the application's allocate rate. The only exception
598 // to that is humongous objects that are allocated separately. But
599 // given that humongous object allocations do not really affect
600 // either the pause's duration nor when the next pause will take
601 // place we can safely ignore them here.
602 uint regions_allocated = _collection_set->eden_region_length();
603 double alloc_rate_ms = (double) regions_allocated / app_time_ms;
604 _analytics->report_alloc_rate_ms(alloc_rate_ms);
605
606 double interval_ms =
607 (end_time_sec - _analytics->last_known_gc_end_time_sec()) * 1000.0;
608 _analytics->update_recent_gc_times(end_time_sec, pause_time_ms);
609 _analytics->compute_pause_time_ratio(interval_ms, pause_time_ms);
610 }
611
612 bool new_in_marking_window = collector_state()->in_marking_window();
613 bool new_in_marking_window_im = false;
614 if (last_pause_included_initial_mark) {
615 new_in_marking_window = true;
616 new_in_marking_window_im = true;
617 }
618
619 if (collector_state()->last_young_gc()) {
620 // This is supposed to to be the "last young GC" before we start
621 // doing mixed GCs. Here we decide whether to start mixed GCs or not.
622 assert(!last_pause_included_initial_mark, "The last young GC is not allowed to be an initial mark GC");
623
624 if (next_gc_should_be_mixed("start mixed GCs",
625 "do not start mixed GCs")) {
626 collector_state()->set_gcs_are_young(false);
627 } else {
628 // We aborted the mixed GC phase early.
629 abort_time_to_mixed_tracking();
630 }
631
632 collector_state()->set_last_young_gc(false);
633 }
634
635 if (!collector_state()->last_gc_was_young()) {
636 // This is a mixed GC. Here we decide whether to continue doing
637 // mixed GCs or not.
638 if (!next_gc_should_be_mixed("continue mixed GCs",
639 "do not continue mixed GCs")) {
640 collector_state()->set_gcs_are_young(true);
641
642 maybe_start_marking();
643 }
644 }
645
646 _short_lived_surv_rate_group->start_adding_regions();
647 // Do that for any other surv rate groups
648
649 double scan_hcc_time_ms = G1HotCardCache::default_use_cache() ? average_time_ms(G1GCPhaseTimes::ScanHCC) : 0.0;
650
651 if (update_stats) {
652 double cost_per_card_ms = 0.0;
653 if (_pending_cards > 0) {
654 cost_per_card_ms = (average_time_ms(G1GCPhaseTimes::UpdateRS) - scan_hcc_time_ms) / (double) _pending_cards;
655 _analytics->report_cost_per_card_ms(cost_per_card_ms);
656 }
657 _analytics->report_cost_scan_hcc(scan_hcc_time_ms);
658
659 double cost_per_entry_ms = 0.0;
660 if (cards_scanned > 10) {
661 cost_per_entry_ms = average_time_ms(G1GCPhaseTimes::ScanRS) / (double) cards_scanned;
662 _analytics->report_cost_per_entry_ms(cost_per_entry_ms, collector_state()->last_gc_was_young());
663 }
664
665 if (_max_rs_lengths > 0) {
666 double cards_per_entry_ratio =
667 (double) cards_scanned / (double) _max_rs_lengths;
668 _analytics->report_cards_per_entry_ratio(cards_per_entry_ratio, collector_state()->last_gc_was_young());
669 }
670
671 // This is defensive. For a while _max_rs_lengths could get
672 // smaller than _recorded_rs_lengths which was causing
673 // rs_length_diff to get very large and mess up the RSet length
674 // predictions. The reason was unsafe concurrent updates to the
675 // _inc_cset_recorded_rs_lengths field which the code below guards
676 // against (see CR 7118202). This bug has now been fixed (see CR
677 // 7119027). However, I'm still worried that
678 // _inc_cset_recorded_rs_lengths might still end up somewhat
679 // inaccurate. The concurrent refinement thread calculates an
680 // RSet's length concurrently with other CR threads updating it
681 // which might cause it to calculate the length incorrectly (if,
682 // say, it's in mid-coarsening). So I'll leave in the defensive
683 // conditional below just in case.
684 size_t rs_length_diff = 0;
685 size_t recorded_rs_lengths = _collection_set->recorded_rs_lengths();
686 if (_max_rs_lengths > recorded_rs_lengths) {
687 rs_length_diff = _max_rs_lengths - recorded_rs_lengths;
688 }
689 _analytics->report_rs_length_diff((double) rs_length_diff);
690
691 size_t freed_bytes = heap_used_bytes_before_gc - cur_used_bytes;
692 size_t copied_bytes = _collection_set->bytes_used_before() - freed_bytes;
693 double cost_per_byte_ms = 0.0;
694
695 if (copied_bytes > 0) {
696 cost_per_byte_ms = average_time_ms(G1GCPhaseTimes::ObjCopy) / (double) copied_bytes;
697 _analytics->report_cost_per_byte_ms(cost_per_byte_ms, collector_state()->in_marking_window());
698 }
699
700 if (_collection_set->young_region_length() > 0) {
701 _analytics->report_young_other_cost_per_region_ms(young_other_time_ms() /
702 _collection_set->young_region_length());
703 }
704
705 if (_collection_set->old_region_length() > 0) {
706 _analytics->report_non_young_other_cost_per_region_ms(non_young_other_time_ms() /
707 _collection_set->old_region_length());
708 }
709
710 _analytics->report_constant_other_time_ms(constant_other_time_ms(pause_time_ms));
711
712 _analytics->report_pending_cards((double) _pending_cards);
713 _analytics->report_rs_lengths((double) _max_rs_lengths);
714 }
715
716 collector_state()->set_in_marking_window(new_in_marking_window);
717 collector_state()->set_in_marking_window_im(new_in_marking_window_im);
718 _free_regions_at_end_of_collection = _g1->num_free_regions();
719 // IHOP control wants to know the expected young gen length if it were not
720 // restrained by the heap reserve. Using the actual length would make the
721 // prediction too small and the limit the young gen every time we get to the
722 // predicted target occupancy.
723 size_t last_unrestrained_young_length = update_young_list_max_and_target_length();
724 update_rs_lengths_prediction();
725
726 update_ihop_prediction(app_time_ms / 1000.0,
727 _bytes_allocated_in_old_since_last_gc,
728 last_unrestrained_young_length * HeapRegion::GrainBytes);
729 _bytes_allocated_in_old_since_last_gc = 0;
730
731 _ihop_control->send_trace_event(_g1->gc_tracer_stw());
732
733 // Note that _mmu_tracker->max_gc_time() returns the time in seconds.
734 double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0;
735
736 if (update_rs_time_goal_ms < scan_hcc_time_ms) {
737 log_debug(gc, ergo, refine)("Adjust concurrent refinement thresholds (scanning the HCC expected to take longer than Update RS time goal)."
738 "Update RS time goal: %1.2fms Scan HCC time: %1.2fms",
739 update_rs_time_goal_ms, scan_hcc_time_ms);
740
741 update_rs_time_goal_ms = 0;
742 } else {
743 update_rs_time_goal_ms -= scan_hcc_time_ms;
744 }
745 _g1->concurrent_g1_refine()->adjust(average_time_ms(G1GCPhaseTimes::UpdateRS) - scan_hcc_time_ms,
746 phase_times()->sum_thread_work_items(G1GCPhaseTimes::UpdateRS),
747 update_rs_time_goal_ms);
748
749 cset_chooser()->verify();
750 }
751
752 G1IHOPControl* G1DefaultPolicy::create_ihop_control(const G1Predictions* predictor){
753 if (G1UseAdaptiveIHOP) {
754 return new G1AdaptiveIHOPControl(InitiatingHeapOccupancyPercent,
755 predictor,
756 G1ReservePercent,
757 G1HeapWastePercent);
758 } else {
759 return new G1StaticIHOPControl(InitiatingHeapOccupancyPercent);
760 }
761 }
762
763 void G1DefaultPolicy::update_ihop_prediction(double mutator_time_s,
764 size_t mutator_alloc_bytes,
765 size_t young_gen_size) {
766 // Always try to update IHOP prediction. Even evacuation failures give information
767 // about e.g. whether to start IHOP earlier next time.
768
769 // Avoid using really small application times that might create samples with
770 // very high or very low values. They may be caused by e.g. back-to-back gcs.
771 double const min_valid_time = 1e-6;
772
773 bool report = false;
774
775 double marking_to_mixed_time = -1.0;
776 if (!collector_state()->last_gc_was_young() && _initial_mark_to_mixed.has_result()) {
777 marking_to_mixed_time = _initial_mark_to_mixed.last_marking_time();
778 assert(marking_to_mixed_time > 0.0,
779 "Initial mark to mixed time must be larger than zero but is %.3f",
780 marking_to_mixed_time);
781 if (marking_to_mixed_time > min_valid_time) {
782 _ihop_control->update_marking_length(marking_to_mixed_time);
783 report = true;
784 }
785 }
786
787 // As an approximation for the young gc promotion rates during marking we use
788 // all of them. In many applications there are only a few if any young gcs during
789 // marking, which makes any prediction useless. This increases the accuracy of the
790 // prediction.
791 if (collector_state()->last_gc_was_young() && mutator_time_s > min_valid_time) {
792 _ihop_control->update_allocation_info(mutator_time_s, mutator_alloc_bytes, young_gen_size);
793 report = true;
794 }
795
796 if (report) {
797 report_ihop_statistics();
798 }
799 }
800
801 void G1DefaultPolicy::report_ihop_statistics() {
802 _ihop_control->print();
803 }
804
805 void G1DefaultPolicy::print_phases() {
806 phase_times()->print();
807 }
808
809 double G1DefaultPolicy::predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const {
810 TruncatedSeq* seq = surv_rate_group->get_seq(age);
811 guarantee(seq->num() > 0, "There should be some young gen survivor samples available. Tried to access with age %d", age);
812 double pred = _predictor.get_new_prediction(seq);
813 if (pred > 1.0) {
814 pred = 1.0;
815 }
816 return pred;
817 }
818
819 double G1DefaultPolicy::accum_yg_surv_rate_pred(int age) const {
820 return _short_lived_surv_rate_group->accum_surv_rate_pred(age);
821 }
822
823 double G1DefaultPolicy::predict_base_elapsed_time_ms(size_t pending_cards,
824 size_t scanned_cards) const {
825 return
826 _analytics->predict_rs_update_time_ms(pending_cards) +
827 _analytics->predict_rs_scan_time_ms(scanned_cards, collector_state()->gcs_are_young()) +
828 _analytics->predict_constant_other_time_ms();
829 }
830
831 double G1DefaultPolicy::predict_base_elapsed_time_ms(size_t pending_cards) const {
832 size_t rs_length = _analytics->predict_rs_lengths() + _analytics->predict_rs_length_diff();
833 size_t card_num = _analytics->predict_card_num(rs_length, collector_state()->gcs_are_young());
834 return predict_base_elapsed_time_ms(pending_cards, card_num);
835 }
836
837 size_t G1DefaultPolicy::predict_bytes_to_copy(HeapRegion* hr) const {
838 size_t bytes_to_copy;
839 if (hr->is_marked())
840 bytes_to_copy = hr->max_live_bytes();
841 else {
842 assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "invariant");
843 int age = hr->age_in_surv_rate_group();
844 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group());
845 bytes_to_copy = (size_t) (hr->used() * yg_surv_rate);
846 }
847 return bytes_to_copy;
848 }
849
850 double G1DefaultPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
851 bool for_young_gc) const {
852 size_t rs_length = hr->rem_set()->occupied();
853 // Predicting the number of cards is based on which type of GC
854 // we're predicting for.
855 size_t card_num = _analytics->predict_card_num(rs_length, for_young_gc);
856 size_t bytes_to_copy = predict_bytes_to_copy(hr);
857
858 double region_elapsed_time_ms =
859 _analytics->predict_rs_scan_time_ms(card_num, collector_state()->gcs_are_young()) +
860 _analytics->predict_object_copy_time_ms(bytes_to_copy, collector_state()->during_concurrent_mark());
861
862 // The prediction of the "other" time for this region is based
863 // upon the region type and NOT the GC type.
864 if (hr->is_young()) {
865 region_elapsed_time_ms += _analytics->predict_young_other_time_ms(1);
866 } else {
867 region_elapsed_time_ms += _analytics->predict_non_young_other_time_ms(1);
868 }
869 return region_elapsed_time_ms;
870 }
871
872 bool G1DefaultPolicy::should_allocate_mutator_region() const {
873 uint young_list_length = _g1->young_regions_count();
874 uint young_list_target_length = _young_list_target_length;
875 return young_list_length < young_list_target_length;
876 }
877
878 bool G1DefaultPolicy::can_expand_young_list() const {
879 uint young_list_length = _g1->young_regions_count();
880 uint young_list_max_length = _young_list_max_length;
881 return young_list_length < young_list_max_length;
882 }
883
884 bool G1DefaultPolicy::adaptive_young_list_length() const {
885 return _young_gen_sizer.adaptive_young_list_length();
886 }
887
888 size_t G1DefaultPolicy::desired_survivor_size() const {
889 size_t const survivor_capacity = HeapRegion::GrainWords * _max_survivor_regions;
890 return (size_t)((((double)survivor_capacity) * TargetSurvivorRatio) / 100);
891 }
892
893 void G1DefaultPolicy::print_age_table() {
894 _survivors_age_table.print_age_table(_tenuring_threshold);
895 }
896
897 void G1DefaultPolicy::update_max_gc_locker_expansion() {
898 uint expansion_region_num = 0;
899 if (GCLockerEdenExpansionPercent > 0) {
900 double perc = (double) GCLockerEdenExpansionPercent / 100.0;
901 double expansion_region_num_d = perc * (double) _young_list_target_length;
902 // We use ceiling so that if expansion_region_num_d is > 0.0 (but
903 // less than 1.0) we'll get 1.
904 expansion_region_num = (uint) ceil(expansion_region_num_d);
905 } else {
906 assert(expansion_region_num == 0, "sanity");
907 }
908 _young_list_max_length = _young_list_target_length + expansion_region_num;
909 assert(_young_list_target_length <= _young_list_max_length, "post-condition");
910 }
911
912 // Calculates survivor space parameters.
913 void G1DefaultPolicy::update_survivors_policy() {
914 double max_survivor_regions_d =
915 (double) _young_list_target_length / (double) SurvivorRatio;
916 // We use ceiling so that if max_survivor_regions_d is > 0.0 (but
917 // smaller than 1.0) we'll get 1.
918 _max_survivor_regions = (uint) ceil(max_survivor_regions_d);
919
920 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold(desired_survivor_size());
921 if (UsePerfData) {
922 _policy_counters->tenuring_threshold()->set_value(_tenuring_threshold);
923 _policy_counters->desired_survivor_size()->set_value(desired_survivor_size() * oopSize);
924 }
925 }
926
927 bool G1DefaultPolicy::force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) {
928 // We actually check whether we are marking here and not if we are in a
929 // reclamation phase. This means that we will schedule a concurrent mark
930 // even while we are still in the process of reclaiming memory.
931 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle();
932 if (!during_cycle) {
933 log_debug(gc, ergo)("Request concurrent cycle initiation (requested by GC cause). GC cause: %s", GCCause::to_string(gc_cause));
934 collector_state()->set_initiate_conc_mark_if_possible(true);
935 return true;
936 } else {
937 log_debug(gc, ergo)("Do not request concurrent cycle initiation (concurrent cycle already in progress). GC cause: %s", GCCause::to_string(gc_cause));
938 return false;
939 }
940 }
941
942 void G1DefaultPolicy::initiate_conc_mark() {
943 collector_state()->set_during_initial_mark_pause(true);
944 collector_state()->set_initiate_conc_mark_if_possible(false);
945 }
946
947 void G1DefaultPolicy::decide_on_conc_mark_initiation() {
948 // We are about to decide on whether this pause will be an
949 // initial-mark pause.
950
951 // First, collector_state()->during_initial_mark_pause() should not be already set. We
952 // will set it here if we have to. However, it should be cleared by
953 // the end of the pause (it's only set for the duration of an
954 // initial-mark pause).
955 assert(!collector_state()->during_initial_mark_pause(), "pre-condition");
956
957 if (collector_state()->initiate_conc_mark_if_possible()) {
958 // We had noticed on a previous pause that the heap occupancy has
959 // gone over the initiating threshold and we should start a
960 // concurrent marking cycle. So we might initiate one.
961
962 if (!about_to_start_mixed_phase() && collector_state()->gcs_are_young()) {
963 // Initiate a new initial mark if there is no marking or reclamation going on.
964 initiate_conc_mark();
965 log_debug(gc, ergo)("Initiate concurrent cycle (concurrent cycle initiation requested)");
966 } else if (_g1->is_user_requested_concurrent_full_gc(_g1->gc_cause())) {
967 // Initiate a user requested initial mark. An initial mark must be young only
968 // GC, so the collector state must be updated to reflect this.
969 collector_state()->set_gcs_are_young(true);
970 collector_state()->set_last_young_gc(false);
971
972 abort_time_to_mixed_tracking();
973 initiate_conc_mark();
974 log_debug(gc, ergo)("Initiate concurrent cycle (user requested concurrent cycle)");
975 } else {
976 // The concurrent marking thread is still finishing up the
977 // previous cycle. If we start one right now the two cycles
978 // overlap. In particular, the concurrent marking thread might
979 // be in the process of clearing the next marking bitmap (which
980 // we will use for the next cycle if we start one). Starting a
981 // cycle now will be bad given that parts of the marking
982 // information might get cleared by the marking thread. And we
983 // cannot wait for the marking thread to finish the cycle as it
984 // periodically yields while clearing the next marking bitmap
985 // and, if it's in a yield point, it's waiting for us to
986 // finish. So, at this point we will not start a cycle and we'll
987 // let the concurrent marking thread complete the last one.
988 log_debug(gc, ergo)("Do not initiate concurrent cycle (concurrent cycle already in progress)");
989 }
990 }
991 }
992
993 void G1DefaultPolicy::record_concurrent_mark_cleanup_end() {
994 cset_chooser()->rebuild(_g1->workers(), _g1->num_regions());
995
996 double end_sec = os::elapsedTime();
997 double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0;
998 _analytics->report_concurrent_mark_cleanup_times_ms(elapsed_time_ms);
999 _analytics->append_prev_collection_pause_end_ms(elapsed_time_ms);
1000
1001 record_pause(Cleanup, _mark_cleanup_start_sec, end_sec);
1002 }
1003
1004 double G1DefaultPolicy::reclaimable_bytes_perc(size_t reclaimable_bytes) const {
1005 // Returns the given amount of reclaimable bytes (that represents
1006 // the amount of reclaimable space still to be collected) as a
1007 // percentage of the current heap capacity.
1008 size_t capacity_bytes = _g1->capacity();
1009 return (double) reclaimable_bytes * 100.0 / (double) capacity_bytes;
1010 }
1011
1012 void G1DefaultPolicy::maybe_start_marking() {
1013 if (need_to_start_conc_mark("end of GC")) {
1014 // Note: this might have already been set, if during the last
1015 // pause we decided to start a cycle but at the beginning of
1016 // this pause we decided to postpone it. That's OK.
1017 collector_state()->set_initiate_conc_mark_if_possible(true);
1018 }
1019 }
1020
1021 G1DefaultPolicy::PauseKind G1DefaultPolicy::young_gc_pause_kind() const {
1022 assert(!collector_state()->full_collection(), "must be");
1023 if (collector_state()->during_initial_mark_pause()) {
1024 assert(collector_state()->last_gc_was_young(), "must be");
1025 assert(!collector_state()->last_young_gc(), "must be");
1026 return InitialMarkGC;
1027 } else if (collector_state()->last_young_gc()) {
1028 assert(!collector_state()->during_initial_mark_pause(), "must be");
1029 assert(collector_state()->last_gc_was_young(), "must be");
1030 return LastYoungGC;
1031 } else if (!collector_state()->last_gc_was_young()) {
1032 assert(!collector_state()->during_initial_mark_pause(), "must be");
1033 assert(!collector_state()->last_young_gc(), "must be");
1034 return MixedGC;
1035 } else {
1036 assert(collector_state()->last_gc_was_young(), "must be");
1037 assert(!collector_state()->during_initial_mark_pause(), "must be");
1038 assert(!collector_state()->last_young_gc(), "must be");
1039 return YoungOnlyGC;
1040 }
1041 }
1042
1043 void G1DefaultPolicy::record_pause(PauseKind kind, double start, double end) {
1044 // Manage the MMU tracker. For some reason it ignores Full GCs.
1045 if (kind != FullGC) {
1046 _mmu_tracker->add_pause(start, end);
1047 }
1048 // Manage the mutator time tracking from initial mark to first mixed gc.
1049 switch (kind) {
1050 case FullGC:
1051 abort_time_to_mixed_tracking();
1052 break;
1053 case Cleanup:
1054 case Remark:
1055 case YoungOnlyGC:
1056 case LastYoungGC:
1057 _initial_mark_to_mixed.add_pause(end - start);
1058 break;
1059 case InitialMarkGC:
1060 _initial_mark_to_mixed.record_initial_mark_end(end);
1061 break;
1062 case MixedGC:
1063 _initial_mark_to_mixed.record_mixed_gc_start(start);
1064 break;
1065 default:
1066 ShouldNotReachHere();
1067 }
1068 }
1069
1070 void G1DefaultPolicy::abort_time_to_mixed_tracking() {
1071 _initial_mark_to_mixed.reset();
1072 }
1073
1074 bool G1DefaultPolicy::next_gc_should_be_mixed(const char* true_action_str,
1075 const char* false_action_str) const {
1076 if (cset_chooser()->is_empty()) {
1077 log_debug(gc, ergo)("%s (candidate old regions not available)", false_action_str);
1078 return false;
1079 }
1080
1081 // Is the amount of uncollected reclaimable space above G1HeapWastePercent?
1082 size_t reclaimable_bytes = cset_chooser()->remaining_reclaimable_bytes();
1083 double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes);
1084 double threshold = (double) G1HeapWastePercent;
1085 if (reclaimable_perc <= threshold) {
1086 log_debug(gc, ergo)("%s (reclaimable percentage not over threshold). candidate old regions: %u reclaimable: " SIZE_FORMAT " (%1.2f) threshold: " UINTX_FORMAT,
1087 false_action_str, cset_chooser()->remaining_regions(), reclaimable_bytes, reclaimable_perc, G1HeapWastePercent);
1088 return false;
1089 }
1090 log_debug(gc, ergo)("%s (candidate old regions available). candidate old regions: %u reclaimable: " SIZE_FORMAT " (%1.2f) threshold: " UINTX_FORMAT,
1091 true_action_str, cset_chooser()->remaining_regions(), reclaimable_bytes, reclaimable_perc, G1HeapWastePercent);
1092 return true;
1093 }
1094
1095 uint G1DefaultPolicy::calc_min_old_cset_length() const {
1096 // The min old CSet region bound is based on the maximum desired
1097 // number of mixed GCs after a cycle. I.e., even if some old regions
1098 // look expensive, we should add them to the CSet anyway to make
1099 // sure we go through the available old regions in no more than the
1100 // maximum desired number of mixed GCs.
1101 //
1102 // The calculation is based on the number of marked regions we added
1103 // to the CSet chooser in the first place, not how many remain, so
1104 // that the result is the same during all mixed GCs that follow a cycle.
1105
1106 const size_t region_num = (size_t) cset_chooser()->length();
1107 const size_t gc_num = (size_t) MAX2(G1MixedGCCountTarget, (uintx) 1);
1108 size_t result = region_num / gc_num;
1109 // emulate ceiling
1110 if (result * gc_num < region_num) {
1111 result += 1;
1112 }
1113 return (uint) result;
1114 }
1115
1116 uint G1DefaultPolicy::calc_max_old_cset_length() const {
1117 // The max old CSet region bound is based on the threshold expressed
1118 // as a percentage of the heap size. I.e., it should bound the
1119 // number of old regions added to the CSet irrespective of how many
1120 // of them are available.
1121
1122 const G1CollectedHeap* g1h = G1CollectedHeap::heap();
1123 const size_t region_num = g1h->num_regions();
1124 const size_t perc = (size_t) G1OldCSetRegionThresholdPercent;
1125 size_t result = region_num * perc / 100;
1126 // emulate ceiling
1127 if (100 * result < region_num * perc) {
1128 result += 1;
1129 }
1130 return (uint) result;
1131 }
1132
1133 void G1DefaultPolicy::finalize_collection_set(double target_pause_time_ms, G1SurvivorRegions* survivor) {
1134 double time_remaining_ms = _collection_set->finalize_young_part(target_pause_time_ms, survivor);
1135 _collection_set->finalize_old_part(time_remaining_ms);
1136 }
1137
1138 void G1DefaultPolicy::transfer_survivors_to_cset(const G1SurvivorRegions* survivors) {
1139
1140 // Add survivor regions to SurvRateGroup.
1141 note_start_adding_survivor_regions();
1142 finished_recalculating_age_indexes(true /* is_survivors */);
1143
1144 HeapRegion* last = NULL;
1145 for (GrowableArrayIterator<HeapRegion*> it = survivors->regions()->begin();
1146 it != survivors->regions()->end();
1147 ++it) {
1148 HeapRegion* curr = *it;
1149 set_region_survivor(curr);
1150
1151 // The region is a non-empty survivor so let's add it to
1152 // the incremental collection set for the next evacuation
1153 // pause.
1154 _collection_set->add_survivor_regions(curr);
1155
1156 last = curr;
1157 }
1158 note_stop_adding_survivor_regions();
1159
1160 // Don't clear the survivor list handles until the start of
1161 // the next evacuation pause - we need it in order to re-tag
1162 // the survivor regions from this evacuation pause as 'young'
1163 // at the start of the next.
1164
1165 finished_recalculating_age_indexes(false /* is_survivors */);
1166 }