< prev index next >

src/share/vm/gc/parallel/psAdaptiveSizePolicy.cpp

Print this page




 353     log_debug(gc, ergo)(
 354           "PSAdaptiveSizePolicy::compute_eden_space_size limits:"
 355           " desired_eden_size: " SIZE_FORMAT
 356           " old_eden_size: " SIZE_FORMAT
 357           " eden_limit: " SIZE_FORMAT
 358           " cur_eden: " SIZE_FORMAT
 359           " max_eden_size: " SIZE_FORMAT
 360           " avg_young_live: " SIZE_FORMAT,
 361           desired_eden_size, _eden_size, eden_limit, cur_eden,
 362           max_eden_size, (size_t)avg_young_live()->average());
 363   }
 364   if (gc_cost() > gc_cost_limit) {
 365     log_debug(gc, ergo)(
 366           "PSAdaptiveSizePolicy::compute_eden_space_size: gc time limit"
 367           " gc_cost: %f "
 368           " GCTimeLimit: " UINTX_FORMAT,
 369           gc_cost(), GCTimeLimit);
 370   }
 371 
 372   // Align everything and make a final limit check
 373   desired_eden_size  = align_size_up(desired_eden_size, _space_alignment);
 374   desired_eden_size  = MAX2(desired_eden_size, _space_alignment);
 375 
 376   eden_limit  = align_size_down(eden_limit, _space_alignment);
 377 
 378   // And one last limit check, now that we've aligned things.
 379   if (desired_eden_size > eden_limit) {
 380     // If the policy says to get a larger eden but
 381     // is hitting the limit, don't decrease eden.
 382     // This can lead to a general drifting down of the
 383     // eden size.  Let the tenuring calculation push more
 384     // into the old gen.
 385     desired_eden_size = MAX2(eden_limit, cur_eden);
 386   }
 387 
 388   log_debug(gc, ergo)("PSAdaptiveSizePolicy::compute_eden_space_size: costs minor_time: %f major_cost: %f mutator_cost: %f throughput_goal: %f",
 389              minor_gc_cost(), major_gc_cost(), mutator_cost(), _throughput_goal);
 390 
 391   log_trace(gc, ergo)("Minor_pause: %f major_pause: %f minor_interval: %f major_interval: %fpause_goal: %f",
 392                       _avg_minor_pause->padded_average(),
 393                       _avg_major_pause->padded_average(),
 394                       _avg_minor_interval->average(),
 395                       _avg_major_interval->average(),
 396                       gc_pause_goal_sec());


 530     size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average());
 531     log_debug(gc, ergo)(
 532           "PSAdaptiveSizePolicy::compute_old_gen_free_space limits:"
 533           " desired_promo_size: " SIZE_FORMAT
 534           " promo_limit: " SIZE_FORMAT
 535           " free_in_old_gen: " SIZE_FORMAT
 536           " max_old_gen_size: " SIZE_FORMAT
 537           " avg_old_live: " SIZE_FORMAT,
 538           desired_promo_size, promo_limit, free_in_old_gen,
 539           max_old_gen_size, (size_t) avg_old_live()->average());
 540   }
 541   if (gc_cost() > gc_cost_limit) {
 542     log_debug(gc, ergo)(
 543           "PSAdaptiveSizePolicy::compute_old_gen_free_space: gc time limit"
 544           " gc_cost: %f "
 545           " GCTimeLimit: " UINTX_FORMAT,
 546           gc_cost(), GCTimeLimit);
 547   }
 548 
 549   // Align everything and make a final limit check
 550   desired_promo_size = align_size_up(desired_promo_size, _space_alignment);
 551   desired_promo_size = MAX2(desired_promo_size, _space_alignment);
 552 
 553   promo_limit = align_size_down(promo_limit, _space_alignment);
 554 
 555   // And one last limit check, now that we've aligned things.
 556   desired_promo_size = MIN2(desired_promo_size, promo_limit);
 557 
 558   // Timing stats
 559   log_debug(gc, ergo)("PSAdaptiveSizePolicy::compute_old_gen_free_space: costs minor_time: %f major_cost: %f  mutator_cost: %f throughput_goal: %f",
 560              minor_gc_cost(), major_gc_cost(), mutator_cost(), _throughput_goal);
 561 
 562   log_trace(gc, ergo)("Minor_pause: %f major_pause: %f minor_interval: %f major_interval: %f pause_goal: %f",
 563                       _avg_minor_pause->padded_average(),
 564                       _avg_major_pause->padded_average(),
 565                       _avg_minor_interval->average(),
 566                       _avg_major_interval->average(),
 567                       gc_pause_goal_sec());
 568 
 569   // Footprint stats
 570   log_debug(gc, ergo)("Live_space: " SIZE_FORMAT " free_space: " SIZE_FORMAT,
 571                       live_space(), free_space());
 572 
 573   log_trace(gc, ergo)("Base_footprint: " SIZE_FORMAT " avg_young_live: " SIZE_FORMAT " avg_old_live: " SIZE_FORMAT,


 908     double fraction =  part / total;
 909     reduced_change = (size_t) (fraction * (double) change);
 910   }
 911   assert(reduced_change <= change, "Inconsistent result");
 912   return reduced_change;
 913 }
 914 
 915 size_t PSAdaptiveSizePolicy::eden_increment(size_t cur_eden,
 916                                             uint percent_change) {
 917   size_t eden_heap_delta;
 918   eden_heap_delta = cur_eden / 100 * percent_change;
 919   return eden_heap_delta;
 920 }
 921 
 922 size_t PSAdaptiveSizePolicy::eden_increment(size_t cur_eden) {
 923   return eden_increment(cur_eden, YoungGenerationSizeIncrement);
 924 }
 925 
 926 size_t PSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
 927   size_t result = eden_increment(cur_eden, YoungGenerationSizeIncrement);
 928   return align_size_up(result, _space_alignment);
 929 }
 930 
 931 size_t PSAdaptiveSizePolicy::eden_increment_aligned_down(size_t cur_eden) {
 932   size_t result = eden_increment(cur_eden);
 933   return align_size_down(result, _space_alignment);
 934 }
 935 
 936 size_t PSAdaptiveSizePolicy::eden_increment_with_supplement_aligned_up(
 937   size_t cur_eden) {
 938   size_t result = eden_increment(cur_eden,
 939     YoungGenerationSizeIncrement + _young_gen_size_increment_supplement);
 940   return align_size_up(result, _space_alignment);
 941 }
 942 
 943 size_t PSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
 944   size_t eden_heap_delta = eden_decrement(cur_eden);
 945   return align_size_down(eden_heap_delta, _space_alignment);
 946 }
 947 
 948 size_t PSAdaptiveSizePolicy::eden_decrement(size_t cur_eden) {
 949   size_t eden_heap_delta = eden_increment(cur_eden) /
 950     AdaptiveSizeDecrementScaleFactor;
 951   return eden_heap_delta;
 952 }
 953 
 954 size_t PSAdaptiveSizePolicy::promo_increment(size_t cur_promo,
 955                                              uint percent_change) {
 956   size_t promo_heap_delta;
 957   promo_heap_delta = cur_promo / 100 * percent_change;
 958   return promo_heap_delta;
 959 }
 960 
 961 size_t PSAdaptiveSizePolicy::promo_increment(size_t cur_promo) {
 962   return promo_increment(cur_promo, TenuredGenerationSizeIncrement);
 963 }
 964 
 965 size_t PSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
 966   size_t result =  promo_increment(cur_promo, TenuredGenerationSizeIncrement);
 967   return align_size_up(result, _space_alignment);
 968 }
 969 
 970 size_t PSAdaptiveSizePolicy::promo_increment_aligned_down(size_t cur_promo) {
 971   size_t result =  promo_increment(cur_promo, TenuredGenerationSizeIncrement);
 972   return align_size_down(result, _space_alignment);
 973 }
 974 
 975 size_t PSAdaptiveSizePolicy::promo_increment_with_supplement_aligned_up(
 976   size_t cur_promo) {
 977   size_t result =  promo_increment(cur_promo,
 978     TenuredGenerationSizeIncrement + _old_gen_size_increment_supplement);
 979   return align_size_up(result, _space_alignment);
 980 }
 981 
 982 size_t PSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
 983   size_t promo_heap_delta = promo_decrement(cur_promo);
 984   return align_size_down(promo_heap_delta, _space_alignment);
 985 }
 986 
 987 size_t PSAdaptiveSizePolicy::promo_decrement(size_t cur_promo) {
 988   size_t promo_heap_delta = promo_increment(cur_promo);
 989   promo_heap_delta = promo_heap_delta / AdaptiveSizeDecrementScaleFactor;
 990   return promo_heap_delta;
 991 }
 992 
 993 uint PSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold(
 994                                              bool is_survivor_overflow,
 995                                              uint tenuring_threshold,
 996                                              size_t survivor_limit) {
 997   assert(survivor_limit >= _space_alignment,
 998          "survivor_limit too small");
 999   assert(is_size_aligned(survivor_limit, _space_alignment),
1000          "survivor_limit not aligned");
1001 
1002   // This method is called even if the tenuring threshold and survivor
1003   // spaces are not adjusted so that the averages are sampled above.
1004   if (!UsePSAdaptiveSurvivorSizePolicy ||
1005       !young_gen_policy_is_ready()) {
1006     return tenuring_threshold;
1007   }
1008 
1009   // We'll decide whether to increase or decrease the tenuring
1010   // threshold based partly on the newly computed survivor size
1011   // (if we hit the maximum limit allowed, we'll always choose to
1012   // decrement the threshold).
1013   bool incr_tenuring_threshold = false;
1014   bool decr_tenuring_threshold = false;
1015 
1016   set_decrement_tenuring_threshold_for_gc_cost(false);
1017   set_increment_tenuring_threshold_for_gc_cost(false);
1018   set_decrement_tenuring_threshold_for_survivor_limit(false);
1019 


1042       set_increment_tenuring_threshold_for_gc_cost(true);
1043     }
1044 
1045   } else {
1046     // Survivor space overflow occurred, so promoted and survived are
1047     // not accurate. We'll make our best guess by combining survived
1048     // and promoted and count them as survivors.
1049     //
1050     // We'll lower the tenuring threshold to see if we can correct
1051     // things. Also, set the survivor size conservatively. We're
1052     // trying to avoid many overflows from occurring if defnew size
1053     // is just too small.
1054 
1055     decr_tenuring_threshold = true;
1056   }
1057 
1058   // The padded average also maintains a deviation from the average;
1059   // we use this to see how good of an estimate we have of what survived.
1060   // We're trying to pad the survivor size as little as possible without
1061   // overflowing the survivor spaces.
1062   size_t target_size = align_size_up((size_t)_avg_survived->padded_average(),
1063                                      _space_alignment);
1064   target_size = MAX2(target_size, _space_alignment);
1065 
1066   if (target_size > survivor_limit) {
1067     // Target size is bigger than we can handle. Let's also reduce
1068     // the tenuring threshold.
1069     target_size = survivor_limit;
1070     decr_tenuring_threshold = true;
1071     set_decrement_tenuring_threshold_for_survivor_limit(true);
1072   }
1073 
1074   // Finally, increment or decrement the tenuring threshold, as decided above.
1075   // We test for decrementing first, as we might have hit the target size
1076   // limit.
1077   if (decr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
1078     if (tenuring_threshold > 1) {
1079       tenuring_threshold--;
1080     }
1081   } else if (incr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
1082     if (tenuring_threshold < MaxTenuringThreshold) {




 353     log_debug(gc, ergo)(
 354           "PSAdaptiveSizePolicy::compute_eden_space_size limits:"
 355           " desired_eden_size: " SIZE_FORMAT
 356           " old_eden_size: " SIZE_FORMAT
 357           " eden_limit: " SIZE_FORMAT
 358           " cur_eden: " SIZE_FORMAT
 359           " max_eden_size: " SIZE_FORMAT
 360           " avg_young_live: " SIZE_FORMAT,
 361           desired_eden_size, _eden_size, eden_limit, cur_eden,
 362           max_eden_size, (size_t)avg_young_live()->average());
 363   }
 364   if (gc_cost() > gc_cost_limit) {
 365     log_debug(gc, ergo)(
 366           "PSAdaptiveSizePolicy::compute_eden_space_size: gc time limit"
 367           " gc_cost: %f "
 368           " GCTimeLimit: " UINTX_FORMAT,
 369           gc_cost(), GCTimeLimit);
 370   }
 371 
 372   // Align everything and make a final limit check
 373   desired_eden_size  = align_up(desired_eden_size, _space_alignment);
 374   desired_eden_size  = MAX2(desired_eden_size, _space_alignment);
 375 
 376   eden_limit  = align_down(eden_limit, _space_alignment);
 377 
 378   // And one last limit check, now that we've aligned things.
 379   if (desired_eden_size > eden_limit) {
 380     // If the policy says to get a larger eden but
 381     // is hitting the limit, don't decrease eden.
 382     // This can lead to a general drifting down of the
 383     // eden size.  Let the tenuring calculation push more
 384     // into the old gen.
 385     desired_eden_size = MAX2(eden_limit, cur_eden);
 386   }
 387 
 388   log_debug(gc, ergo)("PSAdaptiveSizePolicy::compute_eden_space_size: costs minor_time: %f major_cost: %f mutator_cost: %f throughput_goal: %f",
 389              minor_gc_cost(), major_gc_cost(), mutator_cost(), _throughput_goal);
 390 
 391   log_trace(gc, ergo)("Minor_pause: %f major_pause: %f minor_interval: %f major_interval: %fpause_goal: %f",
 392                       _avg_minor_pause->padded_average(),
 393                       _avg_major_pause->padded_average(),
 394                       _avg_minor_interval->average(),
 395                       _avg_major_interval->average(),
 396                       gc_pause_goal_sec());


 530     size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average());
 531     log_debug(gc, ergo)(
 532           "PSAdaptiveSizePolicy::compute_old_gen_free_space limits:"
 533           " desired_promo_size: " SIZE_FORMAT
 534           " promo_limit: " SIZE_FORMAT
 535           " free_in_old_gen: " SIZE_FORMAT
 536           " max_old_gen_size: " SIZE_FORMAT
 537           " avg_old_live: " SIZE_FORMAT,
 538           desired_promo_size, promo_limit, free_in_old_gen,
 539           max_old_gen_size, (size_t) avg_old_live()->average());
 540   }
 541   if (gc_cost() > gc_cost_limit) {
 542     log_debug(gc, ergo)(
 543           "PSAdaptiveSizePolicy::compute_old_gen_free_space: gc time limit"
 544           " gc_cost: %f "
 545           " GCTimeLimit: " UINTX_FORMAT,
 546           gc_cost(), GCTimeLimit);
 547   }
 548 
 549   // Align everything and make a final limit check
 550   desired_promo_size = align_up(desired_promo_size, _space_alignment);
 551   desired_promo_size = MAX2(desired_promo_size, _space_alignment);
 552 
 553   promo_limit = align_down(promo_limit, _space_alignment);
 554 
 555   // And one last limit check, now that we've aligned things.
 556   desired_promo_size = MIN2(desired_promo_size, promo_limit);
 557 
 558   // Timing stats
 559   log_debug(gc, ergo)("PSAdaptiveSizePolicy::compute_old_gen_free_space: costs minor_time: %f major_cost: %f  mutator_cost: %f throughput_goal: %f",
 560              minor_gc_cost(), major_gc_cost(), mutator_cost(), _throughput_goal);
 561 
 562   log_trace(gc, ergo)("Minor_pause: %f major_pause: %f minor_interval: %f major_interval: %f pause_goal: %f",
 563                       _avg_minor_pause->padded_average(),
 564                       _avg_major_pause->padded_average(),
 565                       _avg_minor_interval->average(),
 566                       _avg_major_interval->average(),
 567                       gc_pause_goal_sec());
 568 
 569   // Footprint stats
 570   log_debug(gc, ergo)("Live_space: " SIZE_FORMAT " free_space: " SIZE_FORMAT,
 571                       live_space(), free_space());
 572 
 573   log_trace(gc, ergo)("Base_footprint: " SIZE_FORMAT " avg_young_live: " SIZE_FORMAT " avg_old_live: " SIZE_FORMAT,


 908     double fraction =  part / total;
 909     reduced_change = (size_t) (fraction * (double) change);
 910   }
 911   assert(reduced_change <= change, "Inconsistent result");
 912   return reduced_change;
 913 }
 914 
 915 size_t PSAdaptiveSizePolicy::eden_increment(size_t cur_eden,
 916                                             uint percent_change) {
 917   size_t eden_heap_delta;
 918   eden_heap_delta = cur_eden / 100 * percent_change;
 919   return eden_heap_delta;
 920 }
 921 
 922 size_t PSAdaptiveSizePolicy::eden_increment(size_t cur_eden) {
 923   return eden_increment(cur_eden, YoungGenerationSizeIncrement);
 924 }
 925 
 926 size_t PSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
 927   size_t result = eden_increment(cur_eden, YoungGenerationSizeIncrement);
 928   return align_up(result, _space_alignment);
 929 }
 930 
 931 size_t PSAdaptiveSizePolicy::eden_increment_aligned_down(size_t cur_eden) {
 932   size_t result = eden_increment(cur_eden);
 933   return align_down(result, _space_alignment);
 934 }
 935 
 936 size_t PSAdaptiveSizePolicy::eden_increment_with_supplement_aligned_up(
 937   size_t cur_eden) {
 938   size_t result = eden_increment(cur_eden,
 939     YoungGenerationSizeIncrement + _young_gen_size_increment_supplement);
 940   return align_up(result, _space_alignment);
 941 }
 942 
 943 size_t PSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
 944   size_t eden_heap_delta = eden_decrement(cur_eden);
 945   return align_down(eden_heap_delta, _space_alignment);
 946 }
 947 
 948 size_t PSAdaptiveSizePolicy::eden_decrement(size_t cur_eden) {
 949   size_t eden_heap_delta = eden_increment(cur_eden) /
 950     AdaptiveSizeDecrementScaleFactor;
 951   return eden_heap_delta;
 952 }
 953 
 954 size_t PSAdaptiveSizePolicy::promo_increment(size_t cur_promo,
 955                                              uint percent_change) {
 956   size_t promo_heap_delta;
 957   promo_heap_delta = cur_promo / 100 * percent_change;
 958   return promo_heap_delta;
 959 }
 960 
 961 size_t PSAdaptiveSizePolicy::promo_increment(size_t cur_promo) {
 962   return promo_increment(cur_promo, TenuredGenerationSizeIncrement);
 963 }
 964 
 965 size_t PSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
 966   size_t result =  promo_increment(cur_promo, TenuredGenerationSizeIncrement);
 967   return align_up(result, _space_alignment);
 968 }
 969 
 970 size_t PSAdaptiveSizePolicy::promo_increment_aligned_down(size_t cur_promo) {
 971   size_t result =  promo_increment(cur_promo, TenuredGenerationSizeIncrement);
 972   return align_down(result, _space_alignment);
 973 }
 974 
 975 size_t PSAdaptiveSizePolicy::promo_increment_with_supplement_aligned_up(
 976   size_t cur_promo) {
 977   size_t result =  promo_increment(cur_promo,
 978     TenuredGenerationSizeIncrement + _old_gen_size_increment_supplement);
 979   return align_up(result, _space_alignment);
 980 }
 981 
 982 size_t PSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
 983   size_t promo_heap_delta = promo_decrement(cur_promo);
 984   return align_down(promo_heap_delta, _space_alignment);
 985 }
 986 
 987 size_t PSAdaptiveSizePolicy::promo_decrement(size_t cur_promo) {
 988   size_t promo_heap_delta = promo_increment(cur_promo);
 989   promo_heap_delta = promo_heap_delta / AdaptiveSizeDecrementScaleFactor;
 990   return promo_heap_delta;
 991 }
 992 
 993 uint PSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold(
 994                                              bool is_survivor_overflow,
 995                                              uint tenuring_threshold,
 996                                              size_t survivor_limit) {
 997   assert(survivor_limit >= _space_alignment,
 998          "survivor_limit too small");
 999   assert(is_aligned(survivor_limit, _space_alignment),
1000          "survivor_limit not aligned");
1001 
1002   // This method is called even if the tenuring threshold and survivor
1003   // spaces are not adjusted so that the averages are sampled above.
1004   if (!UsePSAdaptiveSurvivorSizePolicy ||
1005       !young_gen_policy_is_ready()) {
1006     return tenuring_threshold;
1007   }
1008 
1009   // We'll decide whether to increase or decrease the tenuring
1010   // threshold based partly on the newly computed survivor size
1011   // (if we hit the maximum limit allowed, we'll always choose to
1012   // decrement the threshold).
1013   bool incr_tenuring_threshold = false;
1014   bool decr_tenuring_threshold = false;
1015 
1016   set_decrement_tenuring_threshold_for_gc_cost(false);
1017   set_increment_tenuring_threshold_for_gc_cost(false);
1018   set_decrement_tenuring_threshold_for_survivor_limit(false);
1019 


1042       set_increment_tenuring_threshold_for_gc_cost(true);
1043     }
1044 
1045   } else {
1046     // Survivor space overflow occurred, so promoted and survived are
1047     // not accurate. We'll make our best guess by combining survived
1048     // and promoted and count them as survivors.
1049     //
1050     // We'll lower the tenuring threshold to see if we can correct
1051     // things. Also, set the survivor size conservatively. We're
1052     // trying to avoid many overflows from occurring if defnew size
1053     // is just too small.
1054 
1055     decr_tenuring_threshold = true;
1056   }
1057 
1058   // The padded average also maintains a deviation from the average;
1059   // we use this to see how good of an estimate we have of what survived.
1060   // We're trying to pad the survivor size as little as possible without
1061   // overflowing the survivor spaces.
1062   size_t target_size = align_up((size_t)_avg_survived->padded_average(),
1063                                      _space_alignment);
1064   target_size = MAX2(target_size, _space_alignment);
1065 
1066   if (target_size > survivor_limit) {
1067     // Target size is bigger than we can handle. Let's also reduce
1068     // the tenuring threshold.
1069     target_size = survivor_limit;
1070     decr_tenuring_threshold = true;
1071     set_decrement_tenuring_threshold_for_survivor_limit(true);
1072   }
1073 
1074   // Finally, increment or decrement the tenuring threshold, as decided above.
1075   // We test for decrementing first, as we might have hit the target size
1076   // limit.
1077   if (decr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
1078     if (tenuring_threshold > 1) {
1079       tenuring_threshold--;
1080     }
1081   } else if (incr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
1082     if (tenuring_threshold < MaxTenuringThreshold) {


< prev index next >