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

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

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

Tue, 13 Apr 2010 13:52:10 -0700

author

jmasa

date

Tue, 13 Apr 2010 13:52:10 -0700

changeset 1822

0bfd3fb24150

parent 435

a61af66fc99e

child 1907

c18cbe5936b8

permissions

-rw-r--r--

6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
Summary: Ensure a full GC that clears SoftReferences before throwing an out-of-memory
Reviewed-by: ysr, jcoomes

duke@435	1	/*
jmasa@1822	2	* Copyright 2002-2010 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	// If this is not a full GC, only test and modify the young generation.
duke@435	188
jmasa@1822	189	void PSAdaptiveSizePolicy::compute_generation_free_space(
jmasa@1822	190	size_t young_live,
jmasa@1822	191	size_t eden_live,
jmasa@1822	192	size_t old_live,
jmasa@1822	193	size_t perm_live,
jmasa@1822	194	size_t cur_eden,
jmasa@1822	195	size_t max_old_gen_size,
jmasa@1822	196	size_t max_eden_size,
jmasa@1822	197	bool is_full_gc,
jmasa@1822	198	GCCause::Cause gc_cause,
jmasa@1822	199	CollectorPolicy* collector_policy) {
duke@435	200
duke@435	201	// Update statistics
duke@435	202	// Time statistics are updated as we go, update footprint stats here
duke@435	203	_avg_base_footprint->sample(BaseFootPrintEstimate + perm_live);
duke@435	204	avg_young_live()->sample(young_live);
duke@435	205	avg_eden_live()->sample(eden_live);
duke@435	206	if (is_full_gc) {
duke@435	207	// old_live is only accurate after a full gc
duke@435	208	avg_old_live()->sample(old_live);
duke@435	209	}
duke@435	210
duke@435	211	// This code used to return if the policy was not ready , i.e.,
duke@435	212	// policy_is_ready() returning false. The intent was that
duke@435	213	// decisions below needed major collection times and so could
duke@435	214	// not be made before two major collections. A consequence was
duke@435	215	// adjustments to the young generation were not done until after
duke@435	216	// two major collections even if the minor collections times
duke@435	217	// exceeded the requested goals. Now let the young generation
duke@435	218	// adjust for the minor collection times. Major collection times
duke@435	219	// will be zero for the first collection and will naturally be
duke@435	220	// ignored. Tenured generation adjustments are only made at the
duke@435	221	// full collections so until the second major collection has
duke@435	222	// been reached, no tenured generation adjustments will be made.
duke@435	223
duke@435	224	// Until we know better, desired promotion size uses the last calculation
duke@435	225	size_t desired_promo_size = _promo_size;
duke@435	226
duke@435	227	// Start eden at the current value. The desired value that is stored
duke@435	228	// in _eden_size is not bounded by constraints of the heap and can
duke@435	229	// run away.
duke@435	230	//
duke@435	231	// As expected setting desired_eden_size to the current
duke@435	232	// value of desired_eden_size as a starting point
duke@435	233	// caused desired_eden_size to grow way too large and caused
duke@435	234	// an overflow down stream. It may have improved performance in
duke@435	235	// some case but is dangerous.
duke@435	236	size_t desired_eden_size = cur_eden;
duke@435	237
duke@435	238	#ifdef ASSERT
duke@435	239	size_t original_promo_size = desired_promo_size;
duke@435	240	size_t original_eden_size = desired_eden_size;
duke@435	241	#endif
duke@435	242
duke@435	243	// Cache some values. There's a bit of work getting these, so
duke@435	244	// we might save a little time.
duke@435	245	const double major_cost = major_gc_cost();
duke@435	246	const double minor_cost = minor_gc_cost();
duke@435	247
duke@435	248	// Used for diagnostics
duke@435	249	clear_generation_free_space_flags();
duke@435	250
duke@435	251	// Limits on our growth
duke@435	252	size_t promo_limit = (size_t)(max_old_gen_size - avg_old_live()->average());
duke@435	253
duke@435	254	// This method sets the desired eden size. That plus the
duke@435	255	// desired survivor space sizes sets the desired young generation
duke@435	256	// size. This methods does not know what the desired survivor
duke@435	257	// size is but expects that other policy will attempt to make
duke@435	258	// the survivor sizes compatible with the live data in the
duke@435	259	// young generation. This limit is an estimate of the space left
duke@435	260	// in the young generation after the survivor spaces have been
duke@435	261	// subtracted out.
duke@435	262	size_t eden_limit = max_eden_size;
duke@435	263
duke@435	264	// But don't force a promo size below the current promo size. Otherwise,
duke@435	265	// the promo size will shrink for no good reason.
duke@435	266	promo_limit = MAX2(promo_limit, _promo_size);
duke@435	267
duke@435	268	const double gc_cost_limit = GCTimeLimit/100.0;
duke@435	269
duke@435	270	// Which way should we go?
duke@435	271	// if pause requirement is not met
duke@435	272	// adjust size of any generation with average paus exceeding
duke@435	273	// the pause limit. Adjust one pause at a time (the larger)
duke@435	274	// and only make adjustments for the major pause at full collections.
duke@435	275	// else if throughput requirement not met
duke@435	276	// adjust the size of the generation with larger gc time. Only
duke@435	277	// adjust one generation at a time.
duke@435	278	// else
duke@435	279	// adjust down the total heap size. Adjust down the larger of the
duke@435	280	// generations.
duke@435	281
duke@435	282	// Add some checks for a threshhold for a change. For example,
duke@435	283	// a change less than the necessary alignment is probably not worth
duke@435	284	// attempting.
duke@435	285
duke@435	286
duke@435	287	if ((_avg_minor_pause->padded_average() > gc_pause_goal_sec()) ||
duke@435	288	(_avg_major_pause->padded_average() > gc_pause_goal_sec())) {
duke@435	289	//
duke@435	290	// Check pauses
duke@435	291	//
duke@435	292	// Make changes only to affect one of the pauses (the larger)
duke@435	293	// at a time.
duke@435	294	adjust_for_pause_time(is_full_gc, &desired_promo_size, &desired_eden_size);
duke@435	295
duke@435	296	} else if (_avg_minor_pause->padded_average() > gc_minor_pause_goal_sec()) {
duke@435	297	// Adjust only for the minor pause time goal
duke@435	298	adjust_for_minor_pause_time(is_full_gc, &desired_promo_size, &desired_eden_size);
duke@435	299
duke@435	300	} else if(adjusted_mutator_cost() < _throughput_goal) {
duke@435	301	// This branch used to require that (mutator_cost() > 0.0 in 1.4.2.
duke@435	302	// This sometimes resulted in skipping to the minimize footprint
duke@435	303	// code. Change this to try and reduce GC time if mutator time is
duke@435	304	// negative for whatever reason. Or for future consideration,
duke@435	305	// bail out of the code if mutator time is negative.
duke@435	306	//
duke@435	307	// Throughput
duke@435	308	//
duke@435	309	assert(major_cost >= 0.0, "major cost is < 0.0");
duke@435	310	assert(minor_cost >= 0.0, "minor cost is < 0.0");
duke@435	311	// Try to reduce the GC times.
duke@435	312	adjust_for_throughput(is_full_gc, &desired_promo_size, &desired_eden_size);
duke@435	313
duke@435	314	} else {
duke@435	315
duke@435	316	// Be conservative about reducing the footprint.
duke@435	317	// Do a minimum number of major collections first.
duke@435	318	// Have reasonable averages for major and minor collections costs.
duke@435	319	if (UseAdaptiveSizePolicyFootprintGoal &&
duke@435	320	young_gen_policy_is_ready() &&
duke@435	321	avg_major_gc_cost()->average() >= 0.0 &&
duke@435	322	avg_minor_gc_cost()->average() >= 0.0) {
duke@435	323	size_t desired_sum = desired_eden_size + desired_promo_size;
duke@435	324	desired_eden_size = adjust_eden_for_footprint(desired_eden_size,
duke@435	325	desired_sum);
duke@435	326	if (is_full_gc) {
duke@435	327	set_decide_at_full_gc(decide_at_full_gc_true);
duke@435	328	desired_promo_size = adjust_promo_for_footprint(desired_promo_size,
duke@435	329	desired_sum);
duke@435	330	}
duke@435	331	}
duke@435	332	}
duke@435	333
duke@435	334	// Note we make the same tests as in the code block below; the code
duke@435	335	// seems a little easier to read with the printing in another block.
duke@435	336	if (PrintAdaptiveSizePolicy) {
duke@435	337	if (desired_promo_size > promo_limit) {
duke@435	338	// "free_in_old_gen" was the original value for used for promo_limit
duke@435	339	size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average());
duke@435	340	gclog_or_tty->print_cr(
duke@435	341	"PSAdaptiveSizePolicy::compute_generation_free_space limits:"
duke@435	342	" desired_promo_size: " SIZE_FORMAT
duke@435	343	" promo_limit: " SIZE_FORMAT
duke@435	344	" free_in_old_gen: " SIZE_FORMAT
duke@435	345	" max_old_gen_size: " SIZE_FORMAT
duke@435	346	" avg_old_live: " SIZE_FORMAT,
duke@435	347	desired_promo_size, promo_limit, free_in_old_gen,
duke@435	348	max_old_gen_size, (size_t) avg_old_live()->average());
duke@435	349	}
duke@435	350	if (desired_eden_size > eden_limit) {
duke@435	351	gclog_or_tty->print_cr(
duke@435	352	"AdaptiveSizePolicy::compute_generation_free_space limits:"
duke@435	353	" desired_eden_size: " SIZE_FORMAT
duke@435	354	" old_eden_size: " SIZE_FORMAT
duke@435	355	" eden_limit: " SIZE_FORMAT
duke@435	356	" cur_eden: " SIZE_FORMAT
duke@435	357	" max_eden_size: " SIZE_FORMAT
duke@435	358	" avg_young_live: " SIZE_FORMAT,
duke@435	359	desired_eden_size, _eden_size, eden_limit, cur_eden,
duke@435	360	max_eden_size, (size_t)avg_young_live()->average());
duke@435	361	}
duke@435	362	if (gc_cost() > gc_cost_limit) {
duke@435	363	gclog_or_tty->print_cr(
duke@435	364	"AdaptiveSizePolicy::compute_generation_free_space: gc time limit"
duke@435	365	" gc_cost: %f "
duke@435	366	" GCTimeLimit: %d",
duke@435	367	gc_cost(), GCTimeLimit);
duke@435	368	}
duke@435	369	}
duke@435	370
duke@435	371	// Align everything and make a final limit check
duke@435	372	const size_t alignment = _intra_generation_alignment;
duke@435	373	desired_eden_size = align_size_up(desired_eden_size, alignment);
duke@435	374	desired_eden_size = MAX2(desired_eden_size, alignment);
duke@435	375	desired_promo_size = align_size_up(desired_promo_size, alignment);
duke@435	376	desired_promo_size = MAX2(desired_promo_size, alignment);
duke@435	377
duke@435	378	eden_limit = align_size_down(eden_limit, alignment);
duke@435	379	promo_limit = align_size_down(promo_limit, alignment);
duke@435	380
duke@435	381	// Is too much time being spent in GC?
duke@435	382	// Is the heap trying to grow beyond it's limits?
duke@435	383
jmasa@1822	384	const size_t free_in_old_gen =
jmasa@1822	385	(size_t)(max_old_gen_size - avg_old_live()->average());
duke@435	386	if (desired_promo_size > free_in_old_gen && desired_eden_size > eden_limit) {
jmasa@1822	387	check_gc_overhead_limit(young_live,
jmasa@1822	388	eden_live,
jmasa@1822	389	max_old_gen_size,
jmasa@1822	390	max_eden_size,
jmasa@1822	391	is_full_gc,
jmasa@1822	392	gc_cause,
jmasa@1822	393	collector_policy);
duke@435	394	}
duke@435	395
duke@435	396
duke@435	397	// And one last limit check, now that we've aligned things.
duke@435	398	if (desired_eden_size > eden_limit) {
duke@435	399	// If the policy says to get a larger eden but
duke@435	400	// is hitting the limit, don't decrease eden.
duke@435	401	// This can lead to a general drifting down of the
duke@435	402	// eden size. Let the tenuring calculation push more
duke@435	403	// into the old gen.
duke@435	404	desired_eden_size = MAX2(eden_limit, cur_eden);
duke@435	405	}
duke@435	406	desired_promo_size = MIN2(desired_promo_size, promo_limit);
duke@435	407
duke@435	408
duke@435	409	if (PrintAdaptiveSizePolicy) {
duke@435	410	// Timing stats
duke@435	411	gclog_or_tty->print(
duke@435	412	"PSAdaptiveSizePolicy::compute_generation_free_space: costs"
duke@435	413	" minor_time: %f"
duke@435	414	" major_cost: %f"
duke@435	415	" mutator_cost: %f"
duke@435	416	" throughput_goal: %f",
duke@435	417	minor_gc_cost(), major_gc_cost(), mutator_cost(),
duke@435	418	_throughput_goal);
duke@435	419
duke@435	420	// We give more details if Verbose is set
duke@435	421	if (Verbose) {
duke@435	422	gclog_or_tty->print( " minor_pause: %f"
duke@435	423	" major_pause: %f"
duke@435	424	" minor_interval: %f"
duke@435	425	" major_interval: %f"
duke@435	426	" pause_goal: %f",
duke@435	427	_avg_minor_pause->padded_average(),
duke@435	428	_avg_major_pause->padded_average(),
duke@435	429	_avg_minor_interval->average(),
duke@435	430	_avg_major_interval->average(),
duke@435	431	gc_pause_goal_sec());
duke@435	432	}
duke@435	433
duke@435	434	// Footprint stats
duke@435	435	gclog_or_tty->print( " live_space: " SIZE_FORMAT
duke@435	436	" free_space: " SIZE_FORMAT,
duke@435	437	live_space(), free_space());
duke@435	438	// More detail
duke@435	439	if (Verbose) {
duke@435	440	gclog_or_tty->print( " base_footprint: " SIZE_FORMAT
duke@435	441	" avg_young_live: " SIZE_FORMAT
duke@435	442	" avg_old_live: " SIZE_FORMAT,
duke@435	443	(size_t)_avg_base_footprint->average(),
duke@435	444	(size_t)avg_young_live()->average(),
duke@435	445	(size_t)avg_old_live()->average());
duke@435	446	}
duke@435	447
duke@435	448	// And finally, our old and new sizes.
duke@435	449	gclog_or_tty->print(" old_promo_size: " SIZE_FORMAT
duke@435	450	" old_eden_size: " SIZE_FORMAT
duke@435	451	" desired_promo_size: " SIZE_FORMAT
duke@435	452	" desired_eden_size: " SIZE_FORMAT,
duke@435	453	_promo_size, _eden_size,
duke@435	454	desired_promo_size, desired_eden_size);
duke@435	455	gclog_or_tty->cr();
duke@435	456	}
duke@435	457
duke@435	458	decay_supplemental_growth(is_full_gc);
duke@435	459
duke@435	460	set_promo_size(desired_promo_size);
duke@435	461	set_eden_size(desired_eden_size);
duke@435	462	};
duke@435	463
duke@435	464	void PSAdaptiveSizePolicy::decay_supplemental_growth(bool is_full_gc) {
duke@435	465	// Decay the supplemental increment? Decay the supplement growth
duke@435	466	// factor even if it is not used. It is only meant to give a boost
duke@435	467	// to the initial growth and if it is not used, then it was not
duke@435	468	// needed.
duke@435	469	if (is_full_gc) {
duke@435	470	// Don't wait for the threshold value for the major collections. If
duke@435	471	// here, the supplemental growth term was used and should decay.
duke@435	472	if ((_avg_major_pause->count() % TenuredGenerationSizeSupplementDecay)
duke@435	473	== 0) {
duke@435	474	_old_gen_size_increment_supplement =
duke@435	475	_old_gen_size_increment_supplement >> 1;
duke@435	476	}
duke@435	477	} else {
duke@435	478	if ((_avg_minor_pause->count() >= AdaptiveSizePolicyReadyThreshold) &&
duke@435	479	(_avg_minor_pause->count() % YoungGenerationSizeSupplementDecay) == 0) {
duke@435	480	_young_gen_size_increment_supplement =
duke@435	481	_young_gen_size_increment_supplement >> 1;
duke@435	482	}
duke@435	483	}
duke@435	484	}
duke@435	485
duke@435	486	void PSAdaptiveSizePolicy::adjust_for_minor_pause_time(bool is_full_gc,
duke@435	487	size_t* desired_promo_size_ptr, size_t* desired_eden_size_ptr) {
duke@435	488
duke@435	489	// Adjust the young generation size to reduce pause time of
duke@435	490	// of collections.
duke@435	491	//
duke@435	492	// The AdaptiveSizePolicyInitializingSteps test is not used
duke@435	493	// here. It has not seemed to be needed but perhaps should
duke@435	494	// be added for consistency.
duke@435	495	if (minor_pause_young_estimator()->decrement_will_decrease()) {
duke@435	496	// reduce eden size
duke@435	497	set_change_young_gen_for_min_pauses(
duke@435	498	decrease_young_gen_for_min_pauses_true);
duke@435	499	*desired_eden_size_ptr = *desired_eden_size_ptr -
duke@435	500	eden_decrement_aligned_down(*desired_eden_size_ptr);
duke@435	501	} else {
duke@435	502	// EXPERIMENTAL ADJUSTMENT
duke@435	503	// Only record that the estimator indicated such an action.
duke@435	504	// *desired_eden_size_ptr = *desired_eden_size_ptr + eden_heap_delta;
duke@435	505	set_change_young_gen_for_min_pauses(
duke@435	506	increase_young_gen_for_min_pauses_true);
duke@435	507	}
duke@435	508	if (PSAdjustTenuredGenForMinorPause) {
duke@435	509	// If the desired eden size is as small as it will get,
duke@435	510	// try to adjust the old gen size.
duke@435	511	if (*desired_eden_size_ptr <= _intra_generation_alignment) {
duke@435	512	// Vary the old gen size to reduce the young gen pause. This
duke@435	513	// may not be a good idea. This is just a test.
duke@435	514	if (minor_pause_old_estimator()->decrement_will_decrease()) {
duke@435	515	set_change_old_gen_for_min_pauses(
duke@435	516	decrease_old_gen_for_min_pauses_true);
duke@435	517	*desired_promo_size_ptr =
duke@435	518	_promo_size - promo_decrement_aligned_down(*desired_promo_size_ptr);
duke@435	519	} else {
duke@435	520	set_change_old_gen_for_min_pauses(
duke@435	521	increase_old_gen_for_min_pauses_true);
duke@435	522	size_t promo_heap_delta =
duke@435	523	promo_increment_with_supplement_aligned_up(*desired_promo_size_ptr);
duke@435	524	if ((*desired_promo_size_ptr + promo_heap_delta) >
duke@435	525	*desired_promo_size_ptr) {
duke@435	526	*desired_promo_size_ptr =
duke@435	527	_promo_size + promo_heap_delta;
duke@435	528	}
duke@435	529	}
duke@435	530	}
duke@435	531	}
duke@435	532	}
duke@435	533
duke@435	534	void PSAdaptiveSizePolicy::adjust_for_pause_time(bool is_full_gc,
duke@435	535	size_t* desired_promo_size_ptr,
duke@435	536	size_t* desired_eden_size_ptr) {
duke@435	537
duke@435	538	size_t promo_heap_delta = 0;
duke@435	539	size_t eden_heap_delta = 0;
duke@435	540	// Add some checks for a threshhold for a change. For example,
duke@435	541	// a change less than the required alignment is probably not worth
duke@435	542	// attempting.
duke@435	543	if (is_full_gc) {
duke@435	544	set_decide_at_full_gc(decide_at_full_gc_true);
duke@435	545	}
duke@435	546
duke@435	547	if (_avg_minor_pause->padded_average() > _avg_major_pause->padded_average()) {
duke@435	548	adjust_for_minor_pause_time(is_full_gc,
duke@435	549	desired_promo_size_ptr,
duke@435	550	desired_eden_size_ptr);
duke@435	551	// major pause adjustments
duke@435	552	} else if (is_full_gc) {
duke@435	553	// Adjust for the major pause time only at full gc's because the
duke@435	554	// affects of a change can only be seen at full gc's.
duke@435	555
duke@435	556	// Reduce old generation size to reduce pause?
duke@435	557	if (major_pause_old_estimator()->decrement_will_decrease()) {
duke@435	558	// reduce old generation size
duke@435	559	set_change_old_gen_for_maj_pauses(decrease_old_gen_for_maj_pauses_true);
duke@435	560	promo_heap_delta = promo_decrement_aligned_down(*desired_promo_size_ptr);
duke@435	561	*desired_promo_size_ptr = _promo_size - promo_heap_delta;
duke@435	562	} else {
duke@435	563	// EXPERIMENTAL ADJUSTMENT
duke@435	564	// Only record that the estimator indicated such an action.
duke@435	565	// *desired_promo_size_ptr = _promo_size +
duke@435	566	// promo_increment_aligned_up(*desired_promo_size_ptr);
duke@435	567	set_change_old_gen_for_maj_pauses(increase_old_gen_for_maj_pauses_true);
duke@435	568	}
duke@435	569	if (PSAdjustYoungGenForMajorPause) {
duke@435	570	// If the promo size is at the minimum (i.e., the old gen
duke@435	571	// size will not actually decrease), consider changing the
duke@435	572	// young gen size.
duke@435	573	if (*desired_promo_size_ptr < _intra_generation_alignment) {
duke@435	574	// If increasing the young generation will decrease the old gen
duke@435	575	// pause, do it.
duke@435	576	// During startup there is noise in the statistics for deciding
duke@435	577	// on whether to increase or decrease the young gen size. For
duke@435	578	// some number of iterations, just try to increase the young
duke@435	579	// gen size if the major pause is too long to try and establish
duke@435	580	// good statistics for later decisions.
duke@435	581	if (major_pause_young_estimator()->increment_will_decrease() ||
duke@435	582	(_young_gen_change_for_major_pause_count
duke@435	583	<= AdaptiveSizePolicyInitializingSteps)) {
duke@435	584	set_change_young_gen_for_maj_pauses(
duke@435	585	increase_young_gen_for_maj_pauses_true);
duke@435	586	eden_heap_delta = eden_increment_aligned_up(*desired_eden_size_ptr);
duke@435	587	*desired_eden_size_ptr = _eden_size + eden_heap_delta;
duke@435	588	_young_gen_change_for_major_pause_count++;
duke@435	589	} else {
duke@435	590	// Record that decreasing the young gen size would decrease
duke@435	591	// the major pause
duke@435	592	set_change_young_gen_for_maj_pauses(
duke@435	593	decrease_young_gen_for_maj_pauses_true);
duke@435	594	eden_heap_delta = eden_decrement_aligned_down(*desired_eden_size_ptr);
duke@435	595	*desired_eden_size_ptr = _eden_size - eden_heap_delta;
duke@435	596	}
duke@435	597	}
duke@435	598	}
duke@435	599	}
duke@435	600
duke@435	601	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	602	gclog_or_tty->print_cr(
duke@435	603	"AdaptiveSizePolicy::compute_generation_free_space "
duke@435	604	"adjusting gen sizes for major pause (avg %f goal %f). "
duke@435	605	"desired_promo_size " SIZE_FORMAT "desired_eden_size "
duke@435	606	SIZE_FORMAT
duke@435	607	" promo delta " SIZE_FORMAT " eden delta " SIZE_FORMAT,
duke@435	608	_avg_major_pause->average(), gc_pause_goal_sec(),
duke@435	609	*desired_promo_size_ptr, *desired_eden_size_ptr,
duke@435	610	promo_heap_delta, eden_heap_delta);
duke@435	611	}
duke@435	612	}
duke@435	613
duke@435	614	void PSAdaptiveSizePolicy::adjust_for_throughput(bool is_full_gc,
duke@435	615	size_t* desired_promo_size_ptr,
duke@435	616	size_t* desired_eden_size_ptr) {
duke@435	617
duke@435	618	// Add some checks for a threshhold for a change. For example,
duke@435	619	// a change less than the required alignment is probably not worth
duke@435	620	// attempting.
duke@435	621	if (is_full_gc) {
duke@435	622	set_decide_at_full_gc(decide_at_full_gc_true);
duke@435	623	}
duke@435	624
duke@435	625	if ((gc_cost() + mutator_cost()) == 0.0) {
duke@435	626	return;
duke@435	627	}
duke@435	628
duke@435	629	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	630	gclog_or_tty->print("\nPSAdaptiveSizePolicy::adjust_for_throughput("
duke@435	631	"is_full: %d, promo: " SIZE_FORMAT ", cur_eden: " SIZE_FORMAT "): ",
duke@435	632	is_full_gc, *desired_promo_size_ptr, *desired_eden_size_ptr);
duke@435	633	gclog_or_tty->print_cr("mutator_cost %f major_gc_cost %f "
duke@435	634	"minor_gc_cost %f", mutator_cost(), major_gc_cost(), minor_gc_cost());
duke@435	635	}
duke@435	636
duke@435	637	// Tenured generation
duke@435	638	if (is_full_gc) {
duke@435	639
duke@435	640	// Calculate the change to use for the tenured gen.
duke@435	641	size_t scaled_promo_heap_delta = 0;
duke@435	642	// Can the increment to the generation be scaled?
duke@435	643	if (gc_cost() >= 0.0 && major_gc_cost() >= 0.0) {
duke@435	644	size_t promo_heap_delta =
duke@435	645	promo_increment_with_supplement_aligned_up(*desired_promo_size_ptr);
duke@435	646	double scale_by_ratio = major_gc_cost() / gc_cost();
duke@435	647	scaled_promo_heap_delta =
duke@435	648	(size_t) (scale_by_ratio * (double) promo_heap_delta);
duke@435	649	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	650	gclog_or_tty->print_cr(
duke@435	651	"Scaled tenured increment: " SIZE_FORMAT " by %f down to "
duke@435	652	SIZE_FORMAT,
duke@435	653	promo_heap_delta, scale_by_ratio, scaled_promo_heap_delta);
duke@435	654	}
duke@435	655	} else if (major_gc_cost() >= 0.0) {
duke@435	656	// Scaling is not going to work. If the major gc time is the
duke@435	657	// larger, give it a full increment.
duke@435	658	if (major_gc_cost() >= minor_gc_cost()) {
duke@435	659	scaled_promo_heap_delta =
duke@435	660	promo_increment_with_supplement_aligned_up(*desired_promo_size_ptr);
duke@435	661	}
duke@435	662	} else {
duke@435	663	// Don't expect to get here but it's ok if it does
duke@435	664	// in the product build since the delta will be 0
duke@435	665	// and nothing will change.
duke@435	666	assert(false, "Unexpected value for gc costs");
duke@435	667	}
duke@435	668
duke@435	669	switch (AdaptiveSizeThroughPutPolicy) {
duke@435	670	case 1:
duke@435	671	// Early in the run the statistics might not be good. Until
duke@435	672	// a specific number of collections have been, use the heuristic
duke@435	673	// that a larger generation size means lower collection costs.
duke@435	674	if (major_collection_estimator()->increment_will_decrease() ||
duke@435	675	(_old_gen_change_for_major_throughput
duke@435	676	<= AdaptiveSizePolicyInitializingSteps)) {
duke@435	677	// Increase tenured generation size to reduce major collection cost
duke@435	678	if ((*desired_promo_size_ptr + scaled_promo_heap_delta) >
duke@435	679	*desired_promo_size_ptr) {
duke@435	680	*desired_promo_size_ptr = _promo_size + scaled_promo_heap_delta;
duke@435	681	}
duke@435	682	set_change_old_gen_for_throughput(
duke@435	683	increase_old_gen_for_throughput_true);
duke@435	684	_old_gen_change_for_major_throughput++;
duke@435	685	} else {
duke@435	686	// EXPERIMENTAL ADJUSTMENT
duke@435	687	// Record that decreasing the old gen size would decrease
duke@435	688	// the major collection cost but don't do it.
duke@435	689	// *desired_promo_size_ptr = _promo_size -
duke@435	690	// promo_decrement_aligned_down(*desired_promo_size_ptr);
duke@435	691	set_change_old_gen_for_throughput(
duke@435	692	decrease_old_gen_for_throughput_true);
duke@435	693	}
duke@435	694
duke@435	695	break;
duke@435	696	default:
duke@435	697	// Simplest strategy
duke@435	698	if ((*desired_promo_size_ptr + scaled_promo_heap_delta) >
duke@435	699	*desired_promo_size_ptr) {
duke@435	700	*desired_promo_size_ptr = *desired_promo_size_ptr +
duke@435	701	scaled_promo_heap_delta;
duke@435	702	}
duke@435	703	set_change_old_gen_for_throughput(
duke@435	704	increase_old_gen_for_throughput_true);
duke@435	705	_old_gen_change_for_major_throughput++;
duke@435	706	}
duke@435	707
duke@435	708	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	709	gclog_or_tty->print_cr(
duke@435	710	"adjusting tenured gen for throughput (avg %f goal %f). "
duke@435	711	"desired_promo_size " SIZE_FORMAT " promo_delta " SIZE_FORMAT ,
duke@435	712	mutator_cost(), _throughput_goal,
duke@435	713	*desired_promo_size_ptr, scaled_promo_heap_delta);
duke@435	714	}
duke@435	715	}
duke@435	716
duke@435	717	// Young generation
duke@435	718	size_t scaled_eden_heap_delta = 0;
duke@435	719	// Can the increment to the generation be scaled?
duke@435	720	if (gc_cost() >= 0.0 && minor_gc_cost() >= 0.0) {
duke@435	721	size_t eden_heap_delta =
duke@435	722	eden_increment_with_supplement_aligned_up(*desired_eden_size_ptr);
duke@435	723	double scale_by_ratio = minor_gc_cost() / gc_cost();
duke@435	724	assert(scale_by_ratio <= 1.0 && scale_by_ratio >= 0.0, "Scaling is wrong");
duke@435	725	scaled_eden_heap_delta =
duke@435	726	(size_t) (scale_by_ratio * (double) eden_heap_delta);
duke@435	727	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	728	gclog_or_tty->print_cr(
duke@435	729	"Scaled eden increment: " SIZE_FORMAT " by %f down to "
duke@435	730	SIZE_FORMAT,
duke@435	731	eden_heap_delta, scale_by_ratio, scaled_eden_heap_delta);
duke@435	732	}
duke@435	733	} else if (minor_gc_cost() >= 0.0) {
duke@435	734	// Scaling is not going to work. If the minor gc time is the
duke@435	735	// larger, give it a full increment.
duke@435	736	if (minor_gc_cost() > major_gc_cost()) {
duke@435	737	scaled_eden_heap_delta =
duke@435	738	eden_increment_with_supplement_aligned_up(*desired_eden_size_ptr);
duke@435	739	}
duke@435	740	} else {
duke@435	741	// Don't expect to get here but it's ok if it does
duke@435	742	// in the product build since the delta will be 0
duke@435	743	// and nothing will change.
duke@435	744	assert(false, "Unexpected value for gc costs");
duke@435	745	}
duke@435	746
duke@435	747	// Use a heuristic for some number of collections to give
duke@435	748	// the averages time to settle down.
duke@435	749	switch (AdaptiveSizeThroughPutPolicy) {
duke@435	750	case 1:
duke@435	751	if (minor_collection_estimator()->increment_will_decrease() ||
duke@435	752	(_young_gen_change_for_minor_throughput
duke@435	753	<= AdaptiveSizePolicyInitializingSteps)) {
duke@435	754	// Expand young generation size to reduce frequency of
duke@435	755	// of collections.
duke@435	756	if ((*desired_eden_size_ptr + scaled_eden_heap_delta) >
duke@435	757	*desired_eden_size_ptr) {
duke@435	758	*desired_eden_size_ptr =
duke@435	759	*desired_eden_size_ptr + scaled_eden_heap_delta;
duke@435	760	}
duke@435	761	set_change_young_gen_for_throughput(
duke@435	762	increase_young_gen_for_througput_true);
duke@435	763	_young_gen_change_for_minor_throughput++;
duke@435	764	} else {
duke@435	765	// EXPERIMENTAL ADJUSTMENT
duke@435	766	// Record that decreasing the young gen size would decrease
duke@435	767	// the minor collection cost but don't do it.
duke@435	768	// *desired_eden_size_ptr = _eden_size -
duke@435	769	// eden_decrement_aligned_down(*desired_eden_size_ptr);
duke@435	770	set_change_young_gen_for_throughput(
duke@435	771	decrease_young_gen_for_througput_true);
duke@435	772	}
duke@435	773	break;
duke@435	774	default:
duke@435	775	if ((*desired_eden_size_ptr + scaled_eden_heap_delta) >
duke@435	776	*desired_eden_size_ptr) {
duke@435	777	*desired_eden_size_ptr =
duke@435	778	*desired_eden_size_ptr + scaled_eden_heap_delta;
duke@435	779	}
duke@435	780	set_change_young_gen_for_throughput(
duke@435	781	increase_young_gen_for_througput_true);
duke@435	782	_young_gen_change_for_minor_throughput++;
duke@435	783	}
duke@435	784
duke@435	785	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	786	gclog_or_tty->print_cr(
duke@435	787	"adjusting eden for throughput (avg %f goal %f). desired_eden_size "
duke@435	788	SIZE_FORMAT " eden delta " SIZE_FORMAT "\n",
duke@435	789	mutator_cost(), _throughput_goal,
duke@435	790	*desired_eden_size_ptr, scaled_eden_heap_delta);
duke@435	791	}
duke@435	792	}
duke@435	793
duke@435	794	size_t PSAdaptiveSizePolicy::adjust_promo_for_footprint(
duke@435	795	size_t desired_promo_size, size_t desired_sum) {
duke@435	796	assert(desired_promo_size <= desired_sum, "Inconsistent parameters");
duke@435	797	set_decrease_for_footprint(decrease_old_gen_for_footprint_true);
duke@435	798
duke@435	799	size_t change = promo_decrement(desired_promo_size);
duke@435	800	change = scale_down(change, desired_promo_size, desired_sum);
duke@435	801
duke@435	802	size_t reduced_size = desired_promo_size - change;
duke@435	803
duke@435	804	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	805	gclog_or_tty->print_cr(
duke@435	806	"AdaptiveSizePolicy::compute_generation_free_space "
duke@435	807	"adjusting tenured gen for footprint. "
duke@435	808	"starting promo size " SIZE_FORMAT
duke@435	809	" reduced promo size " SIZE_FORMAT,
duke@435	810	" promo delta " SIZE_FORMAT,
duke@435	811	desired_promo_size, reduced_size, change );
duke@435	812	}
duke@435	813
duke@435	814	assert(reduced_size <= desired_promo_size, "Inconsistent result");
duke@435	815	return reduced_size;
duke@435	816	}
duke@435	817
duke@435	818	size_t PSAdaptiveSizePolicy::adjust_eden_for_footprint(
duke@435	819	size_t desired_eden_size, size_t desired_sum) {
duke@435	820	assert(desired_eden_size <= desired_sum, "Inconsistent parameters");
duke@435	821	set_decrease_for_footprint(decrease_young_gen_for_footprint_true);
duke@435	822
duke@435	823	size_t change = eden_decrement(desired_eden_size);
duke@435	824	change = scale_down(change, desired_eden_size, desired_sum);
duke@435	825
duke@435	826	size_t reduced_size = desired_eden_size - change;
duke@435	827
duke@435	828	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	829	gclog_or_tty->print_cr(
duke@435	830	"AdaptiveSizePolicy::compute_generation_free_space "
duke@435	831	"adjusting eden for footprint. "
duke@435	832	" starting eden size " SIZE_FORMAT
duke@435	833	" reduced eden size " SIZE_FORMAT
duke@435	834	" eden delta " SIZE_FORMAT,
duke@435	835	desired_eden_size, reduced_size, change);
duke@435	836	}
duke@435	837
duke@435	838	assert(reduced_size <= desired_eden_size, "Inconsistent result");
duke@435	839	return reduced_size;
duke@435	840	}
duke@435	841
duke@435	842	// Scale down "change" by the factor
duke@435	843	// part / total
duke@435	844	// Don't align the results.
duke@435	845
duke@435	846	size_t PSAdaptiveSizePolicy::scale_down(size_t change,
duke@435	847	double part,
duke@435	848	double total) {
duke@435	849	assert(part <= total, "Inconsistent input");
duke@435	850	size_t reduced_change = change;
duke@435	851	if (total > 0) {
duke@435	852	double fraction = part / total;
duke@435	853	reduced_change = (size_t) (fraction * (double) change);
duke@435	854	}
duke@435	855	assert(reduced_change <= change, "Inconsistent result");
duke@435	856	return reduced_change;
duke@435	857	}
duke@435	858
duke@435	859	size_t PSAdaptiveSizePolicy::eden_increment(size_t cur_eden,
duke@435	860	uint percent_change) {
duke@435	861	size_t eden_heap_delta;
duke@435	862	eden_heap_delta = cur_eden / 100 * percent_change;
duke@435	863	return eden_heap_delta;
duke@435	864	}
duke@435	865
duke@435	866	size_t PSAdaptiveSizePolicy::eden_increment(size_t cur_eden) {
duke@435	867	return eden_increment(cur_eden, YoungGenerationSizeIncrement);
duke@435	868	}
duke@435	869
duke@435	870	size_t PSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
duke@435	871	size_t result = eden_increment(cur_eden, YoungGenerationSizeIncrement);
duke@435	872	return align_size_up(result, _intra_generation_alignment);
duke@435	873	}
duke@435	874
duke@435	875	size_t PSAdaptiveSizePolicy::eden_increment_aligned_down(size_t cur_eden) {
duke@435	876	size_t result = eden_increment(cur_eden);
duke@435	877	return align_size_down(result, _intra_generation_alignment);
duke@435	878	}
duke@435	879
duke@435	880	size_t PSAdaptiveSizePolicy::eden_increment_with_supplement_aligned_up(
duke@435	881	size_t cur_eden) {
duke@435	882	size_t result = eden_increment(cur_eden,
duke@435	883	YoungGenerationSizeIncrement + _young_gen_size_increment_supplement);
duke@435	884	return align_size_up(result, _intra_generation_alignment);
duke@435	885	}
duke@435	886
duke@435	887	size_t PSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
duke@435	888	size_t eden_heap_delta = eden_decrement(cur_eden);
duke@435	889	return align_size_down(eden_heap_delta, _intra_generation_alignment);
duke@435	890	}
duke@435	891
duke@435	892	size_t PSAdaptiveSizePolicy::eden_decrement(size_t cur_eden) {
duke@435	893	size_t eden_heap_delta = eden_increment(cur_eden) /
duke@435	894	AdaptiveSizeDecrementScaleFactor;
duke@435	895	return eden_heap_delta;
duke@435	896	}
duke@435	897
duke@435	898	size_t PSAdaptiveSizePolicy::promo_increment(size_t cur_promo,
duke@435	899	uint percent_change) {
duke@435	900	size_t promo_heap_delta;
duke@435	901	promo_heap_delta = cur_promo / 100 * percent_change;
duke@435	902	return promo_heap_delta;
duke@435	903	}
duke@435	904
duke@435	905	size_t PSAdaptiveSizePolicy::promo_increment(size_t cur_promo) {
duke@435	906	return promo_increment(cur_promo, TenuredGenerationSizeIncrement);
duke@435	907	}
duke@435	908
duke@435	909	size_t PSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
duke@435	910	size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
duke@435	911	return align_size_up(result, _intra_generation_alignment);
duke@435	912	}
duke@435	913
duke@435	914	size_t PSAdaptiveSizePolicy::promo_increment_aligned_down(size_t cur_promo) {
duke@435	915	size_t result = promo_increment(cur_promo, TenuredGenerationSizeIncrement);
duke@435	916	return align_size_down(result, _intra_generation_alignment);
duke@435	917	}
duke@435	918
duke@435	919	size_t PSAdaptiveSizePolicy::promo_increment_with_supplement_aligned_up(
duke@435	920	size_t cur_promo) {
duke@435	921	size_t result = promo_increment(cur_promo,
duke@435	922	TenuredGenerationSizeIncrement + _old_gen_size_increment_supplement);
duke@435	923	return align_size_up(result, _intra_generation_alignment);
duke@435	924	}
duke@435	925
duke@435	926	size_t PSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
duke@435	927	size_t promo_heap_delta = promo_decrement(cur_promo);
duke@435	928	return align_size_down(promo_heap_delta, _intra_generation_alignment);
duke@435	929	}
duke@435	930
duke@435	931	size_t PSAdaptiveSizePolicy::promo_decrement(size_t cur_promo) {
duke@435	932	size_t promo_heap_delta = promo_increment(cur_promo);
duke@435	933	promo_heap_delta = promo_heap_delta / AdaptiveSizeDecrementScaleFactor;
duke@435	934	return promo_heap_delta;
duke@435	935	}
duke@435	936
duke@435	937	int PSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold(
duke@435	938	bool is_survivor_overflow,
duke@435	939	int tenuring_threshold,
duke@435	940	size_t survivor_limit) {
duke@435	941	assert(survivor_limit >= _intra_generation_alignment,
duke@435	942	"survivor_limit too small");
duke@435	943	assert((size_t)align_size_down(survivor_limit, _intra_generation_alignment)
duke@435	944	== survivor_limit, "survivor_limit not aligned");
duke@435	945
duke@435	946	// This method is called even if the tenuring threshold and survivor
duke@435	947	// spaces are not adjusted so that the averages are sampled above.
duke@435	948	if (!UsePSAdaptiveSurvivorSizePolicy ||
duke@435	949	!young_gen_policy_is_ready()) {
duke@435	950	return tenuring_threshold;
duke@435	951	}
duke@435	952
duke@435	953	// We'll decide whether to increase or decrease the tenuring
duke@435	954	// threshold based partly on the newly computed survivor size
duke@435	955	// (if we hit the maximum limit allowed, we'll always choose to
duke@435	956	// decrement the threshold).
duke@435	957	bool incr_tenuring_threshold = false;
duke@435	958	bool decr_tenuring_threshold = false;
duke@435	959
duke@435	960	set_decrement_tenuring_threshold_for_gc_cost(false);
duke@435	961	set_increment_tenuring_threshold_for_gc_cost(false);
duke@435	962	set_decrement_tenuring_threshold_for_survivor_limit(false);
duke@435	963
duke@435	964	if (!is_survivor_overflow) {
duke@435	965	// Keep running averages on how much survived
duke@435	966
duke@435	967	// We use the tenuring threshold to equalize the cost of major
duke@435	968	// and minor collections.
duke@435	969	// ThresholdTolerance is used to indicate how sensitive the
duke@435	970	// tenuring threshold is to differences in cost betweent the
duke@435	971	// collection types.
duke@435	972
duke@435	973	// Get the times of interest. This involves a little work, so
duke@435	974	// we cache the values here.
duke@435	975	const double major_cost = major_gc_cost();
duke@435	976	const double minor_cost = minor_gc_cost();
duke@435	977
duke@435	978	if (minor_cost > major_cost * _threshold_tolerance_percent) {
duke@435	979	// Minor times are getting too long; lower the threshold so
duke@435	980	// less survives and more is promoted.
duke@435	981	decr_tenuring_threshold = true;
duke@435	982	set_decrement_tenuring_threshold_for_gc_cost(true);
duke@435	983	} else if (major_cost > minor_cost * _threshold_tolerance_percent) {
duke@435	984	// Major times are too long, so we want less promotion.
duke@435	985	incr_tenuring_threshold = true;
duke@435	986	set_increment_tenuring_threshold_for_gc_cost(true);
duke@435	987	}
duke@435	988
duke@435	989	} else {
duke@435	990	// Survivor space overflow occurred, so promoted and survived are
duke@435	991	// not accurate. We'll make our best guess by combining survived
duke@435	992	// and promoted and count them as survivors.
duke@435	993	//
duke@435	994	// We'll lower the tenuring threshold to see if we can correct
duke@435	995	// things. Also, set the survivor size conservatively. We're
duke@435	996	// trying to avoid many overflows from occurring if defnew size
duke@435	997	// is just too small.
duke@435	998
duke@435	999	decr_tenuring_threshold = true;
duke@435	1000	}
duke@435	1001
duke@435	1002	// The padded average also maintains a deviation from the average;
duke@435	1003	// we use this to see how good of an estimate we have of what survived.
duke@435	1004	// We're trying to pad the survivor size as little as possible without
duke@435	1005	// overflowing the survivor spaces.
duke@435	1006	size_t target_size = align_size_up((size_t)_avg_survived->padded_average(),
duke@435	1007	_intra_generation_alignment);
duke@435	1008	target_size = MAX2(target_size, _intra_generation_alignment);
duke@435	1009
duke@435	1010	if (target_size > survivor_limit) {
duke@435	1011	// Target size is bigger than we can handle. Let's also reduce
duke@435	1012	// the tenuring threshold.
duke@435	1013	target_size = survivor_limit;
duke@435	1014	decr_tenuring_threshold = true;
duke@435	1015	set_decrement_tenuring_threshold_for_survivor_limit(true);
duke@435	1016	}
duke@435	1017
duke@435	1018	// Finally, increment or decrement the tenuring threshold, as decided above.
duke@435	1019	// We test for decrementing first, as we might have hit the target size
duke@435	1020	// limit.
duke@435	1021	if (decr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
duke@435	1022	if (tenuring_threshold > 1) {
duke@435	1023	tenuring_threshold--;
duke@435	1024	}
duke@435	1025	} else if (incr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
duke@435	1026	if (tenuring_threshold < MaxTenuringThreshold) {
duke@435	1027	tenuring_threshold++;
duke@435	1028	}
duke@435	1029	}
duke@435	1030
duke@435	1031	// We keep a running average of the amount promoted which is used
duke@435	1032	// to decide when we should collect the old generation (when
duke@435	1033	// the amount of old gen free space is less than what we expect to
duke@435	1034	// promote).
duke@435	1035
duke@435	1036	if (PrintAdaptiveSizePolicy) {
duke@435	1037	// A little more detail if Verbose is on
duke@435	1038	if (Verbose) {
duke@435	1039	gclog_or_tty->print( " avg_survived: %f"
duke@435	1040	" avg_deviation: %f",
duke@435	1041	_avg_survived->average(),
duke@435	1042	_avg_survived->deviation());
duke@435	1043	}
duke@435	1044
duke@435	1045	gclog_or_tty->print( " avg_survived_padded_avg: %f",
duke@435	1046	_avg_survived->padded_average());
duke@435	1047
duke@435	1048	if (Verbose) {
duke@435	1049	gclog_or_tty->print( " avg_promoted_avg: %f"
duke@435	1050	" avg_promoted_dev: %f",
duke@435	1051	avg_promoted()->average(),
duke@435	1052	avg_promoted()->deviation());
duke@435	1053	}
duke@435	1054
duke@435	1055	gclog_or_tty->print( " avg_promoted_padded_avg: %f"
duke@435	1056	" avg_pretenured_padded_avg: %f"
duke@435	1057	" tenuring_thresh: %d"
duke@435	1058	" target_size: " SIZE_FORMAT,
duke@435	1059	avg_promoted()->padded_average(),
duke@435	1060	_avg_pretenured->padded_average(),
duke@435	1061	tenuring_threshold, target_size);
duke@435	1062	tty->cr();
duke@435	1063	}
duke@435	1064
duke@435	1065	set_survivor_size(target_size);
duke@435	1066
duke@435	1067	return tenuring_threshold;
duke@435	1068	}
duke@435	1069
duke@435	1070	void PSAdaptiveSizePolicy::update_averages(bool is_survivor_overflow,
duke@435	1071	size_t survived,
duke@435	1072	size_t promoted) {
duke@435	1073	// Update averages
duke@435	1074	if (!is_survivor_overflow) {
duke@435	1075	// Keep running averages on how much survived
duke@435	1076	_avg_survived->sample(survived);
duke@435	1077	} else {
duke@435	1078	size_t survived_guess = survived + promoted;
duke@435	1079	_avg_survived->sample(survived_guess);
duke@435	1080	}
duke@435	1081	avg_promoted()->sample(promoted + _avg_pretenured->padded_average());
duke@435	1082
duke@435	1083	if (PrintAdaptiveSizePolicy) {
duke@435	1084	gclog_or_tty->print(
duke@435	1085	"AdaptiveSizePolicy::compute_survivor_space_size_and_thresh:"
duke@435	1086	" survived: " SIZE_FORMAT
duke@435	1087	" promoted: " SIZE_FORMAT
duke@435	1088	" overflow: %s",
duke@435	1089	survived, promoted, is_survivor_overflow ? "true" : "false");
duke@435	1090	}
duke@435	1091	}
duke@435	1092
duke@435	1093	bool PSAdaptiveSizePolicy::print_adaptive_size_policy_on(outputStream* st)
duke@435	1094	const {
duke@435	1095
duke@435	1096	if (!UseAdaptiveSizePolicy) return false;
duke@435	1097
duke@435	1098	return AdaptiveSizePolicy::print_adaptive_size_policy_on(
duke@435	1099	st,
duke@435	1100	PSScavenge::tenuring_threshold());
duke@435	1101	}