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

src/share/vm/memory/threadLocalAllocBuffer.cpp@710a3c8b516e (annotated)

src/share/vm/memory/threadLocalAllocBuffer.cpp

Tue, 08 Aug 2017 15:57:29 +0800

author

aoqi

date

Tue, 08 Aug 2017 15:57:29 +0800

changeset 6876

710a3c8b516e

parent 6680

78bbf4d43a14

parent 0

f90c822e73f8

child 7535

7ae4e26cb1e0

permissions

-rw-r--r--

merge

aoqi@0	1	/*
aoqi@0	2	* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
aoqi@0	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
aoqi@0	4	*
aoqi@0	5	* This code is free software; you can redistribute it and/or modify it
aoqi@0	6	* under the terms of the GNU General Public License version 2 only, as
aoqi@0	7	* published by the Free Software Foundation.
aoqi@0	8	*
aoqi@0	9	* This code is distributed in the hope that it will be useful, but WITHOUT
aoqi@0	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
aoqi@0	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
aoqi@0	12	* version 2 for more details (a copy is included in the LICENSE file that
aoqi@0	13	* accompanied this code).
aoqi@0	14	*
aoqi@0	15	* You should have received a copy of the GNU General Public License version
aoqi@0	16	* 2 along with this work; if not, write to the Free Software Foundation,
aoqi@0	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
aoqi@0	18	*
aoqi@0	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
aoqi@0	20	* or visit www.oracle.com if you need additional information or have any
aoqi@0	21	* questions.
aoqi@0	22	*
aoqi@0	23	*/
aoqi@0	24
aoqi@0	25	#include "precompiled.hpp"
aoqi@0	26	#include "memory/genCollectedHeap.hpp"
aoqi@0	27	#include "memory/resourceArea.hpp"
aoqi@0	28	#include "memory/threadLocalAllocBuffer.inline.hpp"
aoqi@0	29	#include "memory/universe.inline.hpp"
aoqi@0	30	#include "oops/oop.inline.hpp"
aoqi@0	31	#include "runtime/thread.inline.hpp"
aoqi@0	32	#include "utilities/copy.hpp"
aoqi@0	33
aoqi@0	34	PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
aoqi@0	35
aoqi@0	36	// Thread-Local Edens support
aoqi@0	37
aoqi@0	38	// static member initialization
aoqi@0	39	size_t ThreadLocalAllocBuffer::_max_size = 0;
aoqi@0	40	unsigned ThreadLocalAllocBuffer::_target_refills = 0;
aoqi@0	41	GlobalTLABStats* ThreadLocalAllocBuffer::_global_stats = NULL;
aoqi@0	42
aoqi@0	43	void ThreadLocalAllocBuffer::clear_before_allocation() {
aoqi@0	44	_slow_refill_waste += (unsigned)remaining();
aoqi@0	45	make_parsable(true); // also retire the TLAB
aoqi@0	46	}
aoqi@0	47
aoqi@0	48	void ThreadLocalAllocBuffer::accumulate_statistics_before_gc() {
aoqi@0	49	global_stats()->initialize();
aoqi@0	50
aoqi@0	51	for (JavaThread *thread = Threads::first(); thread != NULL; thread = thread->next()) {
aoqi@0	52	thread->tlab().accumulate_statistics();
aoqi@0	53	thread->tlab().initialize_statistics();
aoqi@0	54	}
aoqi@0	55
aoqi@0	56	// Publish new stats if some allocation occurred.
aoqi@0	57	if (global_stats()->allocation() != 0) {
aoqi@0	58	global_stats()->publish();
aoqi@0	59	if (PrintTLAB) {
aoqi@0	60	global_stats()->print();
aoqi@0	61	}
aoqi@0	62	}
aoqi@0	63	}
aoqi@0	64
aoqi@0	65	void ThreadLocalAllocBuffer::accumulate_statistics() {
aoqi@0	66	Thread* thread = myThread();
aoqi@0	67	size_t capacity = Universe::heap()->tlab_capacity(thread);
aoqi@0	68	size_t used = Universe::heap()->tlab_used(thread);
aoqi@0	69
aoqi@0	70	_gc_waste += (unsigned)remaining();
aoqi@0	71	size_t total_allocated = thread->allocated_bytes();
aoqi@0	72	size_t allocated_since_last_gc = total_allocated - _allocated_before_last_gc;
aoqi@0	73	_allocated_before_last_gc = total_allocated;
aoqi@0	74
aoqi@0	75	if (PrintTLAB && (_number_of_refills > 0 || Verbose)) {
aoqi@0	76	print_stats("gc");
aoqi@0	77	}
aoqi@0	78
aoqi@0	79	if (_number_of_refills > 0) {
aoqi@0	80	// Update allocation history if a reasonable amount of eden was allocated.
aoqi@0	81	bool update_allocation_history = used > 0.5 * capacity;
aoqi@0	82
aoqi@0	83	if (update_allocation_history) {
aoqi@0	84	// Average the fraction of eden allocated in a tlab by this
aoqi@0	85	// thread for use in the next resize operation.
aoqi@0	86	// _gc_waste is not subtracted because it's included in
aoqi@0	87	// "used".
aoqi@0	88	// The result can be larger than 1.0 due to direct to old allocations.
aoqi@0	89	// These allocations should ideally not be counted but since it is not possible
aoqi@0	90	// to filter them out here we just cap the fraction to be at most 1.0.
aoqi@0	91	double alloc_frac = MIN2(1.0, (double) allocated_since_last_gc / used);
aoqi@0	92	_allocation_fraction.sample(alloc_frac);
aoqi@0	93	}
aoqi@0	94	global_stats()->update_allocating_threads();
aoqi@0	95	global_stats()->update_number_of_refills(_number_of_refills);
aoqi@0	96	global_stats()->update_allocation(_number_of_refills * desired_size());
aoqi@0	97	global_stats()->update_gc_waste(_gc_waste);
aoqi@0	98	global_stats()->update_slow_refill_waste(_slow_refill_waste);
aoqi@0	99	global_stats()->update_fast_refill_waste(_fast_refill_waste);
aoqi@0	100
aoqi@0	101	} else {
aoqi@0	102	assert(_number_of_refills == 0 && _fast_refill_waste == 0 &&
aoqi@0	103	_slow_refill_waste == 0 && _gc_waste == 0,
aoqi@0	104	"tlab stats == 0");
aoqi@0	105	}
aoqi@0	106	global_stats()->update_slow_allocations(_slow_allocations);
aoqi@0	107	}
aoqi@0	108
aoqi@0	109	// Fills the current tlab with a dummy filler array to create
aoqi@0	110	// an illusion of a contiguous Eden and optionally retires the tlab.
aoqi@0	111	// Waste accounting should be done in caller as appropriate; see,
aoqi@0	112	// for example, clear_before_allocation().
aoqi@0	113	void ThreadLocalAllocBuffer::make_parsable(bool retire) {
aoqi@0	114	if (end() != NULL) {
aoqi@0	115	invariants();
aoqi@0	116
aoqi@0	117	if (retire) {
aoqi@0	118	myThread()->incr_allocated_bytes(used_bytes());
aoqi@0	119	}
aoqi@0	120
aoqi@0	121	CollectedHeap::fill_with_object(top(), hard_end(), retire);
aoqi@0	122
aoqi@0	123	if (retire || ZeroTLAB) { // "Reset" the TLAB
aoqi@0	124	set_start(NULL);
aoqi@0	125	set_top(NULL);
aoqi@0	126	set_pf_top(NULL);
aoqi@0	127	set_end(NULL);
aoqi@0	128	}
aoqi@0	129	}
aoqi@0	130	assert(!(retire || ZeroTLAB) ||
aoqi@0	131	(start() == NULL && end() == NULL && top() == NULL),
aoqi@0	132	"TLAB must be reset");
aoqi@0	133	}
aoqi@0	134
aoqi@0	135	void ThreadLocalAllocBuffer::resize_all_tlabs() {
aoqi@0	136	if (ResizeTLAB) {
aoqi@0	137	for (JavaThread *thread = Threads::first(); thread != NULL; thread = thread->next()) {
aoqi@0	138	thread->tlab().resize();
aoqi@0	139	}
aoqi@0	140	}
aoqi@0	141	}
aoqi@0	142
aoqi@0	143	void ThreadLocalAllocBuffer::resize() {
aoqi@0	144	// Compute the next tlab size using expected allocation amount
aoqi@0	145	assert(ResizeTLAB, "Should not call this otherwise");
aoqi@0	146	size_t alloc = (size_t)(_allocation_fraction.average() *
aoqi@0	147	(Universe::heap()->tlab_capacity(myThread()) / HeapWordSize));
aoqi@0	148	size_t new_size = alloc / _target_refills;
aoqi@0	149
aoqi@0	150	new_size = MIN2(MAX2(new_size, min_size()), max_size());
aoqi@0	151
aoqi@0	152	size_t aligned_new_size = align_object_size(new_size);
aoqi@0	153
aoqi@0	154	if (PrintTLAB && Verbose) {
aoqi@0	155	gclog_or_tty->print("TLAB new size: thread: " INTPTR_FORMAT " [id: %2d]"
aoqi@0	156	" refills %d alloc: %8.6f desired_size: " SIZE_FORMAT " -> " SIZE_FORMAT "\n",
aoqi@0	157	myThread(), myThread()->osthread()->thread_id(),
aoqi@0	158	_target_refills, _allocation_fraction.average(), desired_size(), aligned_new_size);
aoqi@0	159	}
aoqi@0	160	set_desired_size(aligned_new_size);
aoqi@0	161	set_refill_waste_limit(initial_refill_waste_limit());
aoqi@0	162	}
aoqi@0	163
aoqi@0	164	void ThreadLocalAllocBuffer::initialize_statistics() {
aoqi@0	165	_number_of_refills = 0;
aoqi@0	166	_fast_refill_waste = 0;
aoqi@0	167	_slow_refill_waste = 0;
aoqi@0	168	_gc_waste = 0;
aoqi@0	169	_slow_allocations = 0;
aoqi@0	170	}
aoqi@0	171
aoqi@0	172	void ThreadLocalAllocBuffer::fill(HeapWord* start,
aoqi@0	173	HeapWord* top,
aoqi@0	174	size_t new_size) {
aoqi@0	175	_number_of_refills++;
aoqi@0	176	if (PrintTLAB && Verbose) {
aoqi@0	177	print_stats("fill");
aoqi@0	178	}
aoqi@0	179	assert(top <= start + new_size - alignment_reserve(), "size too small");
aoqi@0	180	initialize(start, top, start + new_size - alignment_reserve());
aoqi@0	181
aoqi@0	182	// Reset amount of internal fragmentation
aoqi@0	183	set_refill_waste_limit(initial_refill_waste_limit());
aoqi@0	184	}
aoqi@0	185
aoqi@0	186	void ThreadLocalAllocBuffer::initialize(HeapWord* start,
aoqi@0	187	HeapWord* top,
aoqi@0	188	HeapWord* end) {
aoqi@0	189	set_start(start);
aoqi@0	190	set_top(top);
aoqi@0	191	set_pf_top(top);
aoqi@0	192	set_end(end);
aoqi@0	193	invariants();
aoqi@0	194	}
aoqi@0	195
aoqi@0	196	void ThreadLocalAllocBuffer::initialize() {
aoqi@0	197	initialize(NULL, // start
aoqi@0	198	NULL, // top
aoqi@0	199	NULL); // end
aoqi@0	200
aoqi@0	201	set_desired_size(initial_desired_size());
aoqi@0	202
aoqi@0	203	// Following check is needed because at startup the main (primordial)
aoqi@0	204	// thread is initialized before the heap is. The initialization for
aoqi@0	205	// this thread is redone in startup_initialization below.
aoqi@0	206	if (Universe::heap() != NULL) {
aoqi@0	207	size_t capacity = Universe::heap()->tlab_capacity(myThread()) / HeapWordSize;
aoqi@0	208	double alloc_frac = desired_size() * target_refills() / (double) capacity;
aoqi@0	209	_allocation_fraction.sample(alloc_frac);
aoqi@0	210	}
aoqi@0	211
aoqi@0	212	set_refill_waste_limit(initial_refill_waste_limit());
aoqi@0	213
aoqi@0	214	initialize_statistics();
aoqi@0	215	}
aoqi@0	216
aoqi@0	217	void ThreadLocalAllocBuffer::startup_initialization() {
aoqi@0	218
aoqi@0	219	// Assuming each thread's active tlab is, on average,
aoqi@0	220	// 1/2 full at a GC
aoqi@0	221	_target_refills = 100 / (2 * TLABWasteTargetPercent);
aoqi@0	222	_target_refills = MAX2(_target_refills, (unsigned)1U);
aoqi@0	223
aoqi@0	224	_global_stats = new GlobalTLABStats();
aoqi@0	225
aoqi@0	226	// During jvm startup, the main (primordial) thread is initialized
aoqi@0	227	// before the heap is initialized. So reinitialize it now.
aoqi@0	228	guarantee(Thread::current()->is_Java_thread(), "tlab initialization thread not Java thread");
aoqi@0	229	Thread::current()->tlab().initialize();
aoqi@0	230
aoqi@0	231	if (PrintTLAB && Verbose) {
aoqi@0	232	gclog_or_tty->print("TLAB min: " SIZE_FORMAT " initial: " SIZE_FORMAT " max: " SIZE_FORMAT "\n",
aoqi@0	233	min_size(), Thread::current()->tlab().initial_desired_size(), max_size());
aoqi@0	234	}
aoqi@0	235	}
aoqi@0	236
aoqi@0	237	size_t ThreadLocalAllocBuffer::initial_desired_size() {
aoqi@0	238	size_t init_sz;
aoqi@0	239
aoqi@0	240	if (TLABSize > 0) {
aoqi@0	241	init_sz = MIN2(TLABSize / HeapWordSize, max_size());
aoqi@0	242	} else if (global_stats() == NULL) {
aoqi@0	243	// Startup issue - main thread initialized before heap initialized.
aoqi@0	244	init_sz = min_size();
aoqi@0	245	} else {
aoqi@0	246	// Initial size is a function of the average number of allocating threads.
aoqi@0	247	unsigned nof_threads = global_stats()->allocating_threads_avg();
aoqi@0	248
aoqi@0	249	init_sz = (Universe::heap()->tlab_capacity(myThread()) / HeapWordSize) /
aoqi@0	250	(nof_threads * target_refills());
aoqi@0	251	init_sz = align_object_size(init_sz);
aoqi@0	252	init_sz = MIN2(MAX2(init_sz, min_size()), max_size());
aoqi@0	253	}
aoqi@0	254	return init_sz;
aoqi@0	255	}
aoqi@0	256
aoqi@0	257	void ThreadLocalAllocBuffer::print_stats(const char* tag) {
aoqi@0	258	Thread* thrd = myThread();
aoqi@0	259	size_t waste = _gc_waste + _slow_refill_waste + _fast_refill_waste;
aoqi@0	260	size_t alloc = _number_of_refills * _desired_size;
aoqi@0	261	double waste_percent = alloc == 0 ? 0.0 :
aoqi@0	262	100.0 * waste / alloc;
aoqi@0	263	size_t tlab_used = Universe::heap()->tlab_used(thrd);
aoqi@0	264	gclog_or_tty->print("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]"
aoqi@0	265	" desired_size: " SIZE_FORMAT "KB"
aoqi@0	266	" slow allocs: %d refill waste: " SIZE_FORMAT "B"
aoqi@0	267	" alloc:%8.5f %8.0fKB refills: %d waste %4.1f%% gc: %dB"
aoqi@0	268	" slow: %dB fast: %dB\n",
aoqi@0	269	tag, thrd, thrd->osthread()->thread_id(),
aoqi@0	270	_desired_size / (K / HeapWordSize),
aoqi@0	271	_slow_allocations, _refill_waste_limit * HeapWordSize,
aoqi@0	272	_allocation_fraction.average(),
aoqi@0	273	_allocation_fraction.average() * tlab_used / K,
aoqi@0	274	_number_of_refills, waste_percent,
aoqi@0	275	_gc_waste * HeapWordSize,
aoqi@0	276	_slow_refill_waste * HeapWordSize,
aoqi@0	277	_fast_refill_waste * HeapWordSize);
aoqi@0	278	}
aoqi@0	279
aoqi@0	280	void ThreadLocalAllocBuffer::verify() {
aoqi@0	281	HeapWord* p = start();
aoqi@0	282	HeapWord* t = top();
aoqi@0	283	HeapWord* prev_p = NULL;
aoqi@0	284	while (p < t) {
aoqi@0	285	oop(p)->verify();
aoqi@0	286	prev_p = p;
aoqi@0	287	p += oop(p)->size();
aoqi@0	288	}
aoqi@0	289	guarantee(p == top(), "end of last object must match end of space");
aoqi@0	290	}
aoqi@0	291
aoqi@0	292	Thread* ThreadLocalAllocBuffer::myThread() {
aoqi@0	293	return (Thread*)(((char *)this) +
aoqi@0	294	in_bytes(start_offset()) -
aoqi@0	295	in_bytes(Thread::tlab_start_offset()));
aoqi@0	296	}
aoqi@0	297
aoqi@0	298
aoqi@0	299	GlobalTLABStats::GlobalTLABStats() :
aoqi@0	300	_allocating_threads_avg(TLABAllocationWeight) {
aoqi@0	301
aoqi@0	302	initialize();
aoqi@0	303
aoqi@0	304	_allocating_threads_avg.sample(1); // One allocating thread at startup
aoqi@0	305
aoqi@0	306	if (UsePerfData) {
aoqi@0	307
aoqi@0	308	EXCEPTION_MARK;
aoqi@0	309	ResourceMark rm;
aoqi@0	310
aoqi@0	311	char* cname = PerfDataManager::counter_name("tlab", "allocThreads");
aoqi@0	312	_perf_allocating_threads =
aoqi@0	313	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);
aoqi@0	314
aoqi@0	315	cname = PerfDataManager::counter_name("tlab", "fills");
aoqi@0	316	_perf_total_refills =
aoqi@0	317	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);
aoqi@0	318
aoqi@0	319	cname = PerfDataManager::counter_name("tlab", "maxFills");
aoqi@0	320	_perf_max_refills =
aoqi@0	321	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);
aoqi@0	322
aoqi@0	323	cname = PerfDataManager::counter_name("tlab", "alloc");
aoqi@0	324	_perf_allocation =
aoqi@0	325	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);
aoqi@0	326
aoqi@0	327	cname = PerfDataManager::counter_name("tlab", "gcWaste");
aoqi@0	328	_perf_gc_waste =
aoqi@0	329	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);
aoqi@0	330
aoqi@0	331	cname = PerfDataManager::counter_name("tlab", "maxGcWaste");
aoqi@0	332	_perf_max_gc_waste =
aoqi@0	333	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);
aoqi@0	334
aoqi@0	335	cname = PerfDataManager::counter_name("tlab", "slowWaste");
aoqi@0	336	_perf_slow_refill_waste =
aoqi@0	337	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);
aoqi@0	338
aoqi@0	339	cname = PerfDataManager::counter_name("tlab", "maxSlowWaste");
aoqi@0	340	_perf_max_slow_refill_waste =
aoqi@0	341	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);
aoqi@0	342
aoqi@0	343	cname = PerfDataManager::counter_name("tlab", "fastWaste");
aoqi@0	344	_perf_fast_refill_waste =
aoqi@0	345	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);
aoqi@0	346
aoqi@0	347	cname = PerfDataManager::counter_name("tlab", "maxFastWaste");
aoqi@0	348	_perf_max_fast_refill_waste =
aoqi@0	349	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);
aoqi@0	350
aoqi@0	351	cname = PerfDataManager::counter_name("tlab", "slowAlloc");
aoqi@0	352	_perf_slow_allocations =
aoqi@0	353	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);
aoqi@0	354
aoqi@0	355	cname = PerfDataManager::counter_name("tlab", "maxSlowAlloc");
aoqi@0	356	_perf_max_slow_allocations =
aoqi@0	357	PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);
aoqi@0	358	}
aoqi@0	359	}
aoqi@0	360
aoqi@0	361	void GlobalTLABStats::initialize() {
aoqi@0	362	// Clear counters summarizing info from all threads
aoqi@0	363	_allocating_threads = 0;
aoqi@0	364	_total_refills = 0;
aoqi@0	365	_max_refills = 0;
aoqi@0	366	_total_allocation = 0;
aoqi@0	367	_total_gc_waste = 0;
aoqi@0	368	_max_gc_waste = 0;
aoqi@0	369	_total_slow_refill_waste = 0;
aoqi@0	370	_max_slow_refill_waste = 0;
aoqi@0	371	_total_fast_refill_waste = 0;
aoqi@0	372	_max_fast_refill_waste = 0;
aoqi@0	373	_total_slow_allocations = 0;
aoqi@0	374	_max_slow_allocations = 0;
aoqi@0	375	}
aoqi@0	376
aoqi@0	377	void GlobalTLABStats::publish() {
aoqi@0	378	_allocating_threads_avg.sample(_allocating_threads);
aoqi@0	379	if (UsePerfData) {
aoqi@0	380	_perf_allocating_threads ->set_value(_allocating_threads);
aoqi@0	381	_perf_total_refills ->set_value(_total_refills);
aoqi@0	382	_perf_max_refills ->set_value(_max_refills);
aoqi@0	383	_perf_allocation ->set_value(_total_allocation);
aoqi@0	384	_perf_gc_waste ->set_value(_total_gc_waste);
aoqi@0	385	_perf_max_gc_waste ->set_value(_max_gc_waste);
aoqi@0	386	_perf_slow_refill_waste ->set_value(_total_slow_refill_waste);
aoqi@0	387	_perf_max_slow_refill_waste->set_value(_max_slow_refill_waste);
aoqi@0	388	_perf_fast_refill_waste ->set_value(_total_fast_refill_waste);
aoqi@0	389	_perf_max_fast_refill_waste->set_value(_max_fast_refill_waste);
aoqi@0	390	_perf_slow_allocations ->set_value(_total_slow_allocations);
aoqi@0	391	_perf_max_slow_allocations ->set_value(_max_slow_allocations);
aoqi@0	392	}
aoqi@0	393	}
aoqi@0	394
aoqi@0	395	void GlobalTLABStats::print() {
aoqi@0	396	size_t waste = _total_gc_waste + _total_slow_refill_waste + _total_fast_refill_waste;
aoqi@0	397	double waste_percent = _total_allocation == 0 ? 0.0 :
aoqi@0	398	100.0 * waste / _total_allocation;
aoqi@0	399	gclog_or_tty->print("TLAB totals: thrds: %d refills: %d max: %d"
aoqi@0	400	" slow allocs: %d max %d waste: %4.1f%%"
aoqi@0	401	" gc: " SIZE_FORMAT "B max: " SIZE_FORMAT "B"
aoqi@0	402	" slow: " SIZE_FORMAT "B max: " SIZE_FORMAT "B"
aoqi@0	403	" fast: " SIZE_FORMAT "B max: " SIZE_FORMAT "B\n",
aoqi@0	404	_allocating_threads,
aoqi@0	405	_total_refills, _max_refills,
aoqi@0	406	_total_slow_allocations, _max_slow_allocations,
aoqi@0	407	waste_percent,
aoqi@0	408	_total_gc_waste * HeapWordSize,
aoqi@0	409	_max_gc_waste * HeapWordSize,
aoqi@0	410	_total_slow_refill_waste * HeapWordSize,
aoqi@0	411	_max_slow_refill_waste * HeapWordSize,
aoqi@0	412	_total_fast_refill_waste * HeapWordSize,
aoqi@0	413	_max_fast_refill_waste * HeapWordSize);
aoqi@0	414	}