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