< prev index next >
src/share/vm/gc/parallel/psAdaptiveSizePolicy.cpp
Print this page
@@ -28,10 +28,11 @@
#include "gc/parallel/psGCAdaptivePolicyCounters.hpp"
#include "gc/parallel/psScavenge.hpp"
#include "gc/shared/collectorPolicy.hpp"
#include "gc/shared/gcCause.hpp"
#include "gc/shared/gcPolicyCounters.hpp"
+#include "logging/log.hpp"
#include "runtime/timer.hpp"
#include "utilities/top.hpp"
#include <math.h>
@@ -157,18 +158,14 @@
_major_pause_old_estimator->update(promo_size_in_mbytes,
major_pause_in_ms);
_major_pause_young_estimator->update(eden_size_in_mbytes,
major_pause_in_ms);
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print("psAdaptiveSizePolicy::major_collection_end: "
- "major gc cost: %f average: %f", collection_cost,
- avg_major_gc_cost()->average());
- gclog_or_tty->print_cr(" major pause: %f major period %f",
- major_pause_in_ms,
- _latest_major_mutator_interval_seconds * MILLIUNITS);
- }
+ log_trace(gc, ergo)("psAdaptiveSizePolicy::major_collection_end: major gc cost: %f average: %f",
+ collection_cost,avg_major_gc_cost()->average());
+ log_trace(gc, ergo)(" major pause: %f major period %f",
+ major_pause_in_ms, _latest_major_mutator_interval_seconds * MILLIUNITS);
// Calculate variable used to estimate collection cost vs. gen sizes
assert(collection_cost >= 0.0, "Expected to be non-negative");
_major_collection_estimator->update(promo_size_in_mbytes,
collection_cost);
@@ -195,23 +192,15 @@
bool PSAdaptiveSizePolicy::should_full_GC(size_t old_free_in_bytes) {
// A similar test is done in the scavenge's should_attempt_scavenge(). If
// this is changed, decide if that test should also be changed.
bool result = padded_average_promoted_in_bytes() > (float) old_free_in_bytes;
- if (PrintGCDetails && Verbose) {
- if (result) {
- gclog_or_tty->print(" full after scavenge: ");
- } else {
- gclog_or_tty->print(" no full after scavenge: ");
- }
- gclog_or_tty->print_cr(" average_promoted " SIZE_FORMAT
- " padded_average_promoted " SIZE_FORMAT
- " free in old gen " SIZE_FORMAT,
+ log_trace(gc, ergo)("%s after scavenge average_promoted " SIZE_FORMAT " padded_average_promoted " SIZE_FORMAT " free in old gen " SIZE_FORMAT,
+ result ? "Full" : "No full",
(size_t) average_promoted_in_bytes(),
(size_t) padded_average_promoted_in_bytes(),
old_free_in_bytes);
- }
return result;
}
void PSAdaptiveSizePolicy::clear_generation_free_space_flags() {
@@ -359,13 +348,12 @@
}
}
// Note we make the same tests as in the code block below; the code
// seems a little easier to read with the printing in another block.
- if (PrintAdaptiveSizePolicy) {
if (desired_eden_size > eden_limit) {
- gclog_or_tty->print_cr(
+ log_debug(gc, ergo)(
"PSAdaptiveSizePolicy::compute_eden_space_size limits:"
" desired_eden_size: " SIZE_FORMAT
" old_eden_size: " SIZE_FORMAT
" eden_limit: " SIZE_FORMAT
" cur_eden: " SIZE_FORMAT
@@ -373,17 +361,16 @@
" avg_young_live: " SIZE_FORMAT,
desired_eden_size, _eden_size, eden_limit, cur_eden,
max_eden_size, (size_t)avg_young_live()->average());
}
if (gc_cost() > gc_cost_limit) {
- gclog_or_tty->print_cr(
+ log_debug(gc, ergo)(
"PSAdaptiveSizePolicy::compute_eden_space_size: gc time limit"
" gc_cost: %f "
" GCTimeLimit: " UINTX_FORMAT,
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);
@@ -397,55 +384,30 @@
// eden size. Let the tenuring calculation push more
// into the old gen.
desired_eden_size = MAX2(eden_limit, cur_eden);
}
- if (PrintAdaptiveSizePolicy) {
- // Timing stats
- gclog_or_tty->print(
- "PSAdaptiveSizePolicy::compute_eden_space_size: costs"
- " minor_time: %f"
- " major_cost: %f"
- " mutator_cost: %f"
- " throughput_goal: %f",
- minor_gc_cost(), major_gc_cost(), mutator_cost(),
- _throughput_goal);
-
- // We give more details if Verbose is set
- if (Verbose) {
- gclog_or_tty->print( " minor_pause: %f"
- " major_pause: %f"
- " minor_interval: %f"
- " major_interval: %f"
- " pause_goal: %f",
+ log_debug(gc, ergo)("PSAdaptiveSizePolicy::compute_eden_space_size: costs minor_time: %f major_cost: %f mutator_cost: %f throughput_goal: %f",
+ minor_gc_cost(), major_gc_cost(), mutator_cost(), _throughput_goal);
+
+ log_trace(gc, ergo)("Minor_pause: %f major_pause: %f minor_interval: %f major_interval: %fpause_goal: %f",
_avg_minor_pause->padded_average(),
_avg_major_pause->padded_average(),
_avg_minor_interval->average(),
_avg_major_interval->average(),
gc_pause_goal_sec());
- }
- // Footprint stats
- gclog_or_tty->print( " live_space: " SIZE_FORMAT
- " free_space: " SIZE_FORMAT,
+ log_debug(gc, ergo)("Live_space: " SIZE_FORMAT " free_space: " SIZE_FORMAT,
live_space(), free_space());
- // More detail
- if (Verbose) {
- gclog_or_tty->print( " base_footprint: " SIZE_FORMAT
- " avg_young_live: " SIZE_FORMAT
- " avg_old_live: " SIZE_FORMAT,
+
+ log_trace(gc, ergo)("Base_footprint: " SIZE_FORMAT " avg_young_live: " SIZE_FORMAT " avg_old_live: " SIZE_FORMAT,
(size_t)_avg_base_footprint->average(),
(size_t)avg_young_live()->average(),
(size_t)avg_old_live()->average());
- }
- // And finally, our old and new sizes.
- gclog_or_tty->print(" old_eden_size: " SIZE_FORMAT
- " desired_eden_size: " SIZE_FORMAT,
+ log_debug(gc, ergo)("Old eden_size: " SIZE_FORMAT " desired_eden_size: " SIZE_FORMAT,
_eden_size, desired_eden_size);
- gclog_or_tty->cr();
- }
set_eden_size(desired_eden_size);
}
void PSAdaptiveSizePolicy::compute_old_gen_free_space(
@@ -562,87 +524,62 @@
}
}
// Note we make the same tests as in the code block below; the code
// seems a little easier to read with the printing in another block.
- if (PrintAdaptiveSizePolicy) {
if (desired_promo_size > promo_limit) {
// "free_in_old_gen" was the original value for used for promo_limit
size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average());
- gclog_or_tty->print_cr(
+ log_debug(gc, ergo)(
"PSAdaptiveSizePolicy::compute_old_gen_free_space limits:"
" desired_promo_size: " SIZE_FORMAT
" promo_limit: " SIZE_FORMAT
" free_in_old_gen: " SIZE_FORMAT
" max_old_gen_size: " SIZE_FORMAT
" avg_old_live: " SIZE_FORMAT,
desired_promo_size, promo_limit, free_in_old_gen,
max_old_gen_size, (size_t) avg_old_live()->average());
}
if (gc_cost() > gc_cost_limit) {
- gclog_or_tty->print_cr(
+ log_debug(gc, ergo)(
"PSAdaptiveSizePolicy::compute_old_gen_free_space: gc time limit"
" gc_cost: %f "
" GCTimeLimit: " UINTX_FORMAT,
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) {
// Timing stats
- gclog_or_tty->print(
- "PSAdaptiveSizePolicy::compute_old_gen_free_space: costs"
- " minor_time: %f"
- " major_cost: %f"
- " mutator_cost: %f"
- " throughput_goal: %f",
- minor_gc_cost(), major_gc_cost(), mutator_cost(),
- _throughput_goal);
-
- // We give more details if Verbose is set
- if (Verbose) {
- gclog_or_tty->print( " minor_pause: %f"
- " major_pause: %f"
- " minor_interval: %f"
- " major_interval: %f"
- " pause_goal: %f",
+ log_debug(gc, ergo)("PSAdaptiveSizePolicy::compute_old_gen_free_space: costs minor_time: %f major_cost: %f mutator_cost: %f throughput_goal: %f",
+ minor_gc_cost(), major_gc_cost(), mutator_cost(), _throughput_goal);
+
+ log_trace(gc, ergo)("Minor_pause: %f major_pause: %f minor_interval: %f major_interval: %f pause_goal: %f",
_avg_minor_pause->padded_average(),
_avg_major_pause->padded_average(),
_avg_minor_interval->average(),
_avg_major_interval->average(),
gc_pause_goal_sec());
- }
// Footprint stats
- gclog_or_tty->print( " live_space: " SIZE_FORMAT
- " free_space: " SIZE_FORMAT,
+ log_debug(gc, ergo)("Live_space: " SIZE_FORMAT " free_space: " SIZE_FORMAT,
live_space(), free_space());
- // More detail
- if (Verbose) {
- gclog_or_tty->print( " base_footprint: " SIZE_FORMAT
- " avg_young_live: " SIZE_FORMAT
- " avg_old_live: " SIZE_FORMAT,
+
+ log_trace(gc, ergo)("Base_footprint: " SIZE_FORMAT " avg_young_live: " SIZE_FORMAT " avg_old_live: " SIZE_FORMAT,
(size_t)_avg_base_footprint->average(),
(size_t)avg_young_live()->average(),
(size_t)avg_old_live()->average());
- }
- // And finally, our old and new sizes.
- gclog_or_tty->print(" old_promo_size: " SIZE_FORMAT
- " desired_promo_size: " SIZE_FORMAT,
+ log_debug(gc, ergo)("Old promo_size: " SIZE_FORMAT " desired_promo_size: " SIZE_FORMAT,
_promo_size, desired_promo_size);
- gclog_or_tty->cr();
- }
set_promo_size(desired_promo_size);
}
void PSAdaptiveSizePolicy::decay_supplemental_growth(bool is_full_gc) {
@@ -717,18 +654,16 @@
// promo_increment_aligned_up(*desired_promo_size_ptr);
set_change_old_gen_for_maj_pauses(increase_old_gen_for_maj_pauses_true);
}
}
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
+ log_trace(gc, ergo)(
"PSAdaptiveSizePolicy::adjust_promo_for_pause_time "
"adjusting gen sizes for major pause (avg %f goal %f). "
"desired_promo_size " SIZE_FORMAT " promo delta " SIZE_FORMAT,
_avg_major_pause->average(), gc_pause_goal_sec(),
*desired_promo_size_ptr, promo_heap_delta);
- }
}
void PSAdaptiveSizePolicy::adjust_eden_for_pause_time(bool is_full_gc,
size_t* desired_promo_size_ptr,
size_t* desired_eden_size_ptr) {
@@ -738,18 +673,16 @@
// a change less than the required alignment is probably not worth
// attempting.
if (_avg_minor_pause->padded_average() > _avg_major_pause->padded_average()) {
adjust_eden_for_minor_pause_time(is_full_gc, desired_eden_size_ptr);
}
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
+ log_trace(gc, ergo)(
"PSAdaptiveSizePolicy::adjust_eden_for_pause_time "
"adjusting gen sizes for major pause (avg %f goal %f). "
"desired_eden_size " SIZE_FORMAT " eden delta " SIZE_FORMAT,
_avg_major_pause->average(), gc_pause_goal_sec(),
*desired_eden_size_ptr, eden_heap_delta);
- }
}
void PSAdaptiveSizePolicy::adjust_promo_for_throughput(bool is_full_gc,
size_t* desired_promo_size_ptr) {
@@ -759,17 +692,16 @@
if ((gc_cost() + mutator_cost()) == 0.0) {
return;
}
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print("\nPSAdaptiveSizePolicy::adjust_promo_for_throughput("
- "is_full: %d, promo: " SIZE_FORMAT "): ",
- is_full_gc, *desired_promo_size_ptr);
- gclog_or_tty->print_cr("mutator_cost %f major_gc_cost %f "
- "minor_gc_cost %f", mutator_cost(), major_gc_cost(), minor_gc_cost());
- }
+ log_trace(gc, ergo)("PSAdaptiveSizePolicy::adjust_promo_for_throughput(is_full: %d, promo: " SIZE_FORMAT "): mutator_cost %f major_gc_cost %f minor_gc_cost %f",
+ is_full_gc,
+ *desired_promo_size_ptr,
+ mutator_cost(),
+ major_gc_cost(),
+ minor_gc_cost());
// Tenured generation
if (is_full_gc) {
// Calculate the change to use for the tenured gen.
size_t scaled_promo_heap_delta = 0;
@@ -778,16 +710,12 @@
size_t promo_heap_delta =
promo_increment_with_supplement_aligned_up(*desired_promo_size_ptr);
double scale_by_ratio = major_gc_cost() / gc_cost();
scaled_promo_heap_delta =
(size_t) (scale_by_ratio * (double) promo_heap_delta);
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "Scaled tenured increment: " SIZE_FORMAT " by %f down to "
- SIZE_FORMAT,
+ log_trace(gc, ergo)("Scaled tenured increment: " SIZE_FORMAT " by %f down to " SIZE_FORMAT,
promo_heap_delta, scale_by_ratio, scaled_promo_heap_delta);
- }
} else if (major_gc_cost() >= 0.0) {
// Scaling is not going to work. If the major gc time is the
// larger, give it a full increment.
if (major_gc_cost() >= minor_gc_cost()) {
scaled_promo_heap_delta =
@@ -837,18 +765,15 @@
set_change_old_gen_for_throughput(
increase_old_gen_for_throughput_true);
_old_gen_change_for_major_throughput++;
}
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "adjusting tenured gen for throughput (avg %f goal %f). "
- "desired_promo_size " SIZE_FORMAT " promo_delta " SIZE_FORMAT ,
- mutator_cost(), _throughput_goal,
+ log_trace(gc, ergo)("Adjusting tenured gen for throughput (avg %f goal %f). desired_promo_size " SIZE_FORMAT " promo_delta " SIZE_FORMAT ,
+ mutator_cost(),
+ _throughput_goal,
*desired_promo_size_ptr, scaled_promo_heap_delta);
}
- }
}
void PSAdaptiveSizePolicy::adjust_eden_for_throughput(bool is_full_gc,
size_t* desired_eden_size_ptr) {
@@ -858,17 +783,16 @@
if ((gc_cost() + mutator_cost()) == 0.0) {
return;
}
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print("\nPSAdaptiveSizePolicy::adjust_eden_for_throughput("
- "is_full: %d, cur_eden: " SIZE_FORMAT "): ",
- is_full_gc, *desired_eden_size_ptr);
- gclog_or_tty->print_cr("mutator_cost %f major_gc_cost %f "
- "minor_gc_cost %f", mutator_cost(), major_gc_cost(), minor_gc_cost());
- }
+ log_trace(gc, ergo)("PSAdaptiveSizePolicy::adjust_eden_for_throughput(is_full: %d, cur_eden: " SIZE_FORMAT "): mutator_cost %f major_gc_cost %f minor_gc_cost %f",
+ is_full_gc,
+ *desired_eden_size_ptr,
+ mutator_cost(),
+ major_gc_cost(),
+ minor_gc_cost());
// Young generation
size_t scaled_eden_heap_delta = 0;
// Can the increment to the generation be scaled?
if (gc_cost() >= 0.0 && minor_gc_cost() >= 0.0) {
@@ -876,16 +800,12 @@
eden_increment_with_supplement_aligned_up(*desired_eden_size_ptr);
double scale_by_ratio = minor_gc_cost() / gc_cost();
assert(scale_by_ratio <= 1.0 && scale_by_ratio >= 0.0, "Scaling is wrong");
scaled_eden_heap_delta =
(size_t) (scale_by_ratio * (double) eden_heap_delta);
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "Scaled eden increment: " SIZE_FORMAT " by %f down to "
- SIZE_FORMAT,
+ log_trace(gc, ergo)("Scaled eden increment: " SIZE_FORMAT " by %f down to " SIZE_FORMAT,
eden_heap_delta, scale_by_ratio, scaled_eden_heap_delta);
- }
} else if (minor_gc_cost() >= 0.0) {
// Scaling is not going to work. If the minor gc time is the
// larger, give it a full increment.
if (minor_gc_cost() > major_gc_cost()) {
scaled_eden_heap_delta =
@@ -934,17 +854,12 @@
set_change_young_gen_for_throughput(
increase_young_gen_for_througput_true);
_young_gen_change_for_minor_throughput++;
}
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "adjusting eden for throughput (avg %f goal %f). desired_eden_size "
- SIZE_FORMAT " eden delta " SIZE_FORMAT "\n",
- mutator_cost(), _throughput_goal,
- *desired_eden_size_ptr, scaled_eden_heap_delta);
- }
+ log_trace(gc, ergo)("Adjusting eden for throughput (avg %f goal %f). desired_eden_size " SIZE_FORMAT " eden delta " SIZE_FORMAT,
+ mutator_cost(), _throughput_goal, *desired_eden_size_ptr, scaled_eden_heap_delta);
}
size_t PSAdaptiveSizePolicy::adjust_promo_for_footprint(
size_t desired_promo_size, size_t desired_sum) {
assert(desired_promo_size <= desired_sum, "Inconsistent parameters");
@@ -953,19 +868,17 @@
size_t change = promo_decrement(desired_promo_size);
change = scale_down(change, desired_promo_size, desired_sum);
size_t reduced_size = desired_promo_size - change;
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
+ log_trace(gc, ergo)(
"AdaptiveSizePolicy::adjust_promo_for_footprint "
"adjusting tenured gen for footprint. "
"starting promo size " SIZE_FORMAT
" reduced promo size " SIZE_FORMAT
" promo delta " SIZE_FORMAT,
desired_promo_size, reduced_size, change );
- }
assert(reduced_size <= desired_promo_size, "Inconsistent result");
return reduced_size;
}
@@ -977,19 +890,17 @@
size_t change = eden_decrement(desired_eden_size);
change = scale_down(change, desired_eden_size, desired_sum);
size_t reduced_size = desired_eden_size - change;
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
+ log_trace(gc, ergo)(
"AdaptiveSizePolicy::adjust_eden_for_footprint "
"adjusting eden for footprint. "
" starting eden size " SIZE_FORMAT
" reduced eden size " SIZE_FORMAT
" eden delta " SIZE_FORMAT,
desired_eden_size, reduced_size, change);
- }
assert(reduced_size <= desired_eden_size, "Inconsistent result");
return reduced_size;
}
@@ -1185,37 +1096,18 @@
// We keep a running average of the amount promoted which is used
// to decide when we should collect the old generation (when
// the amount of old gen free space is less than what we expect to
// promote).
- if (PrintAdaptiveSizePolicy) {
- // A little more detail if Verbose is on
- if (Verbose) {
- gclog_or_tty->print( " avg_survived: %f"
- " avg_deviation: %f",
- _avg_survived->average(),
- _avg_survived->deviation());
- }
-
- gclog_or_tty->print( " avg_survived_padded_avg: %f",
- _avg_survived->padded_average());
-
- if (Verbose) {
- gclog_or_tty->print( " avg_promoted_avg: %f"
- " avg_promoted_dev: %f",
- avg_promoted()->average(),
- avg_promoted()->deviation());
- }
-
- gclog_or_tty->print_cr( " avg_promoted_padded_avg: %f"
- " avg_pretenured_padded_avg: %f"
- " tenuring_thresh: %d"
- " target_size: " SIZE_FORMAT,
+ log_trace(gc, ergo)("avg_survived: %f avg_deviation: %f", _avg_survived->average(), _avg_survived->deviation());
+ log_debug(gc, ergo)("avg_survived_padded_avg: %f", _avg_survived->padded_average());
+
+ log_trace(gc, ergo)("avg_promoted_avg: %f avg_promoted_dev: %f", avg_promoted()->average(), avg_promoted()->deviation());
+ log_debug(gc, ergo)("avg_promoted_padded_avg: %f avg_pretenured_padded_avg: %f tenuring_thresh: %d target_size: " SIZE_FORMAT,
avg_promoted()->padded_average(),
_avg_pretenured->padded_average(),
tenuring_threshold, target_size);
- }
set_survivor_size(target_size);
return tenuring_threshold;
}
@@ -1231,28 +1123,26 @@
size_t survived_guess = survived + promoted;
_avg_survived->sample(survived_guess);
}
avg_promoted()->sample(promoted);
- if (PrintAdaptiveSizePolicy) {
- gclog_or_tty->print_cr(
- "AdaptiveSizePolicy::update_averages:"
- " survived: " SIZE_FORMAT
- " promoted: " SIZE_FORMAT
- " overflow: %s",
+ log_trace(gc, ergo)("AdaptiveSizePolicy::update_averages: survived: " SIZE_FORMAT " promoted: " SIZE_FORMAT " overflow: %s",
survived, promoted, is_survivor_overflow ? "true" : "false");
- }
}
-bool PSAdaptiveSizePolicy::print_adaptive_size_policy_on(outputStream* st)
- const {
+bool PSAdaptiveSizePolicy::print() const {
+
+ if (!UseAdaptiveSizePolicy) {
+ return false;
+ }
- if (!UseAdaptiveSizePolicy) return false;
+ if (AdaptiveSizePolicy::print()) {
+ AdaptiveSizePolicy::print_tenuring_threshold(PSScavenge::tenuring_threshold());
+ return true;
+ }
- return AdaptiveSizePolicy::print_adaptive_size_policy_on(
- st,
- PSScavenge::tenuring_threshold());
+ return false;
}
#ifndef PRODUCT
void TestOldFreeSpaceCalculation_test() {
< prev index next >