• file
• revisions
• annotate
• diff
• comparison
• raw

src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp@0fbdb4381b99 (annotated)

src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp

Mon, 09 Mar 2009 13:28:46 -0700

author

xdono

date

Mon, 09 Mar 2009 13:28:46 -0700

changeset 1014

0fbdb4381b99

parent 435

a61af66fc99e

child 1822

0bfd3fb24150

permissions

-rw-r--r--

6814575: Update copyright year
Summary: Update copyright for files that have been modified in 2009, up to 03/09
Reviewed-by: katleman, tbell, ohair

duke@435	1	/*
duke@435	2	* Copyright 2002-2007 Sun Microsystems, Inc. All Rights Reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
duke@435	19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435	20	* CA 95054 USA or visit www.sun.com if you need additional information or
duke@435	21	* have any questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	#include "incls/_precompiled.incl"
duke@435	26	#include "incls/_psAdaptiveSizePolicy.cpp.incl"
duke@435	27
duke@435	28	#include <math.h>
duke@435	29
duke@435	30	PSAdaptiveSizePolicy::PSAdaptiveSizePolicy(size_t init_eden_size,
duke@435	31	size_t init_promo_size,
duke@435	32	size_t init_survivor_size,
duke@435	33	size_t intra_generation_alignment,
duke@435	34	double gc_pause_goal_sec,
duke@435	35	double gc_minor_pause_goal_sec,
duke@435	36	uint gc_cost_ratio) :
duke@435	37	AdaptiveSizePolicy(init_eden_size,
duke@435	38	init_promo_size,
duke@435	39	init_survivor_size,
duke@435	40	gc_pause_goal_sec,
duke@435	41	gc_cost_ratio),
duke@435	42	_collection_cost_margin_fraction(AdaptiveSizePolicyCollectionCostMargin/
duke@435	43	100.0),
duke@435	44	_intra_generation_alignment(intra_generation_alignment),
duke@435	45	_live_at_last_full_gc(init_promo_size),
duke@435	46	_gc_minor_pause_goal_sec(gc_minor_pause_goal_sec),
duke@435	47	_latest_major_mutator_interval_seconds(0),
duke@435	48	_young_gen_change_for_major_pause_count(0)
duke@435	49	{
duke@435	50	// Sizing policy statistics
duke@435	51	_avg_major_pause =
duke@435	52	new AdaptivePaddedAverage(AdaptiveTimeWeight, PausePadding);
duke@435	53	_avg_minor_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	54	_avg_major_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	55
duke@435	56	_avg_base_footprint = new AdaptiveWeightedAverage(AdaptiveSizePolicyWeight);
duke@435	57	_major_pause_old_estimator =
duke@435	58	new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
duke@435	59	_major_pause_young_estimator =
duke@435	60	new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
duke@435	61	_major_collection_estimator =
duke@435	62	new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
duke@435	63
duke@435	64	_young_gen_size_increment_supplement = YoungGenerationSizeSupplement;
duke@435	65	_old_gen_size_increment_supplement = TenuredGenerationSizeSupplement;
duke@435	66
duke@435	67	// Start the timers
duke@435	68	_major_timer.start();
duke@435	69
duke@435	70	_old_gen_policy_is_ready = false;
duke@435	71	}
duke@435	72
duke@435	73	void PSAdaptiveSizePolicy::major_collection_begin() {
duke@435	74	// Update the interval time
duke@435	75	_major_timer.stop();
duke@435	76	// Save most recent collection time
duke@435	77	_latest_major_mutator_interval_seconds = _major_timer.seconds();
duke@435	78	_major_timer.reset();
duke@435	79	_major_timer.start();
duke@435	80	}
duke@435	81
duke@435	82	void PSAdaptiveSizePolicy::update_minor_pause_old_estimator(
duke@435	83	double minor_pause_in_ms) {
duke@435	84	double promo_size_in_mbytes = ((double)_promo_size)/((double)M);
duke@435	85	_minor_pause_old_estimator->update(promo_size_in_mbytes,
duke@435	86	minor_pause_in_ms);
duke@435	87	}
duke@435	88
duke@435	89	void PSAdaptiveSizePolicy::major_collection_end(size_t amount_live,
duke@435	90	GCCause::Cause gc_cause) {
duke@435	91	// Update the pause time.
duke@435	92	_major_timer.stop();
duke@435	93
duke@435	94	if (gc_cause != GCCause::_java_lang_system_gc ||
duke@435	95	UseAdaptiveSizePolicyWithSystemGC) {
duke@435	96	double major_pause_in_seconds = _major_timer.seconds();
duke@435	97	double major_pause_in_ms = major_pause_in_seconds * MILLIUNITS;
duke@435	98
duke@435	99	// Sample for performance counter
duke@435	100	_avg_major_pause->sample(major_pause_in_seconds);
duke@435	101
duke@435	102	// Cost of collection (unit-less)
duke@435	103	double collection_cost = 0.0;
duke@435	104	if ((_latest_major_mutator_interval_seconds > 0.0) &&
duke@435	105	(major_pause_in_seconds > 0.0)) {
duke@435	106	double interval_in_seconds =
duke@435	107	_latest_major_mutator_interval_seconds + major_pause_in_seconds;
duke@435	108	collection_cost =
duke@435	109	major_pause_in_seconds / interval_in_seconds;
duke@435	110	avg_major_gc_cost()->sample(collection_cost);
duke@435	111
duke@435	112	// Sample for performance counter
duke@435	113	_avg_major_interval->sample(interval_in_seconds);
duke@435	114	}
duke@435	115
duke@435	116	// Calculate variables used to estimate pause time vs. gen sizes
duke@435	117	double eden_size_in_mbytes = ((double)_eden_size)/((double)M);
duke@435	118	double promo_size_in_mbytes = ((double)_promo_size)/((double)M);
duke@435	119	_major_pause_old_estimator->update(promo_size_in_mbytes,
duke@435	120	major_pause_in_ms);
duke@435	121	_major_pause_young_estimator->update(eden_size_in_mbytes,
duke@435	122	major_pause_in_ms);
duke@435	123
duke@435	124	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	125	gclog_or_tty->print("psAdaptiveSizePolicy::major_collection_end: "
duke@435	126	"major gc cost: %f average: %f", collection_cost,
duke@435	127	avg_major_gc_cost()->average());
duke@435	128	gclog_or_tty->print_cr(" major pause: %f major period %f",
duke@435	129	major_pause_in_ms,
duke@435	130	_latest_major_mutator_interval_seconds * MILLIUNITS);
duke@435	131	}
duke@435	132
duke@435	133	// Calculate variable used to estimate collection cost vs. gen sizes
duke@435	134	assert(collection_cost >= 0.0, "Expected to be non-negative");
duke@435	135	_major_collection_estimator->update(promo_size_in_mbytes,
duke@435	136	collection_cost);
duke@435	137	}
duke@435	138
duke@435	139	// Update the amount live at the end of a full GC
duke@435	140	_live_at_last_full_gc = amount_live;
duke@435	141
duke@435	142	// The policy does not have enough data until at least some major collections
duke@435	143	// have been done.
duke@435	144	if (_avg_major_pause->count() >= AdaptiveSizePolicyReadyThreshold) {
duke@435	145	_old_gen_policy_is_ready = true;
duke@435	146	}
duke@435	147
duke@435	148	// Interval times use this timer to measure the interval that
duke@435	149	// the mutator runs. Reset after the GC pause has been measured.
duke@435	150	_major_timer.reset();
duke@435	151	_major_timer.start();
duke@435	152	}
duke@435	153
duke@435	154	// If the remaining free space in the old generation is less that
duke@435	155	// that expected to be needed by the next collection, do a full
duke@435	156	// collection now.
duke@435	157	bool PSAdaptiveSizePolicy::should_full_GC(size_t old_free_in_bytes) {
duke@435	158
duke@435	159	// A similar test is done in the scavenge's should_attempt_scavenge(). If
duke@435	160	// this is changed, decide if that test should also be changed.
duke@435	161	bool result = padded_average_promoted_in_bytes() > (float) old_free_in_bytes;
duke@435	162	if (PrintGCDetails && Verbose) {
duke@435	163	if (result) {
duke@435	164	gclog_or_tty->print(" full after scavenge: ");
duke@435	165	} else {
duke@435	166	gclog_or_tty->print(" no full after scavenge: ");
duke@435	167	}
duke@435	168	gclog_or_tty->print_cr(" average_promoted " SIZE_FORMAT
duke@435	169	" padded_average_promoted " SIZE_FORMAT
duke@435	170	" free in old gen " SIZE_FORMAT,
duke@435	171	(size_t) average_promoted_in_bytes(),
duke@435	172	(size_t) padded_average_promoted_in_bytes(),
duke@435	173	old_free_in_bytes);
duke@435	174	}
duke@435	175	return result;
duke@435	176	}
duke@435	177
duke@435	178	void PSAdaptiveSizePolicy::clear_generation_free_space_flags() {
duke@435	179
duke@435	180	AdaptiveSizePolicy::clear_generation_free_space_flags();
duke@435	181
duke@435	182	set_change_old_gen_for_min_pauses(0);
duke@435	183
duke@435	184	set_change_young_gen_for_maj_pauses(0);
duke@435	185	}
duke@435	186
duke@435	187
duke@435	188	// If this is not a full GC, only test and modify the young generation.
duke@435	189
duke@435	190	void PSAdaptiveSizePolicy::compute_generation_free_space(size_t young_live,
duke@435	191	size_t eden_live,
duke@435	192	size_t old_live,
duke@435	193	size_t perm_live,
duke@435	194	size_t cur_eden,
duke@435	195	size_t max_old_gen_size,
duke@435	196	size_t max_eden_size,
duke@435	197	bool is_full_gc,
duke@435	198	GCCause::Cause gc_cause) {
duke@435	199
duke@435	200	// Update statistics
duke@435	201	// Time statistics are updated as we go, update footprint stats here
duke@435	202	_avg_base_footprint->sample(BaseFootPrintEstimate + perm_live);
duke@435	203	avg_young_live()->sample(young_live);
duke@435	204	avg_eden_live()->sample(eden_live);
duke@435	205	if (is_full_gc) {
duke@435	206	// old_live is only accurate after a full gc
duke@435	207	avg_old_live()->sample(old_live);
duke@435	208	}
duke@435	209
duke@435	210	// This code used to return if the policy was not ready , i.e.,
duke@435	211	// policy_is_ready() returning false. The intent was that
duke@435	212	// decisions below needed major collection times and so could
duke@435	213	// not be made before two major collections. A consequence was
duke@435	214	// adjustments to the young generation were not done until after
duke@435	215	// two major collections even if the minor collections times
duke@435	216	// exceeded the requested goals. Now let the young generation
duke@435	217	// adjust for the minor collection times. Major collection times
duke@435	218	// will be zero for the first collection and will naturally be
duke@435	219	// ignored. Tenured generation adjustments are only made at the
duke@435	220	// full collections so until the second major collection has
duke@435	221	// been reached, no tenured generation adjustments will be made.
duke@435	222
duke@435	223	// Until we know better, desired promotion size uses the last calculation
duke@435	224	size_t desired_promo_size = _promo_size;
duke@435	225
duke@435	226	// Start eden at the current value. The desired value that is stored
duke@435	227	// in _eden_size is not bounded by constraints of the heap and can
duke@435	228	// run away.
duke@435	229	//
duke@435	230	// As expected setting desired_eden_size to the current
duke@435	231	// value of desired_eden_size as a starting point
duke@435	232	// caused desired_eden_size to grow way too large and caused
duke@435	233	// an overflow down stream. It may have improved performance in
duke@435	234	// some case but is dangerous.
duke@435	235	size_t desired_eden_size = cur_eden;
duke@435	236
duke@435	237	#ifdef ASSERT
duke@435	238	size_t original_promo_size = desired_promo_size;
duke@435	239	size_t original_eden_size = desired_eden_size;
duke@435	240	#endif
duke@435	241
duke@435	242	// Cache some values. There's a bit of work getting these, so
duke@435	243	// we might save a little time.
duke@435	244	const double major_cost = major_gc_cost();
duke@435	245	const double minor_cost = minor_gc_cost();
duke@435	246
duke@435	247	// Used for diagnostics
duke@435	248	clear_generation_free_space_flags();
duke@435	249
duke@435	250	// Limits on our growth
duke@435	251	size_t promo_limit = (size_t)(max_old_gen_size - avg_old_live()->average());
duke@435	252
duke@435	253	// This method sets the desired eden size. That plus the
duke@435	254	// desired survivor space sizes sets the desired young generation
duke@435	255	// size. This methods does not know what the desired survivor
duke@435	256	// size is but expects that other policy will attempt to make
duke@435	257	// the survivor sizes compatible with the live data in the
duke@435	258	// young generation. This limit is an estimate of the space left
duke@435	259	// in the young generation after the survivor spaces have been
duke@435	260	// subtracted out.
duke@435	261	size_t eden_limit = max_eden_size;
duke@435	262
duke@435	263	// But don't force a promo size below the current promo size. Otherwise,
duke@435	264	// the promo size will shrink for no good reason.
duke@435	265	promo_limit = MAX2(promo_limit, _promo_size);
duke@435	266
duke@435	267	const double gc_cost_limit = GCTimeLimit/100.0;
duke@435	268
duke@435	269	// Which way should we go?
duke@435	270	// if pause requirement is not met
duke@435	271	// adjust size of any generation with average paus exceeding
duke@435	272	// the pause limit. Adjust one pause at a time (the larger)
duke@435	273	// and only make adjustments for the major pause at full collections.
duke@435	274	// else if throughput requirement not met
duke@435	275	// adjust the size of the generation with larger gc time. Only
duke@435	276	// adjust one generation at a time.
duke@435	277	// else
duke@435	278	// adjust down the total heap size. Adjust down the larger of the
duke@435	279	// generations.
duke@435	280
duke@435	281	// Add some checks for a threshhold for a change. For example,
duke@435	282	// a change less than the necessary alignment is probably not worth
duke@435	283	// attempting.
duke@435	284
duke@435	285
duke@435	286	if ((_avg_minor_pause->padded_average() > gc_pause_goal_sec()) ||
duke@435	287	(_avg_major_pause->padded_average() > gc_pause_goal_sec())) {
duke@435	288	//
duke@435	289	// Check pauses
duke@435	290	//
duke@435	291	// Make changes only to affect one of the pauses (the larger)
duke@435	292	// at a time.
duke@435	293	adjust_for_pause_time(is_full_gc, &desired_promo_size, &desired_eden_size);
duke@435	294
duke@435	295	} else if (_avg_minor_pause->padded_average() > gc_minor_pause_goal_sec()) {
duke@435	296	// Adjust only for the minor pause time goal
duke@435	297	adjust_for_minor_pause_time(is_full_gc, &desired_promo_size, &desired_eden_size);
duke@435	298
duke@435	299	} else if(adjusted_mutator_cost() < _throughput_goal) {
duke@435	300	// This branch used to require that (mutator_cost() > 0.0 in 1.4.2.
duke@435	301	// This sometimes resulted in skipping to the minimize footprint
duke@435	302	// code. Change this to try and reduce GC time if mutator time is
duke@435	303	// negative for whatever reason. Or for future consideration,
duke@435	304	// bail out of the code if mutator time is negative.
duke@435	305	//
duke@435	306	// Throughput
duke@435	307	//
duke@435	308	assert(major_cost >= 0.0, "major cost is < 0.0");
duke@435	309	assert(minor_cost >= 0.0, "minor cost is < 0.0");
duke@435	310	// Try to reduce the GC times.
duke@435	311	adjust_for_throughput(is_full_gc, &desired_promo_size, &desired_eden_size);
duke@435	312
duke@435	313	} else {
duke@435	314
duke@435	315	// Be conservative about reducing the footprint.
duke@435	316	// Do a minimum number of major collections first.
duke@435	317	// Have reasonable averages for major and minor collections costs.
duke@435	318	if (UseAdaptiveSizePolicyFootprintGoal &&
duke@435	319	young_gen_policy_is_ready() &&
duke@435	320	avg_major_gc_cost()->average() >= 0.0 &&
duke@435	321	avg_minor_gc_cost()->average() >= 0.0) {
duke@435	322	size_t desired_sum = desired_eden_size + desired_promo_size;
duke@435	323	desired_eden_size = adjust_eden_for_footprint(desired_eden_size,
duke@435	324	desired_sum);
duke@435	325	if (is_full_gc) {
duke@435	326	set_decide_at_full_gc(decide_at_full_gc_true);
duke@435	327	desired_promo_size = adjust_promo_for_footprint(desired_promo_size,
duke@435	328	desired_sum);
duke@435	329	}
duke@435	330	}
duke@435	331	}
duke@435	332
duke@435	333	// Note we make the same tests as in the code block below; the code
duke@435	334	// seems a little easier to read with the printing in another block.
duke@435	335	if (PrintAdaptiveSizePolicy) {
duke@435	336	if (desired_promo_size > promo_limit) {
duke@435	337	// "free_in_old_gen" was the original value for used for promo_limit
duke@435	338	size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average());
duke@435	339	gclog_or_tty->print_cr(
duke@435	340	"PSAdaptiveSizePolicy::compute_generation_free_space limits:"
duke@435	341	" desired_promo_size: " SIZE_FORMAT
duke@435	342	" promo_limit: " SIZE_FORMAT
duke@435	343	" free_in_old_gen: " SIZE_FORMAT
duke@435	344	" max_old_gen_size: " SIZE_FORMAT
duke@435	345	" avg_old_live: " SIZE_FORMAT,
duke@435	346	desired_promo_size, promo_limit, free_in_old_gen,
duke@435	347	max_old_gen_size, (size_t) avg_old_live()->average());
duke@435	348	}
duke@435	349	if (desired_eden_size > eden_limit) {
duke@435	350	gclog_or_tty->print_cr(
duke@435	351	"AdaptiveSizePolicy::compute_generation_free_space limits:"
duke@435	352	" desired_eden_size: " SIZE_FORMAT
duke@435	353	" old_eden_size: " SIZE_FORMAT
duke@435	354	" eden_limit: " SIZE_FORMAT
duke@435	355	" cur_eden: " SIZE_FORMAT
duke@435	356	" max_eden_size: " SIZE_FORMAT
duke@435	357	" avg_young_live: " SIZE_FORMAT,
duke@435	358	desired_eden_size, _eden_size, eden_limit, cur_eden,
duke@435	359	max_eden_size, (size_t)avg_young_live()->average());
duke@435	360	}
duke@435	361	if (gc_cost() > gc_cost_limit) {
duke@435	362	gclog_or_tty->print_cr(
duke@435	363	"AdaptiveSizePolicy::compute_generation_free_space: gc time limit"
duke@435	364	" gc_cost: %f "
duke@435	365	" GCTimeLimit: %d",
duke@435	366	gc_cost(), GCTimeLimit);
duke@435	367	}
duke@435	368	}
duke@435	369
duke@435	370	// Align everything and make a final limit check
duke@435	371	const size_t alignment = _intra_generation_alignment;
duke@435	372	desired_eden_size = align_size_up(desired_eden_size, alignment);
duke@435	373	desired_eden_size = MAX2(desired_eden_size, alignment);
duke@435	374	desired_promo_size = align_size_up(desired_promo_size, alignment);
duke@435	375	desired_promo_size = MAX2(desired_promo_size, alignment);
duke@435	376
duke@435	377	eden_limit = align_size_down(eden_limit, alignment);
duke@435	378	promo_limit = align_size_down(promo_limit, alignment);
duke@435	379
duke@435	380	// Is too much time being spent in GC?
duke@435	381	// Is the heap trying to grow beyond it's limits?
duke@435	382
duke@435	383	const size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average());
duke@435	384	if (desired_promo_size > free_in_old_gen && desired_eden_size > eden_limit) {
duke@435	385
duke@435	386	// eden_limit is the upper limit on the size of eden based on
duke@435	387	// the maximum size of the young generation and the sizes
duke@435	388	// of the survivor space.
duke@435	389	// The question being asked is whether the gc costs are high
duke@435	390	// and the space being recovered by a collection is low.
duke@435	391	// free_in_young_gen is the free space in the young generation
duke@435	392	// after a collection and promo_live is the free space in the old
duke@435	393	// generation after a collection.
duke@435	394	//
duke@435	395	// Use the minimum of the current value of the live in the
duke@435	396	// young gen or the average of the live in the young gen.
duke@435	397	// If the current value drops quickly, that should be taken
duke@435	398	// into account (i.e., don't trigger if the amount of free
duke@435	399	// space has suddenly jumped up). If the current is much
duke@435	400	// higher than the average, use the average since it represents
duke@435	401	// the longer term behavor.
duke@435	402	const size_t live_in_eden = MIN2(eden_live, (size_t) avg_eden_live()->average());
duke@435	403	const size_t free_in_eden = eden_limit > live_in_eden ?
duke@435	404	eden_limit - live_in_eden : 0;
duke@435	405	const size_t total_free_limit = free_in_old_gen + free_in_eden;
duke@435	406	const size_t total_mem = max_old_gen_size + max_eden_size;
duke@435	407	const double mem_free_limit = total_mem * (GCHeapFreeLimit/100.0);
duke@435	408	if (PrintAdaptiveSizePolicy && (Verbose ||
duke@435	409	(total_free_limit < (size_t) mem_free_limit))) {
duke@435	410	gclog_or_tty->print_cr(
duke@435	411	"PSAdaptiveSizePolicy::compute_generation_free_space limits:"
duke@435	412	" promo_limit: " SIZE_FORMAT
duke@435	413	" eden_limit: " SIZE_FORMAT
duke@435	414	" total_free_limit: " SIZE_FORMAT
duke@435	415	" max_old_gen_size: " SIZE_FORMAT
duke@435	416	" max_eden_size: " SIZE_FORMAT
duke@435	417	" mem_free_limit: " SIZE_FORMAT,
duke@435	418	promo_limit, eden_limit, total_free_limit,
duke@435	419	max_old_gen_size, max_eden_size,
duke@435	420	(size_t) mem_free_limit);
duke@435	421	}
duke@435	422
duke@435	423	if (is_full_gc) {
duke@435	424	if (gc_cost() > gc_cost_limit &&
duke@435	425	total_free_limit < (size_t) mem_free_limit) {
duke@435	426	// Collections, on average, are taking too much time, and
duke@435	427	// gc_cost() > gc_cost_limit
duke@435	428	// we have too little space available after a full gc.
duke@435	429	// total_free_limit < mem_free_limit
duke@435	430	// where
duke@435	431	// total_free_limit is the free space available in
duke@435	432	// both generations
duke@435	433	// total_mem is the total space available for allocation
duke@435	434	// in both generations (survivor spaces are not included
duke@435	435	// just as they are not included in eden_limit).
duke@435	436	// mem_free_limit is a fraction of total_mem judged to be an
duke@435	437	// acceptable amount that is still unused.
duke@435	438	// The heap can ask for the value of this variable when deciding
duke@435	439	// whether to thrown an OutOfMemory error.
duke@435	440	// Note that the gc time limit test only works for the collections
duke@435	441	// of the young gen + tenured gen and not for collections of the
duke@435	442	// permanent gen. That is because the calculation of the space
duke@435	443	// freed by the collection is the free space in the young gen +
duke@435	444	// tenured gen.
duke@435	445	// Ignore explicit GC's. Ignoring explicit GC's at this level
duke@435	446	// is the equivalent of the GC did not happen as far as the
duke@435	447	// overhead calculation is concerted (i.e., the flag is not set
duke@435	448	// and the count is not affected). Also the average will not
duke@435	449	// have been updated unless UseAdaptiveSizePolicyWithSystemGC is on.
duke@435	450	if (!GCCause::is_user_requested_gc(gc_cause) &&
duke@435	451	!GCCause::is_serviceability_requested_gc(gc_cause)) {
duke@435	452	inc_gc_time_limit_count();
duke@435	453	if (UseGCOverheadLimit &&
duke@435	454	(gc_time_limit_count() > AdaptiveSizePolicyGCTimeLimitThreshold)){
duke@435	455	// All conditions have been met for throwing an out-of-memory
duke@435	456	_gc_time_limit_exceeded = true;
duke@435	457	// Avoid consecutive OOM due to the gc time limit by resetting
duke@435	458	// the counter.
duke@435	459	reset_gc_time_limit_count();
duke@435	460	}
duke@435	461	_print_gc_time_limit_would_be_exceeded = true;
duke@435	462	}
duke@435	463	} else {
duke@435	464	// Did not exceed overhead limits
duke@435	465	reset_gc_time_limit_count();
duke@435	466	}
duke@435	467	}
duke@435	468	}
duke@435	469
duke@435	470
duke@435	471	// And one last limit check, now that we've aligned things.
duke@435	472	if (desired_eden_size > eden_limit) {
duke@435	473	// If the policy says to get a larger eden but
duke@435	474	// is hitting the limit, don't decrease eden.
duke@435	475	// This can lead to a general drifting down of the
duke@435	476	// eden size. Let the tenuring calculation push more
duke@435	477	// into the old gen.
duke@435	478	desired_eden_size = MAX2(eden_limit, cur_eden);
duke@435	479	}
duke@435	480	desired_promo_size = MIN2(desired_promo_size, promo_limit);
duke@435	481
duke@435	482
duke@435	483	if (PrintAdaptiveSizePolicy) {
duke@435	484	// Timing stats
duke@435	485	gclog_or_tty->print(
duke@435	486	"PSAdaptiveSizePolicy::compute_generation_free_space: costs"
duke@435	487	" minor_time: %f"
duke@435	488	" major_cost: %f"
duke@435	489	" mutator_cost: %f"
duke@435	490	" throughput_goal: %f",
duke@435	491	minor_gc_cost(), major_gc_cost(), mutator_cost(),
duke@435	492	_throughput_goal);
duke@435	493
duke@435	494	// We give more details if Verbose is set
duke@435	495	if (Verbose) {
duke@435	496	gclog_or_tty->print( " minor_pause: %f"
duke@435	497	" major_pause: %f"
duke@435	498	" minor_interval: %f"
duke@435	499	" major_interval: %f"
duke@435	500	" pause_goal: %f",
duke@435	501	_avg_minor_pause->padded_average(),
duke@435	502	_avg_major_pause->padded_average(),
duke@435	503	_avg_minor_interval->average(),
duke@435	504	_avg_major_interval->average(),
duke@435	505	gc_pause_goal_sec());
duke@435	506	}
duke@435	507
duke@435	508	// Footprint stats
duke@435	509	gclog_or_tty->print( " live_space: " SIZE_FORMAT
duke@435	510	" free_space: " SIZE_FORMAT,
duke@435	511	live_space(), free_space());
duke@435	512	// More detail
duke@435	513	if (Verbose) {
duke@435	514	gclog_or_tty->print( " base_footprint: " SIZE_FORMAT
duke@435	515	" avg_young_live: " SIZE_FORMAT
duke@435	516	" avg_old_live: " SIZE_FORMAT,
duke@435	517	(size_t)_avg_base_footprint->average(),
duke@435	518	(size_t)avg_young_live()->average(),
duke@435	519	(size_t)avg_old_live()->average());
duke@435	520	}
duke@435	521
duke@435	522	// And finally, our old and new sizes.
duke@435	523	gclog_or_tty->print(" old_promo_size: " SIZE_FORMAT
duke@435	524	" old_eden_size: " SIZE_FORMAT
duke@435	525	" desired_promo_size: " SIZE_FORMAT
duke@435	526	" desired_eden_size: " SIZE_FORMAT,
duke@435	527	_promo_size, _eden_size,
duke@435	528	desired_promo_size, desired_eden_size);
duke@435	529	gclog_or_tty->cr();
duke@435	530	}
duke@435	531
duke@435	532	decay_supplemental_growth(is_full_gc);
duke@435	533
duke@435	534	set_promo_size(desired_promo_size);
duke@435	535	set_eden_size(desired_eden_size);
duke@435	536	};
duke@435	537
duke@435	538	void PSAdaptiveSizePolicy::decay_supplemental_growth(bool is_full_gc) {
duke@435	539	// Decay the supplemental increment? Decay the supplement growth
duke@435	540	// factor even if it is not used. It is only meant to give a boost
duke@435	541	// to the initial growth and if it is not used, then it was not
duke@435	542	// needed.
duke@435	543	if (is_full_gc) {
duke@435	544	// Don't wait for the threshold value for the major collections. If
duke@435	545	// here, the supplemental growth term was used and should decay.
duke@435	546	if ((_avg_major_pause->count() % TenuredGenerationSizeSupplementDecay)
duke@435	547	== 0) {
duke@435	548	_old_gen_size_increment_supplement =
duke@435	549	_old_gen_size_increment_supplement >> 1;
duke@435	550	}
duke@435	551	} else {
duke@435	552	if ((_avg_minor_pause->count() >= AdaptiveSizePolicyReadyThreshold) &&
duke@435	553	(_avg_minor_pause->count() % YoungGenerationSizeSupplementDecay) == 0) {
duke@435	554	_young_gen_size_increment_supplement =
duke@435	555	_young_gen_size_increment_supplement >> 1;
duke@435	556	}
duke@435	557	}
duke@435	558	}
duke@435	559
duke@435	560	void PSAdaptiveSizePolicy::adjust_for_minor_pause_time(bool is_full_gc,
duke@435	561	size_t* desired_promo_size_ptr, size_t* desired_eden_size_ptr) {
duke@435	562
duke@435	563	// Adjust the young generation size to reduce pause time of
duke@435	564	// of collections.
duke@435	565	//
duke@435	566	// The AdaptiveSizePolicyInitializingSteps test is not used
duke@435	567	// here. It has not seemed to be needed but perhaps should
duke@435	568	// be added for consistency.
duke@435	569	if (minor_pause_young_estimator()->decrement_will_decrease()) {
duke@435	570	// reduce eden size
duke@435	571	set_change_young_gen_for_min_pauses(
duke@435	572	decrease_young_gen_for_min_pauses_true);
duke@435	573	*desired_eden_size_ptr = *desired_eden_size_ptr -
duke@435	574	eden_decrement_aligned_down(*desired_eden_size_ptr);
duke@435	575	} else {
duke@435	576	// EXPERIMENTAL ADJUSTMENT
duke@435	577	// Only record that the estimator indicated such an action.
duke@435	578	// *desired_eden_size_ptr = *desired_eden_size_ptr + eden_heap_delta;
duke@435	579	set_change_young_gen_for_min_pauses(
duke@435	580	increase_young_gen_for_min_pauses_true);
duke@435	581	}
duke@435	582	if (PSAdjustTenuredGenForMinorPause) {
duke@435	583	// If the desired eden size is as small as it will get,
duke@435	584	// try to adjust the old gen size.
duke@435	585	if (*desired_eden_size_ptr <= _intra_generation_alignment) {
duke@435	586	// Vary the old gen size to reduce the young gen pause. This
duke@435	587	// may not be a good idea. This is just a test.
duke@435	588	if (minor_pause_old_estimator()->decrement_will_decrease()) {
duke@435	589	set_change_old_gen_for_min_pauses(
duke@435	590	decrease_old_gen_for_min_pauses_true);
duke@435	591	*desired_promo_size_ptr =
duke@435	592	_promo_size - promo_decrement_aligned_down(*desired_promo_size_ptr);
duke@435	593	} else {
duke@435	594	set_change_old_gen_for_min_pauses(
duke@435	595	increase_old_gen_for_min_pauses_true);
duke@435	596	size_t promo_heap_delta =
duke@435	597	promo_increment_with_supplement_aligned_up(*desired_promo_size_ptr);
duke@435	598	if ((*desired_promo_size_ptr + promo_heap_delta) >
duke@435	599	*desired_promo_size_ptr) {
duke@435	600	*desired_promo_size_ptr =
duke@435	601	_promo_size + promo_heap_delta;
duke@435	602	}
duke@435	603	}
duke@435	604	}
duke@435	605	}
duke@435	606	}
duke@435	607
duke@435	608	void PSAdaptiveSizePolicy::adjust_for_pause_time(bool is_full_gc,
duke@435	609	size_t* desired_promo_size_ptr,
duke@435	610	size_t* desired_eden_size_ptr) {
duke@435	611
duke@435	612	size_t promo_heap_delta = 0;
duke@435	613	size_t eden_heap_delta = 0;
duke@435	614	// Add some checks for a threshhold for a change. For example,
duke@435	615	// a change less than the required alignment is probably not worth
duke@435	616	// attempting.
duke@435	617	if (is_full_gc) {
duke@435	618	set_decide_at_full_gc(decide_at_full_gc_true);
duke@435	619	}
duke@435	620
duke@435	621	if (_avg_minor_pause->padded_average() > _avg_major_pause->padded_average()) {
duke@435	622	adjust_for_minor_pause_time(is_full_gc,
duke@435	623	desired_promo_size_ptr,
duke@435	624	desired_eden_size_ptr);
duke@435	625	// major pause adjustments
duke@435	626	} else if (is_full_gc) {
duke@435	627	// Adjust for the major pause time only at full gc's because the
duke@435	628	// affects of a change can only be seen at full gc's.
duke@435	629
duke@435	630	// Reduce old generation size to reduce pause?
duke@435	631	if (major_pause_old_estimator()->decrement_will_decrease()) {
duke@435	632	// reduce old generation size
duke@435	633	set_change_old_gen_for_maj_pauses(decrease_old_gen_for_maj_pauses_true);
duke@435	634	promo_heap_delta = promo_decrement_aligned_down(*desired_promo_size_ptr);
duke@435	635	*desired_promo_size_ptr = _promo_size - promo_heap_delta;
duke@435	636	} else {
duke@435	637	// EXPERIMENTAL ADJUSTMENT
duke@435	638	// Only record that the estimator indicated such an action.
duke@435	639	// *desired_promo_size_ptr = _promo_size +
duke@435	640	// promo_increment_aligned_up(*desired_promo_size_ptr);
duke@435	641	set_change_old_gen_for_maj_pauses(increase_old_gen_for_maj_pauses_true);
duke@435	642	}
duke@435	643	if (PSAdjustYoungGenForMajorPause) {
duke@435	644	// If the promo size is at the minimum (i.e., the old gen
duke@435	645	// size will not actually decrease), consider changing the
duke@435	646	// young gen size.
duke@435	647	if (*desired_promo_size_ptr < _intra_generation_alignment) {
duke@435	648	// If increasing the young generation will decrease the old gen
duke@435	649	// pause, do it.
duke@435	650	// During startup there is noise in the statistics for deciding
duke@435	651	// on whether to increase or decrease the young gen size. For
duke@435	652	// some number of iterations, just try to increase the young
duke@435	653	// gen size if the major pause is too long to try and establish
duke@435	654	// good statistics for later decisions.
duke@435	655	if (major_pause_young_estimator()->increment_will_decrease() ||
duke@435	656	(_young_gen_change_for_major_pause_count
duke@435	657	<= AdaptiveSizePolicyInitializingSteps)) {
duke@435	658	set_change_young_gen_for_maj_pauses(
duke@435	659	increase_young_gen_for_maj_pauses_true);
duke@435	660	eden_heap_delta = eden_increment_aligned_up(*desired_eden_size_ptr);
duke@435	661	*desired_eden_size_ptr = _eden_size + eden_heap_delta;
duke@435	662	_young_gen_change_for_major_pause_count++;
duke@435	663	} else {
duke@435	664	// Record that decreasing the young gen size would decrease
duke@435	665	// the major pause
duke@435	666	set_change_young_gen_for_maj_pauses(
duke@435	667	decrease_young_gen_for_maj_pauses_true);
duke@435	668	eden_heap_delta = eden_decrement_aligned_down(*desired_eden_size_ptr);
duke@435	669	*desired_eden_size_ptr = _eden_size - eden_heap_delta;
duke@435	670	}
duke@435	671	}
duke@435	672	}
duke@435	673	}
duke@435	674
duke@435	675	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	676	gclog_or_tty->print_cr(
duke@435	677	"AdaptiveSizePolicy::compute_generation_free_space "
duke@435	678	"adjusting gen sizes for major pause (avg %f goal %f). "
duke@435	679	"desired_promo_size " SIZE_FORMAT "desired_eden_size "
duke@435	680	SIZE_FORMAT
duke@435	681	" promo delta " SIZE_FORMAT " eden delta " SIZE_FORMAT,
duke@435	682	_avg_major_pause->average(), gc_pause_goal_sec(),
duke@435	683	*desired_promo_size_ptr, *desired_eden_size_ptr,
duke@435	684	promo_heap_delta, eden_heap_delta);
duke@435	685	}
duke@435	686	}
duke@435	687
duke@435	688	void PSAdaptiveSizePolicy::adjust_for_throughput(bool is_full_gc,
duke@435	689	size_t* desired_promo_size_ptr,
duke@435	690	size_t* desired_eden_size_ptr) {
duke@435	691
duke@435	692	// Add some checks for a threshhold for a change. For example,
duke@435	693	// a change less than the required alignment is probably not worth
duke@435	694	// attempting.
duke@435	695	if (is_full_gc) {
duke@435	696	set_decide_at_full_gc(decide_at_full_gc_true);
duke@435	697	}
duke@435	698
duke@435	699	if ((gc_cost() + mutator_cost()) == 0.0) {
duke@435	700	return;
duke@435	701	}
duke@435	702
duke@435	703	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	704	gclog_or_tty->print("\nPSAdaptiveSizePolicy::adjust_for_throughput("
duke@435	705	"is_full: %d, promo: " SIZE_FORMAT ", cur_eden: " SIZE_FORMAT "): ",
duke@435	706	is_full_gc, *desired_promo_size_ptr, *desired_eden_size_ptr);
duke@435	707	gclog_or_tty->print_cr("mutator_cost %f major_gc_cost %f "
duke@435	708	"minor_gc_cost %f", mutator_cost(), major_gc_cost(), minor_gc_cost());
duke@435	709	}
duke@435	710
duke@435	711	// Tenured generation
duke@435	712	if (is_full_gc) {
duke@435	713
duke@435	714	// Calculate the change to use for the tenured gen.
duke@435	715	size_t scaled_promo_heap_delta = 0;
duke@435	716	// Can the increment to the generation be scaled?
duke@435	717	if (gc_cost() >= 0.0 && major_gc_cost() >= 0.0) {
duke@435	718	size_t promo_heap_delta =
duke@435	719	promo_increment_with_supplement_aligned_up(*desired_promo_size_ptr);
duke@435	720	double scale_by_ratio = major_gc_cost() / gc_cost();
duke@435	721	scaled_promo_heap_delta =
duke@435	722	(size_t) (scale_by_ratio * (double) promo_heap_delta);
duke@435	723	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	724	gclog_or_tty->print_cr(
duke@435	725	"Scaled tenured increment: " SIZE_FORMAT " by %f down to "
duke@435	726	SIZE_FORMAT,
duke@435	727	promo_heap_delta, scale_by_ratio, scaled_promo_heap_delta);
duke@435	728	}
duke@435	729	} else if (major_gc_cost() >= 0.0) {
duke@435	730	// Scaling is not going to work. If the major gc time is the
duke@435	731	// larger, give it a full increment.
duke@435	732	if (major_gc_cost() >= minor_gc_cost()) {
duke@435	733	scaled_promo_heap_delta =
duke@435	734	promo_increment_with_supplement_aligned_up(*desired_promo_size_ptr);
duke@435	735	}
duke@435	736	} else {
duke@435	737	// Don't expect to get here but it's ok if it does
duke@435	738	// in the product build since the delta will be 0
duke@435	739	// and nothing will change.
duke@435	740	assert(false, "Unexpected value for gc costs");
duke@435	741	}
duke@435	742
duke@435	743	switch (AdaptiveSizeThroughPutPolicy) {
duke@435	744	case 1:
duke@435	745	// Early in the run the statistics might not be good. Until
duke@435	746	// a specific number of collections have been, use the heuristic
duke@435	747	// that a larger generation size means lower collection costs.
duke@435	748	if (major_collection_estimator()->increment_will_decrease() ||
duke@435	749	(_old_gen_change_for_major_throughput
duke@435	750	<= AdaptiveSizePolicyInitializingSteps)) {
duke@435	751	// Increase tenured generation size to reduce major collection cost
duke@435	752	if ((*desired_promo_size_ptr + scaled_promo_heap_delta) >
duke@435	753	*desired_promo_size_ptr) {
duke@435	754	*desired_promo_size_ptr = _promo_size + scaled_promo_heap_delta;
duke@435	755	}
duke@435	756	set_change_old_gen_for_throughput(
duke@435	757	increase_old_gen_for_throughput_true);
duke@435	758	_old_gen_change_for_major_throughput++;
duke@435	759	} else {
duke@435	760	// EXPERIMENTAL ADJUSTMENT
duke@435	761	// Record that decreasing the old gen size would decrease
duke@435	762	// the major collection cost but don't do it.
duke@435	763	// *desired_promo_size_ptr = _promo_size -
duke@435	764	// promo_decrement_aligned_down(*desired_promo_size_ptr);
duke@435	765	set_change_old_gen_for_throughput(
duke@435	766	decrease_old_gen_for_throughput_true);
duke@435	767	}
duke@435	768
duke@435	769	break;
duke@435	770	default:
duke@435	771	// Simplest strategy
duke@435	772	if ((*desired_promo_size_ptr + scaled_promo_heap_delta) >
duke@435	773	*desired_promo_size_ptr) {
duke@435	774	*desired_promo_size_ptr = *desired_promo_size_ptr +
duke@435	775	scaled_promo_heap_delta;
duke@435	776	}
duke@435	777	set_change_old_gen_for_throughput(
duke@435	778	increase_old_gen_for_throughput_true);
duke@435	779	_old_gen_change_for_major_throughput++;
duke@435	780	}
duke@435	781
duke@435	782	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	783	gclog_or_tty->print_cr(
duke@435	784	"adjusting tenured gen for throughput (avg %f goal %f). "
duke@435	785	"desired_promo_size " SIZE_FORMAT " promo_delta " SIZE_FORMAT ,
duke@435	786	mutator_cost(), _throughput_goal,
duke@435	787	*desired_promo_size_ptr, scaled_promo_heap_delta);
duke@435	788	}
duke@435	789	}
duke@435	790
duke@435	791	// Young generation
duke@435	792	size_t scaled_eden_heap_delta = 0;
duke@435	793	// Can the increment to the generation be scaled?
duke@435	794	if (gc_cost() >= 0.0 && minor_gc_cost() >= 0.0) {
duke@435	795	size_t eden_heap_delta =
duke@435	796	eden_increment_with_supplement_aligned_up(*desired_eden_size_ptr);
duke@435	797	double scale_by_ratio = minor_gc_cost() / gc_cost();
duke@435	798	assert(scale_by_ratio <= 1.0 && scale_by_ratio >= 0.0, "Scaling is wrong");
duke@435	799	scaled_eden_heap_delta =
duke@435	800	(size_t) (scale_by_ratio * (double) eden_heap_delta);
duke@435	801	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	802	gclog_or_tty->print_cr(
duke@435	803	"Scaled eden increment: " SIZE_FORMAT " by %f down to "
duke@435	804	SIZE_FORMAT,
duke@435	805	eden_heap_delta, scale_by_ratio, scaled_eden_heap_delta);
duke@435	806	}
duke@435	807	} else if (minor_gc_cost() >= 0.0) {
duke@435	808	// Scaling is not going to work. If the minor gc time is the
duke@435	809	// larger, give it a full increment.
duke@435	810	if (minor_gc_cost() > major_gc_cost()) {
duke@435	811	scaled_eden_heap_delta =
duke@435	812	eden_increment_with_supplement_aligned_up(*desired_eden_size_ptr);
duke@435	813	}
duke@435	814	} else {
duke@435	815	// Don't expect to get here but it's ok if it does
duke@435	816	// in the product build since the delta will be 0
duke@435	817	// and nothing will change.
duke@435	818	assert(false, "Unexpected value for gc costs");
duke@435	819	}
duke@435	820
duke@435	821	// Use a heuristic for some number of collections to give
duke@435	822	// the averages time to settle down.
duke@435	823	switch (AdaptiveSizeThroughPutPolicy) {
duke@435	824	case 1:
duke@435	825	if (minor_collection_estimator()->increment_will_decrease() ||
duke@435	826	(_young_gen_change_for_minor_throughput
duke@435	827	<= AdaptiveSizePolicyInitializingSteps)) {
duke@435	828	// Expand young generation size to reduce frequency of
duke@435	829	// of collections.
duke@435	830	if ((*desired_eden_size_ptr + scaled_eden_heap_delta) >
duke@435	831	*desired_eden_size_ptr) {
duke@435	832	*desired_eden_size_ptr =
duke@435	833	*desired_eden_size_ptr + scaled_eden_heap_delta;
duke@435	834	}
duke@435	835	set_change_young_gen_for_throughput(
duke@435	836	increase_young_gen_for_througput_true);
duke@435	837	_young_gen_change_for_minor_throughput++;
duke@435	838	} else {
duke@435	839	// EXPERIMENTAL ADJUSTMENT
duke@435	840	// Record that decreasing the young gen size would decrease
duke@435	841	// the minor collection cost but don't do it.
duke@435	842	// *desired_eden_size_ptr = _eden_size -
duke@435	843	// eden_decrement_aligned_down(*desired_eden_size_ptr);
duke@435	844	set_change_young_gen_for_throughput(
duke@435	845	decrease_young_gen_for_througput_true);
duke@435	846	}
duke@435	847	break;
duke@435	848	default:
duke@435	849	if ((*desired_eden_size_ptr + scaled_eden_heap_delta) >
duke@435	850	*desired_eden_size_ptr) {
duke@435	851	*desired_eden_size_ptr =
duke@435	852	*desired_eden_size_ptr + scaled_eden_heap_delta;
duke@435	853	}
duke@435	854	set_change_young_gen_for_throughput(
duke@435	855	increase_young_gen_for_througput_true);
duke@435	856	_young_gen_change_for_minor_throughput++;
duke@435	857	}
duke@435	858
duke@435	859	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	860	gclog_or_tty->print_cr(
duke@435	861	"adjusting eden for throughput (avg %f goal %f). desired_eden_size "
duke@435	862	SIZE_FORMAT " eden delta " SIZE_FORMAT "\n",
duke@435	863	mutator_cost(), _throughput_goal,
duke@435	864	*desired_eden_size_ptr, scaled_eden_heap_delta);
duke@435	865	}
duke@435	866	}
duke@435	867
duke@435	868	size_t PSAdaptiveSizePolicy::adjust_promo_for_footprint(
duke@435	869	size_t desired_promo_size, size_t desired_sum) {
duke@435	870	assert(desired_promo_size <= desired_sum, "Inconsistent parameters");
duke@435	871	set_decrease_for_footprint(decrease_old_gen_for_footprint_true);
duke@435	872
duke@435	873	size_t change = promo_decrement(desired_promo_size);
duke@435	874	change = scale_down(change, desired_promo_size, desired_sum);
duke@435	875
duke@435	876	size_t reduced_size = desired_promo_size - change;
duke@435	877
duke@435	878	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	879	gclog_or_tty->print_cr(
duke@435	880	"AdaptiveSizePolicy::compute_generation_free_space "
duke@435	881	"adjusting tenured gen for footprint. "
duke@435	882	"starting promo size " SIZE_FORMAT
duke@435	883	" reduced promo size " SIZE_FORMAT,
duke@435	884	" promo delta " SIZE_FORMAT,
duke@435	885	desired_promo_size, reduced_size, change );
duke@435	886	}
duke@435	887
duke@435	888	assert(reduced_size <= desired_promo_size, "Inconsistent result");
duke@435	889	return reduced_size;
duke@435	890	}
duke@435	891
duke@435	892	size_t PSAdaptiveSizePolicy::adjust_eden_for_footprint(
duke@435	893	size_t desired_eden_size, size_t desired_sum) {
duke@435	894	assert(desired_eden_size <= desired_sum, "Inconsistent parameters");
duke@435	895	set_decrease_for_footprint(decrease_young_gen_for_footprint_true);
duke@435	896
duke@435	897	size_t change = eden_decrement(desired_eden_size);
duke@435	898	change = scale_down(change, desired_eden_size, desired_sum);
duke@435	899
duke@435	900	size_t reduced_size = desired_eden_size - change;
duke@435	901
duke@435	902	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	903	gclog_or_tty->print_cr(
duke@435	904	"AdaptiveSizePolicy::compute_generation_free_space "
duke@435	905	"adjusting eden for footprint. "
duke@435	906	" starting eden size " SIZE_FORMAT
duke@435	907	" reduced eden size " SIZE_FORMAT
duke@435	908	" eden delta " SIZE_FORMAT,
duke@435	909	desired_eden_size, reduced_size, change);
duke@435	910	}
duke@435	911
duke@435	912	assert(reduced_size <= desired_eden_size, "Inconsistent result");
duke@435	913	return reduced_size;
duke@435	914	}
duke@435	915
duke@435	916	// Scale down "change" by the factor
duke@435	917	// part / total
duke@435	918	// Don't align the results.
duke@435	919
duke@435	920	size_t PSAdaptiveSizePolicy::scale_down(size_t change,
duke@435	921	double part,
duke@435	922	double total) {
duke@435	923	assert(part <= total, "Inconsistent input");
duke@435	924	size_t reduced_change = change;
duke@435	925	if (total > 0) {
duke@435	926	double fraction = part / total;
duke@435	927	reduced_change = (size_t) (fraction * (double) change);
duke@435	928	}
duke@435	929	assert(reduced_change <= change, "Inconsistent result");
duke@435	930	return reduced_change;
duke@435	931	}
duke@435	932
duke@435	933	size_t PSAdaptiveSizePolicy::eden_increment(size_t cur_eden,
duke@435	934	uint percent_change) {
duke@435	935	size_t eden_heap_delta;
duke@435	936	eden_heap_delta = cur_eden / 100 * percent_change;
duke@435	937	return eden_heap_delta;
duke@435	938	}
duke@435	939
duke@435	940	size_t PSAdaptiveSizePolicy::eden_increment(size_t cur_eden) {
duke@435	941	return eden_increment(cur_eden, YoungGenerationSizeIncrement);
duke@435	942	}
duke@435	943
duke@435	944	size_t PSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
duke@435	945	size_t result = eden_increment(cur_eden, YoungGenerationSizeIncrement);
duke@435	946	return align_size_up(result, _intra_generation_alignment);
duke@435	947	}
duke@435	948
duke@435	949	size_t PSAdaptiveSizePolicy::eden_increment_aligned_down(size_t cur_eden) {
duke@435	950	size_t result = eden_increment(cur_eden);
duke@435	951	return align_size_down(result, _intra_generation_alignment);
duke@435	952	}
duke@435	953
duke@435	954	size_t PSAdaptiveSizePolicy::eden_increment_with_supplement_aligned_up(
duke@435	955	size_t cur_eden) {
duke@435	956	size_t result = eden_increment(cur_eden,
duke@435	957	YoungGenerationSizeIncrement + _young_gen_size_increment_supplement);
duke@435	958	return align_size_up(result, _intra_generation_alignment);
duke@435	959	}
duke@435	960
duke@435	961	size_t PSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
duke@435	962	size_t eden_heap_delta = eden_decrement(cur_eden);
duke@435	963	return align_size_down(eden_heap_delta, _intra_generation_alignment);
duke@435	964	}
duke@435	965
duke@435	966	size_t PSAdaptiveSizePolicy::eden_decrement(size_t cur_eden) {
duke@435	967	size_t eden_heap_delta = eden_increment(cur_eden) /
duke@435	968	AdaptiveSizeDecrementScaleFactor;
duke@435	969	return eden_heap_delta;
duke@435	970	}
duke@435	971
duke@435	972	size_t PSAdaptiveSizePolicy::promo_increment(size_t cur_promo,
duke@435	973	uint percent_change) {
duke@435	974	size_t promo_heap_delta;
duke@435	975	promo_heap_delta = cur_promo / 100 * percent_change;
duke@435	976	return promo_heap_delta;
duke@435	977	}
duke@435	978
duke@435	979	size_t PSAdaptiveSizePolicy::promo_increment(size_t cur_promo) {
duke@435	980	return promo_increment(cur_promo, TenuredGenerationSizeIncrement);
duke@435	981	}
duke@435	982
duke@435	983	size_t PSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
duke@435	984	size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
duke@435	985	return align_size_up(result, _intra_generation_alignment);
duke@435	986	}
duke@435	987
duke@435	988	size_t PSAdaptiveSizePolicy::promo_increment_aligned_down(size_t cur_promo) {
duke@435	989	size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
duke@435	990	return align_size_down(result, _intra_generation_alignment);
duke@435	991	}
duke@435	992
duke@435	993	size_t PSAdaptiveSizePolicy::promo_increment_with_supplement_aligned_up(
duke@435	994	size_t cur_promo) {
duke@435	995	size_t result = promo_increment(cur_promo,
duke@435	996	TenuredGenerationSizeIncrement + _old_gen_size_increment_supplement);
duke@435	997	return align_size_up(result, _intra_generation_alignment);
duke@435	998	}
duke@435	999
duke@435	1000	size_t PSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
duke@435	1001	size_t promo_heap_delta = promo_decrement(cur_promo);
duke@435	1002	return align_size_down(promo_heap_delta, _intra_generation_alignment);
duke@435	1003	}
duke@435	1004
duke@435	1005	size_t PSAdaptiveSizePolicy::promo_decrement(size_t cur_promo) {
duke@435	1006	size_t promo_heap_delta = promo_increment(cur_promo);
duke@435	1007	promo_heap_delta = promo_heap_delta / AdaptiveSizeDecrementScaleFactor;
duke@435	1008	return promo_heap_delta;
duke@435	1009	}
duke@435	1010
duke@435	1011	int PSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold(
duke@435	1012	bool is_survivor_overflow,
duke@435	1013	int tenuring_threshold,
duke@435	1014	size_t survivor_limit) {
duke@435	1015	assert(survivor_limit >= _intra_generation_alignment,
duke@435	1016	"survivor_limit too small");
duke@435	1017	assert((size_t)align_size_down(survivor_limit, _intra_generation_alignment)
duke@435	1018	== survivor_limit, "survivor_limit not aligned");
duke@435	1019
duke@435	1020	// This method is called even if the tenuring threshold and survivor
duke@435	1021	// spaces are not adjusted so that the averages are sampled above.
duke@435	1022	if (!UsePSAdaptiveSurvivorSizePolicy ||
duke@435	1023	!young_gen_policy_is_ready()) {
duke@435	1024	return tenuring_threshold;
duke@435	1025	}
duke@435	1026
duke@435	1027	// We'll decide whether to increase or decrease the tenuring
duke@435	1028	// threshold based partly on the newly computed survivor size
duke@435	1029	// (if we hit the maximum limit allowed, we'll always choose to
duke@435	1030	// decrement the threshold).
duke@435	1031	bool incr_tenuring_threshold = false;
duke@435	1032	bool decr_tenuring_threshold = false;
duke@435	1033
duke@435	1034	set_decrement_tenuring_threshold_for_gc_cost(false);
duke@435	1035	set_increment_tenuring_threshold_for_gc_cost(false);
duke@435	1036	set_decrement_tenuring_threshold_for_survivor_limit(false);
duke@435	1037
duke@435	1038	if (!is_survivor_overflow) {
duke@435	1039	// Keep running averages on how much survived
duke@435	1040
duke@435	1041	// We use the tenuring threshold to equalize the cost of major
duke@435	1042	// and minor collections.
duke@435	1043	// ThresholdTolerance is used to indicate how sensitive the
duke@435	1044	// tenuring threshold is to differences in cost betweent the
duke@435	1045	// collection types.
duke@435	1046
duke@435	1047	// Get the times of interest. This involves a little work, so
duke@435	1048	// we cache the values here.
duke@435	1049	const double major_cost = major_gc_cost();
duke@435	1050	const double minor_cost = minor_gc_cost();
duke@435	1051
duke@435	1052	if (minor_cost > major_cost * _threshold_tolerance_percent) {
duke@435	1053	// Minor times are getting too long; lower the threshold so
duke@435	1054	// less survives and more is promoted.
duke@435	1055	decr_tenuring_threshold = true;
duke@435	1056	set_decrement_tenuring_threshold_for_gc_cost(true);
duke@435	1057	} else if (major_cost > minor_cost * _threshold_tolerance_percent) {
duke@435	1058	// Major times are too long, so we want less promotion.
duke@435	1059	incr_tenuring_threshold = true;
duke@435	1060	set_increment_tenuring_threshold_for_gc_cost(true);
duke@435	1061	}
duke@435	1062
duke@435	1063	} else {
duke@435	1064	// Survivor space overflow occurred, so promoted and survived are
duke@435	1065	// not accurate. We'll make our best guess by combining survived
duke@435	1066	// and promoted and count them as survivors.
duke@435	1067	//
duke@435	1068	// We'll lower the tenuring threshold to see if we can correct
duke@435	1069	// things. Also, set the survivor size conservatively. We're
duke@435	1070	// trying to avoid many overflows from occurring if defnew size
duke@435	1071	// is just too small.
duke@435	1072
duke@435	1073	decr_tenuring_threshold = true;
duke@435	1074	}
duke@435	1075
duke@435	1076	// The padded average also maintains a deviation from the average;
duke@435	1077	// we use this to see how good of an estimate we have of what survived.
duke@435	1078	// We're trying to pad the survivor size as little as possible without
duke@435	1079	// overflowing the survivor spaces.
duke@435	1080	size_t target_size = align_size_up((size_t)_avg_survived->padded_average(),
duke@435	1081	_intra_generation_alignment);
duke@435	1082	target_size = MAX2(target_size, _intra_generation_alignment);
duke@435	1083
duke@435	1084	if (target_size > survivor_limit) {
duke@435	1085	// Target size is bigger than we can handle. Let's also reduce
duke@435	1086	// the tenuring threshold.
duke@435	1087	target_size = survivor_limit;
duke@435	1088	decr_tenuring_threshold = true;
duke@435	1089	set_decrement_tenuring_threshold_for_survivor_limit(true);
duke@435	1090	}
duke@435	1091
duke@435	1092	// Finally, increment or decrement the tenuring threshold, as decided above.
duke@435	1093	// We test for decrementing first, as we might have hit the target size
duke@435	1094	// limit.
duke@435	1095	if (decr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
duke@435	1096	if (tenuring_threshold > 1) {
duke@435	1097	tenuring_threshold--;
duke@435	1098	}
duke@435	1099	} else if (incr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
duke@435	1100	if (tenuring_threshold < MaxTenuringThreshold) {
duke@435	1101	tenuring_threshold++;
duke@435	1102	}
duke@435	1103	}
duke@435	1104
duke@435	1105	// We keep a running average of the amount promoted which is used
duke@435	1106	// to decide when we should collect the old generation (when
duke@435	1107	// the amount of old gen free space is less than what we expect to
duke@435	1108	// promote).
duke@435	1109
duke@435	1110	if (PrintAdaptiveSizePolicy) {
duke@435	1111	// A little more detail if Verbose is on
duke@435	1112	if (Verbose) {
duke@435	1113	gclog_or_tty->print( " avg_survived: %f"
duke@435	1114	" avg_deviation: %f",
duke@435	1115	_avg_survived->average(),
duke@435	1116	_avg_survived->deviation());
duke@435	1117	}
duke@435	1118
duke@435	1119	gclog_or_tty->print( " avg_survived_padded_avg: %f",
duke@435	1120	_avg_survived->padded_average());
duke@435	1121
duke@435	1122	if (Verbose) {
duke@435	1123	gclog_or_tty->print( " avg_promoted_avg: %f"
duke@435	1124	" avg_promoted_dev: %f",
duke@435	1125	avg_promoted()->average(),
duke@435	1126	avg_promoted()->deviation());
duke@435	1127	}
duke@435	1128
duke@435	1129	gclog_or_tty->print( " avg_promoted_padded_avg: %f"
duke@435	1130	" avg_pretenured_padded_avg: %f"
duke@435	1131	" tenuring_thresh: %d"
duke@435	1132	" target_size: " SIZE_FORMAT,
duke@435	1133	avg_promoted()->padded_average(),
duke@435	1134	_avg_pretenured->padded_average(),
duke@435	1135	tenuring_threshold, target_size);
duke@435	1136	tty->cr();
duke@435	1137	}
duke@435	1138
duke@435	1139	set_survivor_size(target_size);
duke@435	1140
duke@435	1141	return tenuring_threshold;
duke@435	1142	}
duke@435	1143
duke@435	1144	void PSAdaptiveSizePolicy::update_averages(bool is_survivor_overflow,
duke@435	1145	size_t survived,
duke@435	1146	size_t promoted) {
duke@435	1147	// Update averages
duke@435	1148	if (!is_survivor_overflow) {
duke@435	1149	// Keep running averages on how much survived
duke@435	1150	_avg_survived->sample(survived);
duke@435	1151	} else {
duke@435	1152	size_t survived_guess = survived + promoted;
duke@435	1153	_avg_survived->sample(survived_guess);
duke@435	1154	}
duke@435	1155	avg_promoted()->sample(promoted + _avg_pretenured->padded_average());
duke@435	1156
duke@435	1157	if (PrintAdaptiveSizePolicy) {
duke@435	1158	gclog_or_tty->print(
duke@435	1159	"AdaptiveSizePolicy::compute_survivor_space_size_and_thresh:"
duke@435	1160	" survived: " SIZE_FORMAT
duke@435	1161	" promoted: " SIZE_FORMAT
duke@435	1162	" overflow: %s",
duke@435	1163	survived, promoted, is_survivor_overflow ? "true" : "false");
duke@435	1164	}
duke@435	1165	}
duke@435	1166
duke@435	1167	bool PSAdaptiveSizePolicy::print_adaptive_size_policy_on(outputStream* st)
duke@435	1168	const {
duke@435	1169
duke@435	1170	if (!UseAdaptiveSizePolicy) return false;
duke@435	1171
duke@435	1172	return AdaptiveSizePolicy::print_adaptive_size_policy_on(
duke@435	1173	st,
duke@435	1174	PSScavenge::tenuring_threshold());
duke@435	1175	}