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