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

src/share/vm/gc_implementation/parallelScavenge/asPSYoungGen.cpp@27a80744a83b (annotated)

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

Mon, 01 Dec 2008 23:25:24 -0800

author

ysr

date

Mon, 01 Dec 2008 23:25:24 -0800

changeset 892

27a80744a83b

parent 704

850fdf70db2b

child 1844

cff162798819

permissions

-rw-r--r--

6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
Summary: Renamed Reference{Policy,Pocessor} methods from snap{,_policy}() to setup{,_policy}()
Reviewed-by: apetrusenko

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;
jmasa@698	173	HeapWord* prev_low = (HeapWord*) virtual_space()->low();
duke@435	174	if (!virtual_space()->expand_by(change)) {
duke@435	175	return false;
duke@435	176	}
jmasa@698	177	if (ZapUnusedHeapArea) {
jmasa@698	178	// Mangle newly committed space immediately because it
jmasa@698	179	// can be done here more simply that after the new
jmasa@698	180	// spaces have been computed.
jmasa@698	181	HeapWord* new_low = (HeapWord*) virtual_space()->low();
jmasa@698	182	assert(new_low < prev_low, "Did not grow");
jmasa@698	183
jmasa@698	184	MemRegion mangle_region(new_low, prev_low);
jmasa@698	185	SpaceMangler::mangle_region(mangle_region);
jmasa@698	186	}
duke@435	187	size_changed = true;
duke@435	188	} else if (desired_size < orig_size) {
duke@435	189	size_t desired_change = orig_size - desired_size;
duke@435	190
duke@435	191	// How much is available for shrinking.
duke@435	192	size_t available_bytes = limit_gen_shrink(desired_change);
duke@435	193	size_t change = MIN2(desired_change, available_bytes);
duke@435	194	virtual_space()->shrink_by(change);
duke@435	195	size_changed = true;
duke@435	196	} else {
duke@435	197	if (Verbose && PrintGC) {
duke@435	198	if (orig_size == gen_size_limit()) {
duke@435	199	gclog_or_tty->print_cr("ASPSYoung generation size at maximum: "
duke@435	200	SIZE_FORMAT "K", orig_size/K);
duke@435	201	} else if (orig_size == min_gen_size()) {
duke@435	202	gclog_or_tty->print_cr("ASPSYoung generation size at minium: "
duke@435	203	SIZE_FORMAT "K", orig_size/K);
duke@435	204	}
duke@435	205	}
duke@435	206	}
duke@435	207
duke@435	208	if (size_changed) {
duke@435	209	reset_after_change();
duke@435	210	if (Verbose && PrintGC) {
duke@435	211	size_t current_size = virtual_space()->committed_size();
duke@435	212	gclog_or_tty->print_cr("ASPSYoung generation size changed: "
duke@435	213	SIZE_FORMAT "K->" SIZE_FORMAT "K",
duke@435	214	orig_size/K, current_size/K);
duke@435	215	}
duke@435	216	}
duke@435	217
duke@435	218	guarantee(eden_plus_survivors <= virtual_space()->committed_size() ||
duke@435	219	virtual_space()->committed_size() == max_size(), "Sanity");
duke@435	220
duke@435	221	return true;
duke@435	222	}
duke@435	223
duke@435	224	// Similar to PSYoungGen::resize_spaces() but
duke@435	225	// eden always starts at the low end of the committed virtual space
duke@435	226	// current implementation does not allow holes between the spaces
duke@435	227	// _young_generation_boundary has to be reset because it changes.
duke@435	228	// so additional verification
jmasa@698	229
duke@435	230	void ASPSYoungGen::resize_spaces(size_t requested_eden_size,
duke@435	231	size_t requested_survivor_size) {
jmasa@698	232	assert(UseAdaptiveSizePolicy, "sanity check");
duke@435	233	assert(requested_eden_size > 0 && requested_survivor_size > 0,
duke@435	234	"just checking");
duke@435	235
duke@435	236	space_invariants();
duke@435	237
duke@435	238	// We require eden and to space to be empty
duke@435	239	if ((!eden_space()->is_empty()) || (!to_space()->is_empty())) {
duke@435	240	return;
duke@435	241	}
duke@435	242
duke@435	243	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	244	gclog_or_tty->print_cr("PSYoungGen::resize_spaces(requested_eden_size: "
duke@435	245	SIZE_FORMAT
duke@435	246	", requested_survivor_size: " SIZE_FORMAT ")",
duke@435	247	requested_eden_size, requested_survivor_size);
duke@435	248	gclog_or_tty->print_cr(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") "
duke@435	249	SIZE_FORMAT,
duke@435	250	eden_space()->bottom(),
duke@435	251	eden_space()->end(),
duke@435	252	pointer_delta(eden_space()->end(),
duke@435	253	eden_space()->bottom(),
duke@435	254	sizeof(char)));
duke@435	255	gclog_or_tty->print_cr(" from: [" PTR_FORMAT ".." PTR_FORMAT ") "
duke@435	256	SIZE_FORMAT,
duke@435	257	from_space()->bottom(),
duke@435	258	from_space()->end(),
duke@435	259	pointer_delta(from_space()->end(),
duke@435	260	from_space()->bottom(),
duke@435	261	sizeof(char)));
duke@435	262	gclog_or_tty->print_cr(" to: [" PTR_FORMAT ".." PTR_FORMAT ") "
duke@435	263	SIZE_FORMAT,
duke@435	264	to_space()->bottom(),
duke@435	265	to_space()->end(),
duke@435	266	pointer_delta( to_space()->end(),
duke@435	267	to_space()->bottom(),
duke@435	268	sizeof(char)));
duke@435	269	}
duke@435	270
duke@435	271	// There's nothing to do if the new sizes are the same as the current
duke@435	272	if (requested_survivor_size == to_space()->capacity_in_bytes() &&
duke@435	273	requested_survivor_size == from_space()->capacity_in_bytes() &&
duke@435	274	requested_eden_size == eden_space()->capacity_in_bytes()) {
duke@435	275	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	276	gclog_or_tty->print_cr(" capacities are the right sizes, returning");
duke@435	277	}
duke@435	278	return;
duke@435	279	}
duke@435	280
duke@435	281	char* eden_start = (char*)virtual_space()->low();
duke@435	282	char* eden_end = (char*)eden_space()->end();
duke@435	283	char* from_start = (char*)from_space()->bottom();
duke@435	284	char* from_end = (char*)from_space()->end();
duke@435	285	char* to_start = (char*)to_space()->bottom();
duke@435	286	char* to_end = (char*)to_space()->end();
duke@435	287
duke@435	288	assert(eden_start < from_start, "Cannot push into from_space");
duke@435	289
duke@435	290	ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
jmasa@448	291	const size_t alignment = heap->intra_heap_alignment();
jmasa@698	292	const bool maintain_minimum =
jmasa@698	293	(requested_eden_size + 2 * requested_survivor_size) <= min_gen_size();
duke@435	294
jmasa@698	295	bool eden_from_to_order = from_start < to_start;
duke@435	296	// Check whether from space is below to space
jmasa@698	297	if (eden_from_to_order) {
duke@435	298	// Eden, from, to
jmasa@698	299
duke@435	300	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	301	gclog_or_tty->print_cr(" Eden, from, to:");
duke@435	302	}
duke@435	303
duke@435	304	// Set eden
jmasa@698	305	// "requested_eden_size" is a goal for the size of eden
jmasa@698	306	// and may not be attainable. "eden_size" below is
jmasa@698	307	// calculated based on the location of from-space and
jmasa@698	308	// the goal for the size of eden. from-space is
jmasa@698	309	// fixed in place because it contains live data.
jmasa@698	310	// The calculation is done this way to avoid 32bit
jmasa@698	311	// overflow (i.e., eden_start + requested_eden_size
jmasa@698	312	// may too large for representation in 32bits).
jmasa@698	313	size_t eden_size;
jmasa@698	314	if (maintain_minimum) {
jmasa@698	315	// Only make eden larger than the requested size if
jmasa@698	316	// the minimum size of the generation has to be maintained.
jmasa@698	317	// This could be done in general but policy at a higher
jmasa@698	318	// level is determining a requested size for eden and that
jmasa@698	319	// should be honored unless there is a fundamental reason.
jmasa@698	320	eden_size = pointer_delta(from_start,
jmasa@698	321	eden_start,
jmasa@698	322	sizeof(char));
jmasa@698	323	} else {
jmasa@698	324	eden_size = MIN2(requested_eden_size,
jmasa@698	325	pointer_delta(from_start, eden_start, sizeof(char)));
jmasa@698	326	}
jmasa@698	327
duke@435	328	eden_end = eden_start + eden_size;
duke@435	329	assert(eden_end >= eden_start, "addition overflowed")
duke@435	330
duke@435	331	// To may resize into from space as long as it is clear of live data.
duke@435	332	// From space must remain page aligned, though, so we need to do some
duke@435	333	// extra calculations.
duke@435	334
duke@435	335	// First calculate an optimal to-space
duke@435	336	to_end = (char*)virtual_space()->high();
duke@435	337	to_start = (char*)pointer_delta(to_end,
duke@435	338	(char*)requested_survivor_size,
duke@435	339	sizeof(char));
duke@435	340
duke@435	341	// Does the optimal to-space overlap from-space?
duke@435	342	if (to_start < (char*)from_space()->end()) {
duke@435	343	assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
duke@435	344
duke@435	345	// Calculate the minimum offset possible for from_end
duke@435	346	size_t from_size =
duke@435	347	pointer_delta(from_space()->top(), from_start, sizeof(char));
duke@435	348
duke@435	349	// Should we be in this method if from_space is empty? Why not the set_space method? FIX ME!
duke@435	350	if (from_size == 0) {
duke@435	351	from_size = alignment;
duke@435	352	} else {
duke@435	353	from_size = align_size_up(from_size, alignment);
duke@435	354	}
duke@435	355
duke@435	356	from_end = from_start + from_size;
duke@435	357	assert(from_end > from_start, "addition overflow or from_size problem");
duke@435	358
duke@435	359	guarantee(from_end <= (char*)from_space()->end(),
duke@435	360	"from_end moved to the right");
duke@435	361
duke@435	362	// Now update to_start with the new from_end
duke@435	363	to_start = MAX2(from_end, to_start);
duke@435	364	}
duke@435	365
duke@435	366	guarantee(to_start != to_end, "to space is zero sized");
duke@435	367
duke@435	368	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	369	gclog_or_tty->print_cr(" [eden_start .. eden_end): "
duke@435	370	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	371	eden_start,
duke@435	372	eden_end,
duke@435	373	pointer_delta(eden_end, eden_start, sizeof(char)));
duke@435	374	gclog_or_tty->print_cr(" [from_start .. from_end): "
duke@435	375	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	376	from_start,
duke@435	377	from_end,
duke@435	378	pointer_delta(from_end, from_start, sizeof(char)));
duke@435	379	gclog_or_tty->print_cr(" [ to_start .. to_end): "
duke@435	380	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	381	to_start,
duke@435	382	to_end,
duke@435	383	pointer_delta( to_end, to_start, sizeof(char)));
duke@435	384	}
duke@435	385	} else {
duke@435	386	// Eden, to, from
duke@435	387	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	388	gclog_or_tty->print_cr(" Eden, to, from:");
duke@435	389	}
duke@435	390
duke@435	391	// To space gets priority over eden resizing. Note that we position
duke@435	392	// to space as if we were able to resize from space, even though from
duke@435	393	// space is not modified.
duke@435	394	// Giving eden priority was tried and gave poorer performance.
duke@435	395	to_end = (char*)pointer_delta(virtual_space()->high(),
duke@435	396	(char*)requested_survivor_size,
duke@435	397	sizeof(char));
duke@435	398	to_end = MIN2(to_end, from_start);
duke@435	399	to_start = (char*)pointer_delta(to_end, (char*)requested_survivor_size,
duke@435	400	sizeof(char));
duke@435	401	// if the space sizes are to be increased by several times then
duke@435	402	// 'to_start' will point beyond the young generation. In this case
duke@435	403	// 'to_start' should be adjusted.
duke@435	404	to_start = MAX2(to_start, eden_start + alignment);
duke@435	405
duke@435	406	// Compute how big eden can be, then adjust end.
jmasa@698	407	// See comments above on calculating eden_end.
jmasa@698	408	size_t eden_size;
jmasa@698	409	if (maintain_minimum) {
jmasa@698	410	eden_size = pointer_delta(to_start, eden_start, sizeof(char));
jmasa@698	411	} else {
jmasa@698	412	eden_size = MIN2(requested_eden_size,
jmasa@698	413	pointer_delta(to_start, eden_start, sizeof(char)));
jmasa@698	414	}
duke@435	415	eden_end = eden_start + eden_size;
duke@435	416	assert(eden_end >= eden_start, "addition overflowed")
duke@435	417
duke@435	418	// Don't let eden shrink down to 0 or less.
duke@435	419	eden_end = MAX2(eden_end, eden_start + alignment);
duke@435	420	to_start = MAX2(to_start, eden_end);
duke@435	421
duke@435	422	if (PrintAdaptiveSizePolicy && Verbose) {
duke@435	423	gclog_or_tty->print_cr(" [eden_start .. eden_end): "
duke@435	424	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	425	eden_start,
duke@435	426	eden_end,
duke@435	427	pointer_delta(eden_end, eden_start, sizeof(char)));
duke@435	428	gclog_or_tty->print_cr(" [ to_start .. to_end): "
duke@435	429	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	430	to_start,
duke@435	431	to_end,
duke@435	432	pointer_delta( to_end, to_start, sizeof(char)));
duke@435	433	gclog_or_tty->print_cr(" [from_start .. from_end): "
duke@435	434	"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
duke@435	435	from_start,
duke@435	436	from_end,
duke@435	437	pointer_delta(from_end, from_start, sizeof(char)));
duke@435	438	}
duke@435	439	}
duke@435	440
duke@435	441
duke@435	442	guarantee((HeapWord*)from_start <= from_space()->bottom(),
duke@435	443	"from start moved to the right");
duke@435	444	guarantee((HeapWord*)from_end >= from_space()->top(),
duke@435	445	"from end moved into live data");
duke@435	446	assert(is_object_aligned((intptr_t)eden_start), "checking alignment");
duke@435	447	assert(is_object_aligned((intptr_t)from_start), "checking alignment");
duke@435	448	assert(is_object_aligned((intptr_t)to_start), "checking alignment");
duke@435	449
duke@435	450	MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)eden_end);
duke@435	451	MemRegion toMR ((HeapWord*)to_start, (HeapWord*)to_end);
duke@435	452	MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);
duke@435	453
duke@435	454	// Let's make sure the call to initialize doesn't reset "top"!
duke@435	455	DEBUG_ONLY(HeapWord* old_from_top = from_space()->top();)
duke@435	456
duke@435	457	// For PrintAdaptiveSizePolicy block below
duke@435	458	size_t old_from = from_space()->capacity_in_bytes();
duke@435	459	size_t old_to = to_space()->capacity_in_bytes();
duke@435	460
jmasa@698	461	if (ZapUnusedHeapArea) {
jmasa@698	462	// NUMA is a special case because a numa space is not mangled
jmasa@698	463	// in order to not prematurely bind its address to memory to
jmasa@698	464	// the wrong memory (i.e., don't want the GC thread to first
jmasa@698	465	// touch the memory). The survivor spaces are not numa
jmasa@698	466	// spaces and are mangled.
jmasa@698	467	if (UseNUMA) {
jmasa@698	468	if (eden_from_to_order) {
jmasa@698	469	mangle_survivors(from_space(), fromMR, to_space(), toMR);
jmasa@698	470	} else {
jmasa@698	471	mangle_survivors(to_space(), toMR, from_space(), fromMR);
jmasa@698	472	}
jmasa@698	473	}
jmasa@698	474
jmasa@698	475	// If not mangling the spaces, do some checking to verify that
jmasa@698	476	// the spaces are already mangled.
jmasa@698	477	// The spaces should be correctly mangled at this point so
jmasa@698	478	// do some checking here. Note that they are not being mangled
jmasa@698	479	// in the calls to initialize().
jmasa@698	480	// Must check mangling before the spaces are reshaped. Otherwise,
jmasa@698	481	// the bottom or end of one space may have moved into an area
jmasa@698	482	// covered by another space and a failure of the check may
jmasa@698	483	// not correctly indicate which space is not properly mangled.
jmasa@698	484
jmasa@698	485	HeapWord* limit = (HeapWord*) virtual_space()->high();
jmasa@698	486	eden_space()->check_mangled_unused_area(limit);
jmasa@698	487	from_space()->check_mangled_unused_area(limit);
jmasa@698	488	to_space()->check_mangled_unused_area(limit);
jmasa@698	489	}
jmasa@698	490	// When an existing space is being initialized, it is not
jmasa@698	491	// mangled because the space has been previously mangled.
jmasa@698	492	eden_space()->initialize(edenMR,
jmasa@698	493	SpaceDecorator::Clear,
jmasa@698	494	SpaceDecorator::DontMangle);
jmasa@698	495	to_space()->initialize(toMR,
jmasa@698	496	SpaceDecorator::Clear,
jmasa@698	497	SpaceDecorator::DontMangle);
jmasa@698	498	from_space()->initialize(fromMR,
jmasa@698	499	SpaceDecorator::DontClear,
jmasa@698	500	SpaceDecorator::DontMangle);
jmasa@698	501
duke@435	502	PSScavenge::set_young_generation_boundary(eden_space()->bottom());
duke@435	503
duke@435	504	assert(from_space()->top() == old_from_top, "from top changed!");
duke@435	505
duke@435	506	if (PrintAdaptiveSizePolicy) {
duke@435	507	ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
duke@435	508	assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
duke@435	509
duke@435	510	gclog_or_tty->print("AdaptiveSizePolicy::survivor space sizes: "
duke@435	511	"collection: %d "
duke@435	512	"(" SIZE_FORMAT ", " SIZE_FORMAT ") -> "
duke@435	513	"(" SIZE_FORMAT ", " SIZE_FORMAT ") ",
duke@435	514	heap->total_collections(),
duke@435	515	old_from, old_to,
duke@435	516	from_space()->capacity_in_bytes(),
duke@435	517	to_space()->capacity_in_bytes());
duke@435	518	gclog_or_tty->cr();
duke@435	519	}
duke@435	520	space_invariants();
duke@435	521	}
duke@435	522	void ASPSYoungGen::reset_after_change() {
duke@435	523	assert_locked_or_safepoint(Heap_lock);
duke@435	524
duke@435	525	_reserved = MemRegion((HeapWord*)virtual_space()->low_boundary(),
duke@435	526	(HeapWord*)virtual_space()->high_boundary());
duke@435	527	PSScavenge::reference_processor()->set_span(_reserved);
duke@435	528
duke@435	529	HeapWord* new_eden_bottom = (HeapWord*)virtual_space()->low();
duke@435	530	HeapWord* eden_bottom = eden_space()->bottom();
duke@435	531	if (new_eden_bottom != eden_bottom) {
duke@435	532	MemRegion eden_mr(new_eden_bottom, eden_space()->end());
jmasa@698	533	eden_space()->initialize(eden_mr,
jmasa@698	534	SpaceDecorator::Clear,
jmasa@698	535	SpaceDecorator::Mangle);
duke@435	536	PSScavenge::set_young_generation_boundary(eden_space()->bottom());
duke@435	537	}
duke@435	538	MemRegion cmr((HeapWord*)virtual_space()->low(),
duke@435	539	(HeapWord*)virtual_space()->high());
duke@435	540	Universe::heap()->barrier_set()->resize_covered_region(cmr);
duke@435	541
duke@435	542	space_invariants();
duke@435	543	}