Print this page
| Split |
Split |
Close |
| Expand all |
| Collapse all |
--- old/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
+++ new/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
1 1 /*
2 - * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
2 + * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
3 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 4 *
5 5 * This code is free software; you can redistribute it and/or modify it
6 6 * under the terms of the GNU General Public License version 2 only, as
7 7 * published by the Free Software Foundation.
8 8 *
9 9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 12 * version 2 for more details (a copy is included in the LICENSE file that
13 13 * accompanied this code).
14 14 *
15 15 * You should have received a copy of the GNU General Public License version
16 16 * 2 along with this work; if not, write to the Free Software Foundation,
17 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 18 *
19 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 20 * or visit www.oracle.com if you need additional information or have any
21 21 * questions.
22 22 *
23 23 */
24 24
25 25 #include "precompiled.hpp"
26 26 #include "gc_implementation/g1/concurrentG1Refine.hpp"
27 27 #include "gc_implementation/g1/concurrentMark.hpp"
28 28 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
29 29 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
30 30 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
31 31 #include "gc_implementation/g1/g1ErgoVerbose.hpp"
32 32 #include "gc_implementation/g1/g1GCPhaseTimes.hpp"
33 33 #include "gc_implementation/g1/g1Log.hpp"
34 34 #include "gc_implementation/g1/heapRegionRemSet.hpp"
35 35 #include "gc_implementation/shared/gcPolicyCounters.hpp"
36 36 #include "runtime/arguments.hpp"
37 37 #include "runtime/java.hpp"
38 38 #include "runtime/mutexLocker.hpp"
39 39 #include "utilities/debug.hpp"
40 40
41 41 // Different defaults for different number of GC threads
42 42 // They were chosen by running GCOld and SPECjbb on debris with different
43 43 // numbers of GC threads and choosing them based on the results
44 44
45 45 // all the same
46 46 static double rs_length_diff_defaults[] = {
47 47 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
48 48 };
49 49
50 50 static double cost_per_card_ms_defaults[] = {
51 51 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015
52 52 };
53 53
54 54 // all the same
55 55 static double young_cards_per_entry_ratio_defaults[] = {
56 56 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
57 57 };
58 58
59 59 static double cost_per_entry_ms_defaults[] = {
60 60 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005
61 61 };
62 62
63 63 static double cost_per_byte_ms_defaults[] = {
64 64 0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009
65 65 };
66 66
67 67 // these should be pretty consistent
68 68 static double constant_other_time_ms_defaults[] = {
69 69 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0
70 70 };
71 71
72 72
73 73 static double young_other_cost_per_region_ms_defaults[] = {
74 74 0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1
75 75 };
76 76
77 77 static double non_young_other_cost_per_region_ms_defaults[] = {
78 78 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30
79 79 };
80 80
81 81 G1CollectorPolicy::G1CollectorPolicy() :
82 82 _parallel_gc_threads(G1CollectedHeap::use_parallel_gc_threads()
83 83 ? ParallelGCThreads : 1),
84 84
85 85 _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
86 86 _stop_world_start(0.0),
87 87
88 88 _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
89 89 _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
90 90
91 91 _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
92 92 _prev_collection_pause_end_ms(0.0),
93 93 _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)),
94 94 _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
95 95 _young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),
96 96 _mixed_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),
97 97 _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
98 98 _mixed_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
99 99 _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
100 100 _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)),
101 101 _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
102 102 _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
103 103 _non_young_other_cost_per_region_ms_seq(
104 104 new TruncatedSeq(TruncatedSeqLength)),
105 105
106 106 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
107 107 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)),
108 108
109 109 _pause_time_target_ms((double) MaxGCPauseMillis),
110 110
111 111 _gcs_are_young(true),
112 112
113 113 _during_marking(false),
114 114 _in_marking_window(false),
115 115 _in_marking_window_im(false),
116 116
117 117 _recent_prev_end_times_for_all_gcs_sec(
118 118 new TruncatedSeq(NumPrevPausesForHeuristics)),
119 119
120 120 _recent_avg_pause_time_ratio(0.0),
121 121
122 122 _initiate_conc_mark_if_possible(false),
123 123 _during_initial_mark_pause(false),
124 124 _last_young_gc(false),
125 125 _last_gc_was_young(false),
126 126
127 127 _eden_bytes_before_gc(0),
128 128 _survivor_bytes_before_gc(0),
129 129 _capacity_before_gc(0),
130 130
131 131 _eden_cset_region_length(0),
132 132 _survivor_cset_region_length(0),
133 133 _old_cset_region_length(0),
134 134
135 135 _collection_set(NULL),
136 136 _collection_set_bytes_used_before(0),
137 137
138 138 // Incremental CSet attributes
139 139 _inc_cset_build_state(Inactive),
140 140 _inc_cset_head(NULL),
141 141 _inc_cset_tail(NULL),
142 142 _inc_cset_bytes_used_before(0),
143 143 _inc_cset_max_finger(NULL),
144 144 _inc_cset_recorded_rs_lengths(0),
145 145 _inc_cset_recorded_rs_lengths_diffs(0),
146 146 _inc_cset_predicted_elapsed_time_ms(0.0),
147 147 _inc_cset_predicted_elapsed_time_ms_diffs(0.0),
148 148
149 149 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away
150 150 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list
151 151 #endif // _MSC_VER
152 152
153 153 _short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived",
154 154 G1YoungSurvRateNumRegionsSummary)),
155 155 _survivor_surv_rate_group(new SurvRateGroup(this, "Survivor",
156 156 G1YoungSurvRateNumRegionsSummary)),
157 157 // add here any more surv rate groups
158 158 _recorded_survivor_regions(0),
159 159 _recorded_survivor_head(NULL),
160 160 _recorded_survivor_tail(NULL),
161 161 _survivors_age_table(true),
162 162
163 163 _gc_overhead_perc(0.0) {
164 164
165 165 // Set up the region size and associated fields. Given that the
166 166 // policy is created before the heap, we have to set this up here,
167 167 // so it's done as soon as possible.
168 168 HeapRegion::setup_heap_region_size(Arguments::min_heap_size());
169 169 HeapRegionRemSet::setup_remset_size();
170 170
171 171 G1ErgoVerbose::initialize();
172 172 if (PrintAdaptiveSizePolicy) {
173 173 // Currently, we only use a single switch for all the heuristics.
174 174 G1ErgoVerbose::set_enabled(true);
175 175 // Given that we don't currently have a verboseness level
176 176 // parameter, we'll hardcode this to high. This can be easily
177 177 // changed in the future.
178 178 G1ErgoVerbose::set_level(ErgoHigh);
179 179 } else {
180 180 G1ErgoVerbose::set_enabled(false);
181 181 }
182 182
183 183 // Verify PLAB sizes
184 184 const size_t region_size = HeapRegion::GrainWords;
185 185 if (YoungPLABSize > region_size || OldPLABSize > region_size) {
186 186 char buffer[128];
187 187 jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most "SIZE_FORMAT,
188 188 OldPLABSize > region_size ? "Old" : "Young", region_size);
189 189 vm_exit_during_initialization(buffer);
190 190 }
191 191
192 192 _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime());
193 193 _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0;
194 194
195 195 _phase_times = new G1GCPhaseTimes(_parallel_gc_threads);
196 196
197 197 int index = MIN2(_parallel_gc_threads - 1, 7);
198 198
199 199 _rs_length_diff_seq->add(rs_length_diff_defaults[index]);
200 200 _cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]);
201 201 _young_cards_per_entry_ratio_seq->add(
202 202 young_cards_per_entry_ratio_defaults[index]);
203 203 _cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]);
204 204 _cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]);
205 205 _constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]);
206 206 _young_other_cost_per_region_ms_seq->add(
207 207 young_other_cost_per_region_ms_defaults[index]);
208 208 _non_young_other_cost_per_region_ms_seq->add(
209 209 non_young_other_cost_per_region_ms_defaults[index]);
210 210
211 211 // Below, we might need to calculate the pause time target based on
212 212 // the pause interval. When we do so we are going to give G1 maximum
213 213 // flexibility and allow it to do pauses when it needs to. So, we'll
214 214 // arrange that the pause interval to be pause time target + 1 to
215 215 // ensure that a) the pause time target is maximized with respect to
216 216 // the pause interval and b) we maintain the invariant that pause
217 217 // time target < pause interval. If the user does not want this
218 218 // maximum flexibility, they will have to set the pause interval
219 219 // explicitly.
220 220
221 221 // First make sure that, if either parameter is set, its value is
222 222 // reasonable.
223 223 if (!FLAG_IS_DEFAULT(MaxGCPauseMillis)) {
224 224 if (MaxGCPauseMillis < 1) {
225 225 vm_exit_during_initialization("MaxGCPauseMillis should be "
226 226 "greater than 0");
227 227 }
228 228 }
229 229 if (!FLAG_IS_DEFAULT(GCPauseIntervalMillis)) {
230 230 if (GCPauseIntervalMillis < 1) {
231 231 vm_exit_during_initialization("GCPauseIntervalMillis should be "
232 232 "greater than 0");
233 233 }
234 234 }
235 235
236 236 // Then, if the pause time target parameter was not set, set it to
237 237 // the default value.
238 238 if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) {
239 239 if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) {
240 240 // The default pause time target in G1 is 200ms
241 241 FLAG_SET_DEFAULT(MaxGCPauseMillis, 200);
242 242 } else {
243 243 // We do not allow the pause interval to be set without the
244 244 // pause time target
245 245 vm_exit_during_initialization("GCPauseIntervalMillis cannot be set "
246 246 "without setting MaxGCPauseMillis");
247 247 }
248 248 }
249 249
250 250 // Then, if the interval parameter was not set, set it according to
251 251 // the pause time target (this will also deal with the case when the
252 252 // pause time target is the default value).
253 253 if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) {
254 254 FLAG_SET_DEFAULT(GCPauseIntervalMillis, MaxGCPauseMillis + 1);
255 255 }
256 256
257 257 // Finally, make sure that the two parameters are consistent.
258 258 if (MaxGCPauseMillis >= GCPauseIntervalMillis) {
259 259 char buffer[256];
260 260 jio_snprintf(buffer, 256,
261 261 "MaxGCPauseMillis (%u) should be less than "
262 262 "GCPauseIntervalMillis (%u)",
263 263 MaxGCPauseMillis, GCPauseIntervalMillis);
264 264 vm_exit_during_initialization(buffer);
265 265 }
266 266
267 267 double max_gc_time = (double) MaxGCPauseMillis / 1000.0;
268 268 double time_slice = (double) GCPauseIntervalMillis / 1000.0;
269 269 _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time);
270 270
271 271 uintx confidence_perc = G1ConfidencePercent;
272 272 // Put an artificial ceiling on this so that it's not set to a silly value.
273 273 if (confidence_perc > 100) {
274 274 confidence_perc = 100;
275 275 warning("G1ConfidencePercent is set to a value that is too large, "
276 276 "it's been updated to %u", confidence_perc);
277 277 }
278 278 _sigma = (double) confidence_perc / 100.0;
279 279
280 280 // start conservatively (around 50ms is about right)
281 281 _concurrent_mark_remark_times_ms->add(0.05);
282 282 _concurrent_mark_cleanup_times_ms->add(0.20);
283 283 _tenuring_threshold = MaxTenuringThreshold;
284 284 // _max_survivor_regions will be calculated by
285 285 // update_young_list_target_length() during initialization.
286 286 _max_survivor_regions = 0;
287 287
288 288 assert(GCTimeRatio > 0,
289 289 "we should have set it to a default value set_g1_gc_flags() "
290 290 "if a user set it to 0");
291 291 _gc_overhead_perc = 100.0 * (1.0 / (1.0 + GCTimeRatio));
292 292
293 293 uintx reserve_perc = G1ReservePercent;
294 294 // Put an artificial ceiling on this so that it's not set to a silly value.
295 295 if (reserve_perc > 50) {
296 296 reserve_perc = 50;
297 297 warning("G1ReservePercent is set to a value that is too large, "
298 298 "it's been updated to %u", reserve_perc);
299 299 }
300 300 _reserve_factor = (double) reserve_perc / 100.0;
301 301 // This will be set when the heap is expanded
302 302 // for the first time during initialization.
303 303 _reserve_regions = 0;
304 304
305 305 initialize_all();
306 306 _collectionSetChooser = new CollectionSetChooser();
307 307 _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags
308 308 }
309 309
310 310 void G1CollectorPolicy::initialize_flags() {
311 311 set_min_alignment(HeapRegion::GrainBytes);
312 312 set_max_alignment(GenRemSet::max_alignment_constraint(rem_set_name()));
313 313 if (SurvivorRatio < 1) {
314 314 vm_exit_during_initialization("Invalid survivor ratio specified");
315 315 }
316 316 CollectorPolicy::initialize_flags();
317 317 }
318 318
319 319 G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true) {
320 320 assert(G1NewSizePercent <= G1MaxNewSizePercent, "Min larger than max");
321 321 assert(G1NewSizePercent > 0 && G1NewSizePercent < 100, "Min out of bounds");
322 322 assert(G1MaxNewSizePercent > 0 && G1MaxNewSizePercent < 100, "Max out of bounds");
323 323
324 324 if (FLAG_IS_CMDLINE(NewRatio)) {
325 325 if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) {
326 326 warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio");
327 327 } else {
328 328 _sizer_kind = SizerNewRatio;
329 329 _adaptive_size = false;
330 330 return;
331 331 }
332 332 }
333 333
334 334 if (FLAG_IS_CMDLINE(NewSize)) {
335 335 _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes),
336 336 1U);
337 337 if (FLAG_IS_CMDLINE(MaxNewSize)) {
338 338 _max_desired_young_length =
339 339 MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
340 340 1U);
341 341 _sizer_kind = SizerMaxAndNewSize;
342 342 _adaptive_size = _min_desired_young_length == _max_desired_young_length;
343 343 } else {
344 344 _sizer_kind = SizerNewSizeOnly;
345 345 }
346 346 } else if (FLAG_IS_CMDLINE(MaxNewSize)) {
347 347 _max_desired_young_length =
348 348 MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
349 349 1U);
350 350 _sizer_kind = SizerMaxNewSizeOnly;
351 351 }
352 352 }
353 353
354 354 uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) {
355 355 uint default_value = (new_number_of_heap_regions * G1NewSizePercent) / 100;
356 356 return MAX2(1U, default_value);
357 357 }
358 358
359 359 uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) {
360 360 uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100;
361 361 return MAX2(1U, default_value);
362 362 }
363 363
364 364 void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) {
365 365 assert(new_number_of_heap_regions > 0, "Heap must be initialized");
366 366
367 367 switch (_sizer_kind) {
368 368 case SizerDefaults:
369 369 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions);
370 370 _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions);
371 371 break;
372 372 case SizerNewSizeOnly:
373 373 _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions);
374 374 _max_desired_young_length = MAX2(_min_desired_young_length, _max_desired_young_length);
375 375 break;
376 376 case SizerMaxNewSizeOnly:
377 377 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions);
378 378 _min_desired_young_length = MIN2(_min_desired_young_length, _max_desired_young_length);
379 379 break;
380 380 case SizerMaxAndNewSize:
381 381 // Do nothing. Values set on the command line, don't update them at runtime.
382 382 break;
383 383 case SizerNewRatio:
384 384 _min_desired_young_length = new_number_of_heap_regions / (NewRatio + 1);
385 385 _max_desired_young_length = _min_desired_young_length;
386 386 break;
387 387 default:
388 388 ShouldNotReachHere();
389 389 }
390 390
391 391 assert(_min_desired_young_length <= _max_desired_young_length, "Invalid min/max young gen size values");
392 392 }
393 393
394 394 void G1CollectorPolicy::init() {
395 395 // Set aside an initial future to_space.
396 396 _g1 = G1CollectedHeap::heap();
397 397
398 398 assert(Heap_lock->owned_by_self(), "Locking discipline.");
|
↓ open down ↓ |
386 lines elided |
↑ open up ↑ |
399 399
400 400 initialize_gc_policy_counters();
401 401
402 402 if (adaptive_young_list_length()) {
403 403 _young_list_fixed_length = 0;
404 404 } else {
405 405 _young_list_fixed_length = _young_gen_sizer->min_desired_young_length();
406 406 }
407 407 _free_regions_at_end_of_collection = _g1->free_regions();
408 408 update_young_list_target_length();
409 - _prev_eden_capacity = _young_list_target_length * HeapRegion::GrainBytes;
410 409
411 410 // We may immediately start allocating regions and placing them on the
412 411 // collection set list. Initialize the per-collection set info
413 412 start_incremental_cset_building();
414 413 }
415 414
416 415 // Create the jstat counters for the policy.
417 416 void G1CollectorPolicy::initialize_gc_policy_counters() {
418 417 _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3);
419 418 }
420 419
421 420 bool G1CollectorPolicy::predict_will_fit(uint young_length,
422 421 double base_time_ms,
423 422 uint base_free_regions,
424 423 double target_pause_time_ms) {
425 424 if (young_length >= base_free_regions) {
426 425 // end condition 1: not enough space for the young regions
427 426 return false;
428 427 }
429 428
430 429 double accum_surv_rate = accum_yg_surv_rate_pred((int) young_length - 1);
431 430 size_t bytes_to_copy =
432 431 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);
433 432 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy);
434 433 double young_other_time_ms = predict_young_other_time_ms(young_length);
435 434 double pause_time_ms = base_time_ms + copy_time_ms + young_other_time_ms;
436 435 if (pause_time_ms > target_pause_time_ms) {
437 436 // end condition 2: prediction is over the target pause time
438 437 return false;
439 438 }
440 439
441 440 size_t free_bytes =
442 441 (base_free_regions - young_length) * HeapRegion::GrainBytes;
443 442 if ((2.0 * sigma()) * (double) bytes_to_copy > (double) free_bytes) {
444 443 // end condition 3: out-of-space (conservatively!)
445 444 return false;
446 445 }
447 446
448 447 // success!
449 448 return true;
450 449 }
451 450
452 451 void G1CollectorPolicy::record_new_heap_size(uint new_number_of_regions) {
453 452 // re-calculate the necessary reserve
454 453 double reserve_regions_d = (double) new_number_of_regions * _reserve_factor;
455 454 // We use ceiling so that if reserve_regions_d is > 0.0 (but
456 455 // smaller than 1.0) we'll get 1.
457 456 _reserve_regions = (uint) ceil(reserve_regions_d);
458 457
459 458 _young_gen_sizer->heap_size_changed(new_number_of_regions);
460 459 }
461 460
462 461 uint G1CollectorPolicy::calculate_young_list_desired_min_length(
463 462 uint base_min_length) {
464 463 uint desired_min_length = 0;
465 464 if (adaptive_young_list_length()) {
466 465 if (_alloc_rate_ms_seq->num() > 3) {
467 466 double now_sec = os::elapsedTime();
468 467 double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0;
469 468 double alloc_rate_ms = predict_alloc_rate_ms();
470 469 desired_min_length = (uint) ceil(alloc_rate_ms * when_ms);
471 470 } else {
472 471 // otherwise we don't have enough info to make the prediction
473 472 }
474 473 }
475 474 desired_min_length += base_min_length;
476 475 // make sure we don't go below any user-defined minimum bound
477 476 return MAX2(_young_gen_sizer->min_desired_young_length(), desired_min_length);
478 477 }
479 478
480 479 uint G1CollectorPolicy::calculate_young_list_desired_max_length() {
481 480 // Here, we might want to also take into account any additional
482 481 // constraints (i.e., user-defined minimum bound). Currently, we
483 482 // effectively don't set this bound.
484 483 return _young_gen_sizer->max_desired_young_length();
485 484 }
486 485
487 486 void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) {
488 487 if (rs_lengths == (size_t) -1) {
489 488 // if it's set to the default value (-1), we should predict it;
490 489 // otherwise, use the given value.
491 490 rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq);
492 491 }
493 492
494 493 // Calculate the absolute and desired min bounds.
495 494
496 495 // This is how many young regions we already have (currently: the survivors).
497 496 uint base_min_length = recorded_survivor_regions();
498 497 // This is the absolute minimum young length, which ensures that we
499 498 // can allocate one eden region in the worst-case.
500 499 uint absolute_min_length = base_min_length + 1;
501 500 uint desired_min_length =
502 501 calculate_young_list_desired_min_length(base_min_length);
503 502 if (desired_min_length < absolute_min_length) {
504 503 desired_min_length = absolute_min_length;
505 504 }
506 505
507 506 // Calculate the absolute and desired max bounds.
508 507
509 508 // We will try our best not to "eat" into the reserve.
510 509 uint absolute_max_length = 0;
511 510 if (_free_regions_at_end_of_collection > _reserve_regions) {
512 511 absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions;
513 512 }
514 513 uint desired_max_length = calculate_young_list_desired_max_length();
515 514 if (desired_max_length > absolute_max_length) {
516 515 desired_max_length = absolute_max_length;
517 516 }
518 517
519 518 uint young_list_target_length = 0;
520 519 if (adaptive_young_list_length()) {
521 520 if (gcs_are_young()) {
522 521 young_list_target_length =
523 522 calculate_young_list_target_length(rs_lengths,
524 523 base_min_length,
525 524 desired_min_length,
526 525 desired_max_length);
527 526 _rs_lengths_prediction = rs_lengths;
528 527 } else {
529 528 // Don't calculate anything and let the code below bound it to
530 529 // the desired_min_length, i.e., do the next GC as soon as
531 530 // possible to maximize how many old regions we can add to it.
532 531 }
533 532 } else {
534 533 // The user asked for a fixed young gen so we'll fix the young gen
535 534 // whether the next GC is young or mixed.
536 535 young_list_target_length = _young_list_fixed_length;
537 536 }
538 537
539 538 // Make sure we don't go over the desired max length, nor under the
540 539 // desired min length. In case they clash, desired_min_length wins
541 540 // which is why that test is second.
542 541 if (young_list_target_length > desired_max_length) {
543 542 young_list_target_length = desired_max_length;
544 543 }
545 544 if (young_list_target_length < desired_min_length) {
546 545 young_list_target_length = desired_min_length;
547 546 }
548 547
549 548 assert(young_list_target_length > recorded_survivor_regions(),
550 549 "we should be able to allocate at least one eden region");
551 550 assert(young_list_target_length >= absolute_min_length, "post-condition");
552 551 _young_list_target_length = young_list_target_length;
553 552
554 553 update_max_gc_locker_expansion();
555 554 }
556 555
557 556 uint
558 557 G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths,
559 558 uint base_min_length,
560 559 uint desired_min_length,
561 560 uint desired_max_length) {
562 561 assert(adaptive_young_list_length(), "pre-condition");
563 562 assert(gcs_are_young(), "only call this for young GCs");
564 563
565 564 // In case some edge-condition makes the desired max length too small...
566 565 if (desired_max_length <= desired_min_length) {
567 566 return desired_min_length;
568 567 }
569 568
570 569 // We'll adjust min_young_length and max_young_length not to include
571 570 // the already allocated young regions (i.e., so they reflect the
572 571 // min and max eden regions we'll allocate). The base_min_length
573 572 // will be reflected in the predictions by the
574 573 // survivor_regions_evac_time prediction.
575 574 assert(desired_min_length > base_min_length, "invariant");
576 575 uint min_young_length = desired_min_length - base_min_length;
577 576 assert(desired_max_length > base_min_length, "invariant");
578 577 uint max_young_length = desired_max_length - base_min_length;
579 578
580 579 double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0;
581 580 double survivor_regions_evac_time = predict_survivor_regions_evac_time();
582 581 size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq);
583 582 size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff();
584 583 size_t scanned_cards = predict_young_card_num(adj_rs_lengths);
585 584 double base_time_ms =
586 585 predict_base_elapsed_time_ms(pending_cards, scanned_cards) +
587 586 survivor_regions_evac_time;
588 587 uint available_free_regions = _free_regions_at_end_of_collection;
589 588 uint base_free_regions = 0;
590 589 if (available_free_regions > _reserve_regions) {
591 590 base_free_regions = available_free_regions - _reserve_regions;
592 591 }
593 592
594 593 // Here, we will make sure that the shortest young length that
595 594 // makes sense fits within the target pause time.
596 595
597 596 if (predict_will_fit(min_young_length, base_time_ms,
598 597 base_free_regions, target_pause_time_ms)) {
599 598 // The shortest young length will fit into the target pause time;
600 599 // we'll now check whether the absolute maximum number of young
601 600 // regions will fit in the target pause time. If not, we'll do
602 601 // a binary search between min_young_length and max_young_length.
603 602 if (predict_will_fit(max_young_length, base_time_ms,
604 603 base_free_regions, target_pause_time_ms)) {
605 604 // The maximum young length will fit into the target pause time.
606 605 // We are done so set min young length to the maximum length (as
607 606 // the result is assumed to be returned in min_young_length).
608 607 min_young_length = max_young_length;
609 608 } else {
610 609 // The maximum possible number of young regions will not fit within
611 610 // the target pause time so we'll search for the optimal
612 611 // length. The loop invariants are:
613 612 //
614 613 // min_young_length < max_young_length
615 614 // min_young_length is known to fit into the target pause time
616 615 // max_young_length is known not to fit into the target pause time
617 616 //
618 617 // Going into the loop we know the above hold as we've just
619 618 // checked them. Every time around the loop we check whether
620 619 // the middle value between min_young_length and
621 620 // max_young_length fits into the target pause time. If it
622 621 // does, it becomes the new min. If it doesn't, it becomes
623 622 // the new max. This way we maintain the loop invariants.
624 623
625 624 assert(min_young_length < max_young_length, "invariant");
626 625 uint diff = (max_young_length - min_young_length) / 2;
627 626 while (diff > 0) {
628 627 uint young_length = min_young_length + diff;
629 628 if (predict_will_fit(young_length, base_time_ms,
630 629 base_free_regions, target_pause_time_ms)) {
631 630 min_young_length = young_length;
632 631 } else {
633 632 max_young_length = young_length;
634 633 }
635 634 assert(min_young_length < max_young_length, "invariant");
636 635 diff = (max_young_length - min_young_length) / 2;
637 636 }
638 637 // The results is min_young_length which, according to the
639 638 // loop invariants, should fit within the target pause time.
640 639
641 640 // These are the post-conditions of the binary search above:
642 641 assert(min_young_length < max_young_length,
643 642 "otherwise we should have discovered that max_young_length "
644 643 "fits into the pause target and not done the binary search");
645 644 assert(predict_will_fit(min_young_length, base_time_ms,
646 645 base_free_regions, target_pause_time_ms),
647 646 "min_young_length, the result of the binary search, should "
648 647 "fit into the pause target");
649 648 assert(!predict_will_fit(min_young_length + 1, base_time_ms,
650 649 base_free_regions, target_pause_time_ms),
651 650 "min_young_length, the result of the binary search, should be "
652 651 "optimal, so no larger length should fit into the pause target");
653 652 }
654 653 } else {
655 654 // Even the minimum length doesn't fit into the pause time
656 655 // target, return it as the result nevertheless.
657 656 }
658 657 return base_min_length + min_young_length;
659 658 }
660 659
661 660 double G1CollectorPolicy::predict_survivor_regions_evac_time() {
662 661 double survivor_regions_evac_time = 0.0;
663 662 for (HeapRegion * r = _recorded_survivor_head;
664 663 r != NULL && r != _recorded_survivor_tail->get_next_young_region();
665 664 r = r->get_next_young_region()) {
666 665 survivor_regions_evac_time += predict_region_elapsed_time_ms(r, gcs_are_young());
667 666 }
668 667 return survivor_regions_evac_time;
669 668 }
670 669
671 670 void G1CollectorPolicy::revise_young_list_target_length_if_necessary() {
672 671 guarantee( adaptive_young_list_length(), "should not call this otherwise" );
673 672
674 673 size_t rs_lengths = _g1->young_list()->sampled_rs_lengths();
675 674 if (rs_lengths > _rs_lengths_prediction) {
676 675 // add 10% to avoid having to recalculate often
677 676 size_t rs_lengths_prediction = rs_lengths * 1100 / 1000;
678 677 update_young_list_target_length(rs_lengths_prediction);
679 678 }
680 679 }
681 680
682 681
683 682
684 683 HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size,
685 684 bool is_tlab,
686 685 bool* gc_overhead_limit_was_exceeded) {
687 686 guarantee(false, "Not using this policy feature yet.");
688 687 return NULL;
689 688 }
690 689
691 690 // This method controls how a collector handles one or more
692 691 // of its generations being fully allocated.
693 692 HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size,
694 693 bool is_tlab) {
695 694 guarantee(false, "Not using this policy feature yet.");
696 695 return NULL;
697 696 }
698 697
699 698
700 699 #ifndef PRODUCT
701 700 bool G1CollectorPolicy::verify_young_ages() {
702 701 HeapRegion* head = _g1->young_list()->first_region();
703 702 return
704 703 verify_young_ages(head, _short_lived_surv_rate_group);
705 704 // also call verify_young_ages on any additional surv rate groups
706 705 }
707 706
708 707 bool
709 708 G1CollectorPolicy::verify_young_ages(HeapRegion* head,
710 709 SurvRateGroup *surv_rate_group) {
711 710 guarantee( surv_rate_group != NULL, "pre-condition" );
712 711
713 712 const char* name = surv_rate_group->name();
714 713 bool ret = true;
715 714 int prev_age = -1;
716 715
717 716 for (HeapRegion* curr = head;
718 717 curr != NULL;
719 718 curr = curr->get_next_young_region()) {
720 719 SurvRateGroup* group = curr->surv_rate_group();
721 720 if (group == NULL && !curr->is_survivor()) {
722 721 gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name);
723 722 ret = false;
724 723 }
725 724
726 725 if (surv_rate_group == group) {
727 726 int age = curr->age_in_surv_rate_group();
728 727
729 728 if (age < 0) {
730 729 gclog_or_tty->print_cr("## %s: encountered negative age", name);
731 730 ret = false;
732 731 }
733 732
734 733 if (age <= prev_age) {
735 734 gclog_or_tty->print_cr("## %s: region ages are not strictly increasing "
736 735 "(%d, %d)", name, age, prev_age);
737 736 ret = false;
738 737 }
|
↓ open down ↓ |
319 lines elided |
↑ open up ↑ |
739 738 prev_age = age;
740 739 }
741 740 }
742 741
743 742 return ret;
744 743 }
745 744 #endif // PRODUCT
746 745
747 746 void G1CollectorPolicy::record_full_collection_start() {
748 747 _full_collection_start_sec = os::elapsedTime();
748 + record_heap_size_info_at_start();
749 749 // Release the future to-space so that it is available for compaction into.
750 750 _g1->set_full_collection();
751 751 }
752 752
753 753 void G1CollectorPolicy::record_full_collection_end() {
754 754 // Consider this like a collection pause for the purposes of allocation
755 755 // since last pause.
756 756 double end_sec = os::elapsedTime();
757 757 double full_gc_time_sec = end_sec - _full_collection_start_sec;
758 758 double full_gc_time_ms = full_gc_time_sec * 1000.0;
759 759
760 760 _trace_gen1_time_data.record_full_collection(full_gc_time_ms);
761 761
762 762 update_recent_gc_times(end_sec, full_gc_time_ms);
763 763
764 764 _g1->clear_full_collection();
765 765
766 766 // "Nuke" the heuristics that control the young/mixed GC
767 767 // transitions and make sure we start with young GCs after the Full GC.
768 768 set_gcs_are_young(true);
769 769 _last_young_gc = false;
770 770 clear_initiate_conc_mark_if_possible();
771 771 clear_during_initial_mark_pause();
772 772 _in_marking_window = false;
773 773 _in_marking_window_im = false;
774 774
775 775 _short_lived_surv_rate_group->start_adding_regions();
776 776 // also call this on any additional surv rate groups
777 777
778 778 record_survivor_regions(0, NULL, NULL);
779 779
780 780 _free_regions_at_end_of_collection = _g1->free_regions();
|
↓ open down ↓ |
22 lines elided |
↑ open up ↑ |
781 781 // Reset survivors SurvRateGroup.
782 782 _survivor_surv_rate_group->reset();
783 783 update_young_list_target_length();
784 784 _collectionSetChooser->clear();
785 785 }
786 786
787 787 void G1CollectorPolicy::record_stop_world_start() {
788 788 _stop_world_start = os::elapsedTime();
789 789 }
790 790
791 -void G1CollectorPolicy::record_collection_pause_start(double start_time_sec,
792 - size_t start_used) {
791 +void G1CollectorPolicy::record_collection_pause_start(double start_time_sec) {
793 792 // We only need to do this here as the policy will only be applied
794 793 // to the GC we're about to start. so, no point is calculating this
795 794 // every time we calculate / recalculate the target young length.
796 795 update_survivors_policy();
797 796
798 797 assert(_g1->used() == _g1->recalculate_used(),
799 798 err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT,
800 799 _g1->used(), _g1->recalculate_used()));
801 800
802 801 double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0;
803 802 _trace_gen0_time_data.record_start_collection(s_w_t_ms);
804 803 _stop_world_start = 0.0;
805 804
805 + record_heap_size_info_at_start();
806 +
806 807 phase_times()->record_cur_collection_start_sec(start_time_sec);
807 - _cur_collection_pause_used_at_start_bytes = start_used;
808 - _cur_collection_pause_used_regions_at_start = _g1->used_regions();
809 808 _pending_cards = _g1->pending_card_num();
810 809
811 810 _collection_set_bytes_used_before = 0;
812 811 _bytes_copied_during_gc = 0;
813 812
814 - YoungList* young_list = _g1->young_list();
815 - _eden_bytes_before_gc = young_list->eden_used_bytes();
816 - _survivor_bytes_before_gc = young_list->survivor_used_bytes();
817 - _capacity_before_gc = _g1->capacity();
818 -
819 813 _last_gc_was_young = false;
820 814
821 815 // do that for any other surv rate groups
822 816 _short_lived_surv_rate_group->stop_adding_regions();
823 817 _survivors_age_table.clear();
824 818
825 819 assert( verify_young_ages(), "region age verification" );
826 820 }
827 821
828 822 void G1CollectorPolicy::record_concurrent_mark_init_end(double
829 823 mark_init_elapsed_time_ms) {
830 824 _during_marking = true;
831 825 assert(!initiate_conc_mark_if_possible(), "we should have cleared it by now");
832 826 clear_during_initial_mark_pause();
833 827 _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms;
834 828 }
835 829
836 830 void G1CollectorPolicy::record_concurrent_mark_remark_start() {
837 831 _mark_remark_start_sec = os::elapsedTime();
838 832 _during_marking = false;
839 833 }
840 834
841 835 void G1CollectorPolicy::record_concurrent_mark_remark_end() {
842 836 double end_time_sec = os::elapsedTime();
843 837 double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0;
844 838 _concurrent_mark_remark_times_ms->add(elapsed_time_ms);
845 839 _cur_mark_stop_world_time_ms += elapsed_time_ms;
846 840 _prev_collection_pause_end_ms += elapsed_time_ms;
847 841
848 842 _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true);
849 843 }
850 844
851 845 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() {
852 846 _mark_cleanup_start_sec = os::elapsedTime();
853 847 }
854 848
855 849 void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() {
856 850 _last_young_gc = true;
857 851 _in_marking_window = false;
858 852 }
859 853
860 854 void G1CollectorPolicy::record_concurrent_pause() {
861 855 if (_stop_world_start > 0.0) {
862 856 double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0;
863 857 _trace_gen0_time_data.record_yield_time(yield_ms);
864 858 }
865 859 }
866 860
867 861 bool G1CollectorPolicy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) {
868 862 if (_g1->concurrent_mark()->cmThread()->during_cycle()) {
869 863 return false;
870 864 }
871 865
872 866 size_t marking_initiating_used_threshold =
873 867 (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent;
874 868 size_t cur_used_bytes = _g1->non_young_capacity_bytes();
875 869 size_t alloc_byte_size = alloc_word_size * HeapWordSize;
876 870
877 871 if ((cur_used_bytes + alloc_byte_size) > marking_initiating_used_threshold) {
878 872 if (gcs_are_young()) {
879 873 ergo_verbose5(ErgoConcCycles,
880 874 "request concurrent cycle initiation",
881 875 ergo_format_reason("occupancy higher than threshold")
882 876 ergo_format_byte("occupancy")
883 877 ergo_format_byte("allocation request")
884 878 ergo_format_byte_perc("threshold")
885 879 ergo_format_str("source"),
886 880 cur_used_bytes,
887 881 alloc_byte_size,
888 882 marking_initiating_used_threshold,
889 883 (double) InitiatingHeapOccupancyPercent,
890 884 source);
891 885 return true;
892 886 } else {
893 887 ergo_verbose5(ErgoConcCycles,
894 888 "do not request concurrent cycle initiation",
895 889 ergo_format_reason("still doing mixed collections")
896 890 ergo_format_byte("occupancy")
897 891 ergo_format_byte("allocation request")
898 892 ergo_format_byte_perc("threshold")
899 893 ergo_format_str("source"),
900 894 cur_used_bytes,
901 895 alloc_byte_size,
902 896 marking_initiating_used_threshold,
903 897 (double) InitiatingHeapOccupancyPercent,
904 898 source);
905 899 }
906 900 }
907 901
908 902 return false;
909 903 }
910 904
911 905 // Anything below that is considered to be zero
912 906 #define MIN_TIMER_GRANULARITY 0.0000001
913 907
914 908 void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms, EvacuationInfo& evacuation_info) {
915 909 double end_time_sec = os::elapsedTime();
916 910 assert(_cur_collection_pause_used_regions_at_start >= cset_region_length(),
917 911 "otherwise, the subtraction below does not make sense");
918 912 size_t rs_size =
919 913 _cur_collection_pause_used_regions_at_start - cset_region_length();
920 914 size_t cur_used_bytes = _g1->used();
921 915 assert(cur_used_bytes == _g1->recalculate_used(), "It should!");
922 916 bool last_pause_included_initial_mark = false;
923 917 bool update_stats = !_g1->evacuation_failed();
924 918
925 919 #ifndef PRODUCT
926 920 if (G1YoungSurvRateVerbose) {
927 921 gclog_or_tty->print_cr("");
928 922 _short_lived_surv_rate_group->print();
929 923 // do that for any other surv rate groups too
930 924 }
931 925 #endif // PRODUCT
932 926
933 927 last_pause_included_initial_mark = during_initial_mark_pause();
934 928 if (last_pause_included_initial_mark) {
935 929 record_concurrent_mark_init_end(0.0);
936 930 } else if (!_last_young_gc && need_to_start_conc_mark("end of GC")) {
937 931 // Note: this might have already been set, if during the last
938 932 // pause we decided to start a cycle but at the beginning of
939 933 // this pause we decided to postpone it. That's OK.
940 934 set_initiate_conc_mark_if_possible();
941 935 }
942 936
943 937 _mmu_tracker->add_pause(end_time_sec - pause_time_ms/1000.0,
944 938 end_time_sec, false);
945 939
946 940 size_t freed_bytes =
947 941 _cur_collection_pause_used_at_start_bytes - cur_used_bytes;
948 942 size_t surviving_bytes = _collection_set_bytes_used_before - freed_bytes;
949 943
950 944 double survival_fraction =
951 945 (double)surviving_bytes/
952 946 (double)_collection_set_bytes_used_before;
953 947
954 948 evacuation_info.set_collectionset_used_before(_collection_set_bytes_used_before);
955 949 evacuation_info.set_bytes_copied(_bytes_copied_during_gc);
956 950
957 951 if (update_stats) {
958 952 _trace_gen0_time_data.record_end_collection(pause_time_ms, phase_times());
959 953 // this is where we update the allocation rate of the application
960 954 double app_time_ms =
961 955 (phase_times()->cur_collection_start_sec() * 1000.0 - _prev_collection_pause_end_ms);
962 956 if (app_time_ms < MIN_TIMER_GRANULARITY) {
963 957 // This usually happens due to the timer not having the required
964 958 // granularity. Some Linuxes are the usual culprits.
965 959 // We'll just set it to something (arbitrarily) small.
966 960 app_time_ms = 1.0;
967 961 }
968 962 // We maintain the invariant that all objects allocated by mutator
969 963 // threads will be allocated out of eden regions. So, we can use
970 964 // the eden region number allocated since the previous GC to
971 965 // calculate the application's allocate rate. The only exception
972 966 // to that is humongous objects that are allocated separately. But
973 967 // given that humongous object allocations do not really affect
974 968 // either the pause's duration nor when the next pause will take
975 969 // place we can safely ignore them here.
976 970 uint regions_allocated = eden_cset_region_length();
977 971 double alloc_rate_ms = (double) regions_allocated / app_time_ms;
978 972 _alloc_rate_ms_seq->add(alloc_rate_ms);
979 973
980 974 double interval_ms =
981 975 (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0;
982 976 update_recent_gc_times(end_time_sec, pause_time_ms);
983 977 _recent_avg_pause_time_ratio = _recent_gc_times_ms->sum()/interval_ms;
984 978 if (recent_avg_pause_time_ratio() < 0.0 ||
985 979 (recent_avg_pause_time_ratio() - 1.0 > 0.0)) {
986 980 #ifndef PRODUCT
987 981 // Dump info to allow post-facto debugging
988 982 gclog_or_tty->print_cr("recent_avg_pause_time_ratio() out of bounds");
989 983 gclog_or_tty->print_cr("-------------------------------------------");
990 984 gclog_or_tty->print_cr("Recent GC Times (ms):");
991 985 _recent_gc_times_ms->dump();
992 986 gclog_or_tty->print_cr("(End Time=%3.3f) Recent GC End Times (s):", end_time_sec);
993 987 _recent_prev_end_times_for_all_gcs_sec->dump();
994 988 gclog_or_tty->print_cr("GC = %3.3f, Interval = %3.3f, Ratio = %3.3f",
995 989 _recent_gc_times_ms->sum(), interval_ms, recent_avg_pause_time_ratio());
996 990 // In debug mode, terminate the JVM if the user wants to debug at this point.
997 991 assert(!G1FailOnFPError, "Debugging data for CR 6898948 has been dumped above");
998 992 #endif // !PRODUCT
999 993 // Clip ratio between 0.0 and 1.0, and continue. This will be fixed in
1000 994 // CR 6902692 by redoing the manner in which the ratio is incrementally computed.
1001 995 if (_recent_avg_pause_time_ratio < 0.0) {
1002 996 _recent_avg_pause_time_ratio = 0.0;
1003 997 } else {
1004 998 assert(_recent_avg_pause_time_ratio - 1.0 > 0.0, "Ctl-point invariant");
1005 999 _recent_avg_pause_time_ratio = 1.0;
1006 1000 }
1007 1001 }
1008 1002 }
1009 1003 bool new_in_marking_window = _in_marking_window;
1010 1004 bool new_in_marking_window_im = false;
1011 1005 if (during_initial_mark_pause()) {
1012 1006 new_in_marking_window = true;
1013 1007 new_in_marking_window_im = true;
1014 1008 }
1015 1009
1016 1010 if (_last_young_gc) {
1017 1011 // This is supposed to to be the "last young GC" before we start
1018 1012 // doing mixed GCs. Here we decide whether to start mixed GCs or not.
1019 1013
1020 1014 if (!last_pause_included_initial_mark) {
1021 1015 if (next_gc_should_be_mixed("start mixed GCs",
1022 1016 "do not start mixed GCs")) {
1023 1017 set_gcs_are_young(false);
1024 1018 }
1025 1019 } else {
1026 1020 ergo_verbose0(ErgoMixedGCs,
1027 1021 "do not start mixed GCs",
1028 1022 ergo_format_reason("concurrent cycle is about to start"));
1029 1023 }
1030 1024 _last_young_gc = false;
1031 1025 }
1032 1026
1033 1027 if (!_last_gc_was_young) {
1034 1028 // This is a mixed GC. Here we decide whether to continue doing
1035 1029 // mixed GCs or not.
1036 1030
1037 1031 if (!next_gc_should_be_mixed("continue mixed GCs",
1038 1032 "do not continue mixed GCs")) {
1039 1033 set_gcs_are_young(true);
1040 1034 }
1041 1035 }
1042 1036
1043 1037 _short_lived_surv_rate_group->start_adding_regions();
1044 1038 // do that for any other surv rate groupsx
1045 1039
1046 1040 if (update_stats) {
1047 1041 double cost_per_card_ms = 0.0;
1048 1042 if (_pending_cards > 0) {
1049 1043 cost_per_card_ms = phase_times()->average_last_update_rs_time() / (double) _pending_cards;
1050 1044 _cost_per_card_ms_seq->add(cost_per_card_ms);
1051 1045 }
1052 1046
1053 1047 size_t cards_scanned = _g1->cards_scanned();
1054 1048
1055 1049 double cost_per_entry_ms = 0.0;
1056 1050 if (cards_scanned > 10) {
1057 1051 cost_per_entry_ms = phase_times()->average_last_scan_rs_time() / (double) cards_scanned;
1058 1052 if (_last_gc_was_young) {
1059 1053 _cost_per_entry_ms_seq->add(cost_per_entry_ms);
1060 1054 } else {
1061 1055 _mixed_cost_per_entry_ms_seq->add(cost_per_entry_ms);
1062 1056 }
1063 1057 }
1064 1058
1065 1059 if (_max_rs_lengths > 0) {
1066 1060 double cards_per_entry_ratio =
1067 1061 (double) cards_scanned / (double) _max_rs_lengths;
1068 1062 if (_last_gc_was_young) {
1069 1063 _young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio);
1070 1064 } else {
1071 1065 _mixed_cards_per_entry_ratio_seq->add(cards_per_entry_ratio);
1072 1066 }
1073 1067 }
1074 1068
1075 1069 // This is defensive. For a while _max_rs_lengths could get
1076 1070 // smaller than _recorded_rs_lengths which was causing
1077 1071 // rs_length_diff to get very large and mess up the RSet length
1078 1072 // predictions. The reason was unsafe concurrent updates to the
1079 1073 // _inc_cset_recorded_rs_lengths field which the code below guards
1080 1074 // against (see CR 7118202). This bug has now been fixed (see CR
1081 1075 // 7119027). However, I'm still worried that
1082 1076 // _inc_cset_recorded_rs_lengths might still end up somewhat
1083 1077 // inaccurate. The concurrent refinement thread calculates an
1084 1078 // RSet's length concurrently with other CR threads updating it
1085 1079 // which might cause it to calculate the length incorrectly (if,
1086 1080 // say, it's in mid-coarsening). So I'll leave in the defensive
1087 1081 // conditional below just in case.
1088 1082 size_t rs_length_diff = 0;
1089 1083 if (_max_rs_lengths > _recorded_rs_lengths) {
1090 1084 rs_length_diff = _max_rs_lengths - _recorded_rs_lengths;
1091 1085 }
1092 1086 _rs_length_diff_seq->add((double) rs_length_diff);
1093 1087
1094 1088 size_t copied_bytes = surviving_bytes;
1095 1089 double cost_per_byte_ms = 0.0;
1096 1090 if (copied_bytes > 0) {
1097 1091 cost_per_byte_ms = phase_times()->average_last_obj_copy_time() / (double) copied_bytes;
1098 1092 if (_in_marking_window) {
1099 1093 _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms);
1100 1094 } else {
1101 1095 _cost_per_byte_ms_seq->add(cost_per_byte_ms);
1102 1096 }
1103 1097 }
1104 1098
1105 1099 double all_other_time_ms = pause_time_ms -
1106 1100 (phase_times()->average_last_update_rs_time() + phase_times()->average_last_scan_rs_time()
1107 1101 + phase_times()->average_last_obj_copy_time() + phase_times()->average_last_termination_time());
1108 1102
1109 1103 double young_other_time_ms = 0.0;
1110 1104 if (young_cset_region_length() > 0) {
1111 1105 young_other_time_ms =
1112 1106 phase_times()->young_cset_choice_time_ms() +
1113 1107 phase_times()->young_free_cset_time_ms();
1114 1108 _young_other_cost_per_region_ms_seq->add(young_other_time_ms /
1115 1109 (double) young_cset_region_length());
1116 1110 }
1117 1111 double non_young_other_time_ms = 0.0;
1118 1112 if (old_cset_region_length() > 0) {
1119 1113 non_young_other_time_ms =
1120 1114 phase_times()->non_young_cset_choice_time_ms() +
1121 1115 phase_times()->non_young_free_cset_time_ms();
1122 1116
1123 1117 _non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms /
1124 1118 (double) old_cset_region_length());
1125 1119 }
1126 1120
1127 1121 double constant_other_time_ms = all_other_time_ms -
1128 1122 (young_other_time_ms + non_young_other_time_ms);
1129 1123 _constant_other_time_ms_seq->add(constant_other_time_ms);
1130 1124
1131 1125 double survival_ratio = 0.0;
1132 1126 if (_collection_set_bytes_used_before > 0) {
1133 1127 survival_ratio = (double) _bytes_copied_during_gc /
1134 1128 (double) _collection_set_bytes_used_before;
1135 1129 }
1136 1130
1137 1131 _pending_cards_seq->add((double) _pending_cards);
1138 1132 _rs_lengths_seq->add((double) _max_rs_lengths);
1139 1133 }
1140 1134
1141 1135 _in_marking_window = new_in_marking_window;
1142 1136 _in_marking_window_im = new_in_marking_window_im;
1143 1137 _free_regions_at_end_of_collection = _g1->free_regions();
1144 1138 update_young_list_target_length();
1145 1139
1146 1140 // Note that _mmu_tracker->max_gc_time() returns the time in seconds.
1147 1141 double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0;
1148 1142 adjust_concurrent_refinement(phase_times()->average_last_update_rs_time(),
|
↓ open down ↓ |
320 lines elided |
↑ open up ↑ |
1149 1143 phase_times()->sum_last_update_rs_processed_buffers(), update_rs_time_goal_ms);
1150 1144
1151 1145 _collectionSetChooser->verify();
1152 1146 }
1153 1147
1154 1148 #define EXT_SIZE_FORMAT "%.1f%s"
1155 1149 #define EXT_SIZE_PARAMS(bytes) \
1156 1150 byte_size_in_proper_unit((double)(bytes)), \
1157 1151 proper_unit_for_byte_size((bytes))
1158 1152
1153 +void G1CollectorPolicy::record_heap_size_info_at_start() {
1154 + YoungList* young_list = _g1->young_list();
1155 + _eden_bytes_before_gc = young_list->eden_used_bytes();
1156 + _survivor_bytes_before_gc = young_list->survivor_used_bytes();
1157 + _capacity_before_gc = _g1->capacity();
1158 +
1159 + _cur_collection_pause_used_at_start_bytes = _g1->used();
1160 + _cur_collection_pause_used_regions_at_start = _g1->used_regions();
1161 +
1162 + size_t eden_capacity_before_gc =
1163 + (_young_list_target_length * HeapRegion::GrainBytes) - _survivor_bytes_before_gc;
1164 +
1165 + _prev_eden_capacity = eden_capacity_before_gc;
1166 +}
1167 +
1159 1168 void G1CollectorPolicy::print_heap_transition() {
1160 1169 _g1->print_size_transition(gclog_or_tty,
1161 1170 _cur_collection_pause_used_at_start_bytes, _g1->used(), _g1->capacity());
1162 1171 }
1163 1172
1164 1173 void G1CollectorPolicy::print_detailed_heap_transition() {
1165 1174 YoungList* young_list = _g1->young_list();
1166 1175 size_t eden_bytes = young_list->eden_used_bytes();
1167 1176 size_t survivor_bytes = young_list->survivor_used_bytes();
1168 1177 size_t used_before_gc = _cur_collection_pause_used_at_start_bytes;
1169 1178 size_t used = _g1->used();
1170 1179 size_t capacity = _g1->capacity();
1171 1180 size_t eden_capacity =
1172 1181 (_young_list_target_length * HeapRegion::GrainBytes) - survivor_bytes;
1173 1182
1174 1183 gclog_or_tty->print_cr(
1175 1184 " [Eden: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->"EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT") "
1176 1185 "Survivors: "EXT_SIZE_FORMAT"->"EXT_SIZE_FORMAT" "
1177 1186 "Heap: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->"
1178 1187 EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")]",
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
1179 1188 EXT_SIZE_PARAMS(_eden_bytes_before_gc),
1180 1189 EXT_SIZE_PARAMS(_prev_eden_capacity),
1181 1190 EXT_SIZE_PARAMS(eden_bytes),
1182 1191 EXT_SIZE_PARAMS(eden_capacity),
1183 1192 EXT_SIZE_PARAMS(_survivor_bytes_before_gc),
1184 1193 EXT_SIZE_PARAMS(survivor_bytes),
1185 1194 EXT_SIZE_PARAMS(used_before_gc),
1186 1195 EXT_SIZE_PARAMS(_capacity_before_gc),
1187 1196 EXT_SIZE_PARAMS(used),
1188 1197 EXT_SIZE_PARAMS(capacity));
1189 -
1190 - _prev_eden_capacity = eden_capacity;
1191 1198 }
1192 1199
1193 1200 void G1CollectorPolicy::adjust_concurrent_refinement(double update_rs_time,
1194 1201 double update_rs_processed_buffers,
1195 1202 double goal_ms) {
1196 1203 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
1197 1204 ConcurrentG1Refine *cg1r = G1CollectedHeap::heap()->concurrent_g1_refine();
1198 1205
1199 1206 if (G1UseAdaptiveConcRefinement) {
1200 1207 const int k_gy = 3, k_gr = 6;
1201 1208 const double inc_k = 1.1, dec_k = 0.9;
1202 1209
1203 1210 int g = cg1r->green_zone();
1204 1211 if (update_rs_time > goal_ms) {
1205 1212 g = (int)(g * dec_k); // Can become 0, that's OK. That would mean a mutator-only processing.
1206 1213 } else {
1207 1214 if (update_rs_time < goal_ms && update_rs_processed_buffers > g) {
1208 1215 g = (int)MAX2(g * inc_k, g + 1.0);
1209 1216 }
1210 1217 }
1211 1218 // Change the refinement threads params
1212 1219 cg1r->set_green_zone(g);
1213 1220 cg1r->set_yellow_zone(g * k_gy);
1214 1221 cg1r->set_red_zone(g * k_gr);
1215 1222 cg1r->reinitialize_threads();
1216 1223
1217 1224 int processing_threshold_delta = MAX2((int)(cg1r->green_zone() * sigma()), 1);
1218 1225 int processing_threshold = MIN2(cg1r->green_zone() + processing_threshold_delta,
1219 1226 cg1r->yellow_zone());
1220 1227 // Change the barrier params
1221 1228 dcqs.set_process_completed_threshold(processing_threshold);
1222 1229 dcqs.set_max_completed_queue(cg1r->red_zone());
1223 1230 }
1224 1231
1225 1232 int curr_queue_size = dcqs.completed_buffers_num();
1226 1233 if (curr_queue_size >= cg1r->yellow_zone()) {
1227 1234 dcqs.set_completed_queue_padding(curr_queue_size);
1228 1235 } else {
1229 1236 dcqs.set_completed_queue_padding(0);
1230 1237 }
1231 1238 dcqs.notify_if_necessary();
1232 1239 }
1233 1240
1234 1241 double
1235 1242 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards,
1236 1243 size_t scanned_cards) {
1237 1244 return
1238 1245 predict_rs_update_time_ms(pending_cards) +
1239 1246 predict_rs_scan_time_ms(scanned_cards) +
1240 1247 predict_constant_other_time_ms();
1241 1248 }
1242 1249
1243 1250 double
1244 1251 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) {
1245 1252 size_t rs_length = predict_rs_length_diff();
1246 1253 size_t card_num;
1247 1254 if (gcs_are_young()) {
1248 1255 card_num = predict_young_card_num(rs_length);
1249 1256 } else {
1250 1257 card_num = predict_non_young_card_num(rs_length);
1251 1258 }
1252 1259 return predict_base_elapsed_time_ms(pending_cards, card_num);
1253 1260 }
1254 1261
1255 1262 size_t G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) {
1256 1263 size_t bytes_to_copy;
1257 1264 if (hr->is_marked())
1258 1265 bytes_to_copy = hr->max_live_bytes();
1259 1266 else {
1260 1267 assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "invariant");
1261 1268 int age = hr->age_in_surv_rate_group();
1262 1269 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group());
1263 1270 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate);
1264 1271 }
1265 1272 return bytes_to_copy;
1266 1273 }
1267 1274
1268 1275 double
1269 1276 G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
1270 1277 bool for_young_gc) {
1271 1278 size_t rs_length = hr->rem_set()->occupied();
1272 1279 size_t card_num;
1273 1280
1274 1281 // Predicting the number of cards is based on which type of GC
1275 1282 // we're predicting for.
1276 1283 if (for_young_gc) {
1277 1284 card_num = predict_young_card_num(rs_length);
1278 1285 } else {
1279 1286 card_num = predict_non_young_card_num(rs_length);
1280 1287 }
1281 1288 size_t bytes_to_copy = predict_bytes_to_copy(hr);
1282 1289
1283 1290 double region_elapsed_time_ms =
1284 1291 predict_rs_scan_time_ms(card_num) +
1285 1292 predict_object_copy_time_ms(bytes_to_copy);
1286 1293
1287 1294 // The prediction of the "other" time for this region is based
1288 1295 // upon the region type and NOT the GC type.
1289 1296 if (hr->is_young()) {
1290 1297 region_elapsed_time_ms += predict_young_other_time_ms(1);
1291 1298 } else {
1292 1299 region_elapsed_time_ms += predict_non_young_other_time_ms(1);
1293 1300 }
1294 1301 return region_elapsed_time_ms;
1295 1302 }
1296 1303
1297 1304 void
1298 1305 G1CollectorPolicy::init_cset_region_lengths(uint eden_cset_region_length,
1299 1306 uint survivor_cset_region_length) {
1300 1307 _eden_cset_region_length = eden_cset_region_length;
1301 1308 _survivor_cset_region_length = survivor_cset_region_length;
1302 1309 _old_cset_region_length = 0;
1303 1310 }
1304 1311
1305 1312 void G1CollectorPolicy::set_recorded_rs_lengths(size_t rs_lengths) {
1306 1313 _recorded_rs_lengths = rs_lengths;
1307 1314 }
1308 1315
1309 1316 void G1CollectorPolicy::update_recent_gc_times(double end_time_sec,
1310 1317 double elapsed_ms) {
1311 1318 _recent_gc_times_ms->add(elapsed_ms);
1312 1319 _recent_prev_end_times_for_all_gcs_sec->add(end_time_sec);
1313 1320 _prev_collection_pause_end_ms = end_time_sec * 1000.0;
1314 1321 }
1315 1322
1316 1323 size_t G1CollectorPolicy::expansion_amount() {
1317 1324 double recent_gc_overhead = recent_avg_pause_time_ratio() * 100.0;
1318 1325 double threshold = _gc_overhead_perc;
1319 1326 if (recent_gc_overhead > threshold) {
1320 1327 // We will double the existing space, or take
1321 1328 // G1ExpandByPercentOfAvailable % of the available expansion
1322 1329 // space, whichever is smaller, bounded below by a minimum
1323 1330 // expansion (unless that's all that's left.)
1324 1331 const size_t min_expand_bytes = 1*M;
1325 1332 size_t reserved_bytes = _g1->max_capacity();
1326 1333 size_t committed_bytes = _g1->capacity();
1327 1334 size_t uncommitted_bytes = reserved_bytes - committed_bytes;
1328 1335 size_t expand_bytes;
1329 1336 size_t expand_bytes_via_pct =
1330 1337 uncommitted_bytes * G1ExpandByPercentOfAvailable / 100;
1331 1338 expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes);
1332 1339 expand_bytes = MAX2(expand_bytes, min_expand_bytes);
1333 1340 expand_bytes = MIN2(expand_bytes, uncommitted_bytes);
1334 1341
1335 1342 ergo_verbose5(ErgoHeapSizing,
1336 1343 "attempt heap expansion",
1337 1344 ergo_format_reason("recent GC overhead higher than "
1338 1345 "threshold after GC")
1339 1346 ergo_format_perc("recent GC overhead")
1340 1347 ergo_format_perc("threshold")
1341 1348 ergo_format_byte("uncommitted")
1342 1349 ergo_format_byte_perc("calculated expansion amount"),
1343 1350 recent_gc_overhead, threshold,
1344 1351 uncommitted_bytes,
1345 1352 expand_bytes_via_pct, (double) G1ExpandByPercentOfAvailable);
1346 1353
1347 1354 return expand_bytes;
1348 1355 } else {
1349 1356 return 0;
1350 1357 }
1351 1358 }
1352 1359
1353 1360 void G1CollectorPolicy::print_tracing_info() const {
1354 1361 _trace_gen0_time_data.print();
1355 1362 _trace_gen1_time_data.print();
1356 1363 }
1357 1364
1358 1365 void G1CollectorPolicy::print_yg_surv_rate_info() const {
1359 1366 #ifndef PRODUCT
1360 1367 _short_lived_surv_rate_group->print_surv_rate_summary();
1361 1368 // add this call for any other surv rate groups
1362 1369 #endif // PRODUCT
1363 1370 }
1364 1371
1365 1372 #ifndef PRODUCT
1366 1373 // for debugging, bit of a hack...
1367 1374 static char*
1368 1375 region_num_to_mbs(int length) {
1369 1376 static char buffer[64];
1370 1377 double bytes = (double) (length * HeapRegion::GrainBytes);
1371 1378 double mbs = bytes / (double) (1024 * 1024);
1372 1379 sprintf(buffer, "%7.2lfMB", mbs);
1373 1380 return buffer;
1374 1381 }
1375 1382 #endif // PRODUCT
1376 1383
1377 1384 uint G1CollectorPolicy::max_regions(int purpose) {
1378 1385 switch (purpose) {
1379 1386 case GCAllocForSurvived:
1380 1387 return _max_survivor_regions;
1381 1388 case GCAllocForTenured:
1382 1389 return REGIONS_UNLIMITED;
1383 1390 default:
1384 1391 ShouldNotReachHere();
1385 1392 return REGIONS_UNLIMITED;
1386 1393 };
1387 1394 }
1388 1395
1389 1396 void G1CollectorPolicy::update_max_gc_locker_expansion() {
1390 1397 uint expansion_region_num = 0;
1391 1398 if (GCLockerEdenExpansionPercent > 0) {
1392 1399 double perc = (double) GCLockerEdenExpansionPercent / 100.0;
1393 1400 double expansion_region_num_d = perc * (double) _young_list_target_length;
1394 1401 // We use ceiling so that if expansion_region_num_d is > 0.0 (but
1395 1402 // less than 1.0) we'll get 1.
1396 1403 expansion_region_num = (uint) ceil(expansion_region_num_d);
1397 1404 } else {
1398 1405 assert(expansion_region_num == 0, "sanity");
1399 1406 }
1400 1407 _young_list_max_length = _young_list_target_length + expansion_region_num;
1401 1408 assert(_young_list_target_length <= _young_list_max_length, "post-condition");
1402 1409 }
1403 1410
1404 1411 // Calculates survivor space parameters.
1405 1412 void G1CollectorPolicy::update_survivors_policy() {
1406 1413 double max_survivor_regions_d =
1407 1414 (double) _young_list_target_length / (double) SurvivorRatio;
1408 1415 // We use ceiling so that if max_survivor_regions_d is > 0.0 (but
1409 1416 // smaller than 1.0) we'll get 1.
1410 1417 _max_survivor_regions = (uint) ceil(max_survivor_regions_d);
1411 1418
1412 1419 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold(
1413 1420 HeapRegion::GrainWords * _max_survivor_regions);
1414 1421 }
1415 1422
1416 1423 bool G1CollectorPolicy::force_initial_mark_if_outside_cycle(
1417 1424 GCCause::Cause gc_cause) {
1418 1425 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle();
1419 1426 if (!during_cycle) {
1420 1427 ergo_verbose1(ErgoConcCycles,
1421 1428 "request concurrent cycle initiation",
1422 1429 ergo_format_reason("requested by GC cause")
1423 1430 ergo_format_str("GC cause"),
1424 1431 GCCause::to_string(gc_cause));
1425 1432 set_initiate_conc_mark_if_possible();
1426 1433 return true;
1427 1434 } else {
1428 1435 ergo_verbose1(ErgoConcCycles,
1429 1436 "do not request concurrent cycle initiation",
1430 1437 ergo_format_reason("concurrent cycle already in progress")
1431 1438 ergo_format_str("GC cause"),
1432 1439 GCCause::to_string(gc_cause));
1433 1440 return false;
1434 1441 }
1435 1442 }
1436 1443
1437 1444 void
1438 1445 G1CollectorPolicy::decide_on_conc_mark_initiation() {
1439 1446 // We are about to decide on whether this pause will be an
1440 1447 // initial-mark pause.
1441 1448
1442 1449 // First, during_initial_mark_pause() should not be already set. We
1443 1450 // will set it here if we have to. However, it should be cleared by
1444 1451 // the end of the pause (it's only set for the duration of an
1445 1452 // initial-mark pause).
1446 1453 assert(!during_initial_mark_pause(), "pre-condition");
1447 1454
1448 1455 if (initiate_conc_mark_if_possible()) {
1449 1456 // We had noticed on a previous pause that the heap occupancy has
1450 1457 // gone over the initiating threshold and we should start a
1451 1458 // concurrent marking cycle. So we might initiate one.
1452 1459
1453 1460 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle();
1454 1461 if (!during_cycle) {
1455 1462 // The concurrent marking thread is not "during a cycle", i.e.,
1456 1463 // it has completed the last one. So we can go ahead and
1457 1464 // initiate a new cycle.
1458 1465
1459 1466 set_during_initial_mark_pause();
1460 1467 // We do not allow mixed GCs during marking.
1461 1468 if (!gcs_are_young()) {
1462 1469 set_gcs_are_young(true);
1463 1470 ergo_verbose0(ErgoMixedGCs,
1464 1471 "end mixed GCs",
1465 1472 ergo_format_reason("concurrent cycle is about to start"));
1466 1473 }
1467 1474
1468 1475 // And we can now clear initiate_conc_mark_if_possible() as
1469 1476 // we've already acted on it.
1470 1477 clear_initiate_conc_mark_if_possible();
1471 1478
1472 1479 ergo_verbose0(ErgoConcCycles,
1473 1480 "initiate concurrent cycle",
1474 1481 ergo_format_reason("concurrent cycle initiation requested"));
1475 1482 } else {
1476 1483 // The concurrent marking thread is still finishing up the
1477 1484 // previous cycle. If we start one right now the two cycles
1478 1485 // overlap. In particular, the concurrent marking thread might
1479 1486 // be in the process of clearing the next marking bitmap (which
1480 1487 // we will use for the next cycle if we start one). Starting a
1481 1488 // cycle now will be bad given that parts of the marking
1482 1489 // information might get cleared by the marking thread. And we
1483 1490 // cannot wait for the marking thread to finish the cycle as it
1484 1491 // periodically yields while clearing the next marking bitmap
1485 1492 // and, if it's in a yield point, it's waiting for us to
1486 1493 // finish. So, at this point we will not start a cycle and we'll
1487 1494 // let the concurrent marking thread complete the last one.
1488 1495 ergo_verbose0(ErgoConcCycles,
1489 1496 "do not initiate concurrent cycle",
1490 1497 ergo_format_reason("concurrent cycle already in progress"));
1491 1498 }
1492 1499 }
1493 1500 }
1494 1501
1495 1502 class KnownGarbageClosure: public HeapRegionClosure {
1496 1503 G1CollectedHeap* _g1h;
1497 1504 CollectionSetChooser* _hrSorted;
1498 1505
1499 1506 public:
1500 1507 KnownGarbageClosure(CollectionSetChooser* hrSorted) :
1501 1508 _g1h(G1CollectedHeap::heap()), _hrSorted(hrSorted) { }
1502 1509
1503 1510 bool doHeapRegion(HeapRegion* r) {
1504 1511 // We only include humongous regions in collection
1505 1512 // sets when concurrent mark shows that their contained object is
1506 1513 // unreachable.
1507 1514
1508 1515 // Do we have any marking information for this region?
1509 1516 if (r->is_marked()) {
1510 1517 // We will skip any region that's currently used as an old GC
1511 1518 // alloc region (we should not consider those for collection
1512 1519 // before we fill them up).
1513 1520 if (_hrSorted->should_add(r) && !_g1h->is_old_gc_alloc_region(r)) {
1514 1521 _hrSorted->add_region(r);
1515 1522 }
1516 1523 }
1517 1524 return false;
1518 1525 }
1519 1526 };
1520 1527
1521 1528 class ParKnownGarbageHRClosure: public HeapRegionClosure {
1522 1529 G1CollectedHeap* _g1h;
1523 1530 CSetChooserParUpdater _cset_updater;
1524 1531
1525 1532 public:
1526 1533 ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted,
1527 1534 uint chunk_size) :
1528 1535 _g1h(G1CollectedHeap::heap()),
1529 1536 _cset_updater(hrSorted, true /* parallel */, chunk_size) { }
1530 1537
1531 1538 bool doHeapRegion(HeapRegion* r) {
1532 1539 // Do we have any marking information for this region?
1533 1540 if (r->is_marked()) {
1534 1541 // We will skip any region that's currently used as an old GC
1535 1542 // alloc region (we should not consider those for collection
1536 1543 // before we fill them up).
1537 1544 if (_cset_updater.should_add(r) && !_g1h->is_old_gc_alloc_region(r)) {
1538 1545 _cset_updater.add_region(r);
1539 1546 }
1540 1547 }
1541 1548 return false;
1542 1549 }
1543 1550 };
1544 1551
1545 1552 class ParKnownGarbageTask: public AbstractGangTask {
1546 1553 CollectionSetChooser* _hrSorted;
1547 1554 uint _chunk_size;
1548 1555 G1CollectedHeap* _g1;
1549 1556 public:
1550 1557 ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size) :
1551 1558 AbstractGangTask("ParKnownGarbageTask"),
1552 1559 _hrSorted(hrSorted), _chunk_size(chunk_size),
1553 1560 _g1(G1CollectedHeap::heap()) { }
1554 1561
1555 1562 void work(uint worker_id) {
1556 1563 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size);
1557 1564
1558 1565 // Back to zero for the claim value.
1559 1566 _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, worker_id,
1560 1567 _g1->workers()->active_workers(),
1561 1568 HeapRegion::InitialClaimValue);
1562 1569 }
1563 1570 };
1564 1571
1565 1572 void
1566 1573 G1CollectorPolicy::record_concurrent_mark_cleanup_end(int no_of_gc_threads) {
1567 1574 _collectionSetChooser->clear();
1568 1575
1569 1576 uint region_num = _g1->n_regions();
1570 1577 if (G1CollectedHeap::use_parallel_gc_threads()) {
1571 1578 const uint OverpartitionFactor = 4;
1572 1579 uint WorkUnit;
1573 1580 // The use of MinChunkSize = 8 in the original code
1574 1581 // causes some assertion failures when the total number of
1575 1582 // region is less than 8. The code here tries to fix that.
1576 1583 // Should the original code also be fixed?
1577 1584 if (no_of_gc_threads > 0) {
1578 1585 const uint MinWorkUnit = MAX2(region_num / no_of_gc_threads, 1U);
1579 1586 WorkUnit = MAX2(region_num / (no_of_gc_threads * OverpartitionFactor),
1580 1587 MinWorkUnit);
1581 1588 } else {
1582 1589 assert(no_of_gc_threads > 0,
1583 1590 "The active gc workers should be greater than 0");
1584 1591 // In a product build do something reasonable to avoid a crash.
1585 1592 const uint MinWorkUnit = MAX2(region_num / (uint) ParallelGCThreads, 1U);
1586 1593 WorkUnit =
1587 1594 MAX2(region_num / (uint) (ParallelGCThreads * OverpartitionFactor),
1588 1595 MinWorkUnit);
1589 1596 }
1590 1597 _collectionSetChooser->prepare_for_par_region_addition(_g1->n_regions(),
1591 1598 WorkUnit);
1592 1599 ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser,
1593 1600 (int) WorkUnit);
1594 1601 _g1->workers()->run_task(&parKnownGarbageTask);
1595 1602
1596 1603 assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
1597 1604 "sanity check");
1598 1605 } else {
1599 1606 KnownGarbageClosure knownGarbagecl(_collectionSetChooser);
1600 1607 _g1->heap_region_iterate(&knownGarbagecl);
1601 1608 }
1602 1609
1603 1610 _collectionSetChooser->sort_regions();
1604 1611
1605 1612 double end_sec = os::elapsedTime();
1606 1613 double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0;
1607 1614 _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms);
1608 1615 _cur_mark_stop_world_time_ms += elapsed_time_ms;
1609 1616 _prev_collection_pause_end_ms += elapsed_time_ms;
1610 1617 _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_sec, true);
1611 1618 }
1612 1619
1613 1620 // Add the heap region at the head of the non-incremental collection set
1614 1621 void G1CollectorPolicy::add_old_region_to_cset(HeapRegion* hr) {
1615 1622 assert(_inc_cset_build_state == Active, "Precondition");
1616 1623 assert(!hr->is_young(), "non-incremental add of young region");
1617 1624
1618 1625 assert(!hr->in_collection_set(), "should not already be in the CSet");
1619 1626 hr->set_in_collection_set(true);
1620 1627 hr->set_next_in_collection_set(_collection_set);
1621 1628 _collection_set = hr;
1622 1629 _collection_set_bytes_used_before += hr->used();
1623 1630 _g1->register_region_with_in_cset_fast_test(hr);
1624 1631 size_t rs_length = hr->rem_set()->occupied();
1625 1632 _recorded_rs_lengths += rs_length;
1626 1633 _old_cset_region_length += 1;
1627 1634 }
1628 1635
1629 1636 // Initialize the per-collection-set information
1630 1637 void G1CollectorPolicy::start_incremental_cset_building() {
1631 1638 assert(_inc_cset_build_state == Inactive, "Precondition");
1632 1639
1633 1640 _inc_cset_head = NULL;
1634 1641 _inc_cset_tail = NULL;
1635 1642 _inc_cset_bytes_used_before = 0;
1636 1643
1637 1644 _inc_cset_max_finger = 0;
1638 1645 _inc_cset_recorded_rs_lengths = 0;
1639 1646 _inc_cset_recorded_rs_lengths_diffs = 0;
1640 1647 _inc_cset_predicted_elapsed_time_ms = 0.0;
1641 1648 _inc_cset_predicted_elapsed_time_ms_diffs = 0.0;
1642 1649 _inc_cset_build_state = Active;
1643 1650 }
1644 1651
1645 1652 void G1CollectorPolicy::finalize_incremental_cset_building() {
1646 1653 assert(_inc_cset_build_state == Active, "Precondition");
1647 1654 assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint");
1648 1655
1649 1656 // The two "main" fields, _inc_cset_recorded_rs_lengths and
1650 1657 // _inc_cset_predicted_elapsed_time_ms, are updated by the thread
1651 1658 // that adds a new region to the CSet. Further updates by the
1652 1659 // concurrent refinement thread that samples the young RSet lengths
1653 1660 // are accumulated in the *_diffs fields. Here we add the diffs to
1654 1661 // the "main" fields.
1655 1662
1656 1663 if (_inc_cset_recorded_rs_lengths_diffs >= 0) {
1657 1664 _inc_cset_recorded_rs_lengths += _inc_cset_recorded_rs_lengths_diffs;
1658 1665 } else {
1659 1666 // This is defensive. The diff should in theory be always positive
1660 1667 // as RSets can only grow between GCs. However, given that we
1661 1668 // sample their size concurrently with other threads updating them
1662 1669 // it's possible that we might get the wrong size back, which
1663 1670 // could make the calculations somewhat inaccurate.
1664 1671 size_t diffs = (size_t) (-_inc_cset_recorded_rs_lengths_diffs);
1665 1672 if (_inc_cset_recorded_rs_lengths >= diffs) {
1666 1673 _inc_cset_recorded_rs_lengths -= diffs;
1667 1674 } else {
1668 1675 _inc_cset_recorded_rs_lengths = 0;
1669 1676 }
1670 1677 }
1671 1678 _inc_cset_predicted_elapsed_time_ms +=
1672 1679 _inc_cset_predicted_elapsed_time_ms_diffs;
1673 1680
1674 1681 _inc_cset_recorded_rs_lengths_diffs = 0;
1675 1682 _inc_cset_predicted_elapsed_time_ms_diffs = 0.0;
1676 1683 }
1677 1684
1678 1685 void G1CollectorPolicy::add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length) {
1679 1686 // This routine is used when:
1680 1687 // * adding survivor regions to the incremental cset at the end of an
1681 1688 // evacuation pause,
1682 1689 // * adding the current allocation region to the incremental cset
1683 1690 // when it is retired, and
1684 1691 // * updating existing policy information for a region in the
1685 1692 // incremental cset via young list RSet sampling.
1686 1693 // Therefore this routine may be called at a safepoint by the
1687 1694 // VM thread, or in-between safepoints by mutator threads (when
1688 1695 // retiring the current allocation region) or a concurrent
1689 1696 // refine thread (RSet sampling).
1690 1697
1691 1698 double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young());
1692 1699 size_t used_bytes = hr->used();
1693 1700 _inc_cset_recorded_rs_lengths += rs_length;
1694 1701 _inc_cset_predicted_elapsed_time_ms += region_elapsed_time_ms;
1695 1702 _inc_cset_bytes_used_before += used_bytes;
1696 1703
1697 1704 // Cache the values we have added to the aggregated informtion
1698 1705 // in the heap region in case we have to remove this region from
1699 1706 // the incremental collection set, or it is updated by the
1700 1707 // rset sampling code
1701 1708 hr->set_recorded_rs_length(rs_length);
1702 1709 hr->set_predicted_elapsed_time_ms(region_elapsed_time_ms);
1703 1710 }
1704 1711
1705 1712 void G1CollectorPolicy::update_incremental_cset_info(HeapRegion* hr,
1706 1713 size_t new_rs_length) {
1707 1714 // Update the CSet information that is dependent on the new RS length
1708 1715 assert(hr->is_young(), "Precondition");
1709 1716 assert(!SafepointSynchronize::is_at_safepoint(),
1710 1717 "should not be at a safepoint");
1711 1718
1712 1719 // We could have updated _inc_cset_recorded_rs_lengths and
1713 1720 // _inc_cset_predicted_elapsed_time_ms directly but we'd need to do
1714 1721 // that atomically, as this code is executed by a concurrent
1715 1722 // refinement thread, potentially concurrently with a mutator thread
1716 1723 // allocating a new region and also updating the same fields. To
1717 1724 // avoid the atomic operations we accumulate these updates on two
1718 1725 // separate fields (*_diffs) and we'll just add them to the "main"
1719 1726 // fields at the start of a GC.
1720 1727
1721 1728 ssize_t old_rs_length = (ssize_t) hr->recorded_rs_length();
1722 1729 ssize_t rs_lengths_diff = (ssize_t) new_rs_length - old_rs_length;
1723 1730 _inc_cset_recorded_rs_lengths_diffs += rs_lengths_diff;
1724 1731
1725 1732 double old_elapsed_time_ms = hr->predicted_elapsed_time_ms();
1726 1733 double new_region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young());
1727 1734 double elapsed_ms_diff = new_region_elapsed_time_ms - old_elapsed_time_ms;
1728 1735 _inc_cset_predicted_elapsed_time_ms_diffs += elapsed_ms_diff;
1729 1736
1730 1737 hr->set_recorded_rs_length(new_rs_length);
1731 1738 hr->set_predicted_elapsed_time_ms(new_region_elapsed_time_ms);
1732 1739 }
1733 1740
1734 1741 void G1CollectorPolicy::add_region_to_incremental_cset_common(HeapRegion* hr) {
1735 1742 assert(hr->is_young(), "invariant");
1736 1743 assert(hr->young_index_in_cset() > -1, "should have already been set");
1737 1744 assert(_inc_cset_build_state == Active, "Precondition");
1738 1745
1739 1746 // We need to clear and set the cached recorded/cached collection set
1740 1747 // information in the heap region here (before the region gets added
1741 1748 // to the collection set). An individual heap region's cached values
1742 1749 // are calculated, aggregated with the policy collection set info,
1743 1750 // and cached in the heap region here (initially) and (subsequently)
1744 1751 // by the Young List sampling code.
1745 1752
1746 1753 size_t rs_length = hr->rem_set()->occupied();
1747 1754 add_to_incremental_cset_info(hr, rs_length);
1748 1755
1749 1756 HeapWord* hr_end = hr->end();
1750 1757 _inc_cset_max_finger = MAX2(_inc_cset_max_finger, hr_end);
1751 1758
1752 1759 assert(!hr->in_collection_set(), "invariant");
1753 1760 hr->set_in_collection_set(true);
1754 1761 assert( hr->next_in_collection_set() == NULL, "invariant");
1755 1762
1756 1763 _g1->register_region_with_in_cset_fast_test(hr);
1757 1764 }
1758 1765
1759 1766 // Add the region at the RHS of the incremental cset
1760 1767 void G1CollectorPolicy::add_region_to_incremental_cset_rhs(HeapRegion* hr) {
1761 1768 // We should only ever be appending survivors at the end of a pause
1762 1769 assert( hr->is_survivor(), "Logic");
1763 1770
1764 1771 // Do the 'common' stuff
1765 1772 add_region_to_incremental_cset_common(hr);
1766 1773
1767 1774 // Now add the region at the right hand side
1768 1775 if (_inc_cset_tail == NULL) {
1769 1776 assert(_inc_cset_head == NULL, "invariant");
1770 1777 _inc_cset_head = hr;
1771 1778 } else {
1772 1779 _inc_cset_tail->set_next_in_collection_set(hr);
1773 1780 }
1774 1781 _inc_cset_tail = hr;
1775 1782 }
1776 1783
1777 1784 // Add the region to the LHS of the incremental cset
1778 1785 void G1CollectorPolicy::add_region_to_incremental_cset_lhs(HeapRegion* hr) {
1779 1786 // Survivors should be added to the RHS at the end of a pause
1780 1787 assert(!hr->is_survivor(), "Logic");
1781 1788
1782 1789 // Do the 'common' stuff
1783 1790 add_region_to_incremental_cset_common(hr);
1784 1791
1785 1792 // Add the region at the left hand side
1786 1793 hr->set_next_in_collection_set(_inc_cset_head);
1787 1794 if (_inc_cset_head == NULL) {
1788 1795 assert(_inc_cset_tail == NULL, "Invariant");
1789 1796 _inc_cset_tail = hr;
1790 1797 }
1791 1798 _inc_cset_head = hr;
1792 1799 }
1793 1800
1794 1801 #ifndef PRODUCT
1795 1802 void G1CollectorPolicy::print_collection_set(HeapRegion* list_head, outputStream* st) {
1796 1803 assert(list_head == inc_cset_head() || list_head == collection_set(), "must be");
1797 1804
1798 1805 st->print_cr("\nCollection_set:");
1799 1806 HeapRegion* csr = list_head;
1800 1807 while (csr != NULL) {
1801 1808 HeapRegion* next = csr->next_in_collection_set();
1802 1809 assert(csr->in_collection_set(), "bad CS");
1803 1810 st->print_cr(" "HR_FORMAT", P: "PTR_FORMAT "N: "PTR_FORMAT", age: %4d",
1804 1811 HR_FORMAT_PARAMS(csr),
1805 1812 csr->prev_top_at_mark_start(), csr->next_top_at_mark_start(),
1806 1813 csr->age_in_surv_rate_group_cond());
1807 1814 csr = next;
1808 1815 }
1809 1816 }
1810 1817 #endif // !PRODUCT
1811 1818
1812 1819 double G1CollectorPolicy::reclaimable_bytes_perc(size_t reclaimable_bytes) {
1813 1820 // Returns the given amount of reclaimable bytes (that represents
1814 1821 // the amount of reclaimable space still to be collected) as a
1815 1822 // percentage of the current heap capacity.
1816 1823 size_t capacity_bytes = _g1->capacity();
1817 1824 return (double) reclaimable_bytes * 100.0 / (double) capacity_bytes;
1818 1825 }
1819 1826
1820 1827 bool G1CollectorPolicy::next_gc_should_be_mixed(const char* true_action_str,
1821 1828 const char* false_action_str) {
1822 1829 CollectionSetChooser* cset_chooser = _collectionSetChooser;
1823 1830 if (cset_chooser->is_empty()) {
1824 1831 ergo_verbose0(ErgoMixedGCs,
1825 1832 false_action_str,
1826 1833 ergo_format_reason("candidate old regions not available"));
1827 1834 return false;
1828 1835 }
1829 1836
1830 1837 // Is the amount of uncollected reclaimable space above G1HeapWastePercent?
1831 1838 size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes();
1832 1839 double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes);
1833 1840 double threshold = (double) G1HeapWastePercent;
1834 1841 if (reclaimable_perc <= threshold) {
1835 1842 ergo_verbose4(ErgoMixedGCs,
1836 1843 false_action_str,
1837 1844 ergo_format_reason("reclaimable percentage not over threshold")
1838 1845 ergo_format_region("candidate old regions")
1839 1846 ergo_format_byte_perc("reclaimable")
1840 1847 ergo_format_perc("threshold"),
1841 1848 cset_chooser->remaining_regions(),
1842 1849 reclaimable_bytes,
1843 1850 reclaimable_perc, threshold);
1844 1851 return false;
1845 1852 }
1846 1853
1847 1854 ergo_verbose4(ErgoMixedGCs,
1848 1855 true_action_str,
1849 1856 ergo_format_reason("candidate old regions available")
1850 1857 ergo_format_region("candidate old regions")
1851 1858 ergo_format_byte_perc("reclaimable")
1852 1859 ergo_format_perc("threshold"),
1853 1860 cset_chooser->remaining_regions(),
1854 1861 reclaimable_bytes,
1855 1862 reclaimable_perc, threshold);
1856 1863 return true;
1857 1864 }
1858 1865
1859 1866 uint G1CollectorPolicy::calc_min_old_cset_length() {
1860 1867 // The min old CSet region bound is based on the maximum desired
1861 1868 // number of mixed GCs after a cycle. I.e., even if some old regions
1862 1869 // look expensive, we should add them to the CSet anyway to make
1863 1870 // sure we go through the available old regions in no more than the
1864 1871 // maximum desired number of mixed GCs.
1865 1872 //
1866 1873 // The calculation is based on the number of marked regions we added
1867 1874 // to the CSet chooser in the first place, not how many remain, so
1868 1875 // that the result is the same during all mixed GCs that follow a cycle.
1869 1876
1870 1877 const size_t region_num = (size_t) _collectionSetChooser->length();
1871 1878 const size_t gc_num = (size_t) MAX2(G1MixedGCCountTarget, (uintx) 1);
1872 1879 size_t result = region_num / gc_num;
1873 1880 // emulate ceiling
1874 1881 if (result * gc_num < region_num) {
1875 1882 result += 1;
1876 1883 }
1877 1884 return (uint) result;
1878 1885 }
1879 1886
1880 1887 uint G1CollectorPolicy::calc_max_old_cset_length() {
1881 1888 // The max old CSet region bound is based on the threshold expressed
1882 1889 // as a percentage of the heap size. I.e., it should bound the
1883 1890 // number of old regions added to the CSet irrespective of how many
1884 1891 // of them are available.
1885 1892
1886 1893 G1CollectedHeap* g1h = G1CollectedHeap::heap();
1887 1894 const size_t region_num = g1h->n_regions();
1888 1895 const size_t perc = (size_t) G1OldCSetRegionThresholdPercent;
1889 1896 size_t result = region_num * perc / 100;
1890 1897 // emulate ceiling
1891 1898 if (100 * result < region_num * perc) {
1892 1899 result += 1;
1893 1900 }
1894 1901 return (uint) result;
1895 1902 }
1896 1903
1897 1904 void G1CollectorPolicy::finalize_cset(double target_pause_time_ms, EvacuationInfo& evacuation_info) {
1898 1905 double young_start_time_sec = os::elapsedTime();
1899 1906
1900 1907 YoungList* young_list = _g1->young_list();
1901 1908 finalize_incremental_cset_building();
1902 1909
1903 1910 guarantee(target_pause_time_ms > 0.0,
1904 1911 err_msg("target_pause_time_ms = %1.6lf should be positive",
1905 1912 target_pause_time_ms));
1906 1913 guarantee(_collection_set == NULL, "Precondition");
1907 1914
1908 1915 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards);
1909 1916 double predicted_pause_time_ms = base_time_ms;
1910 1917 double time_remaining_ms = MAX2(target_pause_time_ms - base_time_ms, 0.0);
1911 1918
1912 1919 ergo_verbose4(ErgoCSetConstruction | ErgoHigh,
1913 1920 "start choosing CSet",
1914 1921 ergo_format_size("_pending_cards")
1915 1922 ergo_format_ms("predicted base time")
1916 1923 ergo_format_ms("remaining time")
1917 1924 ergo_format_ms("target pause time"),
1918 1925 _pending_cards, base_time_ms, time_remaining_ms, target_pause_time_ms);
1919 1926
1920 1927 _last_gc_was_young = gcs_are_young() ? true : false;
1921 1928
1922 1929 if (_last_gc_was_young) {
1923 1930 _trace_gen0_time_data.increment_young_collection_count();
1924 1931 } else {
1925 1932 _trace_gen0_time_data.increment_mixed_collection_count();
1926 1933 }
1927 1934
1928 1935 // The young list is laid with the survivor regions from the previous
1929 1936 // pause are appended to the RHS of the young list, i.e.
1930 1937 // [Newly Young Regions ++ Survivors from last pause].
1931 1938
1932 1939 uint survivor_region_length = young_list->survivor_length();
1933 1940 uint eden_region_length = young_list->length() - survivor_region_length;
1934 1941 init_cset_region_lengths(eden_region_length, survivor_region_length);
1935 1942
1936 1943 HeapRegion* hr = young_list->first_survivor_region();
1937 1944 while (hr != NULL) {
1938 1945 assert(hr->is_survivor(), "badly formed young list");
1939 1946 hr->set_young();
1940 1947 hr = hr->get_next_young_region();
1941 1948 }
1942 1949
1943 1950 // Clear the fields that point to the survivor list - they are all young now.
1944 1951 young_list->clear_survivors();
1945 1952
1946 1953 _collection_set = _inc_cset_head;
1947 1954 _collection_set_bytes_used_before = _inc_cset_bytes_used_before;
1948 1955 time_remaining_ms = MAX2(time_remaining_ms - _inc_cset_predicted_elapsed_time_ms, 0.0);
1949 1956 predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms;
1950 1957
1951 1958 ergo_verbose3(ErgoCSetConstruction | ErgoHigh,
1952 1959 "add young regions to CSet",
1953 1960 ergo_format_region("eden")
1954 1961 ergo_format_region("survivors")
1955 1962 ergo_format_ms("predicted young region time"),
1956 1963 eden_region_length, survivor_region_length,
1957 1964 _inc_cset_predicted_elapsed_time_ms);
1958 1965
1959 1966 // The number of recorded young regions is the incremental
1960 1967 // collection set's current size
1961 1968 set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths);
1962 1969
1963 1970 double young_end_time_sec = os::elapsedTime();
1964 1971 phase_times()->record_young_cset_choice_time_ms((young_end_time_sec - young_start_time_sec) * 1000.0);
1965 1972
1966 1973 // Set the start of the non-young choice time.
1967 1974 double non_young_start_time_sec = young_end_time_sec;
1968 1975
1969 1976 if (!gcs_are_young()) {
1970 1977 CollectionSetChooser* cset_chooser = _collectionSetChooser;
1971 1978 cset_chooser->verify();
1972 1979 const uint min_old_cset_length = calc_min_old_cset_length();
1973 1980 const uint max_old_cset_length = calc_max_old_cset_length();
1974 1981
1975 1982 uint expensive_region_num = 0;
1976 1983 bool check_time_remaining = adaptive_young_list_length();
1977 1984
1978 1985 HeapRegion* hr = cset_chooser->peek();
1979 1986 while (hr != NULL) {
1980 1987 if (old_cset_region_length() >= max_old_cset_length) {
1981 1988 // Added maximum number of old regions to the CSet.
1982 1989 ergo_verbose2(ErgoCSetConstruction,
1983 1990 "finish adding old regions to CSet",
1984 1991 ergo_format_reason("old CSet region num reached max")
1985 1992 ergo_format_region("old")
1986 1993 ergo_format_region("max"),
1987 1994 old_cset_region_length(), max_old_cset_length);
1988 1995 break;
1989 1996 }
1990 1997
1991 1998
1992 1999 // Stop adding regions if the remaining reclaimable space is
1993 2000 // not above G1HeapWastePercent.
1994 2001 size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes();
1995 2002 double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes);
1996 2003 double threshold = (double) G1HeapWastePercent;
1997 2004 if (reclaimable_perc <= threshold) {
1998 2005 // We've added enough old regions that the amount of uncollected
1999 2006 // reclaimable space is at or below the waste threshold. Stop
2000 2007 // adding old regions to the CSet.
2001 2008 ergo_verbose5(ErgoCSetConstruction,
2002 2009 "finish adding old regions to CSet",
2003 2010 ergo_format_reason("reclaimable percentage not over threshold")
2004 2011 ergo_format_region("old")
2005 2012 ergo_format_region("max")
2006 2013 ergo_format_byte_perc("reclaimable")
2007 2014 ergo_format_perc("threshold"),
2008 2015 old_cset_region_length(),
2009 2016 max_old_cset_length,
2010 2017 reclaimable_bytes,
2011 2018 reclaimable_perc, threshold);
2012 2019 break;
2013 2020 }
2014 2021
2015 2022 double predicted_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young());
2016 2023 if (check_time_remaining) {
2017 2024 if (predicted_time_ms > time_remaining_ms) {
2018 2025 // Too expensive for the current CSet.
2019 2026
2020 2027 if (old_cset_region_length() >= min_old_cset_length) {
2021 2028 // We have added the minimum number of old regions to the CSet,
2022 2029 // we are done with this CSet.
2023 2030 ergo_verbose4(ErgoCSetConstruction,
2024 2031 "finish adding old regions to CSet",
2025 2032 ergo_format_reason("predicted time is too high")
2026 2033 ergo_format_ms("predicted time")
2027 2034 ergo_format_ms("remaining time")
2028 2035 ergo_format_region("old")
2029 2036 ergo_format_region("min"),
2030 2037 predicted_time_ms, time_remaining_ms,
2031 2038 old_cset_region_length(), min_old_cset_length);
2032 2039 break;
2033 2040 }
2034 2041
2035 2042 // We'll add it anyway given that we haven't reached the
2036 2043 // minimum number of old regions.
2037 2044 expensive_region_num += 1;
2038 2045 }
2039 2046 } else {
2040 2047 if (old_cset_region_length() >= min_old_cset_length) {
2041 2048 // In the non-auto-tuning case, we'll finish adding regions
2042 2049 // to the CSet if we reach the minimum.
2043 2050 ergo_verbose2(ErgoCSetConstruction,
2044 2051 "finish adding old regions to CSet",
2045 2052 ergo_format_reason("old CSet region num reached min")
2046 2053 ergo_format_region("old")
2047 2054 ergo_format_region("min"),
2048 2055 old_cset_region_length(), min_old_cset_length);
2049 2056 break;
2050 2057 }
2051 2058 }
2052 2059
2053 2060 // We will add this region to the CSet.
2054 2061 time_remaining_ms = MAX2(time_remaining_ms - predicted_time_ms, 0.0);
2055 2062 predicted_pause_time_ms += predicted_time_ms;
2056 2063 cset_chooser->remove_and_move_to_next(hr);
2057 2064 _g1->old_set_remove(hr);
2058 2065 add_old_region_to_cset(hr);
2059 2066
2060 2067 hr = cset_chooser->peek();
2061 2068 }
2062 2069 if (hr == NULL) {
2063 2070 ergo_verbose0(ErgoCSetConstruction,
2064 2071 "finish adding old regions to CSet",
2065 2072 ergo_format_reason("candidate old regions not available"));
2066 2073 }
2067 2074
2068 2075 if (expensive_region_num > 0) {
2069 2076 // We print the information once here at the end, predicated on
2070 2077 // whether we added any apparently expensive regions or not, to
2071 2078 // avoid generating output per region.
2072 2079 ergo_verbose4(ErgoCSetConstruction,
2073 2080 "added expensive regions to CSet",
2074 2081 ergo_format_reason("old CSet region num not reached min")
2075 2082 ergo_format_region("old")
2076 2083 ergo_format_region("expensive")
2077 2084 ergo_format_region("min")
2078 2085 ergo_format_ms("remaining time"),
2079 2086 old_cset_region_length(),
2080 2087 expensive_region_num,
2081 2088 min_old_cset_length,
2082 2089 time_remaining_ms);
2083 2090 }
2084 2091
2085 2092 cset_chooser->verify();
2086 2093 }
2087 2094
2088 2095 stop_incremental_cset_building();
2089 2096
2090 2097 ergo_verbose5(ErgoCSetConstruction,
2091 2098 "finish choosing CSet",
2092 2099 ergo_format_region("eden")
2093 2100 ergo_format_region("survivors")
2094 2101 ergo_format_region("old")
2095 2102 ergo_format_ms("predicted pause time")
2096 2103 ergo_format_ms("target pause time"),
2097 2104 eden_region_length, survivor_region_length,
2098 2105 old_cset_region_length(),
2099 2106 predicted_pause_time_ms, target_pause_time_ms);
2100 2107
2101 2108 double non_young_end_time_sec = os::elapsedTime();
2102 2109 phase_times()->record_non_young_cset_choice_time_ms((non_young_end_time_sec - non_young_start_time_sec) * 1000.0);
2103 2110 evacuation_info.set_collectionset_regions(cset_region_length());
2104 2111 }
2105 2112
2106 2113 void TraceGen0TimeData::record_start_collection(double time_to_stop_the_world_ms) {
2107 2114 if(TraceGen0Time) {
2108 2115 _all_stop_world_times_ms.add(time_to_stop_the_world_ms);
2109 2116 }
2110 2117 }
2111 2118
2112 2119 void TraceGen0TimeData::record_yield_time(double yield_time_ms) {
2113 2120 if(TraceGen0Time) {
2114 2121 _all_yield_times_ms.add(yield_time_ms);
2115 2122 }
2116 2123 }
2117 2124
2118 2125 void TraceGen0TimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) {
2119 2126 if(TraceGen0Time) {
2120 2127 _total.add(pause_time_ms);
2121 2128 _other.add(pause_time_ms - phase_times->accounted_time_ms());
2122 2129 _root_region_scan_wait.add(phase_times->root_region_scan_wait_time_ms());
2123 2130 _parallel.add(phase_times->cur_collection_par_time_ms());
2124 2131 _ext_root_scan.add(phase_times->average_last_ext_root_scan_time());
2125 2132 _satb_filtering.add(phase_times->average_last_satb_filtering_times_ms());
2126 2133 _update_rs.add(phase_times->average_last_update_rs_time());
2127 2134 _scan_rs.add(phase_times->average_last_scan_rs_time());
2128 2135 _obj_copy.add(phase_times->average_last_obj_copy_time());
2129 2136 _termination.add(phase_times->average_last_termination_time());
2130 2137
2131 2138 double parallel_known_time = phase_times->average_last_ext_root_scan_time() +
2132 2139 phase_times->average_last_satb_filtering_times_ms() +
2133 2140 phase_times->average_last_update_rs_time() +
2134 2141 phase_times->average_last_scan_rs_time() +
2135 2142 phase_times->average_last_obj_copy_time() +
2136 2143 + phase_times->average_last_termination_time();
2137 2144
2138 2145 double parallel_other_time = phase_times->cur_collection_par_time_ms() - parallel_known_time;
2139 2146 _parallel_other.add(parallel_other_time);
2140 2147 _clear_ct.add(phase_times->cur_clear_ct_time_ms());
2141 2148 }
2142 2149 }
2143 2150
2144 2151 void TraceGen0TimeData::increment_young_collection_count() {
2145 2152 if(TraceGen0Time) {
2146 2153 ++_young_pause_num;
2147 2154 }
2148 2155 }
2149 2156
2150 2157 void TraceGen0TimeData::increment_mixed_collection_count() {
2151 2158 if(TraceGen0Time) {
2152 2159 ++_mixed_pause_num;
2153 2160 }
2154 2161 }
2155 2162
2156 2163 void TraceGen0TimeData::print_summary(const char* str,
2157 2164 const NumberSeq* seq) const {
2158 2165 double sum = seq->sum();
2159 2166 gclog_or_tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)",
2160 2167 str, sum / 1000.0, seq->avg());
2161 2168 }
2162 2169
2163 2170 void TraceGen0TimeData::print_summary_sd(const char* str,
2164 2171 const NumberSeq* seq) const {
2165 2172 print_summary(str, seq);
2166 2173 gclog_or_tty->print_cr("%+45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)",
2167 2174 "(num", seq->num(), seq->sd(), seq->maximum());
2168 2175 }
2169 2176
2170 2177 void TraceGen0TimeData::print() const {
2171 2178 if (!TraceGen0Time) {
2172 2179 return;
2173 2180 }
2174 2181
2175 2182 gclog_or_tty->print_cr("ALL PAUSES");
2176 2183 print_summary_sd(" Total", &_total);
2177 2184 gclog_or_tty->print_cr("");
2178 2185 gclog_or_tty->print_cr("");
2179 2186 gclog_or_tty->print_cr(" Young GC Pauses: %8d", _young_pause_num);
2180 2187 gclog_or_tty->print_cr(" Mixed GC Pauses: %8d", _mixed_pause_num);
2181 2188 gclog_or_tty->print_cr("");
2182 2189
2183 2190 gclog_or_tty->print_cr("EVACUATION PAUSES");
2184 2191
2185 2192 if (_young_pause_num == 0 && _mixed_pause_num == 0) {
2186 2193 gclog_or_tty->print_cr("none");
2187 2194 } else {
2188 2195 print_summary_sd(" Evacuation Pauses", &_total);
2189 2196 print_summary(" Root Region Scan Wait", &_root_region_scan_wait);
2190 2197 print_summary(" Parallel Time", &_parallel);
2191 2198 print_summary(" Ext Root Scanning", &_ext_root_scan);
2192 2199 print_summary(" SATB Filtering", &_satb_filtering);
2193 2200 print_summary(" Update RS", &_update_rs);
2194 2201 print_summary(" Scan RS", &_scan_rs);
2195 2202 print_summary(" Object Copy", &_obj_copy);
2196 2203 print_summary(" Termination", &_termination);
2197 2204 print_summary(" Parallel Other", &_parallel_other);
2198 2205 print_summary(" Clear CT", &_clear_ct);
2199 2206 print_summary(" Other", &_other);
2200 2207 }
2201 2208 gclog_or_tty->print_cr("");
2202 2209
2203 2210 gclog_or_tty->print_cr("MISC");
2204 2211 print_summary_sd(" Stop World", &_all_stop_world_times_ms);
2205 2212 print_summary_sd(" Yields", &_all_yield_times_ms);
2206 2213 }
2207 2214
2208 2215 void TraceGen1TimeData::record_full_collection(double full_gc_time_ms) {
2209 2216 if (TraceGen1Time) {
2210 2217 _all_full_gc_times.add(full_gc_time_ms);
2211 2218 }
2212 2219 }
2213 2220
2214 2221 void TraceGen1TimeData::print() const {
2215 2222 if (!TraceGen1Time) {
2216 2223 return;
2217 2224 }
2218 2225
2219 2226 if (_all_full_gc_times.num() > 0) {
2220 2227 gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s",
2221 2228 _all_full_gc_times.num(),
2222 2229 _all_full_gc_times.sum() / 1000.0);
2223 2230 gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times.avg());
2224 2231 gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]",
2225 2232 _all_full_gc_times.sd(),
2226 2233 _all_full_gc_times.maximum());
2227 2234 }
2228 2235 }
|
↓ open down ↓ |
1028 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX