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

src/share/vm/gc_implementation/parallelScavenge/adjoiningGenerations.cpp@92ef81e2f571 (annotated)

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

Fri, 10 May 2013 08:27:30 -0700

author

minqi

date

Fri, 10 May 2013 08:27:30 -0700

changeset 5097

92ef81e2f571

parent 4037

da91efe96a93

child 6085

8f07aa079343

permissions

-rw-r--r--

8003557: NPG: Klass* const k should be const Klass* k.
Summary: With NPG, const KlassOop klass which is in fact a definition converted to Klass* const, which is not the original intention. The right usage is converting them to const Klass*.
Reviewed-by: coleenp, kvn
Contributed-by: yumin.qi@oracle.com

duke@435	1	/*
coleenp@4037	2	* Copyright (c) 2003, 2012, Oracle and/or its affiliates. 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	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#include "precompiled.hpp"
stefank@2314	26	#include "gc_implementation/parallelScavenge/adjoiningGenerations.hpp"
stefank@2314	27	#include "gc_implementation/parallelScavenge/adjoiningVirtualSpaces.hpp"
stefank@2314	28	#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
duke@435	29
duke@435	30	// If boundary moving is being used, create the young gen and old
duke@435	31	// gen with ASPSYoungGen and ASPSOldGen, respectively. Revert to
duke@435	32	// the old behavior otherwise (with PSYoungGen and PSOldGen).
duke@435	33
duke@435	34	AdjoiningGenerations::AdjoiningGenerations(ReservedSpace old_young_rs,
duke@435	35	size_t init_low_byte_size,
duke@435	36	size_t min_low_byte_size,
duke@435	37	size_t max_low_byte_size,
duke@435	38	size_t init_high_byte_size,
duke@435	39	size_t min_high_byte_size,
duke@435	40	size_t max_high_byte_size,
duke@435	41	size_t alignment) :
duke@435	42	_virtual_spaces(old_young_rs, min_low_byte_size,
duke@435	43	min_high_byte_size, alignment) {
duke@435	44	assert(min_low_byte_size <= init_low_byte_size &&
duke@435	45	init_low_byte_size <= max_low_byte_size, "Parameter check");
duke@435	46	assert(min_high_byte_size <= init_high_byte_size &&
duke@435	47	init_high_byte_size <= max_high_byte_size, "Parameter check");
duke@435	48	// Create the generations differently based on the option to
duke@435	49	// move the boundary.
duke@435	50	if (UseAdaptiveGCBoundary) {
duke@435	51	// Initialize the adjoining virtual spaces. Then pass the
duke@435	52	// a virtual to each generation for initialization of the
duke@435	53	// generation.
duke@435	54
duke@435	55	// Does the actual creation of the virtual spaces
duke@435	56	_virtual_spaces.initialize(max_low_byte_size,
duke@435	57	init_low_byte_size,
duke@435	58	init_high_byte_size);
duke@435	59
duke@435	60	// Place the young gen at the high end. Passes in the virtual space.
duke@435	61	_young_gen = new ASPSYoungGen(_virtual_spaces.high(),
duke@435	62	_virtual_spaces.high()->committed_size(),
duke@435	63	min_high_byte_size,
duke@435	64	_virtual_spaces.high_byte_size_limit());
duke@435	65
duke@435	66	// Place the old gen at the low end. Passes in the virtual space.
duke@435	67	_old_gen = new ASPSOldGen(_virtual_spaces.low(),
duke@435	68	_virtual_spaces.low()->committed_size(),
duke@435	69	min_low_byte_size,
duke@435	70	_virtual_spaces.low_byte_size_limit(),
duke@435	71	"old", 1);
duke@435	72
duke@435	73	young_gen()->initialize_work();
duke@435	74	assert(young_gen()->reserved().byte_size() <= young_gen()->gen_size_limit(),
duke@435	75	"Consistency check");
duke@435	76	assert(old_young_rs.size() >= young_gen()->gen_size_limit(),
duke@435	77	"Consistency check");
duke@435	78
duke@435	79	old_gen()->initialize_work("old", 1);
duke@435	80	assert(old_gen()->reserved().byte_size() <= old_gen()->gen_size_limit(),
duke@435	81	"Consistency check");
duke@435	82	assert(old_young_rs.size() >= old_gen()->gen_size_limit(),
duke@435	83	"Consistency check");
duke@435	84	} else {
duke@435	85
duke@435	86	// Layout the reserved space for the generations.
duke@435	87	ReservedSpace old_rs =
duke@435	88	virtual_spaces()->reserved_space().first_part(max_low_byte_size);
duke@435	89	ReservedSpace heap_rs =
duke@435	90	virtual_spaces()->reserved_space().last_part(max_low_byte_size);
duke@435	91	ReservedSpace young_rs = heap_rs.first_part(max_high_byte_size);
duke@435	92	assert(young_rs.size() == heap_rs.size(), "Didn't reserve all of the heap");
duke@435	93
duke@435	94	// Create the generations. Virtual spaces are not passed in.
duke@435	95	_young_gen = new PSYoungGen(init_high_byte_size,
duke@435	96	min_high_byte_size,
duke@435	97	max_high_byte_size);
duke@435	98	_old_gen = new PSOldGen(init_low_byte_size,
duke@435	99	min_low_byte_size,
duke@435	100	max_low_byte_size,
duke@435	101	"old", 1);
duke@435	102
duke@435	103	// The virtual spaces are created by the initialization of the gens.
duke@435	104	_young_gen->initialize(young_rs, alignment);
duke@435	105	assert(young_gen()->gen_size_limit() == young_rs.size(),
duke@435	106	"Consistency check");
duke@435	107	_old_gen->initialize(old_rs, alignment, "old", 1);
duke@435	108	assert(old_gen()->gen_size_limit() == old_rs.size(), "Consistency check");
duke@435	109	}
duke@435	110	}
duke@435	111
duke@435	112	size_t AdjoiningGenerations::reserved_byte_size() {
duke@435	113	return virtual_spaces()->reserved_space().size();
duke@435	114	}
duke@435	115
duke@435	116
duke@435	117	// Make checks on the current sizes of the generations and
duke@435	118	// the contraints on the sizes of the generations. Push
duke@435	119	// up the boundary within the contraints. A partial
duke@435	120	// push can occur.
duke@435	121	void AdjoiningGenerations::request_old_gen_expansion(size_t expand_in_bytes) {
duke@435	122	assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check");
duke@435	123
duke@435	124	assert_lock_strong(ExpandHeap_lock);
duke@435	125	assert_locked_or_safepoint(Heap_lock);
duke@435	126
duke@435	127	// These sizes limit the amount the boundaries can move. Effectively,
duke@435	128	// the generation says how much it is willing to yield to the other
duke@435	129	// generation.
duke@435	130	const size_t young_gen_available = young_gen()->available_for_contraction();
duke@435	131	const size_t old_gen_available = old_gen()->available_for_expansion();
duke@435	132	const size_t alignment = virtual_spaces()->alignment();
duke@435	133	size_t change_in_bytes = MIN3(young_gen_available,
duke@435	134	old_gen_available,
duke@435	135	align_size_up_(expand_in_bytes, alignment));
duke@435	136
duke@435	137	if (change_in_bytes == 0) {
duke@435	138	return;
duke@435	139	}
duke@435	140
duke@435	141	if (TraceAdaptiveGCBoundary) {
duke@435	142	gclog_or_tty->print_cr("Before expansion of old gen with boundary move");
duke@435	143	gclog_or_tty->print_cr(" Requested change: 0x%x Attempted change: 0x%x",
duke@435	144	expand_in_bytes, change_in_bytes);
duke@435	145	if (!PrintHeapAtGC) {
duke@435	146	Universe::print_on(gclog_or_tty);
duke@435	147	}
duke@435	148	gclog_or_tty->print_cr(" PSOldGen max size: " SIZE_FORMAT "K",
duke@435	149	old_gen()->max_gen_size()/K);
duke@435	150	}
duke@435	151
duke@435	152	// Move the boundary between the generations up (smaller young gen).
duke@435	153	if (virtual_spaces()->adjust_boundary_up(change_in_bytes)) {
duke@435	154	young_gen()->reset_after_change();
duke@435	155	old_gen()->reset_after_change();
duke@435	156	}
duke@435	157
duke@435	158	// The total reserved for the generations should match the sum
duke@435	159	// of the two even if the boundary is moving.
duke@435	160	assert(reserved_byte_size() ==
duke@435	161	old_gen()->max_gen_size() + young_gen()->max_size(),
duke@435	162	"Space is missing");
duke@435	163	young_gen()->space_invariants();
duke@435	164	old_gen()->space_invariants();
duke@435	165
duke@435	166	if (TraceAdaptiveGCBoundary) {
duke@435	167	gclog_or_tty->print_cr("After expansion of old gen with boundary move");
duke@435	168	if (!PrintHeapAtGC) {
duke@435	169	Universe::print_on(gclog_or_tty);
duke@435	170	}
duke@435	171	gclog_or_tty->print_cr(" PSOldGen max size: " SIZE_FORMAT "K",
duke@435	172	old_gen()->max_gen_size()/K);
duke@435	173	}
duke@435	174	}
duke@435	175
duke@435	176	// See comments on request_old_gen_expansion()
duke@435	177	bool AdjoiningGenerations::request_young_gen_expansion(size_t expand_in_bytes) {
duke@435	178	assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check");
duke@435	179
duke@435	180	// If eden is not empty, the boundary can be moved but no advantage
duke@435	181	// can be made of the move since eden cannot be moved.
duke@435	182	if (!young_gen()->eden_space()->is_empty()) {
duke@435	183	return false;
duke@435	184	}
duke@435	185
duke@435	186
duke@435	187	bool result = false;
duke@435	188	const size_t young_gen_available = young_gen()->available_for_expansion();
duke@435	189	const size_t old_gen_available = old_gen()->available_for_contraction();
duke@435	190	const size_t alignment = virtual_spaces()->alignment();
duke@435	191	size_t change_in_bytes = MIN3(young_gen_available,
duke@435	192	old_gen_available,
duke@435	193	align_size_up_(expand_in_bytes, alignment));
duke@435	194
duke@435	195	if (change_in_bytes == 0) {
duke@435	196	return false;
duke@435	197	}
duke@435	198
duke@435	199	if (TraceAdaptiveGCBoundary) {
duke@435	200	gclog_or_tty->print_cr("Before expansion of young gen with boundary move");
duke@435	201	gclog_or_tty->print_cr(" Requested change: 0x%x Attempted change: 0x%x",
duke@435	202	expand_in_bytes, change_in_bytes);
duke@435	203	if (!PrintHeapAtGC) {
duke@435	204	Universe::print_on(gclog_or_tty);
duke@435	205	}
duke@435	206	gclog_or_tty->print_cr(" PSYoungGen max size: " SIZE_FORMAT "K",
duke@435	207	young_gen()->max_size()/K);
duke@435	208	}
duke@435	209
duke@435	210	// Move the boundary between the generations down (smaller old gen).
duke@435	211	MutexLocker x(ExpandHeap_lock);
duke@435	212	if (virtual_spaces()->adjust_boundary_down(change_in_bytes)) {
duke@435	213	young_gen()->reset_after_change();
duke@435	214	old_gen()->reset_after_change();
duke@435	215	result = true;
duke@435	216	}
duke@435	217
duke@435	218	// The total reserved for the generations should match the sum
duke@435	219	// of the two even if the boundary is moving.
duke@435	220	assert(reserved_byte_size() ==
duke@435	221	old_gen()->max_gen_size() + young_gen()->max_size(),
duke@435	222	"Space is missing");
duke@435	223	young_gen()->space_invariants();
duke@435	224	old_gen()->space_invariants();
duke@435	225
duke@435	226	if (TraceAdaptiveGCBoundary) {
duke@435	227	gclog_or_tty->print_cr("After expansion of young gen with boundary move");
duke@435	228	if (!PrintHeapAtGC) {
duke@435	229	Universe::print_on(gclog_or_tty);
duke@435	230	}
duke@435	231	gclog_or_tty->print_cr(" PSYoungGen max size: " SIZE_FORMAT "K",
duke@435	232	young_gen()->max_size()/K);
duke@435	233	}
duke@435	234
duke@435	235	return result;
duke@435	236	}
duke@435	237
duke@435	238	// Additional space is needed in the old generation. Try to move the boundary
duke@435	239	// up to meet the need. Moves boundary up only
duke@435	240	void AdjoiningGenerations::adjust_boundary_for_old_gen_needs(
duke@435	241	size_t desired_free_space) {
duke@435	242	assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check");
duke@435	243
duke@435	244	// Stress testing.
duke@435	245	if (PSAdaptiveSizePolicyResizeVirtualSpaceAlot == 1) {
duke@435	246	MutexLocker x(ExpandHeap_lock);
duke@435	247	request_old_gen_expansion(virtual_spaces()->alignment() * 3 / 2);
duke@435	248	}
duke@435	249
duke@435	250	// Expand only if the entire generation is already committed.
duke@435	251	if (old_gen()->virtual_space()->uncommitted_size() == 0) {
duke@435	252	if (old_gen()->free_in_bytes() < desired_free_space) {
duke@435	253	MutexLocker x(ExpandHeap_lock);
duke@435	254	request_old_gen_expansion(desired_free_space);
duke@435	255	}
duke@435	256	}
duke@435	257	}
duke@435	258
duke@435	259	// See comment on adjust_boundary_for_old_gen_needss().
duke@435	260	// Adjust boundary down only.
duke@435	261	void AdjoiningGenerations::adjust_boundary_for_young_gen_needs(size_t eden_size,
duke@435	262	size_t survivor_size) {
duke@435	263
duke@435	264	assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check");
duke@435	265
duke@435	266	// Stress testing.
duke@435	267	if (PSAdaptiveSizePolicyResizeVirtualSpaceAlot == 0) {
duke@435	268	request_young_gen_expansion(virtual_spaces()->alignment() * 3 / 2);
duke@435	269	eden_size = young_gen()->eden_space()->capacity_in_bytes();
duke@435	270	}
duke@435	271
duke@435	272	// Expand only if the entire generation is already committed.
duke@435	273	if (young_gen()->virtual_space()->uncommitted_size() == 0) {
duke@435	274	size_t desired_size = eden_size + 2 * survivor_size;
duke@435	275	const size_t committed = young_gen()->virtual_space()->committed_size();
duke@435	276	if (desired_size > committed) {
duke@435	277	request_young_gen_expansion(desired_size - committed);
duke@435	278	}
duke@435	279	}
duke@435	280	}