1.1 --- a/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp Mon Oct 21 18:56:20 2013 +0200
1.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp Fri Nov 01 17:09:38 2013 +0100
1.3 @@ -37,7 +37,7 @@
1.4 PSAdaptiveSizePolicy::PSAdaptiveSizePolicy(size_t init_eden_size,
1.5 size_t init_promo_size,
1.6 size_t init_survivor_size,
1.7 - size_t intra_generation_alignment,
1.8 + size_t space_alignment,
1.9 double gc_pause_goal_sec,
1.10 double gc_minor_pause_goal_sec,
1.11 uint gc_cost_ratio) :
1.12 @@ -47,7 +47,7 @@
1.13 gc_pause_goal_sec,
1.14 gc_cost_ratio),
1.15 _collection_cost_margin_fraction(AdaptiveSizePolicyCollectionCostMargin / 100.0),
1.16 - _intra_generation_alignment(intra_generation_alignment),
1.17 + _space_alignment(space_alignment),
1.18 _live_at_last_full_gc(init_promo_size),
1.19 _gc_minor_pause_goal_sec(gc_minor_pause_goal_sec),
1.20 _latest_major_mutator_interval_seconds(0),
1.21 @@ -352,11 +352,10 @@
1.22 }
1.23
1.24 // Align everything and make a final limit check
1.25 - const size_t alignment = _intra_generation_alignment;
1.26 - desired_eden_size = align_size_up(desired_eden_size, alignment);
1.27 - desired_eden_size = MAX2(desired_eden_size, alignment);
1.28 + desired_eden_size = align_size_up(desired_eden_size, _space_alignment);
1.29 + desired_eden_size = MAX2(desired_eden_size, _space_alignment);
1.30
1.31 - eden_limit = align_size_down(eden_limit, alignment);
1.32 + eden_limit = align_size_down(eden_limit, _space_alignment);
1.33
1.34 // And one last limit check, now that we've aligned things.
1.35 if (desired_eden_size > eden_limit) {
1.36 @@ -560,11 +559,10 @@
1.37 }
1.38
1.39 // Align everything and make a final limit check
1.40 - const size_t alignment = _intra_generation_alignment;
1.41 - desired_promo_size = align_size_up(desired_promo_size, alignment);
1.42 - desired_promo_size = MAX2(desired_promo_size, alignment);
1.43 + desired_promo_size = align_size_up(desired_promo_size, _space_alignment);
1.44 + desired_promo_size = MAX2(desired_promo_size, _space_alignment);
1.45
1.46 - promo_limit = align_size_down(promo_limit, alignment);
1.47 + promo_limit = align_size_down(promo_limit, _space_alignment);
1.48
1.49 // And one last limit check, now that we've aligned things.
1.50 desired_promo_size = MIN2(desired_promo_size, promo_limit);
1.51 @@ -649,7 +647,7 @@
1.52 }
1.53 // If the desired eden size is as small as it will get,
1.54 // try to adjust the old gen size.
1.55 - if (*desired_eden_size_ptr <= _intra_generation_alignment) {
1.56 + if (*desired_eden_size_ptr <= _space_alignment) {
1.57 // Vary the old gen size to reduce the young gen pause. This
1.58 // may not be a good idea. This is just a test.
1.59 if (minor_pause_old_estimator()->decrement_will_decrease()) {
1.60 @@ -754,7 +752,7 @@
1.61 // If the promo size is at the minimum (i.e., the old gen
1.62 // size will not actually decrease), consider changing the
1.63 // young gen size.
1.64 - if (*desired_promo_size_ptr < _intra_generation_alignment) {
1.65 + if (*desired_promo_size_ptr < _space_alignment) {
1.66 // If increasing the young generation will decrease the old gen
1.67 // pause, do it.
1.68 // During startup there is noise in the statistics for deciding
1.69 @@ -1065,24 +1063,24 @@
1.70
1.71 size_t PSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
1.72 size_t result = eden_increment(cur_eden, YoungGenerationSizeIncrement);
1.73 - return align_size_up(result, _intra_generation_alignment);
1.74 + return align_size_up(result, _space_alignment);
1.75 }
1.76
1.77 size_t PSAdaptiveSizePolicy::eden_increment_aligned_down(size_t cur_eden) {
1.78 size_t result = eden_increment(cur_eden);
1.79 - return align_size_down(result, _intra_generation_alignment);
1.80 + return align_size_down(result, _space_alignment);
1.81 }
1.82
1.83 size_t PSAdaptiveSizePolicy::eden_increment_with_supplement_aligned_up(
1.84 size_t cur_eden) {
1.85 size_t result = eden_increment(cur_eden,
1.86 YoungGenerationSizeIncrement + _young_gen_size_increment_supplement);
1.87 - return align_size_up(result, _intra_generation_alignment);
1.88 + return align_size_up(result, _space_alignment);
1.89 }
1.90
1.91 size_t PSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
1.92 size_t eden_heap_delta = eden_decrement(cur_eden);
1.93 - return align_size_down(eden_heap_delta, _intra_generation_alignment);
1.94 + return align_size_down(eden_heap_delta, _space_alignment);
1.95 }
1.96
1.97 size_t PSAdaptiveSizePolicy::eden_decrement(size_t cur_eden) {
1.98 @@ -1104,24 +1102,24 @@
1.99
1.100 size_t PSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
1.101 size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
1.102 - return align_size_up(result, _intra_generation_alignment);
1.103 + return align_size_up(result, _space_alignment);
1.104 }
1.105
1.106 size_t PSAdaptiveSizePolicy::promo_increment_aligned_down(size_t cur_promo) {
1.107 size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
1.108 - return align_size_down(result, _intra_generation_alignment);
1.109 + return align_size_down(result, _space_alignment);
1.110 }
1.111
1.112 size_t PSAdaptiveSizePolicy::promo_increment_with_supplement_aligned_up(
1.113 size_t cur_promo) {
1.114 size_t result = promo_increment(cur_promo,
1.115 TenuredGenerationSizeIncrement + _old_gen_size_increment_supplement);
1.116 - return align_size_up(result, _intra_generation_alignment);
1.117 + return align_size_up(result, _space_alignment);
1.118 }
1.119
1.120 size_t PSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
1.121 size_t promo_heap_delta = promo_decrement(cur_promo);
1.122 - return align_size_down(promo_heap_delta, _intra_generation_alignment);
1.123 + return align_size_down(promo_heap_delta, _space_alignment);
1.124 }
1.125
1.126 size_t PSAdaptiveSizePolicy::promo_decrement(size_t cur_promo) {
1.127 @@ -1134,9 +1132,9 @@
1.128 bool is_survivor_overflow,
1.129 uint tenuring_threshold,
1.130 size_t survivor_limit) {
1.131 - assert(survivor_limit >= _intra_generation_alignment,
1.132 + assert(survivor_limit >= _space_alignment,
1.133 "survivor_limit too small");
1.134 - assert((size_t)align_size_down(survivor_limit, _intra_generation_alignment)
1.135 + assert((size_t)align_size_down(survivor_limit, _space_alignment)
1.136 == survivor_limit, "survivor_limit not aligned");
1.137
1.138 // This method is called even if the tenuring threshold and survivor
1.139 @@ -1200,8 +1198,8 @@
1.140 // We're trying to pad the survivor size as little as possible without
1.141 // overflowing the survivor spaces.
1.142 size_t target_size = align_size_up((size_t)_avg_survived->padded_average(),
1.143 - _intra_generation_alignment);
1.144 - target_size = MAX2(target_size, _intra_generation_alignment);
1.145 + _space_alignment);
1.146 + target_size = MAX2(target_size, _space_alignment);
1.147
1.148 if (target_size > survivor_limit) {
1.149 // Target size is bigger than we can handle. Let's also reduce
