1 /* 2 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 // This class keeps statistical information and computes the 26 // size of the heap. 27 28 // Forward decls 29 class elapsedTimer; 30 class CollectorPolicy; 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. 79 bool _gc_overhead_limit_exceeded; 80 // Use for diagnostics only. If UseGCOverheadLimit is false, 81 // this variable is still set. 82 bool _print_gc_overhead_limit_would_be_exceeded; 83 // Count of consecutive GC that have exceeded the 84 // GC time limit criterion. 85 uint _gc_overhead_limit_count; 86 // This flag signals that GCTimeLimit is being exceeded 87 // but may not have done so for the required number of consequetive 88 // collections. 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 413 bool gc_overhead_limit_exceeded() { 414 return _gc_overhead_limit_exceeded; 415 } 416 void set_gc_overhead_limit_exceeded(bool v) { 417 _gc_overhead_limit_exceeded = v; 418 } 419 420 // Tests conditions indicate the GC overhead limit is being approached. 421 bool gc_overhead_limit_near() { 422 return gc_overhead_limit_count() >= 423 (AdaptiveSizePolicyGCTimeLimitThreshold - 1); 424 } 425 uint gc_overhead_limit_count() { return _gc_overhead_limit_count; } 426 void reset_gc_overhead_limit_count() { _gc_overhead_limit_count = 0; } 427 void inc_gc_overhead_limit_count() { _gc_overhead_limit_count++; } 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 442 // Check the conditions for an out-of-memory due to excessive GC time. 443 // Set _gc_overhead_limit_exceeded if all the conditions have been met. 444 void check_gc_overhead_limit(size_t young_live, 445 size_t eden_live, 446 size_t max_old_gen_size, 447 size_t max_eden_size, 448 bool is_full_gc, 449 GCCause::Cause gc_cause, 450 CollectorPolicy* collector_policy); 451 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 };