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