src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp
Index
Unified diffs
Context diffs
Sdiffs
Patch
New
Old
Previous File
Next File
hotspot Cdiff src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp
src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp
Print this page
*** 35,55 ****
#include <math.h>
PSAdaptiveSizePolicy::PSAdaptiveSizePolicy(size_t init_eden_size,
size_t init_promo_size,
size_t init_survivor_size,
! size_t intra_generation_alignment,
double gc_pause_goal_sec,
double gc_minor_pause_goal_sec,
uint gc_cost_ratio) :
AdaptiveSizePolicy(init_eden_size,
init_promo_size,
init_survivor_size,
gc_pause_goal_sec,
gc_cost_ratio),
_collection_cost_margin_fraction(AdaptiveSizePolicyCollectionCostMargin / 100.0),
! _intra_generation_alignment(intra_generation_alignment),
_live_at_last_full_gc(init_promo_size),
_gc_minor_pause_goal_sec(gc_minor_pause_goal_sec),
_latest_major_mutator_interval_seconds(0),
_young_gen_change_for_major_pause_count(0)
{
--- 35,55 ----
#include <math.h>
PSAdaptiveSizePolicy::PSAdaptiveSizePolicy(size_t init_eden_size,
size_t init_promo_size,
size_t init_survivor_size,
! size_t space_alignment,
double gc_pause_goal_sec,
double gc_minor_pause_goal_sec,
uint gc_cost_ratio) :
AdaptiveSizePolicy(init_eden_size,
init_promo_size,
init_survivor_size,
gc_pause_goal_sec,
gc_cost_ratio),
_collection_cost_margin_fraction(AdaptiveSizePolicyCollectionCostMargin / 100.0),
! _space_alignment(space_alignment),
_live_at_last_full_gc(init_promo_size),
_gc_minor_pause_goal_sec(gc_minor_pause_goal_sec),
_latest_major_mutator_interval_seconds(0),
_young_gen_change_for_major_pause_count(0)
{
*** 350,364 ****
gc_cost(), GCTimeLimit);
}
}
// Align everything and make a final limit check
! const size_t alignment = _intra_generation_alignment;
! desired_eden_size = align_size_up(desired_eden_size, alignment);
! desired_eden_size = MAX2(desired_eden_size, alignment);
! eden_limit = align_size_down(eden_limit, alignment);
// And one last limit check, now that we've aligned things.
if (desired_eden_size > eden_limit) {
// If the policy says to get a larger eden but
// is hitting the limit, don't decrease eden.
--- 350,363 ----
gc_cost(), GCTimeLimit);
}
}
// Align everything and make a final limit check
! desired_eden_size = align_size_up(desired_eden_size, _space_alignment);
! desired_eden_size = MAX2(desired_eden_size, _space_alignment);
! eden_limit = align_size_down(eden_limit, _space_alignment);
// And one last limit check, now that we've aligned things.
if (desired_eden_size > eden_limit) {
// If the policy says to get a larger eden but
// is hitting the limit, don't decrease eden.
*** 558,572 ****
gc_cost(), GCTimeLimit);
}
}
// Align everything and make a final limit check
! const size_t alignment = _intra_generation_alignment;
! desired_promo_size = align_size_up(desired_promo_size, alignment);
! desired_promo_size = MAX2(desired_promo_size, alignment);
! promo_limit = align_size_down(promo_limit, alignment);
// And one last limit check, now that we've aligned things.
desired_promo_size = MIN2(desired_promo_size, promo_limit);
if (PrintAdaptiveSizePolicy) {
--- 557,570 ----
gc_cost(), GCTimeLimit);
}
}
// Align everything and make a final limit check
! desired_promo_size = align_size_up(desired_promo_size, _space_alignment);
! desired_promo_size = MAX2(desired_promo_size, _space_alignment);
! promo_limit = align_size_down(promo_limit, _space_alignment);
// And one last limit check, now that we've aligned things.
desired_promo_size = MIN2(desired_promo_size, promo_limit);
if (PrintAdaptiveSizePolicy) {
*** 647,657 ****
if (is_full_gc) {
set_decide_at_full_gc(decide_at_full_gc_true);
}
// If the desired eden size is as small as it will get,
// try to adjust the old gen size.
! if (*desired_eden_size_ptr <= _intra_generation_alignment) {
// Vary the old gen size to reduce the young gen pause. This
// may not be a good idea. This is just a test.
if (minor_pause_old_estimator()->decrement_will_decrease()) {
set_change_old_gen_for_min_pauses(decrease_old_gen_for_min_pauses_true);
*desired_promo_size_ptr =
--- 645,655 ----
if (is_full_gc) {
set_decide_at_full_gc(decide_at_full_gc_true);
}
// If the desired eden size is as small as it will get,
// try to adjust the old gen size.
! if (*desired_eden_size_ptr <= _space_alignment) {
// Vary the old gen size to reduce the young gen pause. This
// may not be a good idea. This is just a test.
if (minor_pause_old_estimator()->decrement_will_decrease()) {
set_change_old_gen_for_min_pauses(decrease_old_gen_for_min_pauses_true);
*desired_promo_size_ptr =
*** 752,762 ****
// affects of a change can only be seen at full gc's.
if (PSAdjustYoungGenForMajorPause) {
// If the promo size is at the minimum (i.e., the old gen
// size will not actually decrease), consider changing the
// young gen size.
! if (*desired_promo_size_ptr < _intra_generation_alignment) {
// If increasing the young generation will decrease the old gen
// pause, do it.
// During startup there is noise in the statistics for deciding
// on whether to increase or decrease the young gen size. For
// some number of iterations, just try to increase the young
--- 750,760 ----
// affects of a change can only be seen at full gc's.
if (PSAdjustYoungGenForMajorPause) {
// If the promo size is at the minimum (i.e., the old gen
// size will not actually decrease), consider changing the
// young gen size.
! if (*desired_promo_size_ptr < _space_alignment) {
// If increasing the young generation will decrease the old gen
// pause, do it.
// During startup there is noise in the statistics for deciding
// on whether to increase or decrease the young gen size. For
// some number of iterations, just try to increase the young
*** 1063,1090 ****
return eden_increment(cur_eden, YoungGenerationSizeIncrement);
}
size_t PSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
size_t result = eden_increment(cur_eden, YoungGenerationSizeIncrement);
! return align_size_up(result, _intra_generation_alignment);
}
size_t PSAdaptiveSizePolicy::eden_increment_aligned_down(size_t cur_eden) {
size_t result = eden_increment(cur_eden);
! return align_size_down(result, _intra_generation_alignment);
}
size_t PSAdaptiveSizePolicy::eden_increment_with_supplement_aligned_up(
size_t cur_eden) {
size_t result = eden_increment(cur_eden,
YoungGenerationSizeIncrement + _young_gen_size_increment_supplement);
! return align_size_up(result, _intra_generation_alignment);
}
size_t PSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
size_t eden_heap_delta = eden_decrement(cur_eden);
! return align_size_down(eden_heap_delta, _intra_generation_alignment);
}
size_t PSAdaptiveSizePolicy::eden_decrement(size_t cur_eden) {
size_t eden_heap_delta = eden_increment(cur_eden) /
AdaptiveSizeDecrementScaleFactor;
--- 1061,1088 ----
return eden_increment(cur_eden, YoungGenerationSizeIncrement);
}
size_t PSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
size_t result = eden_increment(cur_eden, YoungGenerationSizeIncrement);
! return align_size_up(result, _space_alignment);
}
size_t PSAdaptiveSizePolicy::eden_increment_aligned_down(size_t cur_eden) {
size_t result = eden_increment(cur_eden);
! return align_size_down(result, _space_alignment);
}
size_t PSAdaptiveSizePolicy::eden_increment_with_supplement_aligned_up(
size_t cur_eden) {
size_t result = eden_increment(cur_eden,
YoungGenerationSizeIncrement + _young_gen_size_increment_supplement);
! return align_size_up(result, _space_alignment);
}
size_t PSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
size_t eden_heap_delta = eden_decrement(cur_eden);
! return align_size_down(eden_heap_delta, _space_alignment);
}
size_t PSAdaptiveSizePolicy::eden_decrement(size_t cur_eden) {
size_t eden_heap_delta = eden_increment(cur_eden) /
AdaptiveSizeDecrementScaleFactor;
*** 1102,1129 ****
return promo_increment(cur_promo, TenuredGenerationSizeIncrement);
}
size_t PSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
! return align_size_up(result, _intra_generation_alignment);
}
size_t PSAdaptiveSizePolicy::promo_increment_aligned_down(size_t cur_promo) {
size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
! return align_size_down(result, _intra_generation_alignment);
}
size_t PSAdaptiveSizePolicy::promo_increment_with_supplement_aligned_up(
size_t cur_promo) {
size_t result = promo_increment(cur_promo,
TenuredGenerationSizeIncrement + _old_gen_size_increment_supplement);
! return align_size_up(result, _intra_generation_alignment);
}
size_t PSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
size_t promo_heap_delta = promo_decrement(cur_promo);
! return align_size_down(promo_heap_delta, _intra_generation_alignment);
}
size_t PSAdaptiveSizePolicy::promo_decrement(size_t cur_promo) {
size_t promo_heap_delta = promo_increment(cur_promo);
promo_heap_delta = promo_heap_delta / AdaptiveSizeDecrementScaleFactor;
--- 1100,1127 ----
return promo_increment(cur_promo, TenuredGenerationSizeIncrement);
}
size_t PSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
! return align_size_up(result, _space_alignment);
}
size_t PSAdaptiveSizePolicy::promo_increment_aligned_down(size_t cur_promo) {
size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
! return align_size_down(result, _space_alignment);
}
size_t PSAdaptiveSizePolicy::promo_increment_with_supplement_aligned_up(
size_t cur_promo) {
size_t result = promo_increment(cur_promo,
TenuredGenerationSizeIncrement + _old_gen_size_increment_supplement);
! return align_size_up(result, _space_alignment);
}
size_t PSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
size_t promo_heap_delta = promo_decrement(cur_promo);
! return align_size_down(promo_heap_delta, _space_alignment);
}
size_t PSAdaptiveSizePolicy::promo_decrement(size_t cur_promo) {
size_t promo_heap_delta = promo_increment(cur_promo);
promo_heap_delta = promo_heap_delta / AdaptiveSizeDecrementScaleFactor;
*** 1132,1144 ****
uint PSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold(
bool is_survivor_overflow,
uint tenuring_threshold,
size_t survivor_limit) {
! assert(survivor_limit >= _intra_generation_alignment,
"survivor_limit too small");
! assert((size_t)align_size_down(survivor_limit, _intra_generation_alignment)
== survivor_limit, "survivor_limit not aligned");
// This method is called even if the tenuring threshold and survivor
// spaces are not adjusted so that the averages are sampled above.
if (!UsePSAdaptiveSurvivorSizePolicy ||
--- 1130,1142 ----
uint PSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold(
bool is_survivor_overflow,
uint tenuring_threshold,
size_t survivor_limit) {
! assert(survivor_limit >= _space_alignment,
"survivor_limit too small");
! assert((size_t)align_size_down(survivor_limit, _space_alignment)
== survivor_limit, "survivor_limit not aligned");
// This method is called even if the tenuring threshold and survivor
// spaces are not adjusted so that the averages are sampled above.
if (!UsePSAdaptiveSurvivorSizePolicy ||
*** 1198,1209 ****
// The padded average also maintains a deviation from the average;
// we use this to see how good of an estimate we have of what survived.
// We're trying to pad the survivor size as little as possible without
// overflowing the survivor spaces.
size_t target_size = align_size_up((size_t)_avg_survived->padded_average(),
! _intra_generation_alignment);
! target_size = MAX2(target_size, _intra_generation_alignment);
if (target_size > survivor_limit) {
// Target size is bigger than we can handle. Let's also reduce
// the tenuring threshold.
target_size = survivor_limit;
--- 1196,1207 ----
// The padded average also maintains a deviation from the average;
// we use this to see how good of an estimate we have of what survived.
// We're trying to pad the survivor size as little as possible without
// overflowing the survivor spaces.
size_t target_size = align_size_up((size_t)_avg_survived->padded_average(),
! _space_alignment);
! target_size = MAX2(target_size, _space_alignment);
if (target_size > survivor_limit) {
// Target size is bigger than we can handle. Let's also reduce
// the tenuring threshold.
target_size = survivor_limit;
src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp
Index
Unified diffs
Context diffs
Sdiffs
Patch
New
Old
Previous File
Next File