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

src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp@c96030fff130 (annotated)

src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp

Thu, 20 Nov 2008 16:56:09 -0800

author

ysr

date

Thu, 20 Nov 2008 16:56:09 -0800

changeset 888

c96030fff130

parent 435

a61af66fc99e

child 1719

5f1f51edaff6

permissions

-rw-r--r--

6684579: SoftReference processing can be made more efficient
Summary: For current soft-ref clearing policies, we can decide at marking time if a soft-reference will definitely not be cleared, postponing the decision of whether it will definitely be cleared to the final reference processing phase. This can be especially beneficial in the case of concurrent collectors where the marking is usually concurrent but reference processing is usually not.
Reviewed-by: jmasa

duke@435	1	/*
duke@435	2	* Copyright 2004-2006 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	#include "incls/_precompiled.incl"
duke@435	25	#include "incls/_cmsAdaptiveSizePolicy.cpp.incl"
duke@435	26
duke@435	27	elapsedTimer CMSAdaptiveSizePolicy::_concurrent_timer;
duke@435	28	elapsedTimer CMSAdaptiveSizePolicy::_STW_timer;
duke@435	29
duke@435	30	// Defined if the granularity of the time measurements is potentially too large.
duke@435	31	#define CLOCK_GRANULARITY_TOO_LARGE
duke@435	32
duke@435	33	CMSAdaptiveSizePolicy::CMSAdaptiveSizePolicy(size_t init_eden_size,
duke@435	34	size_t init_promo_size,
duke@435	35	size_t init_survivor_size,
duke@435	36	double max_gc_minor_pause_sec,
duke@435	37	double max_gc_pause_sec,
duke@435	38	uint gc_cost_ratio) :
duke@435	39	AdaptiveSizePolicy(init_eden_size,
duke@435	40	init_promo_size,
duke@435	41	init_survivor_size,
duke@435	42	max_gc_pause_sec,
duke@435	43	gc_cost_ratio) {
duke@435	44
duke@435	45	clear_internal_time_intervals();
duke@435	46
duke@435	47	_processor_count = os::active_processor_count();
duke@435	48
duke@435	49	if (CMSConcurrentMTEnabled && (ParallelCMSThreads > 1)) {
duke@435	50	assert(_processor_count > 0, "Processor count is suspect");
duke@435	51	_concurrent_processor_count = MIN2((uint) ParallelCMSThreads,
duke@435	52	(uint) _processor_count);
duke@435	53	} else {
duke@435	54	_concurrent_processor_count = 1;
duke@435	55	}
duke@435	56
duke@435	57	_avg_concurrent_time = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	58	_avg_concurrent_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	59	_avg_concurrent_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	60
duke@435	61	_avg_initial_pause = new AdaptivePaddedAverage(AdaptiveTimeWeight,
duke@435	62	PausePadding);
duke@435	63	_avg_remark_pause = new AdaptivePaddedAverage(AdaptiveTimeWeight,
duke@435	64	PausePadding);
duke@435	65
duke@435	66	_avg_cms_STW_time = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	67	_avg_cms_STW_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	68
duke@435	69	_avg_cms_free = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	70	_avg_cms_free_at_sweep = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	71	_avg_cms_promo = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	72
duke@435	73	// Mark-sweep-compact
duke@435	74	_avg_msc_pause = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	75	_avg_msc_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	76	_avg_msc_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	77
duke@435	78	// Mark-sweep
duke@435	79	_avg_ms_pause = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	80	_avg_ms_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	81	_avg_ms_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
duke@435	82
duke@435	83	// Variables that estimate pause times as a function of generation
duke@435	84	// size.
duke@435	85	_remark_pause_old_estimator =
duke@435	86	new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
duke@435	87	_initial_pause_old_estimator =
duke@435	88	new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
duke@435	89	_remark_pause_young_estimator =
duke@435	90	new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
duke@435	91	_initial_pause_young_estimator =
duke@435	92	new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
duke@435	93
duke@435	94	// Alignment comes from that used in ReservedSpace.
duke@435	95	_generation_alignment = os::vm_allocation_granularity();
duke@435	96
duke@435	97	// Start the concurrent timer here so that the first
duke@435	98	// concurrent_phases_begin() measures a finite mutator
duke@435	99	// time. A finite mutator time is used to determine
duke@435	100	// if a concurrent collection has been started. If this
duke@435	101	// proves to be a problem, use some explicit flag to
duke@435	102	// signal that a concurrent collection has been started.
duke@435	103	_concurrent_timer.start();
duke@435	104	_STW_timer.start();
duke@435	105	}
duke@435	106
duke@435	107	double CMSAdaptiveSizePolicy::concurrent_processor_fraction() {
duke@435	108	// For now assume no other daemon threads are taking alway
duke@435	109	// cpu's from the application.
duke@435	110	return ((double) _concurrent_processor_count / (double) _processor_count);
duke@435	111	}
duke@435	112
duke@435	113	double CMSAdaptiveSizePolicy::concurrent_collection_cost(
duke@435	114	double interval_in_seconds) {
duke@435	115	// When the precleaning and sweeping phases use multiple
duke@435	116	// threads, change one_processor_fraction to
duke@435	117	// concurrent_processor_fraction().
duke@435	118	double one_processor_fraction = 1.0 / ((double) processor_count());
duke@435	119	double concurrent_cost =
duke@435	120	collection_cost(_latest_cms_concurrent_marking_time_secs,
duke@435	121	interval_in_seconds) * concurrent_processor_fraction() +
duke@435	122	collection_cost(_latest_cms_concurrent_precleaning_time_secs,
duke@435	123	interval_in_seconds) * one_processor_fraction +
duke@435	124	collection_cost(_latest_cms_concurrent_sweeping_time_secs,
duke@435	125	interval_in_seconds) * one_processor_fraction;
duke@435	126	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	127	gclog_or_tty->print_cr(
duke@435	128	"\nCMSAdaptiveSizePolicy::scaled_concurrent_collection_cost(%f) "
duke@435	129	"_latest_cms_concurrent_marking_cost %f "
duke@435	130	"_latest_cms_concurrent_precleaning_cost %f "
duke@435	131	"_latest_cms_concurrent_sweeping_cost %f "
duke@435	132	"concurrent_processor_fraction %f "
duke@435	133	"concurrent_cost %f ",
duke@435	134	interval_in_seconds,
duke@435	135	collection_cost(_latest_cms_concurrent_marking_time_secs,
duke@435	136	interval_in_seconds),
duke@435	137	collection_cost(_latest_cms_concurrent_precleaning_time_secs,
duke@435	138	interval_in_seconds),
duke@435	139	collection_cost(_latest_cms_concurrent_sweeping_time_secs,
duke@435	140	interval_in_seconds),
duke@435	141	concurrent_processor_fraction(),
duke@435	142	concurrent_cost);
duke@435	143	}
duke@435	144	return concurrent_cost;
duke@435	145	}
duke@435	146
duke@435	147	double CMSAdaptiveSizePolicy::concurrent_collection_time() {
duke@435	148	double latest_cms_sum_concurrent_phases_time_secs =
duke@435	149	_latest_cms_concurrent_marking_time_secs +
duke@435	150	_latest_cms_concurrent_precleaning_time_secs +
duke@435	151	_latest_cms_concurrent_sweeping_time_secs;
duke@435	152	return latest_cms_sum_concurrent_phases_time_secs;
duke@435	153	}
duke@435	154
duke@435	155	double CMSAdaptiveSizePolicy::scaled_concurrent_collection_time() {
duke@435	156	// When the precleaning and sweeping phases use multiple
duke@435	157	// threads, change one_processor_fraction to
duke@435	158	// concurrent_processor_fraction().
duke@435	159	double one_processor_fraction = 1.0 / ((double) processor_count());
duke@435	160	double latest_cms_sum_concurrent_phases_time_secs =
duke@435	161	_latest_cms_concurrent_marking_time_secs * concurrent_processor_fraction() +
duke@435	162	_latest_cms_concurrent_precleaning_time_secs * one_processor_fraction +
duke@435	163	_latest_cms_concurrent_sweeping_time_secs * one_processor_fraction ;
duke@435	164	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	165	gclog_or_tty->print_cr(
duke@435	166	"\nCMSAdaptiveSizePolicy::scaled_concurrent_collection_time "
duke@435	167	"_latest_cms_concurrent_marking_time_secs %f "
duke@435	168	"_latest_cms_concurrent_precleaning_time_secs %f "
duke@435	169	"_latest_cms_concurrent_sweeping_time_secs %f "
duke@435	170	"concurrent_processor_fraction %f "
duke@435	171	"latest_cms_sum_concurrent_phases_time_secs %f ",
duke@435	172	_latest_cms_concurrent_marking_time_secs,
duke@435	173	_latest_cms_concurrent_precleaning_time_secs,
duke@435	174	_latest_cms_concurrent_sweeping_time_secs,
duke@435	175	concurrent_processor_fraction(),
duke@435	176	latest_cms_sum_concurrent_phases_time_secs);
duke@435	177	}
duke@435	178	return latest_cms_sum_concurrent_phases_time_secs;
duke@435	179	}
duke@435	180
duke@435	181	void CMSAdaptiveSizePolicy::update_minor_pause_old_estimator(
duke@435	182	double minor_pause_in_ms) {
duke@435	183	// Get the equivalent of the free space
duke@435	184	// that is available for promotions in the CMS generation
duke@435	185	// and use that to update _minor_pause_old_estimator
duke@435	186
duke@435	187	// Don't implement this until it is needed. A warning is
duke@435	188	// printed if _minor_pause_old_estimator is used.
duke@435	189	}
duke@435	190
duke@435	191	void CMSAdaptiveSizePolicy::concurrent_marking_begin() {
duke@435	192	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	193	gclog_or_tty->print(" ");
duke@435	194	gclog_or_tty->stamp();
duke@435	195	gclog_or_tty->print(": concurrent_marking_begin ");
duke@435	196	}
duke@435	197	// Update the interval time
duke@435	198	_concurrent_timer.stop();
duke@435	199	_latest_cms_collection_end_to_collection_start_secs = _concurrent_timer.seconds();
duke@435	200	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	201	gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_marking_begin: "
duke@435	202	"mutator time %f", _latest_cms_collection_end_to_collection_start_secs);
duke@435	203	}
duke@435	204	_concurrent_timer.reset();
duke@435	205	_concurrent_timer.start();
duke@435	206	}
duke@435	207
duke@435	208	void CMSAdaptiveSizePolicy::concurrent_marking_end() {
duke@435	209	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	210	gclog_or_tty->stamp();
duke@435	211	gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_marking_end()");
duke@435	212	}
duke@435	213
duke@435	214	_concurrent_timer.stop();
duke@435	215	_latest_cms_concurrent_marking_time_secs = _concurrent_timer.seconds();
duke@435	216
duke@435	217	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	218	gclog_or_tty->print_cr("\n CMSAdaptiveSizePolicy::concurrent_marking_end"
duke@435	219	":concurrent marking time (s) %f",
duke@435	220	_latest_cms_concurrent_marking_time_secs);
duke@435	221	}
duke@435	222	}
duke@435	223
duke@435	224	void CMSAdaptiveSizePolicy::concurrent_precleaning_begin() {
duke@435	225	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	226	gclog_or_tty->stamp();
duke@435	227	gclog_or_tty->print_cr(
duke@435	228	"CMSAdaptiveSizePolicy::concurrent_precleaning_begin()");
duke@435	229	}
duke@435	230	_concurrent_timer.reset();
duke@435	231	_concurrent_timer.start();
duke@435	232	}
duke@435	233
duke@435	234
duke@435	235	void CMSAdaptiveSizePolicy::concurrent_precleaning_end() {
duke@435	236	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	237	gclog_or_tty->stamp();
duke@435	238	gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_precleaning_end()");
duke@435	239	}
duke@435	240
duke@435	241	_concurrent_timer.stop();
duke@435	242	// May be set again by a second call during the same collection.
duke@435	243	_latest_cms_concurrent_precleaning_time_secs = _concurrent_timer.seconds();
duke@435	244
duke@435	245	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	246	gclog_or_tty->print_cr("\n CMSAdaptiveSizePolicy::concurrent_precleaning_end"
duke@435	247	":concurrent precleaning time (s) %f",
duke@435	248	_latest_cms_concurrent_precleaning_time_secs);
duke@435	249	}
duke@435	250	}
duke@435	251
duke@435	252	void CMSAdaptiveSizePolicy::concurrent_sweeping_begin() {
duke@435	253	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	254	gclog_or_tty->stamp();
duke@435	255	gclog_or_tty->print_cr(
duke@435	256	"CMSAdaptiveSizePolicy::concurrent_sweeping_begin()");
duke@435	257	}
duke@435	258	_concurrent_timer.reset();
duke@435	259	_concurrent_timer.start();
duke@435	260	}
duke@435	261
duke@435	262
duke@435	263	void CMSAdaptiveSizePolicy::concurrent_sweeping_end() {
duke@435	264	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	265	gclog_or_tty->stamp();
duke@435	266	gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_sweeping_end()");
duke@435	267	}
duke@435	268
duke@435	269	_concurrent_timer.stop();
duke@435	270	_latest_cms_concurrent_sweeping_time_secs = _concurrent_timer.seconds();
duke@435	271
duke@435	272	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	273	gclog_or_tty->print_cr("\n CMSAdaptiveSizePolicy::concurrent_sweeping_end"
duke@435	274	":concurrent sweeping time (s) %f",
duke@435	275	_latest_cms_concurrent_sweeping_time_secs);
duke@435	276	}
duke@435	277	}
duke@435	278
duke@435	279	void CMSAdaptiveSizePolicy::concurrent_phases_end(GCCause::Cause gc_cause,
duke@435	280	size_t cur_eden,
duke@435	281	size_t cur_promo) {
duke@435	282	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	283	gclog_or_tty->print(" ");
duke@435	284	gclog_or_tty->stamp();
duke@435	285	gclog_or_tty->print(": concurrent_phases_end ");
duke@435	286	}
duke@435	287
duke@435	288	// Update the concurrent timer
duke@435	289	_concurrent_timer.stop();
duke@435	290
duke@435	291	if (gc_cause != GCCause::_java_lang_system_gc ||
duke@435	292	UseAdaptiveSizePolicyWithSystemGC) {
duke@435	293
duke@435	294	avg_cms_free()->sample(cur_promo);
duke@435	295	double latest_cms_sum_concurrent_phases_time_secs =
duke@435	296	concurrent_collection_time();
duke@435	297
duke@435	298	_avg_concurrent_time->sample(latest_cms_sum_concurrent_phases_time_secs);
duke@435	299
duke@435	300	// Cost of collection (unit-less)
duke@435	301
duke@435	302	// Total interval for collection. May not be valid. Tests
duke@435	303	// below determine whether to use this.
duke@435	304	//
duke@435	305	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	306	gclog_or_tty->print_cr("\nCMSAdaptiveSizePolicy::concurrent_phases_end \n"
duke@435	307	"_latest_cms_reset_end_to_initial_mark_start_secs %f \n"
duke@435	308	"_latest_cms_initial_mark_start_to_end_time_secs %f \n"
duke@435	309	"_latest_cms_remark_start_to_end_time_secs %f \n"
duke@435	310	"_latest_cms_concurrent_marking_time_secs %f \n"
duke@435	311	"_latest_cms_concurrent_precleaning_time_secs %f \n"
duke@435	312	"_latest_cms_concurrent_sweeping_time_secs %f \n"
duke@435	313	"latest_cms_sum_concurrent_phases_time_secs %f \n"
duke@435	314	"_latest_cms_collection_end_to_collection_start_secs %f \n"
duke@435	315	"concurrent_processor_fraction %f",
duke@435	316	_latest_cms_reset_end_to_initial_mark_start_secs,
duke@435	317	_latest_cms_initial_mark_start_to_end_time_secs,
duke@435	318	_latest_cms_remark_start_to_end_time_secs,
duke@435	319	_latest_cms_concurrent_marking_time_secs,
duke@435	320	_latest_cms_concurrent_precleaning_time_secs,
duke@435	321	_latest_cms_concurrent_sweeping_time_secs,
duke@435	322	latest_cms_sum_concurrent_phases_time_secs,
duke@435	323	_latest_cms_collection_end_to_collection_start_secs,
duke@435	324	concurrent_processor_fraction());
duke@435	325	}
duke@435	326	double interval_in_seconds =
duke@435	327	_latest_cms_initial_mark_start_to_end_time_secs +
duke@435	328	_latest_cms_remark_start_to_end_time_secs +
duke@435	329	latest_cms_sum_concurrent_phases_time_secs +
duke@435	330	_latest_cms_collection_end_to_collection_start_secs;
duke@435	331	assert(interval_in_seconds >= 0.0,
duke@435	332	"Bad interval between cms collections");
duke@435	333
duke@435	334	// Sample for performance counter
duke@435	335	avg_concurrent_interval()->sample(interval_in_seconds);
duke@435	336
duke@435	337	// STW costs (initial and remark pauses)
duke@435	338	// Cost of collection (unit-less)
duke@435	339	assert(_latest_cms_initial_mark_start_to_end_time_secs >= 0.0,
duke@435	340	"Bad initial mark pause");
duke@435	341	assert(_latest_cms_remark_start_to_end_time_secs >= 0.0,
duke@435	342	"Bad remark pause");
duke@435	343	double STW_time_in_seconds =
duke@435	344	_latest_cms_initial_mark_start_to_end_time_secs +
duke@435	345	_latest_cms_remark_start_to_end_time_secs;
duke@435	346	double STW_collection_cost = 0.0;
duke@435	347	if (interval_in_seconds > 0.0) {
duke@435	348	// cost for the STW phases of the concurrent collection.
duke@435	349	STW_collection_cost = STW_time_in_seconds / interval_in_seconds;
duke@435	350	avg_cms_STW_gc_cost()->sample(STW_collection_cost);
duke@435	351	}
duke@435	352	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	353	gclog_or_tty->print("cmsAdaptiveSizePolicy::STW_collection_end: "
duke@435	354	"STW gc cost: %f average: %f", STW_collection_cost,
duke@435	355	avg_cms_STW_gc_cost()->average());
duke@435	356	gclog_or_tty->print_cr(" STW pause: %f (ms) STW period %f (ms)",
duke@435	357	(double) STW_time_in_seconds * MILLIUNITS,
duke@435	358	(double) interval_in_seconds * MILLIUNITS);
duke@435	359	}
duke@435	360
duke@435	361	double concurrent_cost = 0.0;
duke@435	362	if (latest_cms_sum_concurrent_phases_time_secs > 0.0) {
duke@435	363	concurrent_cost = concurrent_collection_cost(interval_in_seconds);
duke@435	364
duke@435	365	avg_concurrent_gc_cost()->sample(concurrent_cost);
duke@435	366	// Average this ms cost into all the other types gc costs
duke@435	367
duke@435	368	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	369	gclog_or_tty->print("cmsAdaptiveSizePolicy::concurrent_phases_end: "
duke@435	370	"concurrent gc cost: %f average: %f",
duke@435	371	concurrent_cost,
duke@435	372	_avg_concurrent_gc_cost->average());
duke@435	373	gclog_or_tty->print_cr(" concurrent time: %f (ms) cms period %f (ms)"
duke@435	374	" processor fraction: %f",
duke@435	375	latest_cms_sum_concurrent_phases_time_secs * MILLIUNITS,
duke@435	376	interval_in_seconds * MILLIUNITS,
duke@435	377	concurrent_processor_fraction());
duke@435	378	}
duke@435	379	}
duke@435	380	double total_collection_cost = STW_collection_cost + concurrent_cost;
duke@435	381	avg_major_gc_cost()->sample(total_collection_cost);
duke@435	382
duke@435	383	// Gather information for estimating future behavior
duke@435	384	double initial_pause_in_ms = _latest_cms_initial_mark_start_to_end_time_secs * MILLIUNITS;
duke@435	385	double remark_pause_in_ms = _latest_cms_remark_start_to_end_time_secs * MILLIUNITS;
duke@435	386
duke@435	387	double cur_promo_size_in_mbytes = ((double)cur_promo)/((double)M);
duke@435	388	initial_pause_old_estimator()->update(cur_promo_size_in_mbytes,
duke@435	389	initial_pause_in_ms);
duke@435	390	remark_pause_old_estimator()->update(cur_promo_size_in_mbytes,
duke@435	391	remark_pause_in_ms);
duke@435	392	major_collection_estimator()->update(cur_promo_size_in_mbytes,
duke@435	393	total_collection_cost);
duke@435	394
duke@435	395	// This estimate uses the average eden size. It could also
duke@435	396	// have used the latest eden size. Which is better?
duke@435	397	double cur_eden_size_in_mbytes = ((double)cur_eden)/((double) M);
duke@435	398	initial_pause_young_estimator()->update(cur_eden_size_in_mbytes,
duke@435	399	initial_pause_in_ms);
duke@435	400	remark_pause_young_estimator()->update(cur_eden_size_in_mbytes,
duke@435	401	remark_pause_in_ms);
duke@435	402	}
duke@435	403
duke@435	404	clear_internal_time_intervals();
duke@435	405
duke@435	406	set_first_after_collection();
duke@435	407
duke@435	408	// The concurrent phases keeps track of it's own mutator interval
duke@435	409	// with this timer. This allows the stop-the-world phase to
duke@435	410	// be included in the mutator time so that the stop-the-world time
duke@435	411	// is not double counted. Reset and start it.
duke@435	412	_concurrent_timer.reset();
duke@435	413	_concurrent_timer.start();
duke@435	414
duke@435	415	// The mutator time between STW phases does not include the
duke@435	416	// concurrent collection time.
duke@435	417	_STW_timer.reset();
duke@435	418	_STW_timer.start();
duke@435	419	}
duke@435	420
duke@435	421	void CMSAdaptiveSizePolicy::checkpoint_roots_initial_begin() {
duke@435	422	// Update the interval time
duke@435	423	_STW_timer.stop();
duke@435	424	_latest_cms_reset_end_to_initial_mark_start_secs = _STW_timer.seconds();
duke@435	425	// Reset for the initial mark
duke@435	426	_STW_timer.reset();
duke@435	427	_STW_timer.start();
duke@435	428	}
duke@435	429
duke@435	430	void CMSAdaptiveSizePolicy::checkpoint_roots_initial_end(
duke@435	431	GCCause::Cause gc_cause) {
duke@435	432	_STW_timer.stop();
duke@435	433
duke@435	434	if (gc_cause != GCCause::_java_lang_system_gc ||
duke@435	435	UseAdaptiveSizePolicyWithSystemGC) {
duke@435	436	_latest_cms_initial_mark_start_to_end_time_secs = _STW_timer.seconds();
duke@435	437	avg_initial_pause()->sample(_latest_cms_initial_mark_start_to_end_time_secs);
duke@435	438
duke@435	439	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	440	gclog_or_tty->print(
duke@435	441	"cmsAdaptiveSizePolicy::checkpoint_roots_initial_end: "
duke@435	442	"initial pause: %f ", _latest_cms_initial_mark_start_to_end_time_secs);
duke@435	443	}
duke@435	444	}
duke@435	445
duke@435	446	_STW_timer.reset();
duke@435	447	_STW_timer.start();
duke@435	448	}
duke@435	449
duke@435	450	void CMSAdaptiveSizePolicy::checkpoint_roots_final_begin() {
duke@435	451	_STW_timer.stop();
duke@435	452	_latest_cms_initial_mark_end_to_remark_start_secs = _STW_timer.seconds();
duke@435	453	// Start accumumlating time for the remark in the STW timer.
duke@435	454	_STW_timer.reset();
duke@435	455	_STW_timer.start();
duke@435	456	}
duke@435	457
duke@435	458	void CMSAdaptiveSizePolicy::checkpoint_roots_final_end(
duke@435	459	GCCause::Cause gc_cause) {
duke@435	460	_STW_timer.stop();
duke@435	461	if (gc_cause != GCCause::_java_lang_system_gc ||
duke@435	462	UseAdaptiveSizePolicyWithSystemGC) {
duke@435	463	// Total initial mark pause + remark pause.
duke@435	464	_latest_cms_remark_start_to_end_time_secs = _STW_timer.seconds();
duke@435	465	double STW_time_in_seconds = _latest_cms_initial_mark_start_to_end_time_secs +
duke@435	466	_latest_cms_remark_start_to_end_time_secs;
duke@435	467	double STW_time_in_ms = STW_time_in_seconds * MILLIUNITS;
duke@435	468
duke@435	469	avg_remark_pause()->sample(_latest_cms_remark_start_to_end_time_secs);
duke@435	470
duke@435	471	// Sample total for initial mark + remark
duke@435	472	avg_cms_STW_time()->sample(STW_time_in_seconds);
duke@435	473
duke@435	474	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	475	gclog_or_tty->print("cmsAdaptiveSizePolicy::checkpoint_roots_final_end: "
duke@435	476	"remark pause: %f", _latest_cms_remark_start_to_end_time_secs);
duke@435	477	}
duke@435	478
duke@435	479	}
duke@435	480	// Don't start the STW times here because the concurrent
duke@435	481	// sweep and reset has not happened.
duke@435	482	// Keep the old comment above in case I don't understand
duke@435	483	// what is going on but now
duke@435	484	// Start the STW timer because it is used by ms_collection_begin()
duke@435	485	// and ms_collection_end() to get the sweep time if a MS is being
duke@435	486	// done in the foreground.
duke@435	487	_STW_timer.reset();
duke@435	488	_STW_timer.start();
duke@435	489	}
duke@435	490
duke@435	491	void CMSAdaptiveSizePolicy::msc_collection_begin() {
duke@435	492	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	493	gclog_or_tty->print(" ");
duke@435	494	gclog_or_tty->stamp();
duke@435	495	gclog_or_tty->print(": msc_collection_begin ");
duke@435	496	}
duke@435	497	_STW_timer.stop();
duke@435	498	_latest_cms_msc_end_to_msc_start_time_secs = _STW_timer.seconds();
duke@435	499	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	500	gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::msc_collection_begin: "
duke@435	501	"mutator time %f",
duke@435	502	_latest_cms_msc_end_to_msc_start_time_secs);
duke@435	503	}
duke@435	504	avg_msc_interval()->sample(_latest_cms_msc_end_to_msc_start_time_secs);
duke@435	505	_STW_timer.reset();
duke@435	506	_STW_timer.start();
duke@435	507	}
duke@435	508
duke@435	509	void CMSAdaptiveSizePolicy::msc_collection_end(GCCause::Cause gc_cause) {
duke@435	510	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	511	gclog_or_tty->print(" ");
duke@435	512	gclog_or_tty->stamp();
duke@435	513	gclog_or_tty->print(": msc_collection_end ");
duke@435	514	}
duke@435	515	_STW_timer.stop();
duke@435	516	if (gc_cause != GCCause::_java_lang_system_gc ||
duke@435	517	UseAdaptiveSizePolicyWithSystemGC) {
duke@435	518	double msc_pause_in_seconds = _STW_timer.seconds();
duke@435	519	if ((_latest_cms_msc_end_to_msc_start_time_secs > 0.0) &&
duke@435	520	(msc_pause_in_seconds > 0.0)) {
duke@435	521	avg_msc_pause()->sample(msc_pause_in_seconds);
duke@435	522	double mutator_time_in_seconds = 0.0;
duke@435	523	if (_latest_cms_collection_end_to_collection_start_secs == 0.0) {
duke@435	524	// This assertion may fail because of time stamp gradularity.
duke@435	525	// Comment it out and investiage it at a later time. The large
duke@435	526	// time stamp granularity occurs on some older linux systems.
duke@435	527	#ifndef CLOCK_GRANULARITY_TOO_LARGE
duke@435	528	assert((_latest_cms_concurrent_marking_time_secs == 0.0) &&
duke@435	529	(_latest_cms_concurrent_precleaning_time_secs == 0.0) &&
duke@435	530	(_latest_cms_concurrent_sweeping_time_secs == 0.0),
duke@435	531	"There should not be any concurrent time");
duke@435	532	#endif
duke@435	533	// A concurrent collection did not start. Mutator time
duke@435	534	// between collections comes from the STW MSC timer.
duke@435	535	mutator_time_in_seconds = _latest_cms_msc_end_to_msc_start_time_secs;
duke@435	536	} else {
duke@435	537	// The concurrent collection did start so count the mutator
duke@435	538	// time to the start of the concurrent collection. In this
duke@435	539	// case the _latest_cms_msc_end_to_msc_start_time_secs measures
duke@435	540	// the time between the initial mark or remark and the
duke@435	541	// start of the MSC. That has no real meaning.
duke@435	542	mutator_time_in_seconds = _latest_cms_collection_end_to_collection_start_secs;
duke@435	543	}
duke@435	544
duke@435	545	double latest_cms_sum_concurrent_phases_time_secs =
duke@435	546	concurrent_collection_time();
duke@435	547	double interval_in_seconds =
duke@435	548	mutator_time_in_seconds +
duke@435	549	_latest_cms_initial_mark_start_to_end_time_secs +
duke@435	550	_latest_cms_remark_start_to_end_time_secs +
duke@435	551	latest_cms_sum_concurrent_phases_time_secs +
duke@435	552	msc_pause_in_seconds;
duke@435	553
duke@435	554	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	555	gclog_or_tty->print_cr(" interval_in_seconds %f \n"
duke@435	556	" mutator_time_in_seconds %f \n"
duke@435	557	" _latest_cms_initial_mark_start_to_end_time_secs %f\n"
duke@435	558	" _latest_cms_remark_start_to_end_time_secs %f\n"
duke@435	559	" latest_cms_sum_concurrent_phases_time_secs %f\n"
duke@435	560	" msc_pause_in_seconds %f\n",
duke@435	561	interval_in_seconds,
duke@435	562	mutator_time_in_seconds,
duke@435	563	_latest_cms_initial_mark_start_to_end_time_secs,
duke@435	564	_latest_cms_remark_start_to_end_time_secs,
duke@435	565	latest_cms_sum_concurrent_phases_time_secs,
duke@435	566	msc_pause_in_seconds);
duke@435	567	}
duke@435	568
duke@435	569	// The concurrent cost is wasted cost but it should be
duke@435	570	// included.
duke@435	571	double concurrent_cost = concurrent_collection_cost(interval_in_seconds);
duke@435	572
duke@435	573	// Initial mark and remark, also wasted.
duke@435	574	double STW_time_in_seconds = _latest_cms_initial_mark_start_to_end_time_secs +
duke@435	575	_latest_cms_remark_start_to_end_time_secs;
duke@435	576	double STW_collection_cost =
duke@435	577	collection_cost(STW_time_in_seconds, interval_in_seconds) +
duke@435	578	concurrent_cost;
duke@435	579
duke@435	580	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	581	gclog_or_tty->print_cr(" msc_collection_end:\n"
duke@435	582	"_latest_cms_collection_end_to_collection_start_secs %f\n"
duke@435	583	"_latest_cms_msc_end_to_msc_start_time_secs %f\n"
duke@435	584	"_latest_cms_initial_mark_start_to_end_time_secs %f\n"
duke@435	585	"_latest_cms_remark_start_to_end_time_secs %f\n"
duke@435	586	"latest_cms_sum_concurrent_phases_time_secs %f\n",
duke@435	587	_latest_cms_collection_end_to_collection_start_secs,
duke@435	588	_latest_cms_msc_end_to_msc_start_time_secs,
duke@435	589	_latest_cms_initial_mark_start_to_end_time_secs,
duke@435	590	_latest_cms_remark_start_to_end_time_secs,
duke@435	591	latest_cms_sum_concurrent_phases_time_secs);
duke@435	592
duke@435	593	gclog_or_tty->print_cr(" msc_collection_end: \n"
duke@435	594	"latest_cms_sum_concurrent_phases_time_secs %f\n"
duke@435	595	"STW_time_in_seconds %f\n"
duke@435	596	"msc_pause_in_seconds %f\n",
duke@435	597	latest_cms_sum_concurrent_phases_time_secs,
duke@435	598	STW_time_in_seconds,
duke@435	599	msc_pause_in_seconds);
duke@435	600	}
duke@435	601
duke@435	602	double cost = concurrent_cost + STW_collection_cost +
duke@435	603	collection_cost(msc_pause_in_seconds, interval_in_seconds);
duke@435	604
duke@435	605	_avg_msc_gc_cost->sample(cost);
duke@435	606
duke@435	607	// Average this ms cost into all the other types gc costs
duke@435	608	avg_major_gc_cost()->sample(cost);
duke@435	609
duke@435	610	// Sample for performance counter
duke@435	611	_avg_msc_interval->sample(interval_in_seconds);
duke@435	612	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	613	gclog_or_tty->print("cmsAdaptiveSizePolicy::msc_collection_end: "
duke@435	614	"MSC gc cost: %f average: %f", cost,
duke@435	615	_avg_msc_gc_cost->average());
duke@435	616
duke@435	617	double msc_pause_in_ms = msc_pause_in_seconds * MILLIUNITS;
duke@435	618	gclog_or_tty->print_cr(" MSC pause: %f (ms) MSC period %f (ms)",
duke@435	619	msc_pause_in_ms, (double) interval_in_seconds * MILLIUNITS);
duke@435	620	}
duke@435	621	}
duke@435	622	}
duke@435	623
duke@435	624	clear_internal_time_intervals();
duke@435	625
duke@435	626	// Can this call be put into the epilogue?
duke@435	627	set_first_after_collection();
duke@435	628
duke@435	629	// The concurrent phases keeps track of it's own mutator interval
duke@435	630	// with this timer. This allows the stop-the-world phase to
duke@435	631	// be included in the mutator time so that the stop-the-world time
duke@435	632	// is not double counted. Reset and start it.
duke@435	633	_concurrent_timer.stop();
duke@435	634	_concurrent_timer.reset();
duke@435	635	_concurrent_timer.start();
duke@435	636
duke@435	637	_STW_timer.reset();
duke@435	638	_STW_timer.start();
duke@435	639	}
duke@435	640
duke@435	641	void CMSAdaptiveSizePolicy::ms_collection_begin() {
duke@435	642	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	643	gclog_or_tty->print(" ");
duke@435	644	gclog_or_tty->stamp();
duke@435	645	gclog_or_tty->print(": ms_collection_begin ");
duke@435	646	}
duke@435	647	_STW_timer.stop();
duke@435	648	_latest_cms_ms_end_to_ms_start = _STW_timer.seconds();
duke@435	649	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	650	gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::ms_collection_begin: "
duke@435	651	"mutator time %f",
duke@435	652	_latest_cms_ms_end_to_ms_start);
duke@435	653	}
duke@435	654	avg_ms_interval()->sample(_STW_timer.seconds());
duke@435	655	_STW_timer.reset();
duke@435	656	_STW_timer.start();
duke@435	657	}
duke@435	658
duke@435	659	void CMSAdaptiveSizePolicy::ms_collection_end(GCCause::Cause gc_cause) {
duke@435	660	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	661	gclog_or_tty->print(" ");
duke@435	662	gclog_or_tty->stamp();
duke@435	663	gclog_or_tty->print(": ms_collection_end ");
duke@435	664	}
duke@435	665	_STW_timer.stop();
duke@435	666	if (gc_cause != GCCause::_java_lang_system_gc ||
duke@435	667	UseAdaptiveSizePolicyWithSystemGC) {
duke@435	668	// The MS collection is a foreground collection that does all
duke@435	669	// the parts of a mostly concurrent collection.
duke@435	670	//
duke@435	671	// For this collection include the cost of the
duke@435	672	// initial mark
duke@435	673	// remark
duke@435	674	// all concurrent time (scaled down by the
duke@435	675	// concurrent_processor_fraction). Some
duke@435	676	// may be zero if the baton was passed before
duke@435	677	// it was reached.
duke@435	678	// concurrent marking
duke@435	679	// sweeping
duke@435	680	// resetting
duke@435	681	// STW after baton was passed (STW_in_foreground_in_seconds)
duke@435	682	double STW_in_foreground_in_seconds = _STW_timer.seconds();
duke@435	683
duke@435	684	double latest_cms_sum_concurrent_phases_time_secs =
duke@435	685	concurrent_collection_time();
duke@435	686	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	687	gclog_or_tty->print_cr("\nCMSAdaptiveSizePolicy::ms_collecton_end "
duke@435	688	"STW_in_foreground_in_seconds %f "
duke@435	689	"_latest_cms_initial_mark_start_to_end_time_secs %f "
duke@435	690	"_latest_cms_remark_start_to_end_time_secs %f "
duke@435	691	"latest_cms_sum_concurrent_phases_time_secs %f "
duke@435	692	"_latest_cms_ms_marking_start_to_end_time_secs %f "
duke@435	693	"_latest_cms_ms_end_to_ms_start %f",
duke@435	694	STW_in_foreground_in_seconds,
duke@435	695	_latest_cms_initial_mark_start_to_end_time_secs,
duke@435	696	_latest_cms_remark_start_to_end_time_secs,
duke@435	697	latest_cms_sum_concurrent_phases_time_secs,
duke@435	698	_latest_cms_ms_marking_start_to_end_time_secs,
duke@435	699	_latest_cms_ms_end_to_ms_start);
duke@435	700	}
duke@435	701
duke@435	702	double STW_marking_in_seconds = _latest_cms_initial_mark_start_to_end_time_secs +
duke@435	703	_latest_cms_remark_start_to_end_time_secs;
duke@435	704	#ifndef CLOCK_GRANULARITY_TOO_LARGE
duke@435	705	assert(_latest_cms_ms_marking_start_to_end_time_secs == 0.0 ||
duke@435	706	latest_cms_sum_concurrent_phases_time_secs == 0.0,
duke@435	707	"marking done twice?");
duke@435	708	#endif
duke@435	709	double ms_time_in_seconds = STW_marking_in_seconds +
duke@435	710	STW_in_foreground_in_seconds +
duke@435	711	_latest_cms_ms_marking_start_to_end_time_secs +
duke@435	712	scaled_concurrent_collection_time();
duke@435	713	avg_ms_pause()->sample(ms_time_in_seconds);
duke@435	714	// Use the STW costs from the initial mark and remark plus
duke@435	715	// the cost of the concurrent phase to calculate a
duke@435	716	// collection cost.
duke@435	717	double cost = 0.0;
duke@435	718	if ((_latest_cms_ms_end_to_ms_start > 0.0) &&
duke@435	719	(ms_time_in_seconds > 0.0)) {
duke@435	720	double interval_in_seconds =
duke@435	721	_latest_cms_ms_end_to_ms_start + ms_time_in_seconds;
duke@435	722
duke@435	723	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	724	gclog_or_tty->print_cr("\n ms_time_in_seconds %f "
duke@435	725	"latest_cms_sum_concurrent_phases_time_secs %f "
duke@435	726	"interval_in_seconds %f",
duke@435	727	ms_time_in_seconds,
duke@435	728	latest_cms_sum_concurrent_phases_time_secs,
duke@435	729	interval_in_seconds);
duke@435	730	}
duke@435	731
duke@435	732	cost = collection_cost(ms_time_in_seconds, interval_in_seconds);
duke@435	733
duke@435	734	_avg_ms_gc_cost->sample(cost);
duke@435	735	// Average this ms cost into all the other types gc costs
duke@435	736	avg_major_gc_cost()->sample(cost);
duke@435	737
duke@435	738	// Sample for performance counter
duke@435	739	_avg_ms_interval->sample(interval_in_seconds);
duke@435	740	}
duke@435	741	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	742	gclog_or_tty->print("cmsAdaptiveSizePolicy::ms_collection_end: "
duke@435	743	"MS gc cost: %f average: %f", cost, _avg_ms_gc_cost->average());
duke@435	744
duke@435	745	double ms_time_in_ms = ms_time_in_seconds * MILLIUNITS;
duke@435	746	gclog_or_tty->print_cr(" MS pause: %f (ms) MS period %f (ms)",
duke@435	747	ms_time_in_ms,
duke@435	748	_latest_cms_ms_end_to_ms_start * MILLIUNITS);
duke@435	749	}
duke@435	750	}
duke@435	751
duke@435	752	// Consider putting this code (here to end) into a
duke@435	753	// method for convenience.
duke@435	754	clear_internal_time_intervals();
duke@435	755
duke@435	756	set_first_after_collection();
duke@435	757
duke@435	758	// The concurrent phases keeps track of it's own mutator interval
duke@435	759	// with this timer. This allows the stop-the-world phase to
duke@435	760	// be included in the mutator time so that the stop-the-world time
duke@435	761	// is not double counted. Reset and start it.
duke@435	762	_concurrent_timer.stop();
duke@435	763	_concurrent_timer.reset();
duke@435	764	_concurrent_timer.start();
duke@435	765
duke@435	766	_STW_timer.reset();
duke@435	767	_STW_timer.start();
duke@435	768	}
duke@435	769
duke@435	770	void CMSAdaptiveSizePolicy::clear_internal_time_intervals() {
duke@435	771	_latest_cms_reset_end_to_initial_mark_start_secs = 0.0;
duke@435	772	_latest_cms_initial_mark_end_to_remark_start_secs = 0.0;
duke@435	773	_latest_cms_collection_end_to_collection_start_secs = 0.0;
duke@435	774	_latest_cms_concurrent_marking_time_secs = 0.0;
duke@435	775	_latest_cms_concurrent_precleaning_time_secs = 0.0;
duke@435	776	_latest_cms_concurrent_sweeping_time_secs = 0.0;
duke@435	777	_latest_cms_msc_end_to_msc_start_time_secs = 0.0;
duke@435	778	_latest_cms_ms_end_to_ms_start = 0.0;
duke@435	779	_latest_cms_remark_start_to_end_time_secs = 0.0;
duke@435	780	_latest_cms_initial_mark_start_to_end_time_secs = 0.0;
duke@435	781	_latest_cms_ms_marking_start_to_end_time_secs = 0.0;
duke@435	782	}
duke@435	783
duke@435	784	void CMSAdaptiveSizePolicy::clear_generation_free_space_flags() {
duke@435	785	AdaptiveSizePolicy::clear_generation_free_space_flags();
duke@435	786
duke@435	787	set_change_young_gen_for_maj_pauses(0);
duke@435	788	}
duke@435	789
duke@435	790	void CMSAdaptiveSizePolicy::concurrent_phases_resume() {
duke@435	791	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	792	gclog_or_tty->stamp();
duke@435	793	gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_phases_resume()");
duke@435	794	}
duke@435	795	_concurrent_timer.start();
duke@435	796	}
duke@435	797
duke@435	798	double CMSAdaptiveSizePolicy::time_since_major_gc() const {
duke@435	799	_concurrent_timer.stop();
duke@435	800	double time_since_cms_gc = _concurrent_timer.seconds();
duke@435	801	_concurrent_timer.start();
duke@435	802	_STW_timer.stop();
duke@435	803	double time_since_STW_gc = _STW_timer.seconds();
duke@435	804	_STW_timer.start();
duke@435	805
duke@435	806	return MIN2(time_since_cms_gc, time_since_STW_gc);
duke@435	807	}
duke@435	808
duke@435	809	double CMSAdaptiveSizePolicy::major_gc_interval_average_for_decay() const {
duke@435	810	double cms_interval = _avg_concurrent_interval->average();
duke@435	811	double msc_interval = _avg_msc_interval->average();
duke@435	812	double ms_interval = _avg_ms_interval->average();
duke@435	813
duke@435	814	return MAX3(cms_interval, msc_interval, ms_interval);
duke@435	815	}
duke@435	816
duke@435	817	double CMSAdaptiveSizePolicy::cms_gc_cost() const {
duke@435	818	return avg_major_gc_cost()->average();
duke@435	819	}
duke@435	820
duke@435	821	void CMSAdaptiveSizePolicy::ms_collection_marking_begin() {
duke@435	822	_STW_timer.stop();
duke@435	823	// Start accumumlating time for the marking in the STW timer.
duke@435	824	_STW_timer.reset();
duke@435	825	_STW_timer.start();
duke@435	826	}
duke@435	827
duke@435	828	void CMSAdaptiveSizePolicy::ms_collection_marking_end(
duke@435	829	GCCause::Cause gc_cause) {
duke@435	830	_STW_timer.stop();
duke@435	831	if (gc_cause != GCCause::_java_lang_system_gc ||
duke@435	832	UseAdaptiveSizePolicyWithSystemGC) {
duke@435	833	_latest_cms_ms_marking_start_to_end_time_secs = _STW_timer.seconds();
duke@435	834	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	835	gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::"
duke@435	836	"msc_collection_marking_end: mutator time %f",
duke@435	837	_latest_cms_ms_marking_start_to_end_time_secs);
duke@435	838	}
duke@435	839	}
duke@435	840	_STW_timer.reset();
duke@435	841	_STW_timer.start();
duke@435	842	}
duke@435	843
duke@435	844	double CMSAdaptiveSizePolicy::gc_cost() const {
duke@435	845	double cms_gen_cost = cms_gc_cost();
duke@435	846	double result = MIN2(1.0, minor_gc_cost() + cms_gen_cost);
duke@435	847	assert(result >= 0.0, "Both minor and major costs are non-negative");
duke@435	848	return result;
duke@435	849	}
duke@435	850
duke@435	851	// Cost of collection (unit-less)
duke@435	852	double CMSAdaptiveSizePolicy::collection_cost(double pause_in_seconds,
duke@435	853	double interval_in_seconds) {
duke@435	854	// Cost of collection (unit-less)
duke@435	855	double cost = 0.0;
duke@435	856	if ((interval_in_seconds > 0.0) &&
duke@435	857	(pause_in_seconds > 0.0)) {
duke@435	858	cost =
duke@435	859	pause_in_seconds / interval_in_seconds;
duke@435	860	}
duke@435	861	return cost;
duke@435	862	}
duke@435	863
duke@435	864	size_t CMSAdaptiveSizePolicy::adjust_eden_for_pause_time(size_t cur_eden) {
duke@435	865	size_t change = 0;
duke@435	866	size_t desired_eden = cur_eden;
duke@435	867
duke@435	868	// reduce eden size
duke@435	869	change = eden_decrement_aligned_down(cur_eden);
duke@435	870	desired_eden = cur_eden - change;
duke@435	871
duke@435	872	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	873	gclog_or_tty->print_cr(
duke@435	874	"CMSAdaptiveSizePolicy::adjust_eden_for_pause_time "
duke@435	875	"adjusting eden for pause time. "
duke@435	876	" starting eden size " SIZE_FORMAT
duke@435	877	" reduced eden size " SIZE_FORMAT
duke@435	878	" eden delta " SIZE_FORMAT,
duke@435	879	cur_eden, desired_eden, change);
duke@435	880	}
duke@435	881
duke@435	882	return desired_eden;
duke@435	883	}
duke@435	884
duke@435	885	size_t CMSAdaptiveSizePolicy::adjust_eden_for_throughput(size_t cur_eden) {
duke@435	886
duke@435	887	size_t desired_eden = cur_eden;
duke@435	888
duke@435	889	set_change_young_gen_for_throughput(increase_young_gen_for_througput_true);
duke@435	890
duke@435	891	size_t change = eden_increment_aligned_up(cur_eden);
duke@435	892	size_t scaled_change = scale_by_gen_gc_cost(change, minor_gc_cost());
duke@435	893
duke@435	894	if (cur_eden + scaled_change > cur_eden) {
duke@435	895	desired_eden = cur_eden + scaled_change;
duke@435	896	}
duke@435	897
duke@435	898	_young_gen_change_for_minor_throughput++;
duke@435	899
duke@435	900	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	901	gclog_or_tty->print_cr(
duke@435	902	"CMSAdaptiveSizePolicy::adjust_eden_for_throughput "
duke@435	903	"adjusting eden for throughput. "
duke@435	904	" starting eden size " SIZE_FORMAT
duke@435	905	" increased eden size " SIZE_FORMAT
duke@435	906	" eden delta " SIZE_FORMAT,
duke@435	907	cur_eden, desired_eden, scaled_change);
duke@435	908	}
duke@435	909
duke@435	910	return desired_eden;
duke@435	911	}
duke@435	912
duke@435	913	size_t CMSAdaptiveSizePolicy::adjust_eden_for_footprint(size_t cur_eden) {
duke@435	914
duke@435	915	set_decrease_for_footprint(decrease_young_gen_for_footprint_true);
duke@435	916
duke@435	917	size_t change = eden_decrement(cur_eden);
duke@435	918	size_t desired_eden_size = cur_eden - change;
duke@435	919
duke@435	920	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	921	gclog_or_tty->print_cr(
duke@435	922	"CMSAdaptiveSizePolicy::adjust_eden_for_footprint "
duke@435	923	"adjusting eden for footprint. "
duke@435	924	" starting eden size " SIZE_FORMAT
duke@435	925	" reduced eden size " SIZE_FORMAT
duke@435	926	" eden delta " SIZE_FORMAT,
duke@435	927	cur_eden, desired_eden_size, change);
duke@435	928	}
duke@435	929	return desired_eden_size;
duke@435	930	}
duke@435	931
duke@435	932	// The eden and promo versions should be combined if possible.
duke@435	933	// They are the same except that the sizes of the decrement
duke@435	934	// and increment are different for eden and promo.
duke@435	935	size_t CMSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
duke@435	936	size_t delta = eden_decrement(cur_eden);
duke@435	937	return align_size_down(delta, generation_alignment());
duke@435	938	}
duke@435	939
duke@435	940	size_t CMSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
duke@435	941	size_t delta = eden_increment(cur_eden);
duke@435	942	return align_size_up(delta, generation_alignment());
duke@435	943	}
duke@435	944
duke@435	945	size_t CMSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
duke@435	946	size_t delta = promo_decrement(cur_promo);
duke@435	947	return align_size_down(delta, generation_alignment());
duke@435	948	}
duke@435	949
duke@435	950	size_t CMSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
duke@435	951	size_t delta = promo_increment(cur_promo);
duke@435	952	return align_size_up(delta, generation_alignment());
duke@435	953	}
duke@435	954
duke@435	955
duke@435	956	void CMSAdaptiveSizePolicy::compute_young_generation_free_space(size_t cur_eden,
duke@435	957	size_t max_eden_size)
duke@435	958	{
duke@435	959	size_t desired_eden_size = cur_eden;
duke@435	960	size_t eden_limit = max_eden_size;
duke@435	961
duke@435	962	// Printout input
duke@435	963	if (PrintGC && PrintAdaptiveSizePolicy) {
duke@435	964	gclog_or_tty->print_cr(
duke@435	965	"CMSAdaptiveSizePolicy::compute_young_generation_free_space: "
duke@435	966	"cur_eden " SIZE_FORMAT,
duke@435	967	cur_eden);
duke@435	968	}
duke@435	969
duke@435	970	// Used for diagnostics
duke@435	971	clear_generation_free_space_flags();
duke@435	972
duke@435	973	if (_avg_minor_pause->padded_average() > gc_pause_goal_sec()) {
duke@435	974	if (minor_pause_young_estimator()->decrement_will_decrease()) {
duke@435	975	// If the minor pause is too long, shrink the young gen.
duke@435	976	set_change_young_gen_for_min_pauses(
duke@435	977	decrease_young_gen_for_min_pauses_true);
duke@435	978	desired_eden_size = adjust_eden_for_pause_time(desired_eden_size);
duke@435	979	}
duke@435	980	} else if ((avg_remark_pause()->padded_average() > gc_pause_goal_sec()) ||
duke@435	981	(avg_initial_pause()->padded_average() > gc_pause_goal_sec())) {
duke@435	982	// The remark or initial pauses are not meeting the goal. Should
duke@435	983	// the generation be shrunk?
duke@435	984	if (get_and_clear_first_after_collection() &&
duke@435	985	((avg_remark_pause()->padded_average() > gc_pause_goal_sec() &&
duke@435	986	remark_pause_young_estimator()->decrement_will_decrease()) ||
duke@435	987	(avg_initial_pause()->padded_average() > gc_pause_goal_sec() &&
duke@435	988	initial_pause_young_estimator()->decrement_will_decrease()))) {
duke@435	989
duke@435	990	set_change_young_gen_for_maj_pauses(
duke@435	991	decrease_young_gen_for_maj_pauses_true);
duke@435	992
duke@435	993	// If the remark or initial pause is too long and this is the
duke@435	994	// first young gen collection after a cms collection, shrink
duke@435	995	// the young gen.
duke@435	996	desired_eden_size = adjust_eden_for_pause_time(desired_eden_size);
duke@435	997	}
duke@435	998	// If not the first young gen collection after a cms collection,
duke@435	999	// don't do anything. In this case an adjustment has already
duke@435	1000	// been made and the results of the adjustment has not yet been
duke@435	1001	// measured.
duke@435	1002	} else if ((minor_gc_cost() >= 0.0) &&
duke@435	1003	(adjusted_mutator_cost() < _throughput_goal)) {
duke@435	1004	desired_eden_size = adjust_eden_for_throughput(desired_eden_size);
duke@435	1005	} else {
duke@435	1006	desired_eden_size = adjust_eden_for_footprint(desired_eden_size);
duke@435	1007	}
duke@435	1008
duke@435	1009	if (PrintGC && PrintAdaptiveSizePolicy) {
duke@435	1010	gclog_or_tty->print_cr(
duke@435	1011	"CMSAdaptiveSizePolicy::compute_young_generation_free_space limits:"
duke@435	1012	" desired_eden_size: " SIZE_FORMAT
duke@435	1013	" old_eden_size: " SIZE_FORMAT,
duke@435	1014	desired_eden_size, cur_eden);
duke@435	1015	}
duke@435	1016
duke@435	1017	set_eden_size(desired_eden_size);
duke@435	1018	}
duke@435	1019
duke@435	1020	size_t CMSAdaptiveSizePolicy::adjust_promo_for_pause_time(size_t cur_promo) {
duke@435	1021	size_t change = 0;
duke@435	1022	size_t desired_promo = cur_promo;
duke@435	1023	// Move this test up to caller like the adjust_eden_for_pause_time()
duke@435	1024	// call.
duke@435	1025	if ((AdaptiveSizePausePolicy == 0) &&
duke@435	1026	((avg_remark_pause()->padded_average() > gc_pause_goal_sec()) ||
duke@435	1027	(avg_initial_pause()->padded_average() > gc_pause_goal_sec()))) {
duke@435	1028	set_change_old_gen_for_maj_pauses(decrease_old_gen_for_maj_pauses_true);
duke@435	1029	change = promo_decrement_aligned_down(cur_promo);
duke@435	1030	desired_promo = cur_promo - change;
duke@435	1031	} else if ((AdaptiveSizePausePolicy > 0) &&
duke@435	1032	(((avg_remark_pause()->padded_average() > gc_pause_goal_sec()) &&
duke@435	1033	remark_pause_old_estimator()->decrement_will_decrease()) ||
duke@435	1034	((avg_initial_pause()->padded_average() > gc_pause_goal_sec()) &&
duke@435	1035	initial_pause_old_estimator()->decrement_will_decrease()))) {
duke@435	1036	set_change_old_gen_for_maj_pauses(decrease_old_gen_for_maj_pauses_true);
duke@435	1037	change = promo_decrement_aligned_down(cur_promo);
duke@435	1038	desired_promo = cur_promo - change;
duke@435	1039	}
duke@435	1040
duke@435	1041	if ((change != 0) &&PrintAdaptiveSizePolicy && Verbose) {
duke@435	1042	gclog_or_tty->print_cr(
duke@435	1043	"CMSAdaptiveSizePolicy::adjust_promo_for_pause_time "
duke@435	1044	"adjusting promo for pause time. "
duke@435	1045	" starting promo size " SIZE_FORMAT
duke@435	1046	" reduced promo size " SIZE_FORMAT
duke@435	1047	" promo delta " SIZE_FORMAT,
duke@435	1048	cur_promo, desired_promo, change);
duke@435	1049	}
duke@435	1050
duke@435	1051	return desired_promo;
duke@435	1052	}
duke@435	1053
duke@435	1054	// Try to share this with PS.
duke@435	1055	size_t CMSAdaptiveSizePolicy::scale_by_gen_gc_cost(size_t base_change,
duke@435	1056	double gen_gc_cost) {
duke@435	1057
duke@435	1058	// Calculate the change to use for the tenured gen.
duke@435	1059	size_t scaled_change = 0;
duke@435	1060	// Can the increment to the generation be scaled?
duke@435	1061	if (gc_cost() >= 0.0 && gen_gc_cost >= 0.0) {
duke@435	1062	double scale_by_ratio = gen_gc_cost / gc_cost();
duke@435	1063	scaled_change =
duke@435	1064	(size_t) (scale_by_ratio * (double) base_change);
duke@435	1065	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	1066	gclog_or_tty->print_cr(
duke@435	1067	"Scaled tenured increment: " SIZE_FORMAT " by %f down to "
duke@435	1068	SIZE_FORMAT,
duke@435	1069	base_change, scale_by_ratio, scaled_change);
duke@435	1070	}
duke@435	1071	} else if (gen_gc_cost >= 0.0) {
duke@435	1072	// Scaling is not going to work. If the major gc time is the
duke@435	1073	// larger than the other GC costs, give it a full increment.
duke@435	1074	if (gen_gc_cost >= (gc_cost() - gen_gc_cost)) {
duke@435	1075	scaled_change = base_change;
duke@435	1076	}
duke@435	1077	} else {
duke@435	1078	// Don't expect to get here but it's ok if it does
duke@435	1079	// in the product build since the delta will be 0
duke@435	1080	// and nothing will change.
duke@435	1081	assert(false, "Unexpected value for gc costs");
duke@435	1082	}
duke@435	1083
duke@435	1084	return scaled_change;
duke@435	1085	}
duke@435	1086
duke@435	1087	size_t CMSAdaptiveSizePolicy::adjust_promo_for_throughput(size_t cur_promo) {
duke@435	1088
duke@435	1089	size_t desired_promo = cur_promo;
duke@435	1090
duke@435	1091	set_change_old_gen_for_throughput(increase_old_gen_for_throughput_true);
duke@435	1092
duke@435	1093	size_t change = promo_increment_aligned_up(cur_promo);
duke@435	1094	size_t scaled_change = scale_by_gen_gc_cost(change, major_gc_cost());
duke@435	1095
duke@435	1096	if (cur_promo + scaled_change > cur_promo) {
duke@435	1097	desired_promo = cur_promo + scaled_change;
duke@435	1098	}
duke@435	1099
duke@435	1100	_old_gen_change_for_major_throughput++;
duke@435	1101
duke@435	1102	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	1103	gclog_or_tty->print_cr(
duke@435	1104	"CMSAdaptiveSizePolicy::adjust_promo_for_throughput "
duke@435	1105	"adjusting promo for throughput. "
duke@435	1106	" starting promo size " SIZE_FORMAT
duke@435	1107	" increased promo size " SIZE_FORMAT
duke@435	1108	" promo delta " SIZE_FORMAT,
duke@435	1109	cur_promo, desired_promo, scaled_change);
duke@435	1110	}
duke@435	1111
duke@435	1112	return desired_promo;
duke@435	1113	}
duke@435	1114
duke@435	1115	size_t CMSAdaptiveSizePolicy::adjust_promo_for_footprint(size_t cur_promo,
duke@435	1116	size_t cur_eden) {
duke@435	1117
duke@435	1118	set_decrease_for_footprint(decrease_young_gen_for_footprint_true);
duke@435	1119
duke@435	1120	size_t change = promo_decrement(cur_promo);
duke@435	1121	size_t desired_promo_size = cur_promo - change;
duke@435	1122
duke@435	1123	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	1124	gclog_or_tty->print_cr(
duke@435	1125	"CMSAdaptiveSizePolicy::adjust_promo_for_footprint "
duke@435	1126	"adjusting promo for footprint. "
duke@435	1127	" starting promo size " SIZE_FORMAT
duke@435	1128	" reduced promo size " SIZE_FORMAT
duke@435	1129	" promo delta " SIZE_FORMAT,
duke@435	1130	cur_promo, desired_promo_size, change);
duke@435	1131	}
duke@435	1132	return desired_promo_size;
duke@435	1133	}
duke@435	1134
duke@435	1135	void CMSAdaptiveSizePolicy::compute_tenured_generation_free_space(
duke@435	1136	size_t cur_tenured_free,
duke@435	1137	size_t max_tenured_available,
duke@435	1138	size_t cur_eden) {
duke@435	1139	// This can be bad if the desired value grows/shrinks without
duke@435	1140	// any connection to the read free space
duke@435	1141	size_t desired_promo_size = promo_size();
duke@435	1142	size_t tenured_limit = max_tenured_available;
duke@435	1143
duke@435	1144	// Printout input
duke@435	1145	if (PrintGC && PrintAdaptiveSizePolicy) {
duke@435	1146	gclog_or_tty->print_cr(
duke@435	1147	"CMSAdaptiveSizePolicy::compute_tenured_generation_free_space: "
duke@435	1148	"cur_tenured_free " SIZE_FORMAT
duke@435	1149	" max_tenured_available " SIZE_FORMAT,
duke@435	1150	cur_tenured_free, max_tenured_available);
duke@435	1151	}
duke@435	1152
duke@435	1153	// Used for diagnostics
duke@435	1154	clear_generation_free_space_flags();
duke@435	1155
duke@435	1156	set_decide_at_full_gc(decide_at_full_gc_true);
duke@435	1157	if (avg_remark_pause()->padded_average() > gc_pause_goal_sec() ||
duke@435	1158	avg_initial_pause()->padded_average() > gc_pause_goal_sec()) {
duke@435	1159	desired_promo_size = adjust_promo_for_pause_time(cur_tenured_free);
duke@435	1160	} else if (avg_minor_pause()->padded_average() > gc_pause_goal_sec()) {
duke@435	1161	// Nothing to do since the minor collections are too large and
duke@435	1162	// this method only deals with the cms generation.
duke@435	1163	} else if ((cms_gc_cost() >= 0.0) &&
duke@435	1164	(adjusted_mutator_cost() < _throughput_goal)) {
duke@435	1165	desired_promo_size = adjust_promo_for_throughput(cur_tenured_free);
duke@435	1166	} else {
duke@435	1167	desired_promo_size = adjust_promo_for_footprint(cur_tenured_free,
duke@435	1168	cur_eden);
duke@435	1169	}
duke@435	1170
duke@435	1171	if (PrintGC && PrintAdaptiveSizePolicy) {
duke@435	1172	gclog_or_tty->print_cr(
duke@435	1173	"CMSAdaptiveSizePolicy::compute_tenured_generation_free_space limits:"
duke@435	1174	" desired_promo_size: " SIZE_FORMAT
duke@435	1175	" old_promo_size: " SIZE_FORMAT,
duke@435	1176	desired_promo_size, cur_tenured_free);
duke@435	1177	}
duke@435	1178
duke@435	1179	set_promo_size(desired_promo_size);
duke@435	1180	}
duke@435	1181
duke@435	1182	int CMSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold(
duke@435	1183	bool is_survivor_overflow,
duke@435	1184	int tenuring_threshold,
duke@435	1185	size_t survivor_limit) {
duke@435	1186	assert(survivor_limit >= generation_alignment(),
duke@435	1187	"survivor_limit too small");
duke@435	1188	assert((size_t)align_size_down(survivor_limit, generation_alignment())
duke@435	1189	== survivor_limit, "survivor_limit not aligned");
duke@435	1190
duke@435	1191	// Change UsePSAdaptiveSurvivorSizePolicy -> UseAdaptiveSurvivorSizePolicy?
duke@435	1192	if (!UsePSAdaptiveSurvivorSizePolicy ||
duke@435	1193	!young_gen_policy_is_ready()) {
duke@435	1194	return tenuring_threshold;
duke@435	1195	}
duke@435	1196
duke@435	1197	// We'll decide whether to increase or decrease the tenuring
duke@435	1198	// threshold based partly on the newly computed survivor size
duke@435	1199	// (if we hit the maximum limit allowed, we'll always choose to
duke@435	1200	// decrement the threshold).
duke@435	1201	bool incr_tenuring_threshold = false;
duke@435	1202	bool decr_tenuring_threshold = false;
duke@435	1203
duke@435	1204	set_decrement_tenuring_threshold_for_gc_cost(false);
duke@435	1205	set_increment_tenuring_threshold_for_gc_cost(false);
duke@435	1206	set_decrement_tenuring_threshold_for_survivor_limit(false);
duke@435	1207
duke@435	1208	if (!is_survivor_overflow) {
duke@435	1209	// Keep running averages on how much survived
duke@435	1210
duke@435	1211	// We use the tenuring threshold to equalize the cost of major
duke@435	1212	// and minor collections.
duke@435	1213	// ThresholdTolerance is used to indicate how sensitive the
duke@435	1214	// tenuring threshold is to differences in cost betweent the
duke@435	1215	// collection types.
duke@435	1216
duke@435	1217	// Get the times of interest. This involves a little work, so
duke@435	1218	// we cache the values here.
duke@435	1219	const double major_cost = major_gc_cost();
duke@435	1220	const double minor_cost = minor_gc_cost();
duke@435	1221
duke@435	1222	if (minor_cost > major_cost * _threshold_tolerance_percent) {
duke@435	1223	// Minor times are getting too long; lower the threshold so
duke@435	1224	// less survives and more is promoted.
duke@435	1225	decr_tenuring_threshold = true;
duke@435	1226	set_decrement_tenuring_threshold_for_gc_cost(true);
duke@435	1227	} else if (major_cost > minor_cost * _threshold_tolerance_percent) {
duke@435	1228	// Major times are too long, so we want less promotion.
duke@435	1229	incr_tenuring_threshold = true;
duke@435	1230	set_increment_tenuring_threshold_for_gc_cost(true);
duke@435	1231	}
duke@435	1232
duke@435	1233	} else {
duke@435	1234	// Survivor space overflow occurred, so promoted and survived are
duke@435	1235	// not accurate. We'll make our best guess by combining survived
duke@435	1236	// and promoted and count them as survivors.
duke@435	1237	//
duke@435	1238	// We'll lower the tenuring threshold to see if we can correct
duke@435	1239	// things. Also, set the survivor size conservatively. We're
duke@435	1240	// trying to avoid many overflows from occurring if defnew size
duke@435	1241	// is just too small.
duke@435	1242
duke@435	1243	decr_tenuring_threshold = true;
duke@435	1244	}
duke@435	1245
duke@435	1246	// The padded average also maintains a deviation from the average;
duke@435	1247	// we use this to see how good of an estimate we have of what survived.
duke@435	1248	// We're trying to pad the survivor size as little as possible without
duke@435	1249	// overflowing the survivor spaces.
duke@435	1250	size_t target_size = align_size_up((size_t)_avg_survived->padded_average(),
duke@435	1251	generation_alignment());
duke@435	1252	target_size = MAX2(target_size, generation_alignment());
duke@435	1253
duke@435	1254	if (target_size > survivor_limit) {
duke@435	1255	// Target size is bigger than we can handle. Let's also reduce
duke@435	1256	// the tenuring threshold.
duke@435	1257	target_size = survivor_limit;
duke@435	1258	decr_tenuring_threshold = true;
duke@435	1259	set_decrement_tenuring_threshold_for_survivor_limit(true);
duke@435	1260	}
duke@435	1261
duke@435	1262	// Finally, increment or decrement the tenuring threshold, as decided above.
duke@435	1263	// We test for decrementing first, as we might have hit the target size
duke@435	1264	// limit.
duke@435	1265	if (decr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
duke@435	1266	if (tenuring_threshold > 1) {
duke@435	1267	tenuring_threshold--;
duke@435	1268	}
duke@435	1269	} else if (incr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
duke@435	1270	if (tenuring_threshold < MaxTenuringThreshold) {
duke@435	1271	tenuring_threshold++;
duke@435	1272	}
duke@435	1273	}
duke@435	1274
duke@435	1275	// We keep a running average of the amount promoted which is used
duke@435	1276	// to decide when we should collect the old generation (when
duke@435	1277	// the amount of old gen free space is less than what we expect to
duke@435	1278	// promote).
duke@435	1279
duke@435	1280	if (PrintAdaptiveSizePolicy) {
duke@435	1281	// A little more detail if Verbose is on
duke@435	1282	GenCollectedHeap* gch = GenCollectedHeap::heap();
duke@435	1283	if (Verbose) {
duke@435	1284	gclog_or_tty->print( " avg_survived: %f"
duke@435	1285	" avg_deviation: %f",
duke@435	1286	_avg_survived->average(),
duke@435	1287	_avg_survived->deviation());
duke@435	1288	}
duke@435	1289
duke@435	1290	gclog_or_tty->print( " avg_survived_padded_avg: %f",
duke@435	1291	_avg_survived->padded_average());
duke@435	1292
duke@435	1293	if (Verbose) {
duke@435	1294	gclog_or_tty->print( " avg_promoted_avg: %f"
duke@435	1295	" avg_promoted_dev: %f",
duke@435	1296	gch->gc_stats(1)->avg_promoted()->average(),
duke@435	1297	gch->gc_stats(1)->avg_promoted()->deviation());
duke@435	1298	}
duke@435	1299
duke@435	1300	gclog_or_tty->print( " avg_promoted_padded_avg: %f"
duke@435	1301	" avg_pretenured_padded_avg: %f"
duke@435	1302	" tenuring_thresh: %d"
duke@435	1303	" target_size: " SIZE_FORMAT
duke@435	1304	" survivor_limit: " SIZE_FORMAT,
duke@435	1305	gch->gc_stats(1)->avg_promoted()->padded_average(),
duke@435	1306	_avg_pretenured->padded_average(),
duke@435	1307	tenuring_threshold, target_size, survivor_limit);
duke@435	1308	gclog_or_tty->cr();
duke@435	1309	}
duke@435	1310
duke@435	1311	set_survivor_size(target_size);
duke@435	1312
duke@435	1313	return tenuring_threshold;
duke@435	1314	}
duke@435	1315
duke@435	1316	bool CMSAdaptiveSizePolicy::get_and_clear_first_after_collection() {
duke@435	1317	bool result = _first_after_collection;
duke@435	1318	_first_after_collection = false;
duke@435	1319	return result;
duke@435	1320	}
duke@435	1321
duke@435	1322	bool CMSAdaptiveSizePolicy::print_adaptive_size_policy_on(
duke@435	1323	outputStream* st) const {
duke@435	1324
duke@435	1325	if (!UseAdaptiveSizePolicy) return false;
duke@435	1326
duke@435	1327	GenCollectedHeap* gch = GenCollectedHeap::heap();
duke@435	1328	Generation* gen0 = gch->get_gen(0);
duke@435	1329	DefNewGeneration* def_new = gen0->as_DefNewGeneration();
duke@435	1330	return
duke@435	1331	AdaptiveSizePolicy::print_adaptive_size_policy_on(
duke@435	1332	st,
duke@435	1333	def_new->tenuring_threshold());
duke@435	1334	}