Fri, 12 Aug 2011 11:31:06 -0400
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
Summary: Refactor the allocation code during GC to use the G1AllocRegion abstraction. Use separate subclasses of G1AllocRegion for survivor and old regions. Avoid BOT updates and dirty survivor cards incrementally for the former.
Reviewed-by: brutisso, johnc, ysr
1 /*
2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP
28 #include "gc_implementation/g1/collectionSetChooser.hpp"
29 #include "gc_implementation/g1/g1MMUTracker.hpp"
30 #include "memory/collectorPolicy.hpp"
32 // A G1CollectorPolicy makes policy decisions that determine the
33 // characteristics of the collector. Examples include:
34 // * choice of collection set.
35 // * when to collect.
37 class HeapRegion;
38 class CollectionSetChooser;
40 // Yes, this is a bit unpleasant... but it saves replicating the same thing
41 // over and over again and introducing subtle problems through small typos and
42 // cutting and pasting mistakes. The macros below introduces a number
43 // sequnce into the following two classes and the methods that access it.
45 #define define_num_seq(name) \
46 private: \
47 NumberSeq _all_##name##_times_ms; \
48 public: \
49 void record_##name##_time_ms(double ms) { \
50 _all_##name##_times_ms.add(ms); \
51 } \
52 NumberSeq* get_##name##_seq() { \
53 return &_all_##name##_times_ms; \
54 }
56 class MainBodySummary;
58 class PauseSummary: public CHeapObj {
59 define_num_seq(total)
60 define_num_seq(other)
62 public:
63 virtual MainBodySummary* main_body_summary() { return NULL; }
64 };
66 class MainBodySummary: public CHeapObj {
67 define_num_seq(satb_drain) // optional
68 define_num_seq(parallel) // parallel only
69 define_num_seq(ext_root_scan)
70 define_num_seq(mark_stack_scan)
71 define_num_seq(update_rs)
72 define_num_seq(scan_rs)
73 define_num_seq(obj_copy)
74 define_num_seq(termination) // parallel only
75 define_num_seq(parallel_other) // parallel only
76 define_num_seq(mark_closure)
77 define_num_seq(clear_ct) // parallel only
78 };
80 class Summary: public PauseSummary,
81 public MainBodySummary {
82 public:
83 virtual MainBodySummary* main_body_summary() { return this; }
84 };
86 class G1CollectorPolicy: public CollectorPolicy {
87 protected:
88 // The number of pauses during the execution.
89 long _n_pauses;
91 // either equal to the number of parallel threads, if ParallelGCThreads
92 // has been set, or 1 otherwise
93 int _parallel_gc_threads;
95 enum SomePrivateConstants {
96 NumPrevPausesForHeuristics = 10
97 };
99 G1MMUTracker* _mmu_tracker;
101 void initialize_flags();
103 void initialize_all() {
104 initialize_flags();
105 initialize_size_info();
106 initialize_perm_generation(PermGen::MarkSweepCompact);
107 }
109 virtual size_t default_init_heap_size() {
110 // Pick some reasonable default.
111 return 8*M;
112 }
114 double _cur_collection_start_sec;
115 size_t _cur_collection_pause_used_at_start_bytes;
116 size_t _cur_collection_pause_used_regions_at_start;
117 size_t _prev_collection_pause_used_at_end_bytes;
118 double _cur_collection_par_time_ms;
119 double _cur_satb_drain_time_ms;
120 double _cur_clear_ct_time_ms;
121 bool _satb_drain_time_set;
123 #ifndef PRODUCT
124 // Card Table Count Cache stats
125 double _min_clear_cc_time_ms; // min
126 double _max_clear_cc_time_ms; // max
127 double _cur_clear_cc_time_ms; // clearing time during current pause
128 double _cum_clear_cc_time_ms; // cummulative clearing time
129 jlong _num_cc_clears; // number of times the card count cache has been cleared
130 #endif
132 // Statistics for recent GC pauses. See below for how indexed.
133 TruncatedSeq* _recent_rs_scan_times_ms;
135 // These exclude marking times.
136 TruncatedSeq* _recent_pause_times_ms;
137 TruncatedSeq* _recent_gc_times_ms;
139 TruncatedSeq* _recent_CS_bytes_used_before;
140 TruncatedSeq* _recent_CS_bytes_surviving;
142 TruncatedSeq* _recent_rs_sizes;
144 TruncatedSeq* _concurrent_mark_init_times_ms;
145 TruncatedSeq* _concurrent_mark_remark_times_ms;
146 TruncatedSeq* _concurrent_mark_cleanup_times_ms;
148 Summary* _summary;
150 NumberSeq* _all_pause_times_ms;
151 NumberSeq* _all_full_gc_times_ms;
152 double _stop_world_start;
153 NumberSeq* _all_stop_world_times_ms;
154 NumberSeq* _all_yield_times_ms;
156 size_t _region_num_young;
157 size_t _region_num_tenured;
158 size_t _prev_region_num_young;
159 size_t _prev_region_num_tenured;
161 NumberSeq* _all_mod_union_times_ms;
163 int _aux_num;
164 NumberSeq* _all_aux_times_ms;
165 double* _cur_aux_start_times_ms;
166 double* _cur_aux_times_ms;
167 bool* _cur_aux_times_set;
169 double* _par_last_gc_worker_start_times_ms;
170 double* _par_last_ext_root_scan_times_ms;
171 double* _par_last_mark_stack_scan_times_ms;
172 double* _par_last_update_rs_times_ms;
173 double* _par_last_update_rs_processed_buffers;
174 double* _par_last_scan_rs_times_ms;
175 double* _par_last_obj_copy_times_ms;
176 double* _par_last_termination_times_ms;
177 double* _par_last_termination_attempts;
178 double* _par_last_gc_worker_end_times_ms;
179 double* _par_last_gc_worker_times_ms;
181 // indicates that we are in young GC mode
182 bool _in_young_gc_mode;
184 // indicates whether we are in full young or partially young GC mode
185 bool _full_young_gcs;
187 // if true, then it tries to dynamically adjust the length of the
188 // young list
189 bool _adaptive_young_list_length;
190 size_t _young_list_min_length;
191 size_t _young_list_target_length;
192 size_t _young_list_fixed_length;
194 // The max number of regions we can extend the eden by while the GC
195 // locker is active. This should be >= _young_list_target_length;
196 size_t _young_list_max_length;
198 size_t _young_cset_length;
199 bool _last_young_gc_full;
201 unsigned _full_young_pause_num;
202 unsigned _partial_young_pause_num;
204 bool _during_marking;
205 bool _in_marking_window;
206 bool _in_marking_window_im;
208 SurvRateGroup* _short_lived_surv_rate_group;
209 SurvRateGroup* _survivor_surv_rate_group;
210 // add here any more surv rate groups
212 double _gc_overhead_perc;
214 bool during_marking() {
215 return _during_marking;
216 }
218 // <NEW PREDICTION>
220 private:
221 enum PredictionConstants {
222 TruncatedSeqLength = 10
223 };
225 TruncatedSeq* _alloc_rate_ms_seq;
226 double _prev_collection_pause_end_ms;
228 TruncatedSeq* _pending_card_diff_seq;
229 TruncatedSeq* _rs_length_diff_seq;
230 TruncatedSeq* _cost_per_card_ms_seq;
231 TruncatedSeq* _fully_young_cards_per_entry_ratio_seq;
232 TruncatedSeq* _partially_young_cards_per_entry_ratio_seq;
233 TruncatedSeq* _cost_per_entry_ms_seq;
234 TruncatedSeq* _partially_young_cost_per_entry_ms_seq;
235 TruncatedSeq* _cost_per_byte_ms_seq;
236 TruncatedSeq* _constant_other_time_ms_seq;
237 TruncatedSeq* _young_other_cost_per_region_ms_seq;
238 TruncatedSeq* _non_young_other_cost_per_region_ms_seq;
240 TruncatedSeq* _pending_cards_seq;
241 TruncatedSeq* _scanned_cards_seq;
242 TruncatedSeq* _rs_lengths_seq;
244 TruncatedSeq* _cost_per_byte_ms_during_cm_seq;
246 TruncatedSeq* _young_gc_eff_seq;
248 TruncatedSeq* _max_conc_overhead_seq;
250 size_t _recorded_young_regions;
251 size_t _recorded_non_young_regions;
252 size_t _recorded_region_num;
254 size_t _free_regions_at_end_of_collection;
256 size_t _recorded_rs_lengths;
257 size_t _max_rs_lengths;
259 size_t _recorded_marked_bytes;
260 size_t _recorded_young_bytes;
262 size_t _predicted_pending_cards;
263 size_t _predicted_cards_scanned;
264 size_t _predicted_rs_lengths;
265 size_t _predicted_bytes_to_copy;
267 double _predicted_survival_ratio;
268 double _predicted_rs_update_time_ms;
269 double _predicted_rs_scan_time_ms;
270 double _predicted_object_copy_time_ms;
271 double _predicted_constant_other_time_ms;
272 double _predicted_young_other_time_ms;
273 double _predicted_non_young_other_time_ms;
274 double _predicted_pause_time_ms;
276 double _vtime_diff_ms;
278 double _recorded_young_free_cset_time_ms;
279 double _recorded_non_young_free_cset_time_ms;
281 double _sigma;
282 double _expensive_region_limit_ms;
284 size_t _rs_lengths_prediction;
286 size_t _known_garbage_bytes;
287 double _known_garbage_ratio;
289 double sigma() {
290 return _sigma;
291 }
293 // A function that prevents us putting too much stock in small sample
294 // sets. Returns a number between 2.0 and 1.0, depending on the number
295 // of samples. 5 or more samples yields one; fewer scales linearly from
296 // 2.0 at 1 sample to 1.0 at 5.
297 double confidence_factor(int samples) {
298 if (samples > 4) return 1.0;
299 else return 1.0 + sigma() * ((double)(5 - samples))/2.0;
300 }
302 double get_new_neg_prediction(TruncatedSeq* seq) {
303 return seq->davg() - sigma() * seq->dsd();
304 }
306 #ifndef PRODUCT
307 bool verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group);
308 #endif // PRODUCT
310 void adjust_concurrent_refinement(double update_rs_time,
311 double update_rs_processed_buffers,
312 double goal_ms);
314 protected:
315 double _pause_time_target_ms;
316 double _recorded_young_cset_choice_time_ms;
317 double _recorded_non_young_cset_choice_time_ms;
318 bool _within_target;
319 size_t _pending_cards;
320 size_t _max_pending_cards;
322 public:
324 void set_region_short_lived(HeapRegion* hr) {
325 hr->install_surv_rate_group(_short_lived_surv_rate_group);
326 }
328 void set_region_survivors(HeapRegion* hr) {
329 hr->install_surv_rate_group(_survivor_surv_rate_group);
330 }
332 #ifndef PRODUCT
333 bool verify_young_ages();
334 #endif // PRODUCT
336 double get_new_prediction(TruncatedSeq* seq) {
337 return MAX2(seq->davg() + sigma() * seq->dsd(),
338 seq->davg() * confidence_factor(seq->num()));
339 }
341 size_t young_cset_length() {
342 return _young_cset_length;
343 }
345 void record_max_rs_lengths(size_t rs_lengths) {
346 _max_rs_lengths = rs_lengths;
347 }
349 size_t predict_pending_card_diff() {
350 double prediction = get_new_neg_prediction(_pending_card_diff_seq);
351 if (prediction < 0.00001)
352 return 0;
353 else
354 return (size_t) prediction;
355 }
357 size_t predict_pending_cards() {
358 size_t max_pending_card_num = _g1->max_pending_card_num();
359 size_t diff = predict_pending_card_diff();
360 size_t prediction;
361 if (diff > max_pending_card_num)
362 prediction = max_pending_card_num;
363 else
364 prediction = max_pending_card_num - diff;
366 return prediction;
367 }
369 size_t predict_rs_length_diff() {
370 return (size_t) get_new_prediction(_rs_length_diff_seq);
371 }
373 double predict_alloc_rate_ms() {
374 return get_new_prediction(_alloc_rate_ms_seq);
375 }
377 double predict_cost_per_card_ms() {
378 return get_new_prediction(_cost_per_card_ms_seq);
379 }
381 double predict_rs_update_time_ms(size_t pending_cards) {
382 return (double) pending_cards * predict_cost_per_card_ms();
383 }
385 double predict_fully_young_cards_per_entry_ratio() {
386 return get_new_prediction(_fully_young_cards_per_entry_ratio_seq);
387 }
389 double predict_partially_young_cards_per_entry_ratio() {
390 if (_partially_young_cards_per_entry_ratio_seq->num() < 2)
391 return predict_fully_young_cards_per_entry_ratio();
392 else
393 return get_new_prediction(_partially_young_cards_per_entry_ratio_seq);
394 }
396 size_t predict_young_card_num(size_t rs_length) {
397 return (size_t) ((double) rs_length *
398 predict_fully_young_cards_per_entry_ratio());
399 }
401 size_t predict_non_young_card_num(size_t rs_length) {
402 return (size_t) ((double) rs_length *
403 predict_partially_young_cards_per_entry_ratio());
404 }
406 double predict_rs_scan_time_ms(size_t card_num) {
407 if (full_young_gcs())
408 return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq);
409 else
410 return predict_partially_young_rs_scan_time_ms(card_num);
411 }
413 double predict_partially_young_rs_scan_time_ms(size_t card_num) {
414 if (_partially_young_cost_per_entry_ms_seq->num() < 3)
415 return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq);
416 else
417 return (double) card_num *
418 get_new_prediction(_partially_young_cost_per_entry_ms_seq);
419 }
421 double predict_object_copy_time_ms_during_cm(size_t bytes_to_copy) {
422 if (_cost_per_byte_ms_during_cm_seq->num() < 3)
423 return 1.1 * (double) bytes_to_copy *
424 get_new_prediction(_cost_per_byte_ms_seq);
425 else
426 return (double) bytes_to_copy *
427 get_new_prediction(_cost_per_byte_ms_during_cm_seq);
428 }
430 double predict_object_copy_time_ms(size_t bytes_to_copy) {
431 if (_in_marking_window && !_in_marking_window_im)
432 return predict_object_copy_time_ms_during_cm(bytes_to_copy);
433 else
434 return (double) bytes_to_copy *
435 get_new_prediction(_cost_per_byte_ms_seq);
436 }
438 double predict_constant_other_time_ms() {
439 return get_new_prediction(_constant_other_time_ms_seq);
440 }
442 double predict_young_other_time_ms(size_t young_num) {
443 return
444 (double) young_num *
445 get_new_prediction(_young_other_cost_per_region_ms_seq);
446 }
448 double predict_non_young_other_time_ms(size_t non_young_num) {
449 return
450 (double) non_young_num *
451 get_new_prediction(_non_young_other_cost_per_region_ms_seq);
452 }
454 void check_if_region_is_too_expensive(double predicted_time_ms);
456 double predict_young_collection_elapsed_time_ms(size_t adjustment);
457 double predict_base_elapsed_time_ms(size_t pending_cards);
458 double predict_base_elapsed_time_ms(size_t pending_cards,
459 size_t scanned_cards);
460 size_t predict_bytes_to_copy(HeapRegion* hr);
461 double predict_region_elapsed_time_ms(HeapRegion* hr, bool young);
463 // for use by: calculate_young_list_target_length(rs_length)
464 bool predict_will_fit(size_t young_region_num,
465 double base_time_ms,
466 size_t init_free_regions,
467 double target_pause_time_ms);
469 void start_recording_regions();
470 void record_cset_region_info(HeapRegion* hr, bool young);
471 void record_non_young_cset_region(HeapRegion* hr);
473 void set_recorded_young_regions(size_t n_regions);
474 void set_recorded_young_bytes(size_t bytes);
475 void set_recorded_rs_lengths(size_t rs_lengths);
476 void set_predicted_bytes_to_copy(size_t bytes);
478 void end_recording_regions();
480 void record_vtime_diff_ms(double vtime_diff_ms) {
481 _vtime_diff_ms = vtime_diff_ms;
482 }
484 void record_young_free_cset_time_ms(double time_ms) {
485 _recorded_young_free_cset_time_ms = time_ms;
486 }
488 void record_non_young_free_cset_time_ms(double time_ms) {
489 _recorded_non_young_free_cset_time_ms = time_ms;
490 }
492 double predict_young_gc_eff() {
493 return get_new_neg_prediction(_young_gc_eff_seq);
494 }
496 double predict_survivor_regions_evac_time();
498 // </NEW PREDICTION>
500 public:
501 void cset_regions_freed() {
502 bool propagate = _last_young_gc_full && !_in_marking_window;
503 _short_lived_surv_rate_group->all_surviving_words_recorded(propagate);
504 _survivor_surv_rate_group->all_surviving_words_recorded(propagate);
505 // also call it on any more surv rate groups
506 }
508 void set_known_garbage_bytes(size_t known_garbage_bytes) {
509 _known_garbage_bytes = known_garbage_bytes;
510 size_t heap_bytes = _g1->capacity();
511 _known_garbage_ratio = (double) _known_garbage_bytes / (double) heap_bytes;
512 }
514 void decrease_known_garbage_bytes(size_t known_garbage_bytes) {
515 guarantee( _known_garbage_bytes >= known_garbage_bytes, "invariant" );
517 _known_garbage_bytes -= known_garbage_bytes;
518 size_t heap_bytes = _g1->capacity();
519 _known_garbage_ratio = (double) _known_garbage_bytes / (double) heap_bytes;
520 }
522 G1MMUTracker* mmu_tracker() {
523 return _mmu_tracker;
524 }
526 double max_pause_time_ms() {
527 return _mmu_tracker->max_gc_time() * 1000.0;
528 }
530 double predict_init_time_ms() {
531 return get_new_prediction(_concurrent_mark_init_times_ms);
532 }
534 double predict_remark_time_ms() {
535 return get_new_prediction(_concurrent_mark_remark_times_ms);
536 }
538 double predict_cleanup_time_ms() {
539 return get_new_prediction(_concurrent_mark_cleanup_times_ms);
540 }
542 // Returns an estimate of the survival rate of the region at yg-age
543 // "yg_age".
544 double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) {
545 TruncatedSeq* seq = surv_rate_group->get_seq(age);
546 if (seq->num() == 0)
547 gclog_or_tty->print("BARF! age is %d", age);
548 guarantee( seq->num() > 0, "invariant" );
549 double pred = get_new_prediction(seq);
550 if (pred > 1.0)
551 pred = 1.0;
552 return pred;
553 }
555 double predict_yg_surv_rate(int age) {
556 return predict_yg_surv_rate(age, _short_lived_surv_rate_group);
557 }
559 double accum_yg_surv_rate_pred(int age) {
560 return _short_lived_surv_rate_group->accum_surv_rate_pred(age);
561 }
563 protected:
564 void print_stats(int level, const char* str, double value);
565 void print_stats(int level, const char* str, int value);
567 void print_par_stats(int level, const char* str, double* data);
568 void print_par_sizes(int level, const char* str, double* data);
570 void check_other_times(int level,
571 NumberSeq* other_times_ms,
572 NumberSeq* calc_other_times_ms) const;
574 void print_summary (PauseSummary* stats) const;
576 void print_summary (int level, const char* str, NumberSeq* seq) const;
577 void print_summary_sd (int level, const char* str, NumberSeq* seq) const;
579 double avg_value (double* data);
580 double max_value (double* data);
581 double sum_of_values (double* data);
582 double max_sum (double* data1, double* data2);
584 int _last_satb_drain_processed_buffers;
585 int _last_update_rs_processed_buffers;
586 double _last_pause_time_ms;
588 size_t _bytes_in_collection_set_before_gc;
589 size_t _bytes_copied_during_gc;
591 // Used to count used bytes in CS.
592 friend class CountCSClosure;
594 // Statistics kept per GC stoppage, pause or full.
595 TruncatedSeq* _recent_prev_end_times_for_all_gcs_sec;
597 // We track markings.
598 int _num_markings;
599 double _mark_thread_startup_sec; // Time at startup of marking thread
601 // Add a new GC of the given duration and end time to the record.
602 void update_recent_gc_times(double end_time_sec, double elapsed_ms);
604 // The head of the list (via "next_in_collection_set()") representing the
605 // current collection set. Set from the incrementally built collection
606 // set at the start of the pause.
607 HeapRegion* _collection_set;
609 // The number of regions in the collection set. Set from the incrementally
610 // built collection set at the start of an evacuation pause.
611 size_t _collection_set_size;
613 // The number of bytes in the collection set before the pause. Set from
614 // the incrementally built collection set at the start of an evacuation
615 // pause.
616 size_t _collection_set_bytes_used_before;
618 // The associated information that is maintained while the incremental
619 // collection set is being built with young regions. Used to populate
620 // the recorded info for the evacuation pause.
622 enum CSetBuildType {
623 Active, // We are actively building the collection set
624 Inactive // We are not actively building the collection set
625 };
627 CSetBuildType _inc_cset_build_state;
629 // The head of the incrementally built collection set.
630 HeapRegion* _inc_cset_head;
632 // The tail of the incrementally built collection set.
633 HeapRegion* _inc_cset_tail;
635 // The number of regions in the incrementally built collection set.
636 // Used to set _collection_set_size at the start of an evacuation
637 // pause.
638 size_t _inc_cset_size;
640 // Used as the index in the surving young words structure
641 // which tracks the amount of space, for each young region,
642 // that survives the pause.
643 size_t _inc_cset_young_index;
645 // The number of bytes in the incrementally built collection set.
646 // Used to set _collection_set_bytes_used_before at the start of
647 // an evacuation pause.
648 size_t _inc_cset_bytes_used_before;
650 // Used to record the highest end of heap region in collection set
651 HeapWord* _inc_cset_max_finger;
653 // The number of recorded used bytes in the young regions
654 // of the collection set. This is the sum of the used() bytes
655 // of retired young regions in the collection set.
656 size_t _inc_cset_recorded_young_bytes;
658 // The RSet lengths recorded for regions in the collection set
659 // (updated by the periodic sampling of the regions in the
660 // young list/collection set).
661 size_t _inc_cset_recorded_rs_lengths;
663 // The predicted elapsed time it will take to collect the regions
664 // in the collection set (updated by the periodic sampling of the
665 // regions in the young list/collection set).
666 double _inc_cset_predicted_elapsed_time_ms;
668 // The predicted bytes to copy for the regions in the collection
669 // set (updated by the periodic sampling of the regions in the
670 // young list/collection set).
671 size_t _inc_cset_predicted_bytes_to_copy;
673 // Info about marking.
674 int _n_marks; // Sticky at 2, so we know when we've done at least 2.
676 // The number of collection pauses at the end of the last mark.
677 size_t _n_pauses_at_mark_end;
679 // Stash a pointer to the g1 heap.
680 G1CollectedHeap* _g1;
682 // The average time in ms per collection pause, averaged over recent pauses.
683 double recent_avg_time_for_pauses_ms();
685 // The average time in ms for RS scanning, per pause, averaged
686 // over recent pauses. (Note the RS scanning time for a pause
687 // is itself an average of the RS scanning time for each worker
688 // thread.)
689 double recent_avg_time_for_rs_scan_ms();
691 // The number of "recent" GCs recorded in the number sequences
692 int number_of_recent_gcs();
694 // The average survival ratio, computed by the total number of bytes
695 // suriviving / total number of bytes before collection over the last
696 // several recent pauses.
697 double recent_avg_survival_fraction();
698 // The survival fraction of the most recent pause; if there have been no
699 // pauses, returns 1.0.
700 double last_survival_fraction();
702 // Returns a "conservative" estimate of the recent survival rate, i.e.,
703 // one that may be higher than "recent_avg_survival_fraction".
704 // This is conservative in several ways:
705 // If there have been few pauses, it will assume a potential high
706 // variance, and err on the side of caution.
707 // It puts a lower bound (currently 0.1) on the value it will return.
708 // To try to detect phase changes, if the most recent pause ("latest") has a
709 // higher-than average ("avg") survival rate, it returns that rate.
710 // "work" version is a utility function; young is restricted to young regions.
711 double conservative_avg_survival_fraction_work(double avg,
712 double latest);
714 // The arguments are the two sequences that keep track of the number of bytes
715 // surviving and the total number of bytes before collection, resp.,
716 // over the last evereal recent pauses
717 // Returns the survival rate for the category in the most recent pause.
718 // If there have been no pauses, returns 1.0.
719 double last_survival_fraction_work(TruncatedSeq* surviving,
720 TruncatedSeq* before);
722 // The arguments are the two sequences that keep track of the number of bytes
723 // surviving and the total number of bytes before collection, resp.,
724 // over the last several recent pauses
725 // Returns the average survival ration over the last several recent pauses
726 // If there have been no pauses, return 1.0
727 double recent_avg_survival_fraction_work(TruncatedSeq* surviving,
728 TruncatedSeq* before);
730 double conservative_avg_survival_fraction() {
731 double avg = recent_avg_survival_fraction();
732 double latest = last_survival_fraction();
733 return conservative_avg_survival_fraction_work(avg, latest);
734 }
736 // The ratio of gc time to elapsed time, computed over recent pauses.
737 double _recent_avg_pause_time_ratio;
739 double recent_avg_pause_time_ratio() {
740 return _recent_avg_pause_time_ratio;
741 }
743 // Number of pauses between concurrent marking.
744 size_t _pauses_btwn_concurrent_mark;
746 size_t _n_marks_since_last_pause;
748 // At the end of a pause we check the heap occupancy and we decide
749 // whether we will start a marking cycle during the next pause. If
750 // we decide that we want to do that, we will set this parameter to
751 // true. So, this parameter will stay true between the end of a
752 // pause and the beginning of a subsequent pause (not necessarily
753 // the next one, see the comments on the next field) when we decide
754 // that we will indeed start a marking cycle and do the initial-mark
755 // work.
756 volatile bool _initiate_conc_mark_if_possible;
758 // If initiate_conc_mark_if_possible() is set at the beginning of a
759 // pause, it is a suggestion that the pause should start a marking
760 // cycle by doing the initial-mark work. However, it is possible
761 // that the concurrent marking thread is still finishing up the
762 // previous marking cycle (e.g., clearing the next marking
763 // bitmap). If that is the case we cannot start a new cycle and
764 // we'll have to wait for the concurrent marking thread to finish
765 // what it is doing. In this case we will postpone the marking cycle
766 // initiation decision for the next pause. When we eventually decide
767 // to start a cycle, we will set _during_initial_mark_pause which
768 // will stay true until the end of the initial-mark pause and it's
769 // the condition that indicates that a pause is doing the
770 // initial-mark work.
771 volatile bool _during_initial_mark_pause;
773 bool _should_revert_to_full_young_gcs;
774 bool _last_full_young_gc;
776 // This set of variables tracks the collector efficiency, in order to
777 // determine whether we should initiate a new marking.
778 double _cur_mark_stop_world_time_ms;
779 double _mark_init_start_sec;
780 double _mark_remark_start_sec;
781 double _mark_cleanup_start_sec;
782 double _mark_closure_time_ms;
784 void calculate_young_list_min_length();
785 void calculate_young_list_target_length();
786 void calculate_young_list_target_length(size_t rs_lengths);
788 public:
790 G1CollectorPolicy();
792 virtual G1CollectorPolicy* as_g1_policy() { return this; }
794 virtual CollectorPolicy::Name kind() {
795 return CollectorPolicy::G1CollectorPolicyKind;
796 }
798 void check_prediction_validity();
800 size_t bytes_in_collection_set() {
801 return _bytes_in_collection_set_before_gc;
802 }
804 unsigned calc_gc_alloc_time_stamp() {
805 return _all_pause_times_ms->num() + 1;
806 }
808 protected:
810 // Count the number of bytes used in the CS.
811 void count_CS_bytes_used();
813 // Together these do the base cleanup-recording work. Subclasses might
814 // want to put something between them.
815 void record_concurrent_mark_cleanup_end_work1(size_t freed_bytes,
816 size_t max_live_bytes);
817 void record_concurrent_mark_cleanup_end_work2();
819 public:
821 virtual void init();
823 // Create jstat counters for the policy.
824 virtual void initialize_gc_policy_counters();
826 virtual HeapWord* mem_allocate_work(size_t size,
827 bool is_tlab,
828 bool* gc_overhead_limit_was_exceeded);
830 // This method controls how a collector handles one or more
831 // of its generations being fully allocated.
832 virtual HeapWord* satisfy_failed_allocation(size_t size,
833 bool is_tlab);
835 BarrierSet::Name barrier_set_name() { return BarrierSet::G1SATBCTLogging; }
837 GenRemSet::Name rem_set_name() { return GenRemSet::CardTable; }
839 // The number of collection pauses so far.
840 long n_pauses() const { return _n_pauses; }
842 // Update the heuristic info to record a collection pause of the given
843 // start time, where the given number of bytes were used at the start.
844 // This may involve changing the desired size of a collection set.
846 virtual void record_stop_world_start();
848 virtual void record_collection_pause_start(double start_time_sec,
849 size_t start_used);
851 // Must currently be called while the world is stopped.
852 virtual void record_concurrent_mark_init_start();
853 virtual void record_concurrent_mark_init_end();
854 void record_concurrent_mark_init_end_pre(double
855 mark_init_elapsed_time_ms);
857 void record_mark_closure_time(double mark_closure_time_ms);
859 virtual void record_concurrent_mark_remark_start();
860 virtual void record_concurrent_mark_remark_end();
862 virtual void record_concurrent_mark_cleanup_start();
863 virtual void record_concurrent_mark_cleanup_end(size_t freed_bytes,
864 size_t max_live_bytes);
865 virtual void record_concurrent_mark_cleanup_completed();
867 virtual void record_concurrent_pause();
868 virtual void record_concurrent_pause_end();
870 virtual void record_collection_pause_end();
871 void print_heap_transition();
873 // Record the fact that a full collection occurred.
874 virtual void record_full_collection_start();
875 virtual void record_full_collection_end();
877 void record_gc_worker_start_time(int worker_i, double ms) {
878 _par_last_gc_worker_start_times_ms[worker_i] = ms;
879 }
881 void record_ext_root_scan_time(int worker_i, double ms) {
882 _par_last_ext_root_scan_times_ms[worker_i] = ms;
883 }
885 void record_mark_stack_scan_time(int worker_i, double ms) {
886 _par_last_mark_stack_scan_times_ms[worker_i] = ms;
887 }
889 void record_satb_drain_time(double ms) {
890 _cur_satb_drain_time_ms = ms;
891 _satb_drain_time_set = true;
892 }
894 void record_satb_drain_processed_buffers (int processed_buffers) {
895 _last_satb_drain_processed_buffers = processed_buffers;
896 }
898 void record_mod_union_time(double ms) {
899 _all_mod_union_times_ms->add(ms);
900 }
902 void record_update_rs_time(int thread, double ms) {
903 _par_last_update_rs_times_ms[thread] = ms;
904 }
906 void record_update_rs_processed_buffers (int thread,
907 double processed_buffers) {
908 _par_last_update_rs_processed_buffers[thread] = processed_buffers;
909 }
911 void record_scan_rs_time(int thread, double ms) {
912 _par_last_scan_rs_times_ms[thread] = ms;
913 }
915 void reset_obj_copy_time(int thread) {
916 _par_last_obj_copy_times_ms[thread] = 0.0;
917 }
919 void reset_obj_copy_time() {
920 reset_obj_copy_time(0);
921 }
923 void record_obj_copy_time(int thread, double ms) {
924 _par_last_obj_copy_times_ms[thread] += ms;
925 }
927 void record_termination(int thread, double ms, size_t attempts) {
928 _par_last_termination_times_ms[thread] = ms;
929 _par_last_termination_attempts[thread] = (double) attempts;
930 }
932 void record_gc_worker_end_time(int worker_i, double ms) {
933 _par_last_gc_worker_end_times_ms[worker_i] = ms;
934 }
936 void record_pause_time_ms(double ms) {
937 _last_pause_time_ms = ms;
938 }
940 void record_clear_ct_time(double ms) {
941 _cur_clear_ct_time_ms = ms;
942 }
944 void record_par_time(double ms) {
945 _cur_collection_par_time_ms = ms;
946 }
948 void record_aux_start_time(int i) {
949 guarantee(i < _aux_num, "should be within range");
950 _cur_aux_start_times_ms[i] = os::elapsedTime() * 1000.0;
951 }
953 void record_aux_end_time(int i) {
954 guarantee(i < _aux_num, "should be within range");
955 double ms = os::elapsedTime() * 1000.0 - _cur_aux_start_times_ms[i];
956 _cur_aux_times_set[i] = true;
957 _cur_aux_times_ms[i] += ms;
958 }
960 #ifndef PRODUCT
961 void record_cc_clear_time(double ms) {
962 if (_min_clear_cc_time_ms < 0.0 || ms <= _min_clear_cc_time_ms)
963 _min_clear_cc_time_ms = ms;
964 if (_max_clear_cc_time_ms < 0.0 || ms >= _max_clear_cc_time_ms)
965 _max_clear_cc_time_ms = ms;
966 _cur_clear_cc_time_ms = ms;
967 _cum_clear_cc_time_ms += ms;
968 _num_cc_clears++;
969 }
970 #endif
972 // Record how much space we copied during a GC. This is typically
973 // called when a GC alloc region is being retired.
974 void record_bytes_copied_during_gc(size_t bytes) {
975 _bytes_copied_during_gc += bytes;
976 }
978 // The amount of space we copied during a GC.
979 size_t bytes_copied_during_gc() {
980 return _bytes_copied_during_gc;
981 }
983 // Choose a new collection set. Marks the chosen regions as being
984 // "in_collection_set", and links them together. The head and number of
985 // the collection set are available via access methods.
986 virtual void choose_collection_set(double target_pause_time_ms) = 0;
988 // The head of the list (via "next_in_collection_set()") representing the
989 // current collection set.
990 HeapRegion* collection_set() { return _collection_set; }
992 void clear_collection_set() { _collection_set = NULL; }
994 // The number of elements in the current collection set.
995 size_t collection_set_size() { return _collection_set_size; }
997 // Add "hr" to the CS.
998 void add_to_collection_set(HeapRegion* hr);
1000 // Incremental CSet Support
1002 // The head of the incrementally built collection set.
1003 HeapRegion* inc_cset_head() { return _inc_cset_head; }
1005 // The tail of the incrementally built collection set.
1006 HeapRegion* inc_set_tail() { return _inc_cset_tail; }
1008 // The number of elements in the incrementally built collection set.
1009 size_t inc_cset_size() { return _inc_cset_size; }
1011 // Initialize incremental collection set info.
1012 void start_incremental_cset_building();
1014 void clear_incremental_cset() {
1015 _inc_cset_head = NULL;
1016 _inc_cset_tail = NULL;
1017 }
1019 // Stop adding regions to the incremental collection set
1020 void stop_incremental_cset_building() { _inc_cset_build_state = Inactive; }
1022 // Add/remove information about hr to the aggregated information
1023 // for the incrementally built collection set.
1024 void add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length);
1025 void remove_from_incremental_cset_info(HeapRegion* hr);
1027 // Update information about hr in the aggregated information for
1028 // the incrementally built collection set.
1029 void update_incremental_cset_info(HeapRegion* hr, size_t new_rs_length);
1031 private:
1032 // Update the incremental cset information when adding a region
1033 // (should not be called directly).
1034 void add_region_to_incremental_cset_common(HeapRegion* hr);
1036 public:
1037 // Add hr to the LHS of the incremental collection set.
1038 void add_region_to_incremental_cset_lhs(HeapRegion* hr);
1040 // Add hr to the RHS of the incremental collection set.
1041 void add_region_to_incremental_cset_rhs(HeapRegion* hr);
1043 #ifndef PRODUCT
1044 void print_collection_set(HeapRegion* list_head, outputStream* st);
1045 #endif // !PRODUCT
1047 bool initiate_conc_mark_if_possible() { return _initiate_conc_mark_if_possible; }
1048 void set_initiate_conc_mark_if_possible() { _initiate_conc_mark_if_possible = true; }
1049 void clear_initiate_conc_mark_if_possible() { _initiate_conc_mark_if_possible = false; }
1051 bool during_initial_mark_pause() { return _during_initial_mark_pause; }
1052 void set_during_initial_mark_pause() { _during_initial_mark_pause = true; }
1053 void clear_during_initial_mark_pause(){ _during_initial_mark_pause = false; }
1055 // This sets the initiate_conc_mark_if_possible() flag to start a
1056 // new cycle, as long as we are not already in one. It's best if it
1057 // is called during a safepoint when the test whether a cycle is in
1058 // progress or not is stable.
1059 bool force_initial_mark_if_outside_cycle();
1061 // This is called at the very beginning of an evacuation pause (it
1062 // has to be the first thing that the pause does). If
1063 // initiate_conc_mark_if_possible() is true, and the concurrent
1064 // marking thread has completed its work during the previous cycle,
1065 // it will set during_initial_mark_pause() to so that the pause does
1066 // the initial-mark work and start a marking cycle.
1067 void decide_on_conc_mark_initiation();
1069 // If an expansion would be appropriate, because recent GC overhead had
1070 // exceeded the desired limit, return an amount to expand by.
1071 virtual size_t expansion_amount();
1073 // note start of mark thread
1074 void note_start_of_mark_thread();
1076 // The marked bytes of the "r" has changed; reclassify it's desirability
1077 // for marking. Also asserts that "r" is eligible for a CS.
1078 virtual void note_change_in_marked_bytes(HeapRegion* r) = 0;
1080 #ifndef PRODUCT
1081 // Check any appropriate marked bytes info, asserting false if
1082 // something's wrong, else returning "true".
1083 virtual bool assertMarkedBytesDataOK() = 0;
1084 #endif
1086 // Print tracing information.
1087 void print_tracing_info() const;
1089 // Print stats on young survival ratio
1090 void print_yg_surv_rate_info() const;
1092 void finished_recalculating_age_indexes(bool is_survivors) {
1093 if (is_survivors) {
1094 _survivor_surv_rate_group->finished_recalculating_age_indexes();
1095 } else {
1096 _short_lived_surv_rate_group->finished_recalculating_age_indexes();
1097 }
1098 // do that for any other surv rate groups
1099 }
1101 bool is_young_list_full() {
1102 size_t young_list_length = _g1->young_list()->length();
1103 size_t young_list_target_length = _young_list_target_length;
1104 if (G1FixedEdenSize) {
1105 young_list_target_length -= _max_survivor_regions;
1106 }
1107 return young_list_length >= young_list_target_length;
1108 }
1110 bool can_expand_young_list() {
1111 size_t young_list_length = _g1->young_list()->length();
1112 size_t young_list_max_length = _young_list_max_length;
1113 if (G1FixedEdenSize) {
1114 young_list_max_length -= _max_survivor_regions;
1115 }
1116 return young_list_length < young_list_max_length;
1117 }
1119 void update_region_num(bool young);
1121 bool in_young_gc_mode() {
1122 return _in_young_gc_mode;
1123 }
1124 void set_in_young_gc_mode(bool in_young_gc_mode) {
1125 _in_young_gc_mode = in_young_gc_mode;
1126 }
1128 bool full_young_gcs() {
1129 return _full_young_gcs;
1130 }
1131 void set_full_young_gcs(bool full_young_gcs) {
1132 _full_young_gcs = full_young_gcs;
1133 }
1135 bool adaptive_young_list_length() {
1136 return _adaptive_young_list_length;
1137 }
1138 void set_adaptive_young_list_length(bool adaptive_young_list_length) {
1139 _adaptive_young_list_length = adaptive_young_list_length;
1140 }
1142 inline double get_gc_eff_factor() {
1143 double ratio = _known_garbage_ratio;
1145 double square = ratio * ratio;
1146 // square = square * square;
1147 double ret = square * 9.0 + 1.0;
1148 #if 0
1149 gclog_or_tty->print_cr("ratio = %1.2lf, ret = %1.2lf", ratio, ret);
1150 #endif // 0
1151 guarantee(0.0 <= ret && ret < 10.0, "invariant!");
1152 return ret;
1153 }
1155 //
1156 // Survivor regions policy.
1157 //
1158 protected:
1160 // Current tenuring threshold, set to 0 if the collector reaches the
1161 // maximum amount of suvivors regions.
1162 int _tenuring_threshold;
1164 // The limit on the number of regions allocated for survivors.
1165 size_t _max_survivor_regions;
1167 // For reporting purposes.
1168 size_t _eden_bytes_before_gc;
1169 size_t _survivor_bytes_before_gc;
1170 size_t _capacity_before_gc;
1172 // The amount of survor regions after a collection.
1173 size_t _recorded_survivor_regions;
1174 // List of survivor regions.
1175 HeapRegion* _recorded_survivor_head;
1176 HeapRegion* _recorded_survivor_tail;
1178 ageTable _survivors_age_table;
1180 public:
1182 inline GCAllocPurpose
1183 evacuation_destination(HeapRegion* src_region, int age, size_t word_sz) {
1184 if (age < _tenuring_threshold && src_region->is_young()) {
1185 return GCAllocForSurvived;
1186 } else {
1187 return GCAllocForTenured;
1188 }
1189 }
1191 inline bool track_object_age(GCAllocPurpose purpose) {
1192 return purpose == GCAllocForSurvived;
1193 }
1195 static const size_t REGIONS_UNLIMITED = ~(size_t)0;
1197 size_t max_regions(int purpose);
1199 // The limit on regions for a particular purpose is reached.
1200 void note_alloc_region_limit_reached(int purpose) {
1201 if (purpose == GCAllocForSurvived) {
1202 _tenuring_threshold = 0;
1203 }
1204 }
1206 void note_start_adding_survivor_regions() {
1207 _survivor_surv_rate_group->start_adding_regions();
1208 }
1210 void note_stop_adding_survivor_regions() {
1211 _survivor_surv_rate_group->stop_adding_regions();
1212 }
1214 void record_survivor_regions(size_t regions,
1215 HeapRegion* head,
1216 HeapRegion* tail) {
1217 _recorded_survivor_regions = regions;
1218 _recorded_survivor_head = head;
1219 _recorded_survivor_tail = tail;
1220 }
1222 size_t recorded_survivor_regions() {
1223 return _recorded_survivor_regions;
1224 }
1226 void record_thread_age_table(ageTable* age_table)
1227 {
1228 _survivors_age_table.merge_par(age_table);
1229 }
1231 void calculate_max_gc_locker_expansion();
1233 // Calculates survivor space parameters.
1234 void calculate_survivors_policy();
1236 };
1238 // This encapsulates a particular strategy for a g1 Collector.
1239 //
1240 // Start a concurrent mark when our heap size is n bytes
1241 // greater then our heap size was at the last concurrent
1242 // mark. Where n is a function of the CMSTriggerRatio
1243 // and the MinHeapFreeRatio.
1244 //
1245 // Start a g1 collection pause when we have allocated the
1246 // average number of bytes currently being freed in
1247 // a collection, but only if it is at least one region
1248 // full
1249 //
1250 // Resize Heap based on desired
1251 // allocation space, where desired allocation space is
1252 // a function of survival rate and desired future to size.
1253 //
1254 // Choose collection set by first picking all older regions
1255 // which have a survival rate which beats our projected young
1256 // survival rate. Then fill out the number of needed regions
1257 // with young regions.
1259 class G1CollectorPolicy_BestRegionsFirst: public G1CollectorPolicy {
1260 CollectionSetChooser* _collectionSetChooser;
1261 // If the estimated is less then desirable, resize if possible.
1262 void expand_if_possible(size_t numRegions);
1264 virtual void choose_collection_set(double target_pause_time_ms);
1265 virtual void record_collection_pause_start(double start_time_sec,
1266 size_t start_used);
1267 virtual void record_concurrent_mark_cleanup_end(size_t freed_bytes,
1268 size_t max_live_bytes);
1269 virtual void record_full_collection_end();
1271 public:
1272 G1CollectorPolicy_BestRegionsFirst() {
1273 _collectionSetChooser = new CollectionSetChooser();
1274 }
1275 void record_collection_pause_end();
1276 // This is not needed any more, after the CSet choosing code was
1277 // changed to use the pause prediction work. But let's leave the
1278 // hook in just in case.
1279 void note_change_in_marked_bytes(HeapRegion* r) { }
1280 #ifndef PRODUCT
1281 bool assertMarkedBytesDataOK();
1282 #endif
1283 };
1285 // This should move to some place more general...
1287 // If we have "n" measurements, and we've kept track of their "sum" and the
1288 // "sum_of_squares" of the measurements, this returns the variance of the
1289 // sequence.
1290 inline double variance(int n, double sum_of_squares, double sum) {
1291 double n_d = (double)n;
1292 double avg = sum/n_d;
1293 return (sum_of_squares - 2.0 * avg * sum + n_d * avg * avg) / n_d;
1294 }
1296 // Local Variables: ***
1297 // c-indentation-style: gnu ***
1298 // End: ***
1300 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP