Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | dc467e8b2c5e |
| children | 67fdcb391461 |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. |
| 342 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP | |
| 27 | |
| 28 #include "gc_implementation/g1/collectionSetChooser.hpp" | |
| 29 #include "gc_implementation/g1/g1MMUTracker.hpp" | |
| 30 #include "memory/collectorPolicy.hpp" | |
| 31 | |
| 342 | 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. | |
| 36 | |
| 37 class HeapRegion; | |
| 38 class CollectionSetChooser; | |
| 39 | |
| 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. | |
| 44 | |
| 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 } | |
| 55 | |
| 56 class MainBodySummary; | |
| 57 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
545
diff
changeset
|
58 class PauseSummary: public CHeapObj { |
| 342 | 59 define_num_seq(total) |
| 60 define_num_seq(other) | |
| 61 | |
| 62 public: | |
| 63 virtual MainBodySummary* main_body_summary() { return NULL; } | |
| 64 }; | |
| 65 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
545
diff
changeset
|
66 class MainBodySummary: public CHeapObj { |
| 342 | 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) | |
| 4023 | 77 define_num_seq(clear_ct) |
| 342 | 78 }; |
| 79 | |
| 677 | 80 class Summary: public PauseSummary, |
| 81 public MainBodySummary { | |
| 342 | 82 public: |
| 83 virtual MainBodySummary* main_body_summary() { return this; } | |
| 84 }; | |
| 85 | |
| 86 class G1CollectorPolicy: public CollectorPolicy { | |
| 4013 | 87 private: |
| 342 | 88 // either equal to the number of parallel threads, if ParallelGCThreads |
| 89 // has been set, or 1 otherwise | |
| 90 int _parallel_gc_threads; | |
| 91 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
92 // The number of GC threads currently active. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
93 uintx _no_of_gc_threads; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
94 |
| 342 | 95 enum SomePrivateConstants { |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
96 NumPrevPausesForHeuristics = 10 |
| 342 | 97 }; |
| 98 | |
| 99 G1MMUTracker* _mmu_tracker; | |
| 100 | |
| 101 void initialize_flags(); | |
| 102 | |
| 103 void initialize_all() { | |
| 104 initialize_flags(); | |
| 105 initialize_size_info(); | |
| 106 initialize_perm_generation(PermGen::MarkSweepCompact); | |
| 107 } | |
| 108 | |
| 4013 | 109 CollectionSetChooser* _collectionSetChooser; |
| 342 | 110 |
| 111 double _cur_collection_start_sec; | |
| 112 size_t _cur_collection_pause_used_at_start_bytes; | |
| 113 size_t _cur_collection_pause_used_regions_at_start; | |
| 114 size_t _prev_collection_pause_used_at_end_bytes; | |
| 115 double _cur_collection_par_time_ms; | |
| 116 double _cur_satb_drain_time_ms; | |
| 117 double _cur_clear_ct_time_ms; | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
118 double _cur_ref_proc_time_ms; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
119 double _cur_ref_enq_time_ms; |
| 342 | 120 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
121 #ifndef PRODUCT |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
122 // Card Table Count Cache stats |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
123 double _min_clear_cc_time_ms; // min |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
124 double _max_clear_cc_time_ms; // max |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
125 double _cur_clear_cc_time_ms; // clearing time during current pause |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
126 double _cum_clear_cc_time_ms; // cummulative clearing time |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
127 jlong _num_cc_clears; // number of times the card count cache has been cleared |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
128 #endif |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
129 |
| 342 | 130 // These exclude marking times. |
| 131 TruncatedSeq* _recent_gc_times_ms; | |
| 132 | |
| 133 TruncatedSeq* _concurrent_mark_remark_times_ms; | |
| 134 TruncatedSeq* _concurrent_mark_cleanup_times_ms; | |
| 135 | |
| 677 | 136 Summary* _summary; |
| 342 | 137 |
| 138 NumberSeq* _all_pause_times_ms; | |
| 139 NumberSeq* _all_full_gc_times_ms; | |
| 140 double _stop_world_start; | |
| 141 NumberSeq* _all_stop_world_times_ms; | |
| 142 NumberSeq* _all_yield_times_ms; | |
| 143 | |
| 144 int _aux_num; | |
| 145 NumberSeq* _all_aux_times_ms; | |
| 146 double* _cur_aux_start_times_ms; | |
| 147 double* _cur_aux_times_ms; | |
| 148 bool* _cur_aux_times_set; | |
| 149 | |
| 1611 | 150 double* _par_last_gc_worker_start_times_ms; |
| 342 | 151 double* _par_last_ext_root_scan_times_ms; |
| 152 double* _par_last_mark_stack_scan_times_ms; | |
| 153 double* _par_last_update_rs_times_ms; | |
| 154 double* _par_last_update_rs_processed_buffers; | |
| 155 double* _par_last_scan_rs_times_ms; | |
| 156 double* _par_last_obj_copy_times_ms; | |
| 157 double* _par_last_termination_times_ms; | |
| 1611 | 158 double* _par_last_termination_attempts; |
| 159 double* _par_last_gc_worker_end_times_ms; | |
| 2430 | 160 double* _par_last_gc_worker_times_ms; |
| 342 | 161 |
| 4023 | 162 // Each workers 'other' time i.e. the elapsed time of the parallel |
| 163 // phase of the pause minus the sum of the individual sub-phase | |
| 164 // times for a given worker thread. | |
| 165 double* _par_last_gc_worker_other_times_ms; | |
| 166 | |
| 4710 | 167 // indicates whether we are in young or mixed GC mode |
| 168 bool _gcs_are_young; | |
| 342 | 169 |
| 170 // if true, then it tries to dynamically adjust the length of the | |
| 171 // young list | |
| 172 bool _adaptive_young_list_length; | |
| 173 size_t _young_list_target_length; | |
| 174 size_t _young_list_fixed_length; | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
175 size_t _prev_eden_capacity; // used for logging |
| 342 | 176 |
|
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
177 // The max number of regions we can extend the eden by while the GC |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
178 // locker is active. This should be >= _young_list_target_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
179 size_t _young_list_max_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
180 |
| 4710 | 181 bool _last_gc_was_young; |
| 342 | 182 |
| 4710 | 183 unsigned _young_pause_num; |
| 184 unsigned _mixed_pause_num; | |
| 342 | 185 |
| 186 bool _during_marking; | |
| 187 bool _in_marking_window; | |
| 188 bool _in_marking_window_im; | |
| 189 | |
| 190 SurvRateGroup* _short_lived_surv_rate_group; | |
| 191 SurvRateGroup* _survivor_surv_rate_group; | |
| 192 // add here any more surv rate groups | |
| 193 | |
| 1356 | 194 double _gc_overhead_perc; |
| 195 | |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
196 double _reserve_factor; |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
197 size_t _reserve_regions; |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
198 |
| 342 | 199 bool during_marking() { |
| 200 return _during_marking; | |
| 201 } | |
| 202 | |
| 203 private: | |
| 204 enum PredictionConstants { | |
| 205 TruncatedSeqLength = 10 | |
| 206 }; | |
| 207 | |
| 208 TruncatedSeq* _alloc_rate_ms_seq; | |
| 209 double _prev_collection_pause_end_ms; | |
| 210 | |
| 211 TruncatedSeq* _pending_card_diff_seq; | |
| 212 TruncatedSeq* _rs_length_diff_seq; | |
| 213 TruncatedSeq* _cost_per_card_ms_seq; | |
| 4710 | 214 TruncatedSeq* _young_cards_per_entry_ratio_seq; |
| 215 TruncatedSeq* _mixed_cards_per_entry_ratio_seq; | |
| 342 | 216 TruncatedSeq* _cost_per_entry_ms_seq; |
| 4710 | 217 TruncatedSeq* _mixed_cost_per_entry_ms_seq; |
| 342 | 218 TruncatedSeq* _cost_per_byte_ms_seq; |
| 219 TruncatedSeq* _constant_other_time_ms_seq; | |
| 220 TruncatedSeq* _young_other_cost_per_region_ms_seq; | |
| 221 TruncatedSeq* _non_young_other_cost_per_region_ms_seq; | |
| 222 | |
| 223 TruncatedSeq* _pending_cards_seq; | |
| 224 TruncatedSeq* _rs_lengths_seq; | |
| 225 | |
| 226 TruncatedSeq* _cost_per_byte_ms_during_cm_seq; | |
| 227 | |
| 228 TruncatedSeq* _young_gc_eff_seq; | |
| 229 | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
230 bool _using_new_ratio_calculations; |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
231 size_t _min_desired_young_length; // as set on the command line or default calculations |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
232 size_t _max_desired_young_length; // as set on the command line or default calculations |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
233 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
234 size_t _eden_cset_region_length; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
235 size_t _survivor_cset_region_length; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
236 size_t _old_cset_region_length; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
237 |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
238 void init_cset_region_lengths(size_t eden_cset_region_length, |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
239 size_t survivor_cset_region_length); |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
240 |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
241 size_t eden_cset_region_length() { return _eden_cset_region_length; } |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
242 size_t survivor_cset_region_length() { return _survivor_cset_region_length; } |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
243 size_t old_cset_region_length() { return _old_cset_region_length; } |
| 342 | 244 |
| 245 size_t _free_regions_at_end_of_collection; | |
| 246 | |
| 247 size_t _recorded_rs_lengths; | |
| 248 size_t _max_rs_lengths; | |
| 249 | |
| 250 double _recorded_young_free_cset_time_ms; | |
| 251 double _recorded_non_young_free_cset_time_ms; | |
| 252 | |
| 253 double _sigma; | |
| 254 double _expensive_region_limit_ms; | |
| 255 | |
| 256 size_t _rs_lengths_prediction; | |
| 257 | |
| 258 size_t _known_garbage_bytes; | |
| 259 double _known_garbage_ratio; | |
| 260 | |
| 261 double sigma() { | |
| 262 return _sigma; | |
| 263 } | |
| 264 | |
| 265 // A function that prevents us putting too much stock in small sample | |
| 266 // sets. Returns a number between 2.0 and 1.0, depending on the number | |
| 267 // of samples. 5 or more samples yields one; fewer scales linearly from | |
| 268 // 2.0 at 1 sample to 1.0 at 5. | |
| 269 double confidence_factor(int samples) { | |
| 270 if (samples > 4) return 1.0; | |
| 271 else return 1.0 + sigma() * ((double)(5 - samples))/2.0; | |
| 272 } | |
| 273 | |
| 274 double get_new_neg_prediction(TruncatedSeq* seq) { | |
| 275 return seq->davg() - sigma() * seq->dsd(); | |
| 276 } | |
| 277 | |
| 278 #ifndef PRODUCT | |
| 279 bool verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group); | |
| 280 #endif // PRODUCT | |
| 281 | |
| 1111 | 282 void adjust_concurrent_refinement(double update_rs_time, |
| 283 double update_rs_processed_buffers, | |
| 284 double goal_ms); | |
| 285 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
286 uintx no_of_gc_threads() { return _no_of_gc_threads; } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
287 void set_no_of_gc_threads(uintx v) { _no_of_gc_threads = v; } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
288 |
| 342 | 289 double _pause_time_target_ms; |
| 290 double _recorded_young_cset_choice_time_ms; | |
| 291 double _recorded_non_young_cset_choice_time_ms; | |
| 292 size_t _pending_cards; | |
| 293 size_t _max_pending_cards; | |
| 294 | |
| 295 public: | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
296 // Accessors |
| 342 | 297 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
298 void set_region_eden(HeapRegion* hr, int young_index_in_cset) { |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
299 hr->set_young(); |
| 342 | 300 hr->install_surv_rate_group(_short_lived_surv_rate_group); |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
301 hr->set_young_index_in_cset(young_index_in_cset); |
| 342 | 302 } |
| 303 | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
304 void set_region_survivor(HeapRegion* hr, int young_index_in_cset) { |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
305 assert(hr->is_young() && hr->is_survivor(), "pre-condition"); |
| 342 | 306 hr->install_surv_rate_group(_survivor_surv_rate_group); |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
307 hr->set_young_index_in_cset(young_index_in_cset); |
| 342 | 308 } |
| 309 | |
| 310 #ifndef PRODUCT | |
| 311 bool verify_young_ages(); | |
| 312 #endif // PRODUCT | |
| 313 | |
| 314 double get_new_prediction(TruncatedSeq* seq) { | |
| 315 return MAX2(seq->davg() + sigma() * seq->dsd(), | |
| 316 seq->davg() * confidence_factor(seq->num())); | |
| 317 } | |
| 318 | |
| 319 void record_max_rs_lengths(size_t rs_lengths) { | |
| 320 _max_rs_lengths = rs_lengths; | |
| 321 } | |
| 322 | |
| 323 size_t predict_pending_card_diff() { | |
| 324 double prediction = get_new_neg_prediction(_pending_card_diff_seq); | |
| 4710 | 325 if (prediction < 0.00001) { |
| 342 | 326 return 0; |
| 4710 | 327 } else { |
| 342 | 328 return (size_t) prediction; |
| 4710 | 329 } |
| 342 | 330 } |
| 331 | |
| 332 size_t predict_pending_cards() { | |
| 333 size_t max_pending_card_num = _g1->max_pending_card_num(); | |
| 334 size_t diff = predict_pending_card_diff(); | |
| 335 size_t prediction; | |
| 4710 | 336 if (diff > max_pending_card_num) { |
| 342 | 337 prediction = max_pending_card_num; |
| 4710 | 338 } else { |
| 342 | 339 prediction = max_pending_card_num - diff; |
| 4710 | 340 } |
| 342 | 341 |
| 342 return prediction; | |
| 343 } | |
| 344 | |
| 345 size_t predict_rs_length_diff() { | |
| 346 return (size_t) get_new_prediction(_rs_length_diff_seq); | |
| 347 } | |
| 348 | |
| 349 double predict_alloc_rate_ms() { | |
| 350 return get_new_prediction(_alloc_rate_ms_seq); | |
| 351 } | |
| 352 | |
| 353 double predict_cost_per_card_ms() { | |
| 354 return get_new_prediction(_cost_per_card_ms_seq); | |
| 355 } | |
| 356 | |
| 357 double predict_rs_update_time_ms(size_t pending_cards) { | |
| 358 return (double) pending_cards * predict_cost_per_card_ms(); | |
| 359 } | |
| 360 | |
| 4710 | 361 double predict_young_cards_per_entry_ratio() { |
| 362 return get_new_prediction(_young_cards_per_entry_ratio_seq); | |
| 342 | 363 } |
| 364 | |
| 4710 | 365 double predict_mixed_cards_per_entry_ratio() { |
| 366 if (_mixed_cards_per_entry_ratio_seq->num() < 2) { | |
| 367 return predict_young_cards_per_entry_ratio(); | |
| 368 } else { | |
| 369 return get_new_prediction(_mixed_cards_per_entry_ratio_seq); | |
| 370 } | |
| 342 | 371 } |
| 372 | |
| 373 size_t predict_young_card_num(size_t rs_length) { | |
| 374 return (size_t) ((double) rs_length * | |
| 4710 | 375 predict_young_cards_per_entry_ratio()); |
| 342 | 376 } |
| 377 | |
| 378 size_t predict_non_young_card_num(size_t rs_length) { | |
| 379 return (size_t) ((double) rs_length * | |
| 4710 | 380 predict_mixed_cards_per_entry_ratio()); |
| 342 | 381 } |
| 382 | |
| 383 double predict_rs_scan_time_ms(size_t card_num) { | |
| 4710 | 384 if (gcs_are_young()) { |
| 342 | 385 return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq); |
| 4710 | 386 } else { |
| 387 return predict_mixed_rs_scan_time_ms(card_num); | |
| 388 } | |
| 342 | 389 } |
| 390 | |
| 4710 | 391 double predict_mixed_rs_scan_time_ms(size_t card_num) { |
| 392 if (_mixed_cost_per_entry_ms_seq->num() < 3) { | |
| 342 | 393 return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq); |
| 4710 | 394 } else { |
| 395 return (double) (card_num * | |
| 396 get_new_prediction(_mixed_cost_per_entry_ms_seq)); | |
| 397 } | |
| 342 | 398 } |
| 399 | |
| 400 double predict_object_copy_time_ms_during_cm(size_t bytes_to_copy) { | |
| 4710 | 401 if (_cost_per_byte_ms_during_cm_seq->num() < 3) { |
| 402 return (1.1 * (double) bytes_to_copy) * | |
| 403 get_new_prediction(_cost_per_byte_ms_seq); | |
| 404 } else { | |
| 342 | 405 return (double) bytes_to_copy * |
| 4710 | 406 get_new_prediction(_cost_per_byte_ms_during_cm_seq); |
| 407 } | |
| 342 | 408 } |
| 409 | |
| 410 double predict_object_copy_time_ms(size_t bytes_to_copy) { | |
| 4710 | 411 if (_in_marking_window && !_in_marking_window_im) { |
| 342 | 412 return predict_object_copy_time_ms_during_cm(bytes_to_copy); |
| 4710 | 413 } else { |
| 342 | 414 return (double) bytes_to_copy * |
| 4710 | 415 get_new_prediction(_cost_per_byte_ms_seq); |
| 416 } | |
| 342 | 417 } |
| 418 | |
| 419 double predict_constant_other_time_ms() { | |
| 420 return get_new_prediction(_constant_other_time_ms_seq); | |
| 421 } | |
| 422 | |
| 423 double predict_young_other_time_ms(size_t young_num) { | |
| 4710 | 424 return (double) young_num * |
| 425 get_new_prediction(_young_other_cost_per_region_ms_seq); | |
| 342 | 426 } |
| 427 | |
| 428 double predict_non_young_other_time_ms(size_t non_young_num) { | |
| 4710 | 429 return (double) non_young_num * |
| 430 get_new_prediction(_non_young_other_cost_per_region_ms_seq); | |
| 342 | 431 } |
| 432 | |
| 433 void check_if_region_is_too_expensive(double predicted_time_ms); | |
| 434 | |
| 435 double predict_young_collection_elapsed_time_ms(size_t adjustment); | |
| 436 double predict_base_elapsed_time_ms(size_t pending_cards); | |
| 437 double predict_base_elapsed_time_ms(size_t pending_cards, | |
| 438 size_t scanned_cards); | |
| 439 size_t predict_bytes_to_copy(HeapRegion* hr); | |
| 440 double predict_region_elapsed_time_ms(HeapRegion* hr, bool young); | |
| 441 | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
442 void set_recorded_rs_lengths(size_t rs_lengths); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
443 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
444 size_t cset_region_length() { return young_cset_region_length() + |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
445 old_cset_region_length(); } |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
446 size_t young_cset_region_length() { return eden_cset_region_length() + |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
447 survivor_cset_region_length(); } |
| 342 | 448 |
| 449 void record_young_free_cset_time_ms(double time_ms) { | |
| 450 _recorded_young_free_cset_time_ms = time_ms; | |
| 451 } | |
| 452 | |
| 453 void record_non_young_free_cset_time_ms(double time_ms) { | |
| 454 _recorded_non_young_free_cset_time_ms = time_ms; | |
| 455 } | |
| 456 | |
| 457 double predict_young_gc_eff() { | |
| 458 return get_new_neg_prediction(_young_gc_eff_seq); | |
| 459 } | |
| 460 | |
| 545 | 461 double predict_survivor_regions_evac_time(); |
| 462 | |
| 342 | 463 void cset_regions_freed() { |
| 4710 | 464 bool propagate = _last_gc_was_young && !_in_marking_window; |
| 342 | 465 _short_lived_surv_rate_group->all_surviving_words_recorded(propagate); |
| 466 _survivor_surv_rate_group->all_surviving_words_recorded(propagate); | |
| 467 // also call it on any more surv rate groups | |
| 468 } | |
| 469 | |
| 470 void set_known_garbage_bytes(size_t known_garbage_bytes) { | |
| 471 _known_garbage_bytes = known_garbage_bytes; | |
| 472 size_t heap_bytes = _g1->capacity(); | |
| 473 _known_garbage_ratio = (double) _known_garbage_bytes / (double) heap_bytes; | |
| 474 } | |
| 475 | |
| 476 void decrease_known_garbage_bytes(size_t known_garbage_bytes) { | |
| 477 guarantee( _known_garbage_bytes >= known_garbage_bytes, "invariant" ); | |
| 478 | |
| 479 _known_garbage_bytes -= known_garbage_bytes; | |
| 480 size_t heap_bytes = _g1->capacity(); | |
| 481 _known_garbage_ratio = (double) _known_garbage_bytes / (double) heap_bytes; | |
| 482 } | |
| 483 | |
| 484 G1MMUTracker* mmu_tracker() { | |
| 485 return _mmu_tracker; | |
| 486 } | |
| 487 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
488 double max_pause_time_ms() { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
489 return _mmu_tracker->max_gc_time() * 1000.0; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
490 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
491 |
| 342 | 492 double predict_remark_time_ms() { |
| 493 return get_new_prediction(_concurrent_mark_remark_times_ms); | |
| 494 } | |
| 495 | |
| 496 double predict_cleanup_time_ms() { | |
| 497 return get_new_prediction(_concurrent_mark_cleanup_times_ms); | |
| 498 } | |
| 499 | |
| 500 // Returns an estimate of the survival rate of the region at yg-age | |
| 501 // "yg_age". | |
| 545 | 502 double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) { |
| 503 TruncatedSeq* seq = surv_rate_group->get_seq(age); | |
| 342 | 504 if (seq->num() == 0) |
| 505 gclog_or_tty->print("BARF! age is %d", age); | |
| 506 guarantee( seq->num() > 0, "invariant" ); | |
| 507 double pred = get_new_prediction(seq); | |
| 508 if (pred > 1.0) | |
| 509 pred = 1.0; | |
| 510 return pred; | |
| 511 } | |
| 512 | |
| 545 | 513 double predict_yg_surv_rate(int age) { |
| 514 return predict_yg_surv_rate(age, _short_lived_surv_rate_group); | |
| 515 } | |
| 516 | |
| 342 | 517 double accum_yg_surv_rate_pred(int age) { |
| 518 return _short_lived_surv_rate_group->accum_surv_rate_pred(age); | |
| 519 } | |
| 520 | |
| 4013 | 521 private: |
| 1611 | 522 void print_stats(int level, const char* str, double value); |
| 523 void print_stats(int level, const char* str, int value); | |
| 524 | |
| 2430 | 525 void print_par_stats(int level, const char* str, double* data); |
| 526 void print_par_sizes(int level, const char* str, double* data); | |
| 342 | 527 |
| 528 void check_other_times(int level, | |
| 529 NumberSeq* other_times_ms, | |
| 530 NumberSeq* calc_other_times_ms) const; | |
| 531 | |
| 532 void print_summary (PauseSummary* stats) const; | |
| 533 | |
| 534 void print_summary (int level, const char* str, NumberSeq* seq) const; | |
| 535 void print_summary_sd (int level, const char* str, NumberSeq* seq) const; | |
| 536 | |
| 537 double avg_value (double* data); | |
| 538 double max_value (double* data); | |
| 539 double sum_of_values (double* data); | |
| 540 double max_sum (double* data1, double* data2); | |
| 541 | |
| 542 double _last_pause_time_ms; | |
| 543 | |
| 544 size_t _bytes_in_collection_set_before_gc; | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
545 size_t _bytes_copied_during_gc; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
546 |
| 342 | 547 // Used to count used bytes in CS. |
| 548 friend class CountCSClosure; | |
| 549 | |
| 550 // Statistics kept per GC stoppage, pause or full. | |
| 551 TruncatedSeq* _recent_prev_end_times_for_all_gcs_sec; | |
| 552 | |
| 553 // Add a new GC of the given duration and end time to the record. | |
| 554 void update_recent_gc_times(double end_time_sec, double elapsed_ms); | |
| 555 | |
| 556 // The head of the list (via "next_in_collection_set()") representing the | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
557 // current collection set. Set from the incrementally built collection |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
558 // set at the start of the pause. |
| 342 | 559 HeapRegion* _collection_set; |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
560 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
561 // The number of bytes in the collection set before the pause. Set from |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
562 // the incrementally built collection set at the start of an evacuation |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
563 // pause. |
| 342 | 564 size_t _collection_set_bytes_used_before; |
| 565 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
566 // The associated information that is maintained while the incremental |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
567 // collection set is being built with young regions. Used to populate |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
568 // the recorded info for the evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
569 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
570 enum CSetBuildType { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
571 Active, // We are actively building the collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
572 Inactive // We are not actively building the collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
573 }; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
574 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
575 CSetBuildType _inc_cset_build_state; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
576 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
577 // The head of the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
578 HeapRegion* _inc_cset_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
579 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
580 // The tail of the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
581 HeapRegion* _inc_cset_tail; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
582 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
583 // The number of bytes in the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
584 // Used to set _collection_set_bytes_used_before at the start of |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
585 // an evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
586 size_t _inc_cset_bytes_used_before; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
587 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
588 // Used to record the highest end of heap region in collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
589 HeapWord* _inc_cset_max_finger; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
590 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
591 // The RSet lengths recorded for regions in the collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
592 // (updated by the periodic sampling of the regions in the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
593 // young list/collection set). |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
594 size_t _inc_cset_recorded_rs_lengths; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
595 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
596 // The predicted elapsed time it will take to collect the regions |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
597 // in the collection set (updated by the periodic sampling of the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
598 // regions in the young list/collection set). |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
599 double _inc_cset_predicted_elapsed_time_ms; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
600 |
| 342 | 601 // Stash a pointer to the g1 heap. |
| 602 G1CollectedHeap* _g1; | |
| 603 | |
| 604 // The ratio of gc time to elapsed time, computed over recent pauses. | |
| 605 double _recent_avg_pause_time_ratio; | |
| 606 | |
| 607 double recent_avg_pause_time_ratio() { | |
| 608 return _recent_avg_pause_time_ratio; | |
| 609 } | |
| 610 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
611 // At the end of a pause we check the heap occupancy and we decide |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
612 // whether we will start a marking cycle during the next pause. If |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
613 // we decide that we want to do that, we will set this parameter to |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
614 // true. So, this parameter will stay true between the end of a |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
615 // pause and the beginning of a subsequent pause (not necessarily |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
616 // the next one, see the comments on the next field) when we decide |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
617 // that we will indeed start a marking cycle and do the initial-mark |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
618 // work. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
619 volatile bool _initiate_conc_mark_if_possible; |
| 342 | 620 |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
621 // If initiate_conc_mark_if_possible() is set at the beginning of a |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
622 // pause, it is a suggestion that the pause should start a marking |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
623 // cycle by doing the initial-mark work. However, it is possible |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
624 // that the concurrent marking thread is still finishing up the |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
625 // previous marking cycle (e.g., clearing the next marking |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
626 // bitmap). If that is the case we cannot start a new cycle and |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
627 // we'll have to wait for the concurrent marking thread to finish |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
628 // what it is doing. In this case we will postpone the marking cycle |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
629 // initiation decision for the next pause. When we eventually decide |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
630 // to start a cycle, we will set _during_initial_mark_pause which |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
631 // will stay true until the end of the initial-mark pause and it's |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
632 // the condition that indicates that a pause is doing the |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
633 // initial-mark work. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
634 volatile bool _during_initial_mark_pause; |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
635 |
| 4710 | 636 bool _should_revert_to_young_gcs; |
| 637 bool _last_young_gc; | |
| 342 | 638 |
| 639 // This set of variables tracks the collector efficiency, in order to | |
| 640 // determine whether we should initiate a new marking. | |
| 641 double _cur_mark_stop_world_time_ms; | |
| 642 double _mark_remark_start_sec; | |
| 643 double _mark_cleanup_start_sec; | |
| 644 double _mark_closure_time_ms; | |
| 645 | |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
646 // Update the young list target length either by setting it to the |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
647 // desired fixed value or by calculating it using G1's pause |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
648 // prediction model. If no rs_lengths parameter is passed, predict |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
649 // the RS lengths using the prediction model, otherwise use the |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
650 // given rs_lengths as the prediction. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
651 void update_young_list_target_length(size_t rs_lengths = (size_t) -1); |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
652 |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
653 // Calculate and return the minimum desired young list target |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
654 // length. This is the minimum desired young list length according |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
655 // to the user's inputs. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
656 size_t calculate_young_list_desired_min_length(size_t base_min_length); |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
657 |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
658 // Calculate and return the maximum desired young list target |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
659 // length. This is the maximum desired young list length according |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
660 // to the user's inputs. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
661 size_t calculate_young_list_desired_max_length(); |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
662 |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
663 // Calculate and return the maximum young list target length that |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
664 // can fit into the pause time goal. The parameters are: rs_lengths |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
665 // represent the prediction of how large the young RSet lengths will |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
666 // be, base_min_length is the alreay existing number of regions in |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
667 // the young list, min_length and max_length are the desired min and |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
668 // max young list length according to the user's inputs. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
669 size_t calculate_young_list_target_length(size_t rs_lengths, |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
670 size_t base_min_length, |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
671 size_t desired_min_length, |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
672 size_t desired_max_length); |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
673 |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
674 // Check whether a given young length (young_length) fits into the |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
675 // given target pause time and whether the prediction for the amount |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
676 // of objects to be copied for the given length will fit into the |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
677 // given free space (expressed by base_free_regions). It is used by |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
678 // calculate_young_list_target_length(). |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
679 bool predict_will_fit(size_t young_length, double base_time_ms, |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
680 size_t base_free_regions, double target_pause_time_ms); |
| 342 | 681 |
| 4013 | 682 // Count the number of bytes used in the CS. |
| 683 void count_CS_bytes_used(); | |
| 684 | |
| 685 void update_young_list_size_using_newratio(size_t number_of_heap_regions); | |
| 686 | |
| 342 | 687 public: |
| 688 | |
| 689 G1CollectorPolicy(); | |
| 690 | |
| 691 virtual G1CollectorPolicy* as_g1_policy() { return this; } | |
| 692 | |
| 693 virtual CollectorPolicy::Name kind() { | |
| 694 return CollectorPolicy::G1CollectorPolicyKind; | |
| 695 } | |
| 696 | |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
697 // Check the current value of the young list RSet lengths and |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
698 // compare it against the last prediction. If the current value is |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
699 // higher, recalculate the young list target length prediction. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
700 void revise_young_list_target_length_if_necessary(); |
| 342 | 701 |
| 702 size_t bytes_in_collection_set() { | |
| 703 return _bytes_in_collection_set_before_gc; | |
| 704 } | |
| 705 | |
| 706 unsigned calc_gc_alloc_time_stamp() { | |
| 707 return _all_pause_times_ms->num() + 1; | |
| 708 } | |
| 709 | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
710 // This should be called after the heap is resized. |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
711 void record_new_heap_size(size_t new_number_of_regions); |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
712 |
| 342 | 713 public: |
| 714 | |
| 4013 | 715 void init(); |
| 342 | 716 |
| 545 | 717 // Create jstat counters for the policy. |
| 718 virtual void initialize_gc_policy_counters(); | |
| 719 | |
| 342 | 720 virtual HeapWord* mem_allocate_work(size_t size, |
| 721 bool is_tlab, | |
| 722 bool* gc_overhead_limit_was_exceeded); | |
| 723 | |
| 724 // This method controls how a collector handles one or more | |
| 725 // of its generations being fully allocated. | |
| 726 virtual HeapWord* satisfy_failed_allocation(size_t size, | |
| 727 bool is_tlab); | |
| 728 | |
| 729 BarrierSet::Name barrier_set_name() { return BarrierSet::G1SATBCTLogging; } | |
| 730 | |
| 731 GenRemSet::Name rem_set_name() { return GenRemSet::CardTable; } | |
| 732 | |
| 733 // Update the heuristic info to record a collection pause of the given | |
| 734 // start time, where the given number of bytes were used at the start. | |
| 735 // This may involve changing the desired size of a collection set. | |
| 736 | |
| 4013 | 737 void record_stop_world_start(); |
| 342 | 738 |
| 4013 | 739 void record_collection_pause_start(double start_time_sec, size_t start_used); |
| 342 | 740 |
| 741 // Must currently be called while the world is stopped. | |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
742 void record_concurrent_mark_init_end(double |
| 342 | 743 mark_init_elapsed_time_ms); |
| 744 | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
745 void record_mark_closure_time(double mark_closure_time_ms) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
746 _mark_closure_time_ms = mark_closure_time_ms; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
747 } |
| 342 | 748 |
| 4013 | 749 void record_concurrent_mark_remark_start(); |
| 750 void record_concurrent_mark_remark_end(); | |
| 342 | 751 |
| 4013 | 752 void record_concurrent_mark_cleanup_start(); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
753 void record_concurrent_mark_cleanup_end(int no_of_gc_threads); |
| 4013 | 754 void record_concurrent_mark_cleanup_completed(); |
| 342 | 755 |
| 4013 | 756 void record_concurrent_pause(); |
| 757 void record_concurrent_pause_end(); | |
| 342 | 758 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
759 void record_collection_pause_end(int no_of_gc_threads); |
|
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
760 void print_heap_transition(); |
| 342 | 761 |
| 762 // Record the fact that a full collection occurred. | |
| 4013 | 763 void record_full_collection_start(); |
| 764 void record_full_collection_end(); | |
| 342 | 765 |
| 1611 | 766 void record_gc_worker_start_time(int worker_i, double ms) { |
| 767 _par_last_gc_worker_start_times_ms[worker_i] = ms; | |
| 768 } | |
| 769 | |
| 342 | 770 void record_ext_root_scan_time(int worker_i, double ms) { |
| 771 _par_last_ext_root_scan_times_ms[worker_i] = ms; | |
| 772 } | |
| 773 | |
| 774 void record_mark_stack_scan_time(int worker_i, double ms) { | |
| 775 _par_last_mark_stack_scan_times_ms[worker_i] = ms; | |
| 776 } | |
| 777 | |
| 778 void record_satb_drain_time(double ms) { | |
| 4023 | 779 assert(_g1->mark_in_progress(), "shouldn't be here otherwise"); |
| 342 | 780 _cur_satb_drain_time_ms = ms; |
| 781 } | |
| 782 | |
| 783 void record_update_rs_time(int thread, double ms) { | |
| 784 _par_last_update_rs_times_ms[thread] = ms; | |
| 785 } | |
| 786 | |
| 787 void record_update_rs_processed_buffers (int thread, | |
| 788 double processed_buffers) { | |
| 789 _par_last_update_rs_processed_buffers[thread] = processed_buffers; | |
| 790 } | |
| 791 | |
| 792 void record_scan_rs_time(int thread, double ms) { | |
| 793 _par_last_scan_rs_times_ms[thread] = ms; | |
| 794 } | |
| 795 | |
| 796 void reset_obj_copy_time(int thread) { | |
| 797 _par_last_obj_copy_times_ms[thread] = 0.0; | |
| 798 } | |
| 799 | |
| 800 void reset_obj_copy_time() { | |
| 801 reset_obj_copy_time(0); | |
| 802 } | |
| 803 | |
| 804 void record_obj_copy_time(int thread, double ms) { | |
| 805 _par_last_obj_copy_times_ms[thread] += ms; | |
| 806 } | |
| 807 | |
| 1611 | 808 void record_termination(int thread, double ms, size_t attempts) { |
| 809 _par_last_termination_times_ms[thread] = ms; | |
| 810 _par_last_termination_attempts[thread] = (double) attempts; | |
| 342 | 811 } |
| 812 | |
| 1611 | 813 void record_gc_worker_end_time(int worker_i, double ms) { |
| 814 _par_last_gc_worker_end_times_ms[worker_i] = ms; | |
| 342 | 815 } |
| 816 | |
|
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
549
diff
changeset
|
817 void record_pause_time_ms(double ms) { |
| 342 | 818 _last_pause_time_ms = ms; |
| 819 } | |
| 820 | |
| 821 void record_clear_ct_time(double ms) { | |
| 822 _cur_clear_ct_time_ms = ms; | |
| 823 } | |
| 824 | |
| 825 void record_par_time(double ms) { | |
| 826 _cur_collection_par_time_ms = ms; | |
| 827 } | |
| 828 | |
| 829 void record_aux_start_time(int i) { | |
| 830 guarantee(i < _aux_num, "should be within range"); | |
| 831 _cur_aux_start_times_ms[i] = os::elapsedTime() * 1000.0; | |
| 832 } | |
| 833 | |
| 834 void record_aux_end_time(int i) { | |
| 835 guarantee(i < _aux_num, "should be within range"); | |
| 836 double ms = os::elapsedTime() * 1000.0 - _cur_aux_start_times_ms[i]; | |
| 837 _cur_aux_times_set[i] = true; | |
| 838 _cur_aux_times_ms[i] += ms; | |
| 839 } | |
| 840 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
841 void record_ref_proc_time(double ms) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
842 _cur_ref_proc_time_ms = ms; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
843 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
844 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
845 void record_ref_enq_time(double ms) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
846 _cur_ref_enq_time_ms = ms; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
847 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
848 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
849 #ifndef PRODUCT |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
850 void record_cc_clear_time(double ms) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
851 if (_min_clear_cc_time_ms < 0.0 || ms <= _min_clear_cc_time_ms) |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
852 _min_clear_cc_time_ms = ms; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
853 if (_max_clear_cc_time_ms < 0.0 || ms >= _max_clear_cc_time_ms) |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
854 _max_clear_cc_time_ms = ms; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
855 _cur_clear_cc_time_ms = ms; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
856 _cum_clear_cc_time_ms += ms; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
857 _num_cc_clears++; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
858 } |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
859 #endif |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
860 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
861 // Record how much space we copied during a GC. This is typically |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
862 // called when a GC alloc region is being retired. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
863 void record_bytes_copied_during_gc(size_t bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
864 _bytes_copied_during_gc += bytes; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
865 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
866 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
867 // The amount of space we copied during a GC. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
868 size_t bytes_copied_during_gc() { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
869 return _bytes_copied_during_gc; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
870 } |
| 342 | 871 |
| 872 // Choose a new collection set. Marks the chosen regions as being | |
| 873 // "in_collection_set", and links them together. The head and number of | |
| 874 // the collection set are available via access methods. | |
| 4013 | 875 void choose_collection_set(double target_pause_time_ms); |
| 342 | 876 |
| 877 // The head of the list (via "next_in_collection_set()") representing the | |
| 878 // current collection set. | |
| 879 HeapRegion* collection_set() { return _collection_set; } | |
| 880 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
881 void clear_collection_set() { _collection_set = NULL; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
882 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
883 // Add old region "hr" to the CSet. |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
884 void add_old_region_to_cset(HeapRegion* hr); |
| 342 | 885 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
886 // Incremental CSet Support |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
887 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
888 // The head of the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
889 HeapRegion* inc_cset_head() { return _inc_cset_head; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
890 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
891 // The tail of the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
892 HeapRegion* inc_set_tail() { return _inc_cset_tail; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
893 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
894 // Initialize incremental collection set info. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
895 void start_incremental_cset_building(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
896 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
897 void clear_incremental_cset() { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
898 _inc_cset_head = NULL; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
899 _inc_cset_tail = NULL; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
900 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
901 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
902 // Stop adding regions to the incremental collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
903 void stop_incremental_cset_building() { _inc_cset_build_state = Inactive; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
904 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
905 // Add/remove information about hr to the aggregated information |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
906 // for the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
907 void add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
908 void remove_from_incremental_cset_info(HeapRegion* hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
909 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
910 // Update information about hr in the aggregated information for |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
911 // the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
912 void update_incremental_cset_info(HeapRegion* hr, size_t new_rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
913 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
914 private: |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
915 // Update the incremental cset information when adding a region |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
916 // (should not be called directly). |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
917 void add_region_to_incremental_cset_common(HeapRegion* hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
918 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
919 public: |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
920 // Add hr to the LHS of the incremental collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
921 void add_region_to_incremental_cset_lhs(HeapRegion* hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
922 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
923 // Add hr to the RHS of the incremental collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
924 void add_region_to_incremental_cset_rhs(HeapRegion* hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
925 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
926 #ifndef PRODUCT |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
927 void print_collection_set(HeapRegion* list_head, outputStream* st); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
928 #endif // !PRODUCT |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
929 |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
930 bool initiate_conc_mark_if_possible() { return _initiate_conc_mark_if_possible; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
931 void set_initiate_conc_mark_if_possible() { _initiate_conc_mark_if_possible = true; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
932 void clear_initiate_conc_mark_if_possible() { _initiate_conc_mark_if_possible = false; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
933 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
934 bool during_initial_mark_pause() { return _during_initial_mark_pause; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
935 void set_during_initial_mark_pause() { _during_initial_mark_pause = true; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
936 void clear_during_initial_mark_pause(){ _during_initial_mark_pause = false; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
937 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
938 // This sets the initiate_conc_mark_if_possible() flag to start a |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
939 // new cycle, as long as we are not already in one. It's best if it |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
940 // is called during a safepoint when the test whether a cycle is in |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
941 // progress or not is stable. |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
942 bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
943 |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
944 // This is called at the very beginning of an evacuation pause (it |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
945 // has to be the first thing that the pause does). If |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
946 // initiate_conc_mark_if_possible() is true, and the concurrent |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
947 // marking thread has completed its work during the previous cycle, |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
948 // it will set during_initial_mark_pause() to so that the pause does |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
949 // the initial-mark work and start a marking cycle. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
950 void decide_on_conc_mark_initiation(); |
| 342 | 951 |
| 952 // If an expansion would be appropriate, because recent GC overhead had | |
| 953 // exceeded the desired limit, return an amount to expand by. | |
| 4013 | 954 size_t expansion_amount(); |
| 342 | 955 |
| 956 #ifndef PRODUCT | |
| 957 // Check any appropriate marked bytes info, asserting false if | |
| 958 // something's wrong, else returning "true". | |
| 4013 | 959 bool assertMarkedBytesDataOK(); |
| 342 | 960 #endif |
| 961 | |
| 962 // Print tracing information. | |
| 963 void print_tracing_info() const; | |
| 964 | |
| 965 // Print stats on young survival ratio | |
| 966 void print_yg_surv_rate_info() const; | |
| 967 | |
| 545 | 968 void finished_recalculating_age_indexes(bool is_survivors) { |
| 969 if (is_survivors) { | |
| 970 _survivor_surv_rate_group->finished_recalculating_age_indexes(); | |
| 971 } else { | |
| 972 _short_lived_surv_rate_group->finished_recalculating_age_indexes(); | |
| 973 } | |
| 342 | 974 // do that for any other surv rate groups |
| 975 } | |
| 976 | |
| 1973 | 977 bool is_young_list_full() { |
| 978 size_t young_list_length = _g1->young_list()->length(); | |
|
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
979 size_t young_list_target_length = _young_list_target_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
980 return young_list_length >= young_list_target_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
981 } |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
982 |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
983 bool can_expand_young_list() { |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
984 size_t young_list_length = _g1->young_list()->length(); |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
985 size_t young_list_max_length = _young_list_max_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
986 return young_list_length < young_list_max_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
987 } |
| 1973 | 988 |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
989 size_t young_list_max_length() { |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
990 return _young_list_max_length; |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
991 } |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
992 |
| 4710 | 993 bool gcs_are_young() { |
| 994 return _gcs_are_young; | |
| 342 | 995 } |
| 4710 | 996 void set_gcs_are_young(bool gcs_are_young) { |
| 997 _gcs_are_young = gcs_are_young; | |
| 342 | 998 } |
| 999 | |
| 1000 bool adaptive_young_list_length() { | |
| 1001 return _adaptive_young_list_length; | |
| 1002 } | |
| 1003 void set_adaptive_young_list_length(bool adaptive_young_list_length) { | |
| 1004 _adaptive_young_list_length = adaptive_young_list_length; | |
| 1005 } | |
| 1006 | |
| 1007 inline double get_gc_eff_factor() { | |
| 1008 double ratio = _known_garbage_ratio; | |
| 1009 | |
| 1010 double square = ratio * ratio; | |
| 1011 // square = square * square; | |
| 1012 double ret = square * 9.0 + 1.0; | |
| 1013 #if 0 | |
| 1014 gclog_or_tty->print_cr("ratio = %1.2lf, ret = %1.2lf", ratio, ret); | |
| 1015 #endif // 0 | |
| 1016 guarantee(0.0 <= ret && ret < 10.0, "invariant!"); | |
| 1017 return ret; | |
| 1018 } | |
| 1019 | |
| 4013 | 1020 private: |
| 342 | 1021 // |
| 1022 // Survivor regions policy. | |
| 1023 // | |
| 1024 | |
| 1025 // Current tenuring threshold, set to 0 if the collector reaches the | |
| 1026 // maximum amount of suvivors regions. | |
| 1027 int _tenuring_threshold; | |
| 1028 | |
| 545 | 1029 // The limit on the number of regions allocated for survivors. |
| 1030 size_t _max_survivor_regions; | |
| 1031 | |
|
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1032 // For reporting purposes. |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1033 size_t _eden_bytes_before_gc; |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1034 size_t _survivor_bytes_before_gc; |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1035 size_t _capacity_before_gc; |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1036 |
| 545 | 1037 // The amount of survor regions after a collection. |
| 1038 size_t _recorded_survivor_regions; | |
| 1039 // List of survivor regions. | |
| 1040 HeapRegion* _recorded_survivor_head; | |
| 1041 HeapRegion* _recorded_survivor_tail; | |
| 1042 | |
| 1043 ageTable _survivors_age_table; | |
| 1044 | |
| 342 | 1045 public: |
| 1046 | |
| 1047 inline GCAllocPurpose | |
| 1048 evacuation_destination(HeapRegion* src_region, int age, size_t word_sz) { | |
| 1049 if (age < _tenuring_threshold && src_region->is_young()) { | |
| 1050 return GCAllocForSurvived; | |
| 1051 } else { | |
| 1052 return GCAllocForTenured; | |
| 1053 } | |
| 1054 } | |
| 1055 | |
| 1056 inline bool track_object_age(GCAllocPurpose purpose) { | |
| 1057 return purpose == GCAllocForSurvived; | |
| 1058 } | |
| 1059 | |
| 545 | 1060 static const size_t REGIONS_UNLIMITED = ~(size_t)0; |
| 1061 | |
| 1062 size_t max_regions(int purpose); | |
| 342 | 1063 |
| 1064 // The limit on regions for a particular purpose is reached. | |
| 1065 void note_alloc_region_limit_reached(int purpose) { | |
| 1066 if (purpose == GCAllocForSurvived) { | |
| 1067 _tenuring_threshold = 0; | |
| 1068 } | |
| 1069 } | |
| 1070 | |
| 1071 void note_start_adding_survivor_regions() { | |
| 1072 _survivor_surv_rate_group->start_adding_regions(); | |
| 1073 } | |
| 1074 | |
| 1075 void note_stop_adding_survivor_regions() { | |
| 1076 _survivor_surv_rate_group->stop_adding_regions(); | |
| 1077 } | |
| 545 | 1078 |
| 1079 void record_survivor_regions(size_t regions, | |
| 1080 HeapRegion* head, | |
| 1081 HeapRegion* tail) { | |
| 1082 _recorded_survivor_regions = regions; | |
| 1083 _recorded_survivor_head = head; | |
| 1084 _recorded_survivor_tail = tail; | |
| 1085 } | |
| 1086 | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
794
diff
changeset
|
1087 size_t recorded_survivor_regions() { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
794
diff
changeset
|
1088 return _recorded_survivor_regions; |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
794
diff
changeset
|
1089 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
794
diff
changeset
|
1090 |
| 545 | 1091 void record_thread_age_table(ageTable* age_table) |
| 1092 { | |
| 1093 _survivors_age_table.merge_par(age_table); | |
| 1094 } | |
| 1095 | |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1096 void update_max_gc_locker_expansion(); |
|
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1097 |
| 545 | 1098 // Calculates survivor space parameters. |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1099 void update_survivors_policy(); |
| 545 | 1100 |
| 342 | 1101 }; |
| 1102 | |
| 1103 // This should move to some place more general... | |
| 1104 | |
| 1105 // If we have "n" measurements, and we've kept track of their "sum" and the | |
| 1106 // "sum_of_squares" of the measurements, this returns the variance of the | |
| 1107 // sequence. | |
| 1108 inline double variance(int n, double sum_of_squares, double sum) { | |
| 1109 double n_d = (double)n; | |
| 1110 double avg = sum/n_d; | |
| 1111 return (sum_of_squares - 2.0 * avg * sum + n_d * avg * avg) / n_d; | |
| 1112 } | |
| 1113 | |
| 1972 | 1114 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP |