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

src/share/vm/gc_implementation/parallelScavenge/asPSYoungGen.cpp@1fdb98a17101 (annotated)

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

Sat, 19 Jul 2008 17:38:22 -0400

author

coleenp

date

Sat, 19 Jul 2008 17:38:22 -0400

changeset 672

1fdb98a17101

parent 631

d1605aabd0a1

child 704

850fdf70db2b

permissions

-rw-r--r--

6716785: implicit null checks not triggering with CompressedOops
Summary: allocate alignment-sized page(s) below java heap so that memory accesses at heap_base+1page give signal and cause an implicit null check
Reviewed-by: kvn, jmasa, phh, jcoomes

duke@435	1	/*
xdono@631	2	* Copyright 2003-2008 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/_asPSYoungGen.cpp.incl"
duke@435	27
duke@435	28	ASPSYoungGen::ASPSYoungGen(size_t init_byte_size,
duke@435	29	size_t minimum_byte_size,
duke@435	30	size_t byte_size_limit) :
duke@435	31	PSYoungGen(init_byte_size, minimum_byte_size, byte_size_limit),
duke@435	32	_gen_size_limit(byte_size_limit) {
duke@435	33	}
duke@435	34
duke@435	35
duke@435	36	ASPSYoungGen::ASPSYoungGen(PSVirtualSpace* vs,
duke@435	37	size_t init_byte_size,
duke@435	38	size_t minimum_byte_size,
duke@435	39	size_t byte_size_limit) :
duke@435	40	//PSYoungGen(init_byte_size, minimum_byte_size, byte_size_limit),
duke@435	41	PSYoungGen(vs->committed_size(), minimum_byte_size, byte_size_limit),
duke@435	42	_gen_size_limit(byte_size_limit) {
duke@435	43
duke@435	44	assert(vs->committed_size() == init_byte_size, "Cannot replace with");
duke@435	45
duke@435	46	_virtual_space = vs;
duke@435	47	}
duke@435	48
duke@435	49	void ASPSYoungGen::initialize_virtual_space(ReservedSpace rs,
duke@435	50	size_t alignment) {
duke@435	51	assert(_init_gen_size != 0, "Should have a finite size");
duke@435	52	_virtual_space = new PSVirtualSpaceHighToLow(rs, alignment);
duke@435	53	if (!_virtual_space->expand_by(_init_gen_size)) {
duke@435	54	vm_exit_during_initialization("Could not reserve enough space for "
duke@435	55	"object heap");
duke@435	56	}
duke@435	57	}
duke@435	58
duke@435	59	void ASPSYoungGen::initialize(ReservedSpace rs, size_t alignment) {
duke@435	60	initialize_virtual_space(rs, alignment);
duke@435	61	initialize_work();
duke@435	62	}
duke@435	63
duke@435	64	size_t ASPSYoungGen::available_for_expansion() {
duke@435	65
duke@435	66	size_t current_committed_size = virtual_space()->committed_size();
duke@435	67	assert((gen_size_limit() >= current_committed_size),
duke@435	68	"generation size limit is wrong");
duke@435	69	ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
duke@435	70	size_t result = gen_size_limit() - current_committed_size;
duke@435	71	size_t result_aligned = align_size_down(result, heap->young_gen_alignment());
duke@435	72	return result_aligned;
duke@435	73	}
duke@435	74
duke@435	75	// Return the number of bytes the young gen is willing give up.
duke@435	76	//
duke@435	77	// Future implementations could check the survivors and if to_space is in the
duke@435	78	// right place (below from_space), take a chunk from to_space.
duke@435	79	size_t ASPSYoungGen::available_for_contraction() {
duke@435	80
duke@435	81	size_t uncommitted_bytes = virtual_space()->uncommitted_size();
duke@435	82	if (uncommitted_bytes != 0) {
duke@435	83	return uncommitted_bytes;
duke@435	84	}
duke@435	85
duke@435	86	if (eden_space()->is_empty()) {
duke@435	87	// Respect the minimum size for eden and for the young gen as a whole.
duke@435	88	ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
jmasa@448	89	const size_t eden_alignment = heap->intra_heap_alignment();
duke@435	90	const size_t gen_alignment = heap->young_gen_alignment();
duke@435	91
duke@435	92	assert(eden_space()->capacity_in_bytes() >= eden_alignment,
duke@435	93	"Alignment is wrong");
duke@435	94	size_t eden_avail = eden_space()->capacity_in_bytes() - eden_alignment;
duke@435	95	eden_avail = align_size_down(eden_avail, gen_alignment);
duke@435	96
duke@435	97	assert(virtual_space()->committed_size() >= min_gen_size(),
duke@435	98	"minimum gen size is wrong");
duke@435	99	size_t gen_avail = virtual_space()->committed_size() - min_gen_size();
duke@435	100	assert(virtual_space()->is_aligned(gen_avail), "not aligned");
duke@435	101
duke@435	102	const size_t max_contraction = MIN2(eden_avail, gen_avail);
duke@435	103	// See comment for ASPSOldGen::available_for_contraction()
duke@435	104	// for reasons the "increment" fraction is used.
duke@435	105	PSAdaptiveSizePolicy* policy = heap->size_policy();
duke@435	106	size_t result = policy->eden_increment_aligned_down(max_contraction);
duke@435	107	size_t result_aligned = align_size_down(result, gen_alignment);
duke@435	108	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	109	gclog_or_tty->print_cr("ASPSYoungGen::available_for_contraction: %d K",
duke@435	110	result_aligned/K);
duke@435	111	gclog_or_tty->print_cr(" max_contraction %d K", max_contraction/K);
duke@435	112	gclog_or_tty->print_cr(" eden_avail %d K", eden_avail/K);
duke@435	113	gclog_or_tty->print_cr(" gen_avail %d K", gen_avail/K);
duke@435	114	}
duke@435	115	return result_aligned;
duke@435	116
duke@435	117	}
duke@435	118
duke@435	119	return 0;
duke@435	120	}
duke@435	121
duke@435	122	// The current implementation only considers to the end of eden.
duke@435	123	// If to_space is below from_space, to_space is not considered.
duke@435	124	// to_space can be.
duke@435	125	size_t ASPSYoungGen::available_to_live() {
duke@435	126	ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
jmasa@448	127	const size_t alignment = heap->intra_heap_alignment();
duke@435	128
duke@435	129	// Include any space that is committed but is not in eden.
duke@435	130	size_t available = pointer_delta(eden_space()->bottom(),
duke@435	131	virtual_space()->low(),
duke@435	132	sizeof(char));
duke@435	133
duke@435	134	const size_t eden_capacity = eden_space()->capacity_in_bytes();
duke@435	135	if (eden_space()->is_empty() && eden_capacity > alignment) {
duke@435	136	available += eden_capacity - alignment;
duke@435	137	}
duke@435	138	return available;
duke@435	139	}
duke@435	140
duke@435	141	// Similar to PSYoungGen::resize_generation() but
duke@435	142	// allows sum of eden_size and 2 * survivor_size to exceed _max_gen_size
duke@435	143	// expands at the low end of the virtual space
duke@435	144	// moves the boundary between the generations in order to expand
duke@435	145	// some additional diagnostics
duke@435	146	// If no additional changes are required, this can be deleted
duke@435	147	// and the changes factored back into PSYoungGen::resize_generation().
duke@435	148	bool ASPSYoungGen::resize_generation(size_t eden_size, size_t survivor_size) {
duke@435	149	const size_t alignment = virtual_space()->alignment();
duke@435	150	size_t orig_size = virtual_space()->committed_size();
duke@435	151	bool size_changed = false;
duke@435	152
duke@435	153	// There used to be a guarantee here that
duke@435	154	// (eden_size + 2*survivor_size) <= _max_gen_size
duke@435	155	// This requirement is enforced by the calculation of desired_size
duke@435	156	// below. It may not be true on entry since the size of the
duke@435	157	// eden_size is no bounded by the generation size.
duke@435	158
duke@435	159	assert(max_size() == reserved().byte_size(), "max gen size problem?");
duke@435	160	assert(min_gen_size() <= orig_size && orig_size <= max_size(),
duke@435	161	"just checking");
duke@435	162
duke@435	163	// Adjust new generation size
duke@435	164	const size_t eden_plus_survivors =
duke@435	165	align_size_up(eden_size + 2 * survivor_size, alignment);
duke@435	166	size_t desired_size = MAX2(MIN2(eden_plus_survivors, gen_size_limit()),
duke@435	167	min_gen_size());
duke@435	168	assert(desired_size <= gen_size_limit(), "just checking");
duke@435	169
duke@435	170	if (desired_size > orig_size) {
duke@435	171	// Grow the generation
duke@435	172	size_t change = desired_size - orig_size;
duke@435	173	if (!virtual_space()->expand_by(change)) {
duke@435	174	return false;
duke@435	175	}
duke@435	176	size_changed = true;
duke@435	177	} else if (desired_size < orig_size) {
duke@435	178	size_t desired_change = orig_size - desired_size;
duke@435	179
duke@435	180	// How much is available for shrinking.
duke@435	181	size_t available_bytes = limit_gen_shrink(desired_change);
duke@435	182	size_t change = MIN2(desired_change, available_bytes);
duke@435	183	virtual_space()->shrink_by(change);
duke@435	184	size_changed = true;
duke@435	185	} else {
duke@435	186	if (Verbose && PrintGC) {
duke@435	187	if (orig_size == gen_size_limit()) {
duke@435	188	gclog_or_tty->print_cr("ASPSYoung generation size at maximum: "
duke@435	189	SIZE_FORMAT "K", orig_size/K);
duke@435	190	} else if (orig_size == min_gen_size()) {
duke@435	191	gclog_or_tty->print_cr("ASPSYoung generation size at minium: "
duke@435	192	SIZE_FORMAT "K", orig_size/K);
duke@435	193	}
duke@435	194	}
duke@435	195	}
duke@435	196
duke@435	197	if (size_changed) {
duke@435	198	reset_after_change();
duke@435	199	if (Verbose && PrintGC) {
duke@435	200	size_t current_size = virtual_space()->committed_size();
duke@435	201	gclog_or_tty->print_cr("ASPSYoung generation size changed: "
duke@435	202	SIZE_FORMAT "K->" SIZE_FORMAT "K",
duke@435	203	orig_size/K, current_size/K);
duke@435	204	}
duke@435	205	}
duke@435	206
duke@435	207	guarantee(eden_plus_survivors <= virtual_space()->committed_size() ||
duke@435	208	virtual_space()->committed_size() == max_size(), "Sanity");
duke@435	209
duke@435	210	return true;
duke@435	211	}
duke@435	212
duke@435	213	// Similar to PSYoungGen::resize_spaces() but
duke@435	214	// eden always starts at the low end of the committed virtual space
duke@435	215	// current implementation does not allow holes between the spaces
duke@435	216	// _young_generation_boundary has to be reset because it changes.
duke@435	217	// so additional verification
duke@435	218	void ASPSYoungGen::resize_spaces(size_t requested_eden_size,
duke@435	219	size_t requested_survivor_size) {
duke@435	220	assert(requested_eden_size > 0 && requested_survivor_size > 0,
duke@435	221	"just checking");
duke@435	222
duke@435	223	space_invariants();
duke@435	224
duke@435	225	// We require eden and to space to be empty
duke@435	226	if ((!eden_space()->is_empty()) || (!to_space()->is_empty())) {
duke@435	227	return;
duke@435	228	}
duke@435	229
duke@435	230	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	231	gclog_or_tty->print_cr("PSYoungGen::resize_spaces(requested_eden_size: "
duke@435	232	SIZE_FORMAT
duke@435	233	", requested_survivor_size: " SIZE_FORMAT ")",
duke@435	234	requested_eden_size, requested_survivor_size);
duke@435	235	gclog_or_tty->print_cr(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") "
duke@435	236	SIZE_FORMAT,
duke@435	237	eden_space()->bottom(),
duke@435	238	eden_space()->end(),
duke@435	239	pointer_delta(eden_space()->end(),
duke@435	240	eden_space()->bottom(),
duke@435	241	sizeof(char)));
duke@435	242	gclog_or_tty->print_cr(" from: [" PTR_FORMAT ".." PTR_FORMAT ") "
duke@435	243	SIZE_FORMAT,
duke@435	244	from_space()->bottom(),
duke@435	245	from_space()->end(),
duke@435	246	pointer_delta(from_space()->end(),
duke@435	247	from_space()->bottom(),
duke@435	248	sizeof(char)));
duke@435	249	gclog_or_tty->print_cr(" to: [" PTR_FORMAT ".." PTR_FORMAT ") "
duke@435	250	SIZE_FORMAT,
duke@435	251	to_space()->bottom(),
duke@435	252	to_space()->end(),
duke@435	253	pointer_delta( to_space()->end(),
duke@435	254	to_space()->bottom(),
duke@435	255	sizeof(char)));
duke@435	256	}
duke@435	257
duke@435	258	// There's nothing to do if the new sizes are the same as the current
duke@435	259	if (requested_survivor_size == to_space()->capacity_in_bytes() &&
duke@435	260	requested_survivor_size == from_space()->capacity_in_bytes() &&
duke@435	261	requested_eden_size == eden_space()->capacity_in_bytes()) {
duke@435	262	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	263	gclog_or_tty->print_cr(" capacities are the right sizes, returning");
duke@435	264	}
duke@435	265	return;
duke@435	266	}
duke@435	267
duke@435	268	char* eden_start = (char*)virtual_space()->low();
duke@435	269	char* eden_end = (char*)eden_space()->end();
duke@435	270	char* from_start = (char*)from_space()->bottom();
duke@435	271	char* from_end = (char*)from_space()->end();
duke@435	272	char* to_start = (char*)to_space()->bottom();
duke@435	273	char* to_end = (char*)to_space()->end();
duke@435	274
duke@435	275	assert(eden_start < from_start, "Cannot push into from_space");
duke@435	276
duke@435	277	ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
jmasa@448	278	const size_t alignment = heap->intra_heap_alignment();
duke@435	279
duke@435	280	// Check whether from space is below to space
duke@435	281	if (from_start < to_start) {
duke@435	282	// Eden, from, to
duke@435	283	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	284	gclog_or_tty->print_cr(" Eden, from, to:");
duke@435	285	}
duke@435	286
duke@435	287	// Set eden
duke@435	288	// Compute how big eden can be, then adjust end.
duke@435	289	// See comment in PSYoungGen::resize_spaces() on
duke@435	290	// calculating eden_end.
duke@435	291	const size_t eden_size = MIN2(requested_eden_size,
duke@435	292	pointer_delta(from_start,
duke@435	293	eden_start,
duke@435	294	sizeof(char)));
duke@435	295	eden_end = eden_start + eden_size;
duke@435	296	assert(eden_end >= eden_start, "addition overflowed")
duke@435	297
duke@435	298	// To may resize into from space as long as it is clear of live data.
duke@435	299	// From space must remain page aligned, though, so we need to do some
duke@435	300	// extra calculations.
duke@435	301
duke@435	302	// First calculate an optimal to-space
duke@435	303	to_end = (char*)virtual_space()->high();
duke@435	304	to_start = (char*)pointer_delta(to_end,
duke@435	305	(char*)requested_survivor_size,
duke@435	306	sizeof(char));
duke@435	307
duke@435	308	// Does the optimal to-space overlap from-space?
duke@435	309	if (to_start < (char*)from_space()->end()) {
duke@435	310	assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
duke@435	311
duke@435	312	// Calculate the minimum offset possible for from_end
duke@435	313	size_t from_size =
duke@435	314	pointer_delta(from_space()->top(), from_start, sizeof(char));
duke@435	315
duke@435	316	// Should we be in this method if from_space is empty? Why not the set_space method? FIX ME!
duke@435	317	if (from_size == 0) {
duke@435	318	from_size = alignment;
duke@435	319	} else {
duke@435	320	from_size = align_size_up(from_size, alignment);
duke@435	321	}
duke@435	322
duke@435	323	from_end = from_start + from_size;
duke@435	324	assert(from_end > from_start, "addition overflow or from_size problem");
duke@435	325
duke@435	326	guarantee(from_end <= (char*)from_space()->end(),
duke@435	327	"from_end moved to the right");
duke@435	328
duke@435	329	// Now update to_start with the new from_end
duke@435	330	to_start = MAX2(from_end, to_start);
duke@435	331	}
duke@435	332
duke@435	333	guarantee(to_start != to_end, "to space is zero sized");
duke@435	334
duke@435	335	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	336	gclog_or_tty->print_cr(" [eden_start .. eden_end): "
duke@435	337	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	338	eden_start,
duke@435	339	eden_end,
duke@435	340	pointer_delta(eden_end, eden_start, sizeof(char)));
duke@435	341	gclog_or_tty->print_cr(" [from_start .. from_end): "
duke@435	342	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	343	from_start,
duke@435	344	from_end,
duke@435	345	pointer_delta(from_end, from_start, sizeof(char)));
duke@435	346	gclog_or_tty->print_cr(" [ to_start .. to_end): "
duke@435	347	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	348	to_start,
duke@435	349	to_end,
duke@435	350	pointer_delta( to_end, to_start, sizeof(char)));
duke@435	351	}
duke@435	352	} else {
duke@435	353	// Eden, to, from
duke@435	354	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	355	gclog_or_tty->print_cr(" Eden, to, from:");
duke@435	356	}
duke@435	357
duke@435	358	// To space gets priority over eden resizing. Note that we position
duke@435	359	// to space as if we were able to resize from space, even though from
duke@435	360	// space is not modified.
duke@435	361	// Giving eden priority was tried and gave poorer performance.
duke@435	362	to_end = (char*)pointer_delta(virtual_space()->high(),
duke@435	363	(char*)requested_survivor_size,
duke@435	364	sizeof(char));
duke@435	365	to_end = MIN2(to_end, from_start);
duke@435	366	to_start = (char*)pointer_delta(to_end, (char*)requested_survivor_size,
duke@435	367	sizeof(char));
duke@435	368	// if the space sizes are to be increased by several times then
duke@435	369	// 'to_start' will point beyond the young generation. In this case
duke@435	370	// 'to_start' should be adjusted.
duke@435	371	to_start = MAX2(to_start, eden_start + alignment);
duke@435	372
duke@435	373	// Compute how big eden can be, then adjust end.
duke@435	374	// See comment in PSYoungGen::resize_spaces() on
duke@435	375	// calculating eden_end.
duke@435	376	const size_t eden_size = MIN2(requested_eden_size,
duke@435	377	pointer_delta(to_start,
duke@435	378	eden_start,
duke@435	379	sizeof(char)));
duke@435	380	eden_end = eden_start + eden_size;
duke@435	381	assert(eden_end >= eden_start, "addition overflowed")
duke@435	382
duke@435	383	// Don't let eden shrink down to 0 or less.
duke@435	384	eden_end = MAX2(eden_end, eden_start + alignment);
duke@435	385	to_start = MAX2(to_start, eden_end);
duke@435	386
duke@435	387	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	388	gclog_or_tty->print_cr(" [eden_start .. eden_end): "
duke@435	389	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	390	eden_start,
duke@435	391	eden_end,
duke@435	392	pointer_delta(eden_end, eden_start, sizeof(char)));
duke@435	393	gclog_or_tty->print_cr(" [ to_start .. to_end): "
duke@435	394	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	395	to_start,
duke@435	396	to_end,
duke@435	397	pointer_delta( to_end, to_start, sizeof(char)));
duke@435	398	gclog_or_tty->print_cr(" [from_start .. from_end): "
duke@435	399	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	400	from_start,
duke@435	401	from_end,
duke@435	402	pointer_delta(from_end, from_start, sizeof(char)));
duke@435	403	}
duke@435	404	}
duke@435	405
duke@435	406
duke@435	407	guarantee((HeapWord*)from_start <= from_space()->bottom(),
duke@435	408	"from start moved to the right");
duke@435	409	guarantee((HeapWord*)from_end >= from_space()->top(),
duke@435	410	"from end moved into live data");
duke@435	411	assert(is_object_aligned((intptr_t)eden_start), "checking alignment");
duke@435	412	assert(is_object_aligned((intptr_t)from_start), "checking alignment");
duke@435	413	assert(is_object_aligned((intptr_t)to_start), "checking alignment");
duke@435	414
duke@435	415	MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)eden_end);
duke@435	416	MemRegion toMR ((HeapWord*)to_start, (HeapWord*)to_end);
duke@435	417	MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);
duke@435	418
duke@435	419	// Let's make sure the call to initialize doesn't reset "top"!
duke@435	420	DEBUG_ONLY(HeapWord* old_from_top = from_space()->top();)
duke@435	421
duke@435	422	// For PrintAdaptiveSizePolicy block below
duke@435	423	size_t old_from = from_space()->capacity_in_bytes();
duke@435	424	size_t old_to = to_space()->capacity_in_bytes();
duke@435	425
duke@435	426	eden_space()->initialize(edenMR, true);
duke@435	427	to_space()->initialize(toMR , true);
duke@435	428	from_space()->initialize(fromMR, false); // Note, not cleared!
duke@435	429	PSScavenge::set_young_generation_boundary(eden_space()->bottom());
duke@435	430
duke@435	431	assert(from_space()->top() == old_from_top, "from top changed!");
duke@435	432
duke@435	433	if (PrintAdaptiveSizePolicy) {
duke@435	434	ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
duke@435	435	assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
duke@435	436
duke@435	437	gclog_or_tty->print("AdaptiveSizePolicy::survivor space sizes: "
duke@435	438	"collection: %d "
duke@435	439	"(" SIZE_FORMAT ", " SIZE_FORMAT ") -> "
duke@435	440	"(" SIZE_FORMAT ", " SIZE_FORMAT ") ",
duke@435	441	heap->total_collections(),
duke@435	442	old_from, old_to,
duke@435	443	from_space()->capacity_in_bytes(),
duke@435	444	to_space()->capacity_in_bytes());
duke@435	445	gclog_or_tty->cr();
duke@435	446	}
duke@435	447	space_invariants();
duke@435	448	}
duke@435	449
duke@435	450	void ASPSYoungGen::reset_after_change() {
duke@435	451	assert_locked_or_safepoint(Heap_lock);
duke@435	452
duke@435	453	_reserved = MemRegion((HeapWord*)virtual_space()->low_boundary(),
duke@435	454	(HeapWord*)virtual_space()->high_boundary());
duke@435	455	PSScavenge::reference_processor()->set_span(_reserved);
duke@435	456
duke@435	457	HeapWord* new_eden_bottom = (HeapWord*)virtual_space()->low();
duke@435	458	HeapWord* eden_bottom = eden_space()->bottom();
duke@435	459	if (new_eden_bottom != eden_bottom) {
duke@435	460	MemRegion eden_mr(new_eden_bottom, eden_space()->end());
duke@435	461	eden_space()->initialize(eden_mr, true);
duke@435	462	PSScavenge::set_young_generation_boundary(eden_space()->bottom());
duke@435	463	}
duke@435	464	MemRegion cmr((HeapWord*)virtual_space()->low(),
duke@435	465	(HeapWord*)virtual_space()->high());
duke@435	466	Universe::heap()->barrier_set()->resize_covered_region(cmr);
duke@435	467
duke@435	468	space_invariants();
duke@435	469	}