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