Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp @ 1941:79d04223b8a5
Added caching for resolved types and resolved fields.
This is crucial, because the local load elimination will lead to wrong results, if field equality (of two RiField objects with the same object and the same RiType) is not given. The caching makes sure that the default equals implementation is sufficient.
| author | Thomas Wuerthinger <wuerthinger@ssw.jku.at> |
|---|---|
| date | Tue, 28 Dec 2010 18:33:26 +0100 |
| parents | c18cbe5936b8 |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
2 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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:
1387
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
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:
1387
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 // This class keeps statistical information and computes the | |
| 26 // size of the heap. | |
| 27 | |
| 28 // Forward decls | |
| 29 class elapsedTimer; | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
30 class CollectorPolicy; |
| 0 | 31 |
| 32 class AdaptiveSizePolicy : public CHeapObj { | |
| 33 friend class GCAdaptivePolicyCounters; | |
| 34 friend class PSGCAdaptivePolicyCounters; | |
| 35 friend class CMSGCAdaptivePolicyCounters; | |
| 36 protected: | |
| 37 | |
| 38 enum GCPolicyKind { | |
| 39 _gc_adaptive_size_policy, | |
| 40 _gc_ps_adaptive_size_policy, | |
| 41 _gc_cms_adaptive_size_policy | |
| 42 }; | |
| 43 virtual GCPolicyKind kind() const { return _gc_adaptive_size_policy; } | |
| 44 | |
| 45 enum SizePolicyTrueValues { | |
| 46 decrease_old_gen_for_throughput_true = -7, | |
| 47 decrease_young_gen_for_througput_true = -6, | |
| 48 | |
| 49 increase_old_gen_for_min_pauses_true = -5, | |
| 50 decrease_old_gen_for_min_pauses_true = -4, | |
| 51 decrease_young_gen_for_maj_pauses_true = -3, | |
| 52 increase_young_gen_for_min_pauses_true = -2, | |
| 53 increase_old_gen_for_maj_pauses_true = -1, | |
| 54 | |
| 55 decrease_young_gen_for_min_pauses_true = 1, | |
| 56 decrease_old_gen_for_maj_pauses_true = 2, | |
| 57 increase_young_gen_for_maj_pauses_true = 3, | |
| 58 | |
| 59 increase_old_gen_for_throughput_true = 4, | |
| 60 increase_young_gen_for_througput_true = 5, | |
| 61 | |
| 62 decrease_young_gen_for_footprint_true = 6, | |
| 63 decrease_old_gen_for_footprint_true = 7, | |
| 64 decide_at_full_gc_true = 8 | |
| 65 }; | |
| 66 | |
| 67 // Goal for the fraction of the total time during which application | |
| 68 // threads run. | |
| 69 const double _throughput_goal; | |
| 70 | |
| 71 // Last calculated sizes, in bytes, and aligned | |
| 72 size_t _eden_size; // calculated eden free space in bytes | |
| 73 size_t _promo_size; // calculated cms gen free space in bytes | |
| 74 | |
| 75 size_t _survivor_size; // calculated survivor size in bytes | |
| 76 | |
| 77 // This is a hint for the heap: we've detected that gc times | |
| 78 // are taking longer than GCTimeLimit allows. | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
79 bool _gc_overhead_limit_exceeded; |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
80 // Use for diagnostics only. If UseGCOverheadLimit is false, |
| 0 | 81 // this variable is still set. |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
82 bool _print_gc_overhead_limit_would_be_exceeded; |
| 0 | 83 // Count of consecutive GC that have exceeded the |
| 84 // GC time limit criterion. | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
85 uint _gc_overhead_limit_count; |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
86 // This flag signals that GCTimeLimit is being exceeded |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
87 // but may not have done so for the required number of consequetive |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
88 // collections. |
| 0 | 89 |
| 90 // Minor collection timers used to determine both | |
| 91 // pause and interval times for collections. | |
| 92 static elapsedTimer _minor_timer; | |
| 93 | |
| 94 // Major collection timers, used to determine both | |
| 95 // pause and interval times for collections | |
| 96 static elapsedTimer _major_timer; | |
| 97 | |
| 98 // Time statistics | |
| 99 AdaptivePaddedAverage* _avg_minor_pause; | |
| 100 AdaptiveWeightedAverage* _avg_minor_interval; | |
| 101 AdaptiveWeightedAverage* _avg_minor_gc_cost; | |
| 102 | |
| 103 AdaptiveWeightedAverage* _avg_major_interval; | |
| 104 AdaptiveWeightedAverage* _avg_major_gc_cost; | |
| 105 | |
| 106 // Footprint statistics | |
| 107 AdaptiveWeightedAverage* _avg_young_live; | |
| 108 AdaptiveWeightedAverage* _avg_eden_live; | |
| 109 AdaptiveWeightedAverage* _avg_old_live; | |
| 110 | |
| 111 // Statistics for survivor space calculation for young generation | |
| 112 AdaptivePaddedAverage* _avg_survived; | |
| 113 | |
| 114 // Objects that have been directly allocated in the old generation. | |
| 115 AdaptivePaddedNoZeroDevAverage* _avg_pretenured; | |
| 116 | |
| 117 // Variable for estimating the major and minor pause times. | |
| 118 // These variables represent linear least-squares fits of | |
| 119 // the data. | |
| 120 // minor pause time vs. old gen size | |
| 121 LinearLeastSquareFit* _minor_pause_old_estimator; | |
| 122 // minor pause time vs. young gen size | |
| 123 LinearLeastSquareFit* _minor_pause_young_estimator; | |
| 124 | |
| 125 // Variables for estimating the major and minor collection costs | |
| 126 // minor collection time vs. young gen size | |
| 127 LinearLeastSquareFit* _minor_collection_estimator; | |
| 128 // major collection time vs. cms gen size | |
| 129 LinearLeastSquareFit* _major_collection_estimator; | |
| 130 | |
| 131 // These record the most recent collection times. They | |
| 132 // are available as an alternative to using the averages | |
| 133 // for making ergonomic decisions. | |
| 134 double _latest_minor_mutator_interval_seconds; | |
| 135 | |
| 136 // Allowed difference between major and minor gc times, used | |
| 137 // for computing tenuring_threshold. | |
| 138 const double _threshold_tolerance_percent; | |
| 139 | |
| 140 const double _gc_pause_goal_sec; // goal for maximum gc pause | |
| 141 | |
| 142 // Flag indicating that the adaptive policy is ready to use | |
| 143 bool _young_gen_policy_is_ready; | |
| 144 | |
| 145 // decrease/increase the young generation for minor pause time | |
| 146 int _change_young_gen_for_min_pauses; | |
| 147 | |
| 148 // decrease/increase the old generation for major pause time | |
| 149 int _change_old_gen_for_maj_pauses; | |
| 150 | |
| 151 // change old geneneration for throughput | |
| 152 int _change_old_gen_for_throughput; | |
| 153 | |
| 154 // change young generation for throughput | |
| 155 int _change_young_gen_for_throughput; | |
| 156 | |
| 157 // Flag indicating that the policy would | |
| 158 // increase the tenuring threshold because of the total major gc cost | |
| 159 // is greater than the total minor gc cost | |
| 160 bool _increment_tenuring_threshold_for_gc_cost; | |
| 161 // decrease the tenuring threshold because of the the total minor gc | |
| 162 // cost is greater than the total major gc cost | |
| 163 bool _decrement_tenuring_threshold_for_gc_cost; | |
| 164 // decrease due to survivor size limit | |
| 165 bool _decrement_tenuring_threshold_for_survivor_limit; | |
| 166 | |
| 167 // decrease generation sizes for footprint | |
| 168 int _decrease_for_footprint; | |
| 169 | |
| 170 // Set if the ergonomic decisions were made at a full GC. | |
| 171 int _decide_at_full_gc; | |
| 172 | |
| 173 // Changing the generation sizing depends on the data that is | |
| 174 // gathered about the effects of changes on the pause times and | |
| 175 // throughput. These variable count the number of data points | |
| 176 // gathered. The policy may use these counters as a threshhold | |
| 177 // for reliable data. | |
| 178 julong _young_gen_change_for_minor_throughput; | |
| 179 julong _old_gen_change_for_major_throughput; | |
| 180 | |
| 181 // Accessors | |
| 182 | |
| 183 double gc_pause_goal_sec() const { return _gc_pause_goal_sec; } | |
| 184 // The value returned is unitless: it's the proportion of time | |
| 185 // spent in a particular collection type. | |
| 186 // An interval time will be 0.0 if a collection type hasn't occurred yet. | |
| 187 // The 1.4.2 implementation put a floor on the values of major_gc_cost | |
| 188 // and minor_gc_cost. This was useful because of the way major_gc_cost | |
| 189 // and minor_gc_cost was used in calculating the sizes of the generations. | |
| 190 // Do not use a floor in this implementation because any finite value | |
| 191 // will put a limit on the throughput that can be achieved and any | |
| 192 // throughput goal above that limit will drive the generations sizes | |
| 193 // to extremes. | |
| 194 double major_gc_cost() const { | |
| 195 return MAX2(0.0F, _avg_major_gc_cost->average()); | |
| 196 } | |
| 197 | |
| 198 // The value returned is unitless: it's the proportion of time | |
| 199 // spent in a particular collection type. | |
| 200 // An interval time will be 0.0 if a collection type hasn't occurred yet. | |
| 201 // The 1.4.2 implementation put a floor on the values of major_gc_cost | |
| 202 // and minor_gc_cost. This was useful because of the way major_gc_cost | |
| 203 // and minor_gc_cost was used in calculating the sizes of the generations. | |
| 204 // Do not use a floor in this implementation because any finite value | |
| 205 // will put a limit on the throughput that can be achieved and any | |
| 206 // throughput goal above that limit will drive the generations sizes | |
| 207 // to extremes. | |
| 208 | |
| 209 double minor_gc_cost() const { | |
| 210 return MAX2(0.0F, _avg_minor_gc_cost->average()); | |
| 211 } | |
| 212 | |
| 213 // Because we're dealing with averages, gc_cost() can be | |
| 214 // larger than 1.0 if just the sum of the minor cost the | |
| 215 // the major cost is used. Worse than that is the | |
| 216 // fact that the minor cost and the major cost each | |
| 217 // tend toward 1.0 in the extreme of high gc costs. | |
| 218 // Limit the value of gc_cost to 1.0 so that the mutator | |
| 219 // cost stays non-negative. | |
| 220 virtual double gc_cost() const { | |
| 221 double result = MIN2(1.0, minor_gc_cost() + major_gc_cost()); | |
| 222 assert(result >= 0.0, "Both minor and major costs are non-negative"); | |
| 223 return result; | |
| 224 } | |
| 225 | |
| 226 // Elapsed time since the last major collection. | |
| 227 virtual double time_since_major_gc() const; | |
| 228 | |
| 229 // Average interval between major collections to be used | |
| 230 // in calculating the decaying major gc cost. An overestimate | |
| 231 // of this time would be a conservative estimate because | |
| 232 // this time is used to decide if the major GC cost | |
| 233 // should be decayed (i.e., if the time since the last | |
| 234 // major gc is long compared to the time returned here, | |
| 235 // then the major GC cost will be decayed). See the | |
| 236 // implementations for the specifics. | |
| 237 virtual double major_gc_interval_average_for_decay() const { | |
| 238 return _avg_major_interval->average(); | |
| 239 } | |
| 240 | |
| 241 // Return the cost of the GC where the major gc cost | |
| 242 // has been decayed based on the time since the last | |
| 243 // major collection. | |
| 244 double decaying_gc_cost() const; | |
| 245 | |
| 246 // Decay the major gc cost. Use this only for decisions on | |
| 247 // whether to adjust, not to determine by how much to adjust. | |
| 248 // This approximation is crude and may not be good enough for the | |
| 249 // latter. | |
| 250 double decaying_major_gc_cost() const; | |
| 251 | |
| 252 // Return the mutator cost using the decayed | |
| 253 // GC cost. | |
| 254 double adjusted_mutator_cost() const { | |
| 255 double result = 1.0 - decaying_gc_cost(); | |
| 256 assert(result >= 0.0, "adjusted mutator cost calculation is incorrect"); | |
| 257 return result; | |
| 258 } | |
| 259 | |
| 260 virtual double mutator_cost() const { | |
| 261 double result = 1.0 - gc_cost(); | |
| 262 assert(result >= 0.0, "mutator cost calculation is incorrect"); | |
| 263 return result; | |
| 264 } | |
| 265 | |
| 266 | |
| 267 bool young_gen_policy_is_ready() { return _young_gen_policy_is_ready; } | |
| 268 | |
| 269 void update_minor_pause_young_estimator(double minor_pause_in_ms); | |
| 270 virtual void update_minor_pause_old_estimator(double minor_pause_in_ms) { | |
| 271 // This is not meaningful for all policies but needs to be present | |
| 272 // to use minor_collection_end() in its current form. | |
| 273 } | |
| 274 | |
| 275 virtual size_t eden_increment(size_t cur_eden); | |
| 276 virtual size_t eden_increment(size_t cur_eden, uint percent_change); | |
| 277 virtual size_t eden_decrement(size_t cur_eden); | |
| 278 virtual size_t promo_increment(size_t cur_eden); | |
| 279 virtual size_t promo_increment(size_t cur_eden, uint percent_change); | |
| 280 virtual size_t promo_decrement(size_t cur_eden); | |
| 281 | |
| 282 virtual void clear_generation_free_space_flags(); | |
| 283 | |
| 284 int change_old_gen_for_throughput() const { | |
| 285 return _change_old_gen_for_throughput; | |
| 286 } | |
| 287 void set_change_old_gen_for_throughput(int v) { | |
| 288 _change_old_gen_for_throughput = v; | |
| 289 } | |
| 290 int change_young_gen_for_throughput() const { | |
| 291 return _change_young_gen_for_throughput; | |
| 292 } | |
| 293 void set_change_young_gen_for_throughput(int v) { | |
| 294 _change_young_gen_for_throughput = v; | |
| 295 } | |
| 296 | |
| 297 int change_old_gen_for_maj_pauses() const { | |
| 298 return _change_old_gen_for_maj_pauses; | |
| 299 } | |
| 300 void set_change_old_gen_for_maj_pauses(int v) { | |
| 301 _change_old_gen_for_maj_pauses = v; | |
| 302 } | |
| 303 | |
| 304 bool decrement_tenuring_threshold_for_gc_cost() const { | |
| 305 return _decrement_tenuring_threshold_for_gc_cost; | |
| 306 } | |
| 307 void set_decrement_tenuring_threshold_for_gc_cost(bool v) { | |
| 308 _decrement_tenuring_threshold_for_gc_cost = v; | |
| 309 } | |
| 310 bool increment_tenuring_threshold_for_gc_cost() const { | |
| 311 return _increment_tenuring_threshold_for_gc_cost; | |
| 312 } | |
| 313 void set_increment_tenuring_threshold_for_gc_cost(bool v) { | |
| 314 _increment_tenuring_threshold_for_gc_cost = v; | |
| 315 } | |
| 316 bool decrement_tenuring_threshold_for_survivor_limit() const { | |
| 317 return _decrement_tenuring_threshold_for_survivor_limit; | |
| 318 } | |
| 319 void set_decrement_tenuring_threshold_for_survivor_limit(bool v) { | |
| 320 _decrement_tenuring_threshold_for_survivor_limit = v; | |
| 321 } | |
| 322 // Return true if the policy suggested a change. | |
| 323 bool tenuring_threshold_change() const; | |
| 324 | |
| 325 public: | |
| 326 AdaptiveSizePolicy(size_t init_eden_size, | |
| 327 size_t init_promo_size, | |
| 328 size_t init_survivor_size, | |
| 329 double gc_pause_goal_sec, | |
| 330 uint gc_cost_ratio); | |
| 331 | |
| 332 bool is_gc_cms_adaptive_size_policy() { | |
| 333 return kind() == _gc_cms_adaptive_size_policy; | |
| 334 } | |
| 335 bool is_gc_ps_adaptive_size_policy() { | |
| 336 return kind() == _gc_ps_adaptive_size_policy; | |
| 337 } | |
| 338 | |
| 339 AdaptivePaddedAverage* avg_minor_pause() const { return _avg_minor_pause; } | |
| 340 AdaptiveWeightedAverage* avg_minor_interval() const { | |
| 341 return _avg_minor_interval; | |
| 342 } | |
| 343 AdaptiveWeightedAverage* avg_minor_gc_cost() const { | |
| 344 return _avg_minor_gc_cost; | |
| 345 } | |
| 346 | |
| 347 AdaptiveWeightedAverage* avg_major_gc_cost() const { | |
| 348 return _avg_major_gc_cost; | |
| 349 } | |
| 350 | |
| 351 AdaptiveWeightedAverage* avg_young_live() const { return _avg_young_live; } | |
| 352 AdaptiveWeightedAverage* avg_eden_live() const { return _avg_eden_live; } | |
| 353 AdaptiveWeightedAverage* avg_old_live() const { return _avg_old_live; } | |
| 354 | |
| 355 AdaptivePaddedAverage* avg_survived() const { return _avg_survived; } | |
| 356 AdaptivePaddedNoZeroDevAverage* avg_pretenured() { return _avg_pretenured; } | |
| 357 | |
| 358 // Methods indicating events of interest to the adaptive size policy, | |
| 359 // called by GC algorithms. It is the responsibility of users of this | |
| 360 // policy to call these methods at the correct times! | |
| 361 virtual void minor_collection_begin(); | |
| 362 virtual void minor_collection_end(GCCause::Cause gc_cause); | |
| 363 virtual LinearLeastSquareFit* minor_pause_old_estimator() const { | |
| 364 return _minor_pause_old_estimator; | |
| 365 } | |
| 366 | |
| 367 LinearLeastSquareFit* minor_pause_young_estimator() { | |
| 368 return _minor_pause_young_estimator; | |
| 369 } | |
| 370 LinearLeastSquareFit* minor_collection_estimator() { | |
| 371 return _minor_collection_estimator; | |
| 372 } | |
| 373 | |
| 374 LinearLeastSquareFit* major_collection_estimator() { | |
| 375 return _major_collection_estimator; | |
| 376 } | |
| 377 | |
| 378 float minor_pause_young_slope() { | |
| 379 return _minor_pause_young_estimator->slope(); | |
| 380 } | |
| 381 | |
| 382 float minor_collection_slope() { return _minor_collection_estimator->slope();} | |
| 383 float major_collection_slope() { return _major_collection_estimator->slope();} | |
| 384 | |
| 385 float minor_pause_old_slope() { | |
| 386 return _minor_pause_old_estimator->slope(); | |
| 387 } | |
| 388 | |
| 389 void set_eden_size(size_t new_size) { | |
| 390 _eden_size = new_size; | |
| 391 } | |
| 392 void set_survivor_size(size_t new_size) { | |
| 393 _survivor_size = new_size; | |
| 394 } | |
| 395 | |
| 396 size_t calculated_eden_size_in_bytes() const { | |
| 397 return _eden_size; | |
| 398 } | |
| 399 | |
| 400 size_t calculated_promo_size_in_bytes() const { | |
| 401 return _promo_size; | |
| 402 } | |
| 403 | |
| 404 size_t calculated_survivor_size_in_bytes() const { | |
| 405 return _survivor_size; | |
| 406 } | |
| 407 | |
| 408 // This is a hint for the heap: we've detected that gc times | |
| 409 // are taking longer than GCTimeLimit allows. | |
| 410 // Most heaps will choose to throw an OutOfMemoryError when | |
| 411 // this occurs but it is up to the heap to request this information | |
| 412 // of the policy | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
413 bool gc_overhead_limit_exceeded() { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
414 return _gc_overhead_limit_exceeded; |
| 0 | 415 } |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
416 void set_gc_overhead_limit_exceeded(bool v) { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
417 _gc_overhead_limit_exceeded = v; |
| 0 | 418 } |
| 419 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
420 // Tests conditions indicate the GC overhead limit is being approached. |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
421 bool gc_overhead_limit_near() { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
422 return gc_overhead_limit_count() >= |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
423 (AdaptiveSizePolicyGCTimeLimitThreshold - 1); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
424 } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
425 uint gc_overhead_limit_count() { return _gc_overhead_limit_count; } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
426 void reset_gc_overhead_limit_count() { _gc_overhead_limit_count = 0; } |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
427 void inc_gc_overhead_limit_count() { _gc_overhead_limit_count++; } |
| 0 | 428 // accessors for flags recording the decisions to resize the |
| 429 // generations to meet the pause goal. | |
| 430 | |
| 431 int change_young_gen_for_min_pauses() const { | |
| 432 return _change_young_gen_for_min_pauses; | |
| 433 } | |
| 434 void set_change_young_gen_for_min_pauses(int v) { | |
| 435 _change_young_gen_for_min_pauses = v; | |
| 436 } | |
| 437 void set_decrease_for_footprint(int v) { _decrease_for_footprint = v; } | |
| 438 int decrease_for_footprint() const { return _decrease_for_footprint; } | |
| 439 int decide_at_full_gc() { return _decide_at_full_gc; } | |
| 440 void set_decide_at_full_gc(int v) { _decide_at_full_gc = v; } | |
| 441 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
442 // Check the conditions for an out-of-memory due to excessive GC time. |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
443 // Set _gc_overhead_limit_exceeded if all the conditions have been met. |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
444 void check_gc_overhead_limit(size_t young_live, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
445 size_t eden_live, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
446 size_t max_old_gen_size, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
447 size_t max_eden_size, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
448 bool is_full_gc, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
449 GCCause::Cause gc_cause, |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
450 CollectorPolicy* collector_policy); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
0
diff
changeset
|
451 |
| 0 | 452 // Printing support |
| 453 virtual bool print_adaptive_size_policy_on(outputStream* st) const; | |
| 454 bool print_adaptive_size_policy_on(outputStream* st, int | |
| 455 tenuring_threshold) const; | |
| 456 }; | |
| 457 | |
| 458 // Class that can be used to print information about the | |
| 459 // adaptive size policy at intervals specified by | |
| 460 // AdaptiveSizePolicyOutputInterval. Only print information | |
| 461 // if an adaptive size policy is in use. | |
| 462 class AdaptiveSizePolicyOutput : StackObj { | |
| 463 AdaptiveSizePolicy* _size_policy; | |
| 464 bool _do_print; | |
| 465 bool print_test(uint count) { | |
| 466 // A count of zero is a special value that indicates that the | |
| 467 // interval test should be ignored. An interval is of zero is | |
| 468 // a special value that indicates that the interval test should | |
| 469 // always fail (never do the print based on the interval test). | |
| 470 return PrintGCDetails && | |
| 471 UseAdaptiveSizePolicy && | |
| 472 (UseParallelGC || UseConcMarkSweepGC) && | |
| 473 (AdaptiveSizePolicyOutputInterval > 0) && | |
| 474 ((count == 0) || | |
| 475 ((count % AdaptiveSizePolicyOutputInterval) == 0)); | |
| 476 } | |
| 477 public: | |
| 478 // The special value of a zero count can be used to ignore | |
| 479 // the count test. | |
| 480 AdaptiveSizePolicyOutput(uint count) { | |
| 481 if (UseAdaptiveSizePolicy && (AdaptiveSizePolicyOutputInterval > 0)) { | |
| 482 CollectedHeap* heap = Universe::heap(); | |
| 483 _size_policy = heap->size_policy(); | |
| 484 _do_print = print_test(count); | |
| 485 } else { | |
| 486 _size_policy = NULL; | |
| 487 _do_print = false; | |
| 488 } | |
| 489 } | |
| 490 AdaptiveSizePolicyOutput(AdaptiveSizePolicy* size_policy, | |
| 491 uint count) : | |
| 492 _size_policy(size_policy) { | |
| 493 if (UseAdaptiveSizePolicy && (AdaptiveSizePolicyOutputInterval > 0)) { | |
| 494 _do_print = print_test(count); | |
| 495 } else { | |
| 496 _do_print = false; | |
| 497 } | |
| 498 } | |
| 499 ~AdaptiveSizePolicyOutput() { | |
| 500 if (_do_print) { | |
| 501 assert(UseAdaptiveSizePolicy, "Should not be in use"); | |
| 502 _size_policy->print_adaptive_size_policy_on(gclog_or_tty); | |
| 503 } | |
| 504 } | |
| 505 }; |