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

src/share/vm/services/heapDumper.cpp@72a6752ac432 (annotated)

src/share/vm/services/heapDumper.cpp

Wed, 28 Oct 2009 11:16:42 -0700

author

ysr

date

Wed, 28 Oct 2009 11:16:42 -0700

changeset 1481

72a6752ac432

parent 1063

7bb995fbd3c0

child 1577

4ce7240d622c

permissions

-rw-r--r--

6818264: Heap dumper unexpectedly adds .hprof suffix
Summary: Restore old behaviour wrt HeapDumpPath; first dump goes to <file>, <n>th dump goes to <file>.<n-1>, with default value of <file> the same as before.
Reviewed-by: alanb, jcoomes, tonyp

duke@435	1	/*
xdono@1014	2	* Copyright 2005-2009 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/_heapDumper.cpp.incl"
duke@435	27
duke@435	28	/*
duke@435	29	* HPROF binary format - description copied from:
duke@435	30	* src/share/demo/jvmti/hprof/hprof_io.c
duke@435	31	*
duke@435	32	*
duke@435	33	* header "JAVA PROFILE 1.0.1" or "JAVA PROFILE 1.0.2"
duke@435	34	* (0-terminated)
duke@435	35	*
duke@435	36	* u4 size of identifiers. Identifiers are used to represent
duke@435	37	* UTF8 strings, objects, stack traces, etc. They usually
duke@435	38	* have the same size as host pointers. For example, on
duke@435	39	* Solaris and Win32, the size is 4.
duke@435	40	* u4 high word
duke@435	41	* u4 low word number of milliseconds since 0:00 GMT, 1/1/70
duke@435	42	* [record]* a sequence of records.
duke@435	43	*
duke@435	44	*
duke@435	45	* Record format:
duke@435	46	*
duke@435	47	* u1 a TAG denoting the type of the record
duke@435	48	* u4 number of *microseconds* since the time stamp in the
duke@435	49	* header. (wraps around in a little more than an hour)
duke@435	50	* u4 number of bytes *remaining* in the record. Note that
duke@435	51	* this number excludes the tag and the length field itself.
duke@435	52	* [u1]* BODY of the record (a sequence of bytes)
duke@435	53	*
duke@435	54	*
duke@435	55	* The following TAGs are supported:
duke@435	56	*
duke@435	57	* TAG BODY notes
duke@435	58	*----------------------------------------------------------
duke@435	59	* HPROF_UTF8 a UTF8-encoded name
duke@435	60	*
duke@435	61	* id name ID
duke@435	62	* [u1]* UTF8 characters (no trailing zero)
duke@435	63	*
duke@435	64	* HPROF_LOAD_CLASS a newly loaded class
duke@435	65	*
duke@435	66	* u4 class serial number (> 0)
duke@435	67	* id class object ID
duke@435	68	* u4 stack trace serial number
duke@435	69	* id class name ID
duke@435	70	*
duke@435	71	* HPROF_UNLOAD_CLASS an unloading class
duke@435	72	*
duke@435	73	* u4 class serial_number
duke@435	74	*
duke@435	75	* HPROF_FRAME a Java stack frame
duke@435	76	*
duke@435	77	* id stack frame ID
duke@435	78	* id method name ID
duke@435	79	* id method signature ID
duke@435	80	* id source file name ID
duke@435	81	* u4 class serial number
duke@435	82	* i4 line number. >0: normal
duke@435	83	* -1: unknown
duke@435	84	* -2: compiled method
duke@435	85	* -3: native method
duke@435	86	*
duke@435	87	* HPROF_TRACE a Java stack trace
duke@435	88	*
duke@435	89	* u4 stack trace serial number
duke@435	90	* u4 thread serial number
duke@435	91	* u4 number of frames
duke@435	92	* [id]* stack frame IDs
duke@435	93	*
duke@435	94	*
duke@435	95	* HPROF_ALLOC_SITES a set of heap allocation sites, obtained after GC
duke@435	96	*
duke@435	97	* u2 flags 0x0001: incremental vs. complete
duke@435	98	* 0x0002: sorted by allocation vs. live
duke@435	99	* 0x0004: whether to force a GC
duke@435	100	* u4 cutoff ratio
duke@435	101	* u4 total live bytes
duke@435	102	* u4 total live instances
duke@435	103	* u8 total bytes allocated
duke@435	104	* u8 total instances allocated
duke@435	105	* u4 number of sites that follow
duke@435	106	* [u1 is_array: 0: normal object
duke@435	107	* 2: object array
duke@435	108	* 4: boolean array
duke@435	109	* 5: char array
duke@435	110	* 6: float array
duke@435	111	* 7: double array
duke@435	112	* 8: byte array
duke@435	113	* 9: short array
duke@435	114	* 10: int array
duke@435	115	* 11: long array
duke@435	116	* u4 class serial number (may be zero during startup)
duke@435	117	* u4 stack trace serial number
duke@435	118	* u4 number of bytes alive
duke@435	119	* u4 number of instances alive
duke@435	120	* u4 number of bytes allocated
duke@435	121	* u4]* number of instance allocated
duke@435	122	*
duke@435	123	* HPROF_START_THREAD a newly started thread.
duke@435	124	*
duke@435	125	* u4 thread serial number (> 0)
duke@435	126	* id thread object ID
duke@435	127	* u4 stack trace serial number
duke@435	128	* id thread name ID
duke@435	129	* id thread group name ID
duke@435	130	* id thread group parent name ID
duke@435	131	*
duke@435	132	* HPROF_END_THREAD a terminating thread.
duke@435	133	*
duke@435	134	* u4 thread serial number
duke@435	135	*
duke@435	136	* HPROF_HEAP_SUMMARY heap summary
duke@435	137	*
duke@435	138	* u4 total live bytes
duke@435	139	* u4 total live instances
duke@435	140	* u8 total bytes allocated
duke@435	141	* u8 total instances allocated
duke@435	142	*
duke@435	143	* HPROF_HEAP_DUMP denote a heap dump
duke@435	144	*
duke@435	145	* [heap dump sub-records]*
duke@435	146	*
duke@435	147	* There are four kinds of heap dump sub-records:
duke@435	148	*
duke@435	149	* u1 sub-record type
duke@435	150	*
duke@435	151	* HPROF_GC_ROOT_UNKNOWN unknown root
duke@435	152	*
duke@435	153	* id object ID
duke@435	154	*
duke@435	155	* HPROF_GC_ROOT_THREAD_OBJ thread object
duke@435	156	*
duke@435	157	* id thread object ID (may be 0 for a
duke@435	158	* thread newly attached through JNI)
duke@435	159	* u4 thread sequence number
duke@435	160	* u4 stack trace sequence number
duke@435	161	*
duke@435	162	* HPROF_GC_ROOT_JNI_GLOBAL JNI global ref root
duke@435	163	*
duke@435	164	* id object ID
duke@435	165	* id JNI global ref ID
duke@435	166	*
duke@435	167	* HPROF_GC_ROOT_JNI_LOCAL JNI local ref
duke@435	168	*
duke@435	169	* id object ID
duke@435	170	* u4 thread serial number
duke@435	171	* u4 frame # in stack trace (-1 for empty)
duke@435	172	*
duke@435	173	* HPROF_GC_ROOT_JAVA_FRAME Java stack frame
duke@435	174	*
duke@435	175	* id object ID
duke@435	176	* u4 thread serial number
duke@435	177	* u4 frame # in stack trace (-1 for empty)
duke@435	178	*
duke@435	179	* HPROF_GC_ROOT_NATIVE_STACK Native stack
duke@435	180	*
duke@435	181	* id object ID
duke@435	182	* u4 thread serial number
duke@435	183	*
duke@435	184	* HPROF_GC_ROOT_STICKY_CLASS System class
duke@435	185	*
duke@435	186	* id object ID
duke@435	187	*
duke@435	188	* HPROF_GC_ROOT_THREAD_BLOCK Reference from thread block
duke@435	189	*
duke@435	190	* id object ID
duke@435	191	* u4 thread serial number
duke@435	192	*
duke@435	193	* HPROF_GC_ROOT_MONITOR_USED Busy monitor
duke@435	194	*
duke@435	195	* id object ID
duke@435	196	*
duke@435	197	* HPROF_GC_CLASS_DUMP dump of a class object
duke@435	198	*
duke@435	199	* id class object ID
duke@435	200	* u4 stack trace serial number
duke@435	201	* id super class object ID
duke@435	202	* id class loader object ID
duke@435	203	* id signers object ID
duke@435	204	* id protection domain object ID
duke@435	205	* id reserved
duke@435	206	* id reserved
duke@435	207	*
duke@435	208	* u4 instance size (in bytes)
duke@435	209	*
duke@435	210	* u2 size of constant pool
duke@435	211	* [u2, constant pool index,
duke@435	212	* ty, type
duke@435	213	* 2: object
duke@435	214	* 4: boolean
duke@435	215	* 5: char
duke@435	216	* 6: float
duke@435	217	* 7: double
duke@435	218	* 8: byte
duke@435	219	* 9: short
duke@435	220	* 10: int
duke@435	221	* 11: long
duke@435	222	* vl]* and value
duke@435	223	*
duke@435	224	* u2 number of static fields
duke@435	225	* [id, static field name,
duke@435	226	* ty, type,
duke@435	227	* vl]* and value
duke@435	228	*
duke@435	229	* u2 number of inst. fields (not inc. super)
duke@435	230	* [id, instance field name,
duke@435	231	* ty]* type
duke@435	232	*
duke@435	233	* HPROF_GC_INSTANCE_DUMP dump of a normal object
duke@435	234	*
duke@435	235	* id object ID
duke@435	236	* u4 stack trace serial number
duke@435	237	* id class object ID
duke@435	238	* u4 number of bytes that follow
duke@435	239	* [vl]* instance field values (class, followed
duke@435	240	* by super, super's super ...)
duke@435	241	*
duke@435	242	* HPROF_GC_OBJ_ARRAY_DUMP dump of an object array
duke@435	243	*
duke@435	244	* id array object ID
duke@435	245	* u4 stack trace serial number
duke@435	246	* u4 number of elements
duke@435	247	* id array class ID
duke@435	248	* [id]* elements
duke@435	249	*
duke@435	250	* HPROF_GC_PRIM_ARRAY_DUMP dump of a primitive array
duke@435	251	*
duke@435	252	* id array object ID
duke@435	253	* u4 stack trace serial number
duke@435	254	* u4 number of elements
duke@435	255	* u1 element type
duke@435	256	* 4: boolean array
duke@435	257	* 5: char array
duke@435	258	* 6: float array
duke@435	259	* 7: double array
duke@435	260	* 8: byte array
duke@435	261	* 9: short array
duke@435	262	* 10: int array
duke@435	263	* 11: long array
duke@435	264	* [u1]* elements
duke@435	265	*
duke@435	266	* HPROF_CPU_SAMPLES a set of sample traces of running threads
duke@435	267	*
duke@435	268	* u4 total number of samples
duke@435	269	* u4 # of traces
duke@435	270	* [u4 # of samples
duke@435	271	* u4]* stack trace serial number
duke@435	272	*
duke@435	273	* HPROF_CONTROL_SETTINGS the settings of on/off switches
duke@435	274	*
duke@435	275	* u4 0x00000001: alloc traces on/off
duke@435	276	* 0x00000002: cpu sampling on/off
duke@435	277	* u2 stack trace depth
duke@435	278	*
duke@435	279	*
duke@435	280	* When the header is "JAVA PROFILE 1.0.2" a heap dump can optionally
duke@435	281	* be generated as a sequence of heap dump segments. This sequence is
duke@435	282	* terminated by an end record. The additional tags allowed by format
duke@435	283	* "JAVA PROFILE 1.0.2" are:
duke@435	284	*
duke@435	285	* HPROF_HEAP_DUMP_SEGMENT denote a heap dump segment
duke@435	286	*
duke@435	287	* [heap dump sub-records]*
duke@435	288	* The same sub-record types allowed by HPROF_HEAP_DUMP
duke@435	289	*
duke@435	290	* HPROF_HEAP_DUMP_END denotes the end of a heap dump
duke@435	291	*
duke@435	292	*/
duke@435	293
duke@435	294
duke@435	295	// HPROF tags
duke@435	296
duke@435	297	typedef enum {
duke@435	298	// top-level records
duke@435	299	HPROF_UTF8 = 0x01,
duke@435	300	HPROF_LOAD_CLASS = 0x02,
duke@435	301	HPROF_UNLOAD_CLASS = 0x03,
duke@435	302	HPROF_FRAME = 0x04,
duke@435	303	HPROF_TRACE = 0x05,
duke@435	304	HPROF_ALLOC_SITES = 0x06,
duke@435	305	HPROF_HEAP_SUMMARY = 0x07,
duke@435	306	HPROF_START_THREAD = 0x0A,
duke@435	307	HPROF_END_THREAD = 0x0B,
duke@435	308	HPROF_HEAP_DUMP = 0x0C,
duke@435	309	HPROF_CPU_SAMPLES = 0x0D,
duke@435	310	HPROF_CONTROL_SETTINGS = 0x0E,
duke@435	311
duke@435	312	// 1.0.2 record types
duke@435	313	HPROF_HEAP_DUMP_SEGMENT = 0x1C,
duke@435	314	HPROF_HEAP_DUMP_END = 0x2C,
duke@435	315
duke@435	316	// field types
duke@435	317	HPROF_ARRAY_OBJECT = 0x01,
duke@435	318	HPROF_NORMAL_OBJECT = 0x02,
duke@435	319	HPROF_BOOLEAN = 0x04,
duke@435	320	HPROF_CHAR = 0x05,
duke@435	321	HPROF_FLOAT = 0x06,
duke@435	322	HPROF_DOUBLE = 0x07,
duke@435	323	HPROF_BYTE = 0x08,
duke@435	324	HPROF_SHORT = 0x09,
duke@435	325	HPROF_INT = 0x0A,
duke@435	326	HPROF_LONG = 0x0B,
duke@435	327
duke@435	328	// data-dump sub-records
duke@435	329	HPROF_GC_ROOT_UNKNOWN = 0xFF,
duke@435	330	HPROF_GC_ROOT_JNI_GLOBAL = 0x01,
duke@435	331	HPROF_GC_ROOT_JNI_LOCAL = 0x02,
duke@435	332	HPROF_GC_ROOT_JAVA_FRAME = 0x03,
duke@435	333	HPROF_GC_ROOT_NATIVE_STACK = 0x04,
duke@435	334	HPROF_GC_ROOT_STICKY_CLASS = 0x05,
duke@435	335	HPROF_GC_ROOT_THREAD_BLOCK = 0x06,
duke@435	336	HPROF_GC_ROOT_MONITOR_USED = 0x07,
duke@435	337	HPROF_GC_ROOT_THREAD_OBJ = 0x08,
duke@435	338	HPROF_GC_CLASS_DUMP = 0x20,
duke@435	339	HPROF_GC_INSTANCE_DUMP = 0x21,
duke@435	340	HPROF_GC_OBJ_ARRAY_DUMP = 0x22,
duke@435	341	HPROF_GC_PRIM_ARRAY_DUMP = 0x23
duke@435	342	} hprofTag;
duke@435	343
duke@435	344	// Default stack trace ID (used for dummy HPROF_TRACE record)
duke@435	345	enum {
mchung@831	346	STACK_TRACE_ID = 1,
mchung@831	347	INITIAL_CLASS_COUNT = 200
duke@435	348	};
duke@435	349
duke@435	350	// Supports I/O operations on a dump file
duke@435	351
duke@435	352	class DumpWriter : public StackObj {
duke@435	353	private:
duke@435	354	enum {
duke@435	355	io_buffer_size = 8*M
duke@435	356	};
duke@435	357
duke@435	358	int _fd; // file descriptor (-1 if dump file not open)
duke@435	359	jlong _bytes_written; // number of byte written to dump file
duke@435	360
duke@435	361	char* _buffer; // internal buffer
duke@435	362	int _size;
duke@435	363	int _pos;
duke@435	364
duke@435	365	char* _error; // error message when I/O fails
duke@435	366
duke@435	367	void set_file_descriptor(int fd) { _fd = fd; }
duke@435	368	int file_descriptor() const { return _fd; }
duke@435	369
duke@435	370	char* buffer() const { return _buffer; }
duke@435	371	int buffer_size() const { return _size; }
duke@435	372	int position() const { return _pos; }
duke@435	373	void set_position(int pos) { _pos = pos; }
duke@435	374
duke@435	375	void set_error(const char* error) { _error = (char*)os::strdup(error); }
duke@435	376
duke@435	377	// all I/O go through this function
duke@435	378	void write_internal(void* s, int len);
duke@435	379
duke@435	380	public:
duke@435	381	DumpWriter(const char* path);
duke@435	382	~DumpWriter();
duke@435	383
duke@435	384	void close();
duke@435	385	bool is_open() const { return file_descriptor() >= 0; }
duke@435	386	void flush();
duke@435	387
duke@435	388	// total number of bytes written to the disk
duke@435	389	jlong bytes_written() const { return _bytes_written; }
duke@435	390
duke@435	391	// adjust the number of bytes written to disk (used to keep the count
duke@435	392	// of the number of bytes written in case of rewrites)
duke@435	393	void adjust_bytes_written(jlong n) { _bytes_written += n; }
duke@435	394
duke@435	395	// number of (buffered) bytes as yet unwritten to the dump file
duke@435	396	jlong bytes_unwritten() const { return (jlong)position(); }
duke@435	397
duke@435	398	char* error() const { return _error; }
duke@435	399
duke@435	400	jlong current_offset();
duke@435	401	void seek_to_offset(jlong pos);
duke@435	402
duke@435	403	// writer functions
duke@435	404	void write_raw(void* s, int len);
duke@435	405	void write_u1(u1 x) { write_raw((void*)&x, 1); }
duke@435	406	void write_u2(u2 x);
duke@435	407	void write_u4(u4 x);
duke@435	408	void write_u8(u8 x);
duke@435	409	void write_objectID(oop o);
duke@435	410	void write_classID(Klass* k);
mchung@831	411	void write_id(u4 x);
duke@435	412	};
duke@435	413
duke@435	414	DumpWriter::DumpWriter(const char* path) {
duke@435	415	// try to allocate an I/O buffer of io_buffer_size. If there isn't
duke@435	416	// sufficient memory then reduce size until we can allocate something.
duke@435	417	_size = io_buffer_size;
duke@435	418	do {
duke@435	419	_buffer = (char*)os::malloc(_size);
duke@435	420	if (_buffer == NULL) {
duke@435	421	_size = _size >> 1;
duke@435	422	}
duke@435	423	} while (_buffer == NULL && _size > 0);
duke@435	424	assert((_size > 0 && _buffer != NULL) || (_size == 0 && _buffer == NULL), "sanity check");
duke@435	425	_pos = 0;
duke@435	426	_error = NULL;
duke@435	427	_bytes_written = 0L;
duke@435	428	_fd = os::create_binary_file(path, false); // don't replace existing file
duke@435	429
duke@435	430	// if the open failed we record the error
duke@435	431	if (_fd < 0) {
duke@435	432	_error = (char*)os::strdup(strerror(errno));
duke@435	433	}
duke@435	434	}
duke@435	435
duke@435	436	DumpWriter::~DumpWriter() {
duke@435	437	// flush and close dump file
duke@435	438	if (file_descriptor() >= 0) {
duke@435	439	close();
duke@435	440	}
duke@435	441	if (_buffer != NULL) os::free(_buffer);
duke@435	442	if (_error != NULL) os::free(_error);
duke@435	443	}
duke@435	444
duke@435	445	// closes dump file (if open)
duke@435	446	void DumpWriter::close() {
duke@435	447	// flush and close dump file
duke@435	448	if (file_descriptor() >= 0) {
duke@435	449	flush();
duke@435	450	::close(file_descriptor());
duke@435	451	}
duke@435	452	}
duke@435	453
duke@435	454	// write directly to the file
duke@435	455	void DumpWriter::write_internal(void* s, int len) {
duke@435	456	if (is_open()) {
duke@435	457	int n = ::write(file_descriptor(), s, len);
duke@435	458	if (n > 0) {
duke@435	459	_bytes_written += n;
duke@435	460	}
duke@435	461	if (n != len) {
duke@435	462	if (n < 0) {
duke@435	463	set_error(strerror(errno));
duke@435	464	} else {
duke@435	465	set_error("file size limit");
duke@435	466	}
duke@435	467	::close(file_descriptor());
duke@435	468	set_file_descriptor(-1);
duke@435	469	}
duke@435	470	}
duke@435	471	}
duke@435	472
duke@435	473	// write raw bytes
duke@435	474	void DumpWriter::write_raw(void* s, int len) {
duke@435	475	if (is_open()) {
duke@435	476	// flush buffer to make toom
duke@435	477	if ((position()+ len) >= buffer_size()) {
duke@435	478	flush();
duke@435	479	}
duke@435	480
duke@435	481	// buffer not available or too big to buffer it
duke@435	482	if ((buffer() == NULL) || (len >= buffer_size())) {
duke@435	483	write_internal(s, len);
duke@435	484	} else {
duke@435	485	// Should optimize this for u1/u2/u4/u8 sizes.
duke@435	486	memcpy(buffer() + position(), s, len);
duke@435	487	set_position(position() + len);
duke@435	488	}
duke@435	489	}
duke@435	490	}
duke@435	491
duke@435	492	// flush any buffered bytes to the file
duke@435	493	void DumpWriter::flush() {
duke@435	494	if (is_open() && position() > 0) {
duke@435	495	write_internal(buffer(), position());
duke@435	496	set_position(0);
duke@435	497	}
duke@435	498	}
duke@435	499
duke@435	500
duke@435	501	jlong DumpWriter::current_offset() {
duke@435	502	if (is_open()) {
duke@435	503	// the offset is the file offset plus whatever we have buffered
duke@435	504	jlong offset = os::current_file_offset(file_descriptor());
duke@435	505	assert(offset >= 0, "lseek failed");
duke@435	506	return offset + (jlong)position();
duke@435	507	} else {
duke@435	508	return (jlong)-1;
duke@435	509	}
duke@435	510	}
duke@435	511
duke@435	512	void DumpWriter::seek_to_offset(jlong off) {
duke@435	513	assert(off >= 0, "bad offset");
duke@435	514
duke@435	515	// need to flush before seeking
duke@435	516	flush();
duke@435	517
duke@435	518	// may be closed due to I/O error
duke@435	519	if (is_open()) {
duke@435	520	jlong n = os::seek_to_file_offset(file_descriptor(), off);
duke@435	521	assert(n >= 0, "lseek failed");
duke@435	522	}
duke@435	523	}
duke@435	524
duke@435	525	void DumpWriter::write_u2(u2 x) {
duke@435	526	u2 v;
duke@435	527	Bytes::put_Java_u2((address)&v, x);
duke@435	528	write_raw((void*)&v, 2);
duke@435	529	}
duke@435	530
duke@435	531	void DumpWriter::write_u4(u4 x) {
duke@435	532	u4 v;
duke@435	533	Bytes::put_Java_u4((address)&v, x);
duke@435	534	write_raw((void*)&v, 4);
duke@435	535	}
duke@435	536
duke@435	537	void DumpWriter::write_u8(u8 x) {
duke@435	538	u8 v;
duke@435	539	Bytes::put_Java_u8((address)&v, x);
duke@435	540	write_raw((void*)&v, 8);
duke@435	541	}
duke@435	542
duke@435	543	void DumpWriter::write_objectID(oop o) {
duke@435	544	address a = (address)((uintptr_t)o);
duke@435	545	#ifdef _LP64
duke@435	546	write_u8((u8)a);
duke@435	547	#else
duke@435	548	write_u4((u4)a);
duke@435	549	#endif
duke@435	550	}
duke@435	551
mchung@831	552	void DumpWriter::write_id(u4 x) {
mchung@831	553	#ifdef _LP64
mchung@831	554	write_u8((u8) x);
mchung@831	555	#else
mchung@831	556	write_u4(x);
mchung@831	557	#endif
mchung@831	558	}
mchung@831	559
duke@435	560	// We use java mirror as the class ID
duke@435	561	void DumpWriter::write_classID(Klass* k) {
duke@435	562	write_objectID(k->java_mirror());
duke@435	563	}
duke@435	564
duke@435	565
duke@435	566
duke@435	567	// Support class with a collection of functions used when dumping the heap
duke@435	568
duke@435	569	class DumperSupport : AllStatic {
duke@435	570	public:
duke@435	571
duke@435	572	// write a header of the given type
duke@435	573	static void write_header(DumpWriter* writer, hprofTag tag, u4 len);
duke@435	574
duke@435	575	// returns hprof tag for the given type signature
duke@435	576	static hprofTag sig2tag(symbolOop sig);
duke@435	577	// returns hprof tag for the given basic type
duke@435	578	static hprofTag type2tag(BasicType type);
duke@435	579
duke@435	580	// returns the size of the instance of the given class
duke@435	581	static u4 instance_size(klassOop k);
duke@435	582
duke@435	583	// dump a jfloat
duke@435	584	static void dump_float(DumpWriter* writer, jfloat f);
duke@435	585	// dump a jdouble
duke@435	586	static void dump_double(DumpWriter* writer, jdouble d);
duke@435	587	// dumps the raw value of the given field
duke@435	588	static void dump_field_value(DumpWriter* writer, char type, address addr);
duke@435	589	// dumps static fields of the given class
duke@435	590	static void dump_static_fields(DumpWriter* writer, klassOop k);
duke@435	591	// dump the raw values of the instance fields of the given object
duke@435	592	static void dump_instance_fields(DumpWriter* writer, oop o);
duke@435	593	// dumps the definition of the instance fields for a given class
duke@435	594	static void dump_instance_field_descriptors(DumpWriter* writer, klassOop k);
duke@435	595	// creates HPROF_GC_INSTANCE_DUMP record for the given object
duke@435	596	static void dump_instance(DumpWriter* writer, oop o);
duke@435	597	// creates HPROF_GC_CLASS_DUMP record for the given class and each of its
duke@435	598	// array classes
duke@435	599	static void dump_class_and_array_classes(DumpWriter* writer, klassOop k);
duke@435	600	// creates HPROF_GC_CLASS_DUMP record for a given primitive array
duke@435	601	// class (and each multi-dimensional array class too)
duke@435	602	static void dump_basic_type_array_class(DumpWriter* writer, klassOop k);
duke@435	603
duke@435	604	// creates HPROF_GC_OBJ_ARRAY_DUMP record for the given object array
duke@435	605	static void dump_object_array(DumpWriter* writer, objArrayOop array);
duke@435	606	// creates HPROF_GC_PRIM_ARRAY_DUMP record for the given type array
duke@435	607	static void dump_prim_array(DumpWriter* writer, typeArrayOop array);
mchung@831	608	// create HPROF_FRAME record for the given method and bci
mchung@831	609	static void dump_stack_frame(DumpWriter* writer, int frame_serial_num, int class_serial_num, methodOop m, int bci);
duke@435	610	};
duke@435	611
duke@435	612	// write a header of the given type
duke@435	613	void DumperSupport:: write_header(DumpWriter* writer, hprofTag tag, u4 len) {
duke@435	614	writer->write_u1((u1)tag);
duke@435	615	writer->write_u4(0); // current ticks
duke@435	616	writer->write_u4(len);
duke@435	617	}
duke@435	618
duke@435	619	// returns hprof tag for the given type signature
duke@435	620	hprofTag DumperSupport::sig2tag(symbolOop sig) {
duke@435	621	switch (sig->byte_at(0)) {
duke@435	622	case JVM_SIGNATURE_CLASS : return HPROF_NORMAL_OBJECT;
duke@435	623	case JVM_SIGNATURE_ARRAY : return HPROF_NORMAL_OBJECT;
duke@435	624	case JVM_SIGNATURE_BYTE : return HPROF_BYTE;
duke@435	625	case JVM_SIGNATURE_CHAR : return HPROF_CHAR;
duke@435	626	case JVM_SIGNATURE_FLOAT : return HPROF_FLOAT;
duke@435	627	case JVM_SIGNATURE_DOUBLE : return HPROF_DOUBLE;
duke@435	628	case JVM_SIGNATURE_INT : return HPROF_INT;
duke@435	629	case JVM_SIGNATURE_LONG : return HPROF_LONG;
duke@435	630	case JVM_SIGNATURE_SHORT : return HPROF_SHORT;
duke@435	631	case JVM_SIGNATURE_BOOLEAN : return HPROF_BOOLEAN;
duke@435	632	default : ShouldNotReachHere(); /* to shut up compiler */ return HPROF_BYTE;
duke@435	633	}
duke@435	634	}
duke@435	635
duke@435	636	hprofTag DumperSupport::type2tag(BasicType type) {
duke@435	637	switch (type) {
duke@435	638	case T_BYTE : return HPROF_BYTE;
duke@435	639	case T_CHAR : return HPROF_CHAR;
duke@435	640	case T_FLOAT : return HPROF_FLOAT;
duke@435	641	case T_DOUBLE : return HPROF_DOUBLE;
duke@435	642	case T_INT : return HPROF_INT;
duke@435	643	case T_LONG : return HPROF_LONG;
duke@435	644	case T_SHORT : return HPROF_SHORT;
duke@435	645	case T_BOOLEAN : return HPROF_BOOLEAN;
duke@435	646	default : ShouldNotReachHere(); /* to shut up compiler */ return HPROF_BYTE;
duke@435	647	}
duke@435	648	}
duke@435	649
duke@435	650	// dump a jfloat
duke@435	651	void DumperSupport::dump_float(DumpWriter* writer, jfloat f) {
duke@435	652	if (g_isnan(f)) {
duke@435	653	writer->write_u4(0x7fc00000); // collapsing NaNs
duke@435	654	} else {
duke@435	655	union {
duke@435	656	int i;
duke@435	657	float f;
duke@435	658	} u;
duke@435	659	u.f = (float)f;
duke@435	660	writer->write_u4((u4)u.i);
duke@435	661	}
duke@435	662	}
duke@435	663
duke@435	664	// dump a jdouble
duke@435	665	void DumperSupport::dump_double(DumpWriter* writer, jdouble d) {
duke@435	666	union {
duke@435	667	jlong l;
duke@435	668	double d;
duke@435	669	} u;
duke@435	670	if (g_isnan(d)) { // collapsing NaNs
duke@435	671	u.l = (jlong)(0x7ff80000);
duke@435	672	u.l = (u.l << 32);
duke@435	673	} else {
duke@435	674	u.d = (double)d;
duke@435	675	}
duke@435	676	writer->write_u8((u8)u.l);
duke@435	677	}
duke@435	678
duke@435	679	// dumps the raw value of the given field
duke@435	680	void DumperSupport::dump_field_value(DumpWriter* writer, char type, address addr) {
duke@435	681	switch (type) {
duke@435	682	case JVM_SIGNATURE_CLASS :
duke@435	683	case JVM_SIGNATURE_ARRAY : {
coleenp@548	684	oop o;
coleenp@548	685	if (UseCompressedOops) {
coleenp@548	686	o = oopDesc::load_decode_heap_oop((narrowOop*)addr);
coleenp@548	687	} else {
coleenp@548	688	o = oopDesc::load_decode_heap_oop((oop*)addr);
coleenp@548	689	}
duke@435	690
duke@435	691	// reflection and sun.misc.Unsafe classes may have a reference to a
duke@435	692	// klassOop so filter it out.
duke@435	693	if (o != NULL && o->is_klass()) {
duke@435	694	o = NULL;
duke@435	695	}
duke@435	696
duke@435	697	// FIXME: When sharing is enabled we don't emit field references to objects
duke@435	698	// in shared spaces. We can remove this once we write records for the classes
duke@435	699	// and strings that are shared.
duke@435	700	if (o != NULL && o->is_shared()) {
duke@435	701	o = NULL;
duke@435	702	}
duke@435	703	writer->write_objectID(o);
duke@435	704	break;
duke@435	705	}
duke@435	706	case JVM_SIGNATURE_BYTE : {
duke@435	707	jbyte* b = (jbyte*)addr;
duke@435	708	writer->write_u1((u1)*b);
duke@435	709	break;
duke@435	710	}
duke@435	711	case JVM_SIGNATURE_CHAR : {
duke@435	712	jchar* c = (jchar*)addr;
duke@435	713	writer->write_u2((u2)*c);
duke@435	714	break;
duke@435	715	}
duke@435	716	case JVM_SIGNATURE_SHORT : {
duke@435	717	jshort* s = (jshort*)addr;
duke@435	718	writer->write_u2((u2)*s);
duke@435	719	break;
duke@435	720	}
duke@435	721	case JVM_SIGNATURE_FLOAT : {
duke@435	722	jfloat* f = (jfloat*)addr;
duke@435	723	dump_float(writer, *f);
duke@435	724	break;
duke@435	725	}
duke@435	726	case JVM_SIGNATURE_DOUBLE : {
duke@435	727	jdouble* f = (jdouble*)addr;
duke@435	728	dump_double(writer, *f);
duke@435	729	break;
duke@435	730	}
duke@435	731	case JVM_SIGNATURE_INT : {
duke@435	732	jint* i = (jint*)addr;
duke@435	733	writer->write_u4((u4)*i);
duke@435	734	break;
duke@435	735	}
duke@435	736	case JVM_SIGNATURE_LONG : {
duke@435	737	jlong* l = (jlong*)addr;
duke@435	738	writer->write_u8((u8)*l);
duke@435	739	break;
duke@435	740	}
duke@435	741	case JVM_SIGNATURE_BOOLEAN : {
duke@435	742	jboolean* b = (jboolean*)addr;
duke@435	743	writer->write_u1((u1)*b);
duke@435	744	break;
duke@435	745	}
duke@435	746	default : ShouldNotReachHere();
duke@435	747	}
duke@435	748	}
duke@435	749
duke@435	750	// returns the size of the instance of the given class
duke@435	751	u4 DumperSupport::instance_size(klassOop k) {
duke@435	752	HandleMark hm;
duke@435	753	instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
duke@435	754
duke@435	755	int size = 0;
duke@435	756
duke@435	757	for (FieldStream fld(ikh, false, false); !fld.eos(); fld.next()) {
duke@435	758	if (!fld.access_flags().is_static()) {
duke@435	759	symbolOop sig = fld.signature();
duke@435	760	switch (sig->byte_at(0)) {
duke@435	761	case JVM_SIGNATURE_CLASS :
duke@435	762	case JVM_SIGNATURE_ARRAY : size += oopSize; break;
duke@435	763
duke@435	764	case JVM_SIGNATURE_BYTE :
duke@435	765	case JVM_SIGNATURE_BOOLEAN : size += 1; break;
duke@435	766
duke@435	767	case JVM_SIGNATURE_CHAR :
duke@435	768	case JVM_SIGNATURE_SHORT : size += 2; break;
duke@435	769
duke@435	770	case JVM_SIGNATURE_INT :
duke@435	771	case JVM_SIGNATURE_FLOAT : size += 4; break;
duke@435	772
duke@435	773	case JVM_SIGNATURE_LONG :
duke@435	774	case JVM_SIGNATURE_DOUBLE : size += 8; break;
duke@435	775
duke@435	776	default : ShouldNotReachHere();
duke@435	777	}
duke@435	778	}
duke@435	779	}
duke@435	780	return (u4)size;
duke@435	781	}
duke@435	782
duke@435	783	// dumps static fields of the given class
duke@435	784	void DumperSupport::dump_static_fields(DumpWriter* writer, klassOop k) {
duke@435	785	HandleMark hm;
duke@435	786	instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
duke@435	787
duke@435	788	// pass 1 - count the static fields
duke@435	789	u2 field_count = 0;
duke@435	790	for (FieldStream fldc(ikh, true, true); !fldc.eos(); fldc.next()) {
duke@435	791	if (fldc.access_flags().is_static()) field_count++;
duke@435	792	}
duke@435	793
duke@435	794	writer->write_u2(field_count);
duke@435	795
duke@435	796	// pass 2 - dump the field descriptors and raw values
duke@435	797	for (FieldStream fld(ikh, true, true); !fld.eos(); fld.next()) {
duke@435	798	if (fld.access_flags().is_static()) {
duke@435	799	symbolOop sig = fld.signature();
duke@435	800
duke@435	801	writer->write_objectID(fld.name()); // name
duke@435	802	writer->write_u1(sig2tag(sig)); // type
duke@435	803
duke@435	804	// value
duke@435	805	int offset = fld.offset();
duke@435	806	address addr = (address)k + offset;
duke@435	807
duke@435	808	dump_field_value(writer, sig->byte_at(0), addr);
duke@435	809	}
duke@435	810	}
duke@435	811	}
duke@435	812
duke@435	813	// dump the raw values of the instance fields of the given object
duke@435	814	void DumperSupport::dump_instance_fields(DumpWriter* writer, oop o) {
duke@435	815	HandleMark hm;
duke@435	816	instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), o->klass());
duke@435	817
duke@435	818	for (FieldStream fld(ikh, false, false); !fld.eos(); fld.next()) {
duke@435	819	if (!fld.access_flags().is_static()) {
duke@435	820	symbolOop sig = fld.signature();
duke@435	821	address addr = (address)o + fld.offset();
duke@435	822
duke@435	823	dump_field_value(writer, sig->byte_at(0), addr);
duke@435	824	}
duke@435	825	}
duke@435	826	}
duke@435	827
duke@435	828	// dumps the definition of the instance fields for a given class
duke@435	829	void DumperSupport::dump_instance_field_descriptors(DumpWriter* writer, klassOop k) {
duke@435	830	HandleMark hm;
duke@435	831	instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
duke@435	832
duke@435	833	// pass 1 - count the instance fields
duke@435	834	u2 field_count = 0;
duke@435	835	for (FieldStream fldc(ikh, true, true); !fldc.eos(); fldc.next()) {
duke@435	836	if (!fldc.access_flags().is_static()) field_count++;
duke@435	837	}
duke@435	838
duke@435	839	writer->write_u2(field_count);
duke@435	840
duke@435	841	// pass 2 - dump the field descriptors
duke@435	842	for (FieldStream fld(ikh, true, true); !fld.eos(); fld.next()) {
duke@435	843	if (!fld.access_flags().is_static()) {
duke@435	844	symbolOop sig = fld.signature();
duke@435	845
duke@435	846	writer->write_objectID(fld.name()); // name
duke@435	847	writer->write_u1(sig2tag(sig)); // type
duke@435	848	}
duke@435	849	}
duke@435	850	}
duke@435	851
duke@435	852	// creates HPROF_GC_INSTANCE_DUMP record for the given object
duke@435	853	void DumperSupport::dump_instance(DumpWriter* writer, oop o) {
duke@435	854	klassOop k = o->klass();
duke@435	855
duke@435	856	writer->write_u1(HPROF_GC_INSTANCE_DUMP);
duke@435	857	writer->write_objectID(o);
duke@435	858	writer->write_u4(STACK_TRACE_ID);
duke@435	859
duke@435	860	// class ID
duke@435	861	writer->write_classID(Klass::cast(k));
duke@435	862
duke@435	863	// number of bytes that follow
duke@435	864	writer->write_u4(instance_size(k) );
duke@435	865
duke@435	866	// field values
duke@435	867	dump_instance_fields(writer, o);
duke@435	868	}
duke@435	869
duke@435	870	// creates HPROF_GC_CLASS_DUMP record for the given class and each of
duke@435	871	// its array classes
duke@435	872	void DumperSupport::dump_class_and_array_classes(DumpWriter* writer, klassOop k) {
duke@435	873	Klass* klass = Klass::cast(k);
duke@435	874	assert(klass->oop_is_instance(), "not an instanceKlass");
duke@435	875	instanceKlass* ik = (instanceKlass*)klass;
duke@435	876
duke@435	877	writer->write_u1(HPROF_GC_CLASS_DUMP);
duke@435	878
duke@435	879	// class ID
duke@435	880	writer->write_classID(ik);
duke@435	881	writer->write_u4(STACK_TRACE_ID);
duke@435	882
duke@435	883	// super class ID
duke@435	884	klassOop java_super = ik->java_super();
duke@435	885	if (java_super == NULL) {
duke@435	886	writer->write_objectID(NULL);
duke@435	887	} else {
duke@435	888	writer->write_classID(Klass::cast(java_super));
duke@435	889	}
duke@435	890
duke@435	891	writer->write_objectID(ik->class_loader());
duke@435	892	writer->write_objectID(ik->signers());
duke@435	893	writer->write_objectID(ik->protection_domain());
duke@435	894
duke@435	895	// reserved
duke@435	896	writer->write_objectID(NULL);
duke@435	897	writer->write_objectID(NULL);
duke@435	898
duke@435	899	// instance size
duke@435	900	writer->write_u4(DumperSupport::instance_size(k));
duke@435	901
duke@435	902	// size of constant pool - ignored by HAT 1.1
duke@435	903	writer->write_u2(0);
duke@435	904
duke@435	905	// number of static fields
duke@435	906	dump_static_fields(writer, k);
duke@435	907
duke@435	908	// description of instance fields
duke@435	909	dump_instance_field_descriptors(writer, k);
duke@435	910
duke@435	911	// array classes
duke@435	912	k = klass->array_klass_or_null();
duke@435	913	while (k != NULL) {
duke@435	914	Klass* klass = Klass::cast(k);
duke@435	915	assert(klass->oop_is_objArray(), "not an objArrayKlass");
duke@435	916
duke@435	917	writer->write_u1(HPROF_GC_CLASS_DUMP);
duke@435	918	writer->write_classID(klass);
duke@435	919	writer->write_u4(STACK_TRACE_ID);
duke@435	920
duke@435	921	// super class of array classes is java.lang.Object
duke@435	922	java_super = klass->java_super();
duke@435	923	assert(java_super != NULL, "checking");
duke@435	924	writer->write_classID(Klass::cast(java_super));
duke@435	925
duke@435	926	writer->write_objectID(ik->class_loader());
duke@435	927	writer->write_objectID(ik->signers());
duke@435	928	writer->write_objectID(ik->protection_domain());
duke@435	929
duke@435	930	writer->write_objectID(NULL); // reserved
duke@435	931	writer->write_objectID(NULL);
duke@435	932	writer->write_u4(0); // instance size
duke@435	933	writer->write_u2(0); // constant pool
duke@435	934	writer->write_u2(0); // static fields
duke@435	935	writer->write_u2(0); // instance fields
duke@435	936
duke@435	937	// get the array class for the next rank
duke@435	938	k = klass->array_klass_or_null();
duke@435	939	}
duke@435	940	}
duke@435	941
duke@435	942	// creates HPROF_GC_CLASS_DUMP record for a given primitive array
duke@435	943	// class (and each multi-dimensional array class too)
duke@435	944	void DumperSupport::dump_basic_type_array_class(DumpWriter* writer, klassOop k) {
duke@435	945	// array classes
duke@435	946	while (k != NULL) {
duke@435	947	Klass* klass = Klass::cast(k);
duke@435	948
duke@435	949	writer->write_u1(HPROF_GC_CLASS_DUMP);
duke@435	950	writer->write_classID(klass);
duke@435	951	writer->write_u4(STACK_TRACE_ID);
duke@435	952
duke@435	953	// super class of array classes is java.lang.Object
duke@435	954	klassOop java_super = klass->java_super();
duke@435	955	assert(java_super != NULL, "checking");
duke@435	956	writer->write_classID(Klass::cast(java_super));
duke@435	957
duke@435	958	writer->write_objectID(NULL); // loader
duke@435	959	writer->write_objectID(NULL); // signers
duke@435	960	writer->write_objectID(NULL); // protection domain
duke@435	961
duke@435	962	writer->write_objectID(NULL); // reserved
duke@435	963	writer->write_objectID(NULL);
duke@435	964	writer->write_u4(0); // instance size
duke@435	965	writer->write_u2(0); // constant pool
duke@435	966	writer->write_u2(0); // static fields
duke@435	967	writer->write_u2(0); // instance fields
duke@435	968
duke@435	969	// get the array class for the next rank
duke@435	970	k = klass->array_klass_or_null();
duke@435	971	}
duke@435	972	}
duke@435	973
duke@435	974	// creates HPROF_GC_OBJ_ARRAY_DUMP record for the given object array
duke@435	975	void DumperSupport::dump_object_array(DumpWriter* writer, objArrayOop array) {
duke@435	976
duke@435	977	// filter this
duke@435	978	if (array->klass() == Universe::systemObjArrayKlassObj()) return;
duke@435	979
duke@435	980	writer->write_u1(HPROF_GC_OBJ_ARRAY_DUMP);
duke@435	981	writer->write_objectID(array);
duke@435	982	writer->write_u4(STACK_TRACE_ID);
duke@435	983	writer->write_u4((u4)array->length());
duke@435	984
duke@435	985	// array class ID
duke@435	986	writer->write_classID(Klass::cast(array->klass()));
duke@435	987
duke@435	988	// [id]* elements
duke@435	989	for (int index=0; index<array->length(); index++) {
duke@435	990	oop o = array->obj_at(index);
duke@435	991	writer->write_objectID(o);
duke@435	992	}
duke@435	993	}
duke@435	994
duke@435	995	#define WRITE_ARRAY(Array, Type, Size) \
duke@435	996	for (int i=0; i<Array->length(); i++) { writer->write_##Size((Size)array->Type##_at(i)); }
duke@435	997
duke@435	998
duke@435	999	// creates HPROF_GC_PRIM_ARRAY_DUMP record for the given type array
duke@435	1000	void DumperSupport::dump_prim_array(DumpWriter* writer, typeArrayOop array) {
duke@435	1001	BasicType type = typeArrayKlass::cast(array->klass())->element_type();
duke@435	1002
duke@435	1003	writer->write_u1(HPROF_GC_PRIM_ARRAY_DUMP);
duke@435	1004	writer->write_objectID(array);
duke@435	1005	writer->write_u4(STACK_TRACE_ID);
duke@435	1006	writer->write_u4((u4)array->length());
duke@435	1007	writer->write_u1(type2tag(type));
duke@435	1008
duke@435	1009	// nothing to copy
duke@435	1010	if (array->length() == 0) {
duke@435	1011	return;
duke@435	1012	}
duke@435	1013
duke@435	1014	// If the byte ordering is big endian then we can copy most types directly
kvn@464	1015	int length_in_bytes = array->length() * type2aelembytes(type);
duke@435	1016	assert(length_in_bytes > 0, "nothing to copy");
duke@435	1017
duke@435	1018	switch (type) {
duke@435	1019	case T_INT : {
duke@435	1020	if (Bytes::is_Java_byte_ordering_different()) {
duke@435	1021	WRITE_ARRAY(array, int, u4);
duke@435	1022	} else {
duke@435	1023	writer->write_raw((void*)(array->int_at_addr(0)), length_in_bytes);
duke@435	1024	}
duke@435	1025	break;
duke@435	1026	}
duke@435	1027	case T_BYTE : {
duke@435	1028	writer->write_raw((void*)(array->byte_at_addr(0)), length_in_bytes);
duke@435	1029	break;
duke@435	1030	}
duke@435	1031	case T_CHAR : {
duke@435	1032	if (Bytes::is_Java_byte_ordering_different()) {
duke@435	1033	WRITE_ARRAY(array, char, u2);
duke@435	1034	} else {
duke@435	1035	writer->write_raw((void*)(array->char_at_addr(0)), length_in_bytes);
duke@435	1036	}
duke@435	1037	break;
duke@435	1038	}
duke@435	1039	case T_SHORT : {
duke@435	1040	if (Bytes::is_Java_byte_ordering_different()) {
duke@435	1041	WRITE_ARRAY(array, short, u2);
duke@435	1042	} else {
duke@435	1043	writer->write_raw((void*)(array->short_at_addr(0)), length_in_bytes);
duke@435	1044	}
duke@435	1045	break;
duke@435	1046	}
duke@435	1047	case T_BOOLEAN : {
duke@435	1048	if (Bytes::is_Java_byte_ordering_different()) {
duke@435	1049	WRITE_ARRAY(array, bool, u1);
duke@435	1050	} else {
duke@435	1051	writer->write_raw((void*)(array->bool_at_addr(0)), length_in_bytes);
duke@435	1052	}
duke@435	1053	break;
duke@435	1054	}
duke@435	1055	case T_LONG : {
duke@435	1056	if (Bytes::is_Java_byte_ordering_different()) {
duke@435	1057	WRITE_ARRAY(array, long, u8);
duke@435	1058	} else {
duke@435	1059	writer->write_raw((void*)(array->long_at_addr(0)), length_in_bytes);
duke@435	1060	}
duke@435	1061	break;
duke@435	1062	}
duke@435	1063
duke@435	1064	// handle float/doubles in a special value to ensure than NaNs are
duke@435	1065	// written correctly. TO DO: Check if we can avoid this on processors that
duke@435	1066	// use IEEE 754.
duke@435	1067
duke@435	1068	case T_FLOAT : {
duke@435	1069	for (int i=0; i<array->length(); i++) {
duke@435	1070	dump_float( writer, array->float_at(i) );
duke@435	1071	}
duke@435	1072	break;
duke@435	1073	}
duke@435	1074	case T_DOUBLE : {
duke@435	1075	for (int i=0; i<array->length(); i++) {
duke@435	1076	dump_double( writer, array->double_at(i) );
duke@435	1077	}
duke@435	1078	break;
duke@435	1079	}
duke@435	1080	default : ShouldNotReachHere();
duke@435	1081	}
duke@435	1082	}
duke@435	1083
mchung@831	1084	// create a HPROF_FRAME record of the given methodOop and bci
mchung@831	1085	void DumperSupport::dump_stack_frame(DumpWriter* writer,
mchung@831	1086	int frame_serial_num,
mchung@831	1087	int class_serial_num,
mchung@831	1088	methodOop m,
mchung@831	1089	int bci) {
mchung@831	1090	int line_number;
mchung@831	1091	if (m->is_native()) {
mchung@831	1092	line_number = -3; // native frame
mchung@831	1093	} else {
mchung@831	1094	line_number = m->line_number_from_bci(bci);
mchung@831	1095	}
mchung@831	1096
mchung@831	1097	write_header(writer, HPROF_FRAME, 4*oopSize + 2*sizeof(u4));
mchung@831	1098	writer->write_id(frame_serial_num); // frame serial number
mchung@831	1099	writer->write_objectID(m->name()); // method's name
mchung@831	1100	writer->write_objectID(m->signature()); // method's signature
mchung@831	1101
mchung@831	1102	assert(Klass::cast(m->method_holder())->oop_is_instance(), "not instanceKlass");
mchung@831	1103	writer->write_objectID(instanceKlass::cast(m->method_holder())->source_file_name()); // source file name
mchung@831	1104	writer->write_u4(class_serial_num); // class serial number
mchung@831	1105	writer->write_u4((u4) line_number); // line number
mchung@831	1106	}
duke@435	1107
duke@435	1108	// Support class used to generate HPROF_UTF8 records from the entries in the
duke@435	1109	// SymbolTable.
duke@435	1110
duke@435	1111	class SymbolTableDumper : public OopClosure {
duke@435	1112	private:
duke@435	1113	DumpWriter* _writer;
duke@435	1114	DumpWriter* writer() const { return _writer; }
duke@435	1115	public:
duke@435	1116	SymbolTableDumper(DumpWriter* writer) { _writer = writer; }
duke@435	1117	void do_oop(oop* obj_p);
coleenp@548	1118	void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
duke@435	1119	};
duke@435	1120
duke@435	1121	void SymbolTableDumper::do_oop(oop* obj_p) {
duke@435	1122	ResourceMark rm;
duke@435	1123	symbolOop sym = (symbolOop)*obj_p;
duke@435	1124
duke@435	1125	int len = sym->utf8_length();
duke@435	1126	if (len > 0) {
duke@435	1127	char* s = sym->as_utf8();
duke@435	1128	DumperSupport::write_header(writer(), HPROF_UTF8, oopSize + len);
duke@435	1129	writer()->write_objectID(sym);
duke@435	1130	writer()->write_raw(s, len);
duke@435	1131	}
duke@435	1132	}
duke@435	1133
duke@435	1134
duke@435	1135	// Support class used to generate HPROF_GC_ROOT_JNI_LOCAL records
duke@435	1136
duke@435	1137	class JNILocalsDumper : public OopClosure {
duke@435	1138	private:
duke@435	1139	DumpWriter* _writer;
duke@435	1140	u4 _thread_serial_num;
mchung@831	1141	int _frame_num;
duke@435	1142	DumpWriter* writer() const { return _writer; }
duke@435	1143	public:
duke@435	1144	JNILocalsDumper(DumpWriter* writer, u4 thread_serial_num) {
duke@435	1145	_writer = writer;
duke@435	1146	_thread_serial_num = thread_serial_num;
mchung@831	1147	_frame_num = -1; // default - empty stack
duke@435	1148	}
mchung@831	1149	void set_frame_number(int n) { _frame_num = n; }
duke@435	1150	void do_oop(oop* obj_p);
coleenp@548	1151	void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
duke@435	1152	};
duke@435	1153
duke@435	1154
duke@435	1155	void JNILocalsDumper::do_oop(oop* obj_p) {
duke@435	1156	// ignore null or deleted handles
duke@435	1157	oop o = *obj_p;
duke@435	1158	if (o != NULL && o != JNIHandles::deleted_handle()) {
duke@435	1159	writer()->write_u1(HPROF_GC_ROOT_JNI_LOCAL);
duke@435	1160	writer()->write_objectID(o);
duke@435	1161	writer()->write_u4(_thread_serial_num);
mchung@831	1162	writer()->write_u4((u4)_frame_num);
duke@435	1163	}
duke@435	1164	}
duke@435	1165
duke@435	1166
duke@435	1167	// Support class used to generate HPROF_GC_ROOT_JNI_GLOBAL records
duke@435	1168
duke@435	1169	class JNIGlobalsDumper : public OopClosure {
duke@435	1170	private:
duke@435	1171	DumpWriter* _writer;
duke@435	1172	DumpWriter* writer() const { return _writer; }
duke@435	1173
duke@435	1174	public:
duke@435	1175	JNIGlobalsDumper(DumpWriter* writer) {
duke@435	1176	_writer = writer;
duke@435	1177	}
duke@435	1178	void do_oop(oop* obj_p);
coleenp@548	1179	void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
duke@435	1180	};
duke@435	1181
duke@435	1182	void JNIGlobalsDumper::do_oop(oop* obj_p) {
duke@435	1183	oop o = *obj_p;
duke@435	1184
duke@435	1185	// ignore these
duke@435	1186	if (o == NULL || o == JNIHandles::deleted_handle()) return;
duke@435	1187
duke@435	1188	// we ignore global ref to symbols and other internal objects
duke@435	1189	if (o->is_instance() || o->is_objArray() || o->is_typeArray()) {
duke@435	1190	writer()->write_u1(HPROF_GC_ROOT_JNI_GLOBAL);
duke@435	1191	writer()->write_objectID(o);
duke@435	1192	writer()->write_objectID((oopDesc*)obj_p); // global ref ID
duke@435	1193	}
duke@435	1194	};
duke@435	1195
duke@435	1196
duke@435	1197	// Support class used to generate HPROF_GC_ROOT_MONITOR_USED records
duke@435	1198
duke@435	1199	class MonitorUsedDumper : public OopClosure {
duke@435	1200	private:
duke@435	1201	DumpWriter* _writer;
duke@435	1202	DumpWriter* writer() const { return _writer; }
duke@435	1203	public:
duke@435	1204	MonitorUsedDumper(DumpWriter* writer) {
duke@435	1205	_writer = writer;
duke@435	1206	}
duke@435	1207	void do_oop(oop* obj_p) {
duke@435	1208	writer()->write_u1(HPROF_GC_ROOT_MONITOR_USED);
duke@435	1209	writer()->write_objectID(*obj_p);
duke@435	1210	}
coleenp@548	1211	void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
duke@435	1212	};
duke@435	1213
duke@435	1214
duke@435	1215	// Support class used to generate HPROF_GC_ROOT_STICKY_CLASS records
duke@435	1216
duke@435	1217	class StickyClassDumper : public OopClosure {
duke@435	1218	private:
duke@435	1219	DumpWriter* _writer;
duke@435	1220	DumpWriter* writer() const { return _writer; }
duke@435	1221	public:
duke@435	1222	StickyClassDumper(DumpWriter* writer) {
duke@435	1223	_writer = writer;
duke@435	1224	}
duke@435	1225	void do_oop(oop* obj_p);
coleenp@548	1226	void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
duke@435	1227	};
duke@435	1228
duke@435	1229	void StickyClassDumper::do_oop(oop* obj_p) {
duke@435	1230	if (*obj_p != NULL) {
duke@435	1231	oop o = *obj_p;
duke@435	1232	if (o->is_klass()) {
duke@435	1233	klassOop k = klassOop(o);
duke@435	1234	if (Klass::cast(k)->oop_is_instance()) {
duke@435	1235	instanceKlass* ik = instanceKlass::cast(k);
duke@435	1236	writer()->write_u1(HPROF_GC_ROOT_STICKY_CLASS);
duke@435	1237	writer()->write_classID(ik);
duke@435	1238	}
duke@435	1239	}
duke@435	1240	}
duke@435	1241	}
duke@435	1242
duke@435	1243
duke@435	1244	class VM_HeapDumper;
duke@435	1245
duke@435	1246	// Support class using when iterating over the heap.
duke@435	1247
duke@435	1248	class HeapObjectDumper : public ObjectClosure {
duke@435	1249	private:
duke@435	1250	VM_HeapDumper* _dumper;
duke@435	1251	DumpWriter* _writer;
duke@435	1252
duke@435	1253	VM_HeapDumper* dumper() { return _dumper; }
duke@435	1254	DumpWriter* writer() { return _writer; }
duke@435	1255
duke@435	1256	// used to indicate that a record has been writen
duke@435	1257	void mark_end_of_record();
duke@435	1258
duke@435	1259	public:
duke@435	1260	HeapObjectDumper(VM_HeapDumper* dumper, DumpWriter* writer) {
duke@435	1261	_dumper = dumper;
duke@435	1262	_writer = writer;
duke@435	1263	}
duke@435	1264
duke@435	1265	// called for each object in the heap
duke@435	1266	void do_object(oop o);
duke@435	1267	};
duke@435	1268
duke@435	1269	void HeapObjectDumper::do_object(oop o) {
duke@435	1270	// hide the sentinel for deleted handles
duke@435	1271	if (o == JNIHandles::deleted_handle()) return;
duke@435	1272
duke@435	1273	// ignore KlassKlass objects
duke@435	1274	if (o->is_klass()) return;
duke@435	1275
duke@435	1276	// skip classes as these emitted as HPROF_GC_CLASS_DUMP records
duke@435	1277	if (o->klass() == SystemDictionary::class_klass()) {
duke@435	1278	if (!java_lang_Class::is_primitive(o)) {
duke@435	1279	return;
duke@435	1280	}
duke@435	1281	}
duke@435	1282
duke@435	1283	// create a HPROF_GC_INSTANCE record for each object
duke@435	1284	if (o->is_instance()) {
duke@435	1285	DumperSupport::dump_instance(writer(), o);
duke@435	1286	mark_end_of_record();
duke@435	1287	} else {
duke@435	1288	// create a HPROF_GC_OBJ_ARRAY_DUMP record for each object array
duke@435	1289	if (o->is_objArray()) {
duke@435	1290	DumperSupport::dump_object_array(writer(), objArrayOop(o));
duke@435	1291	mark_end_of_record();
duke@435	1292	} else {
duke@435	1293	// create a HPROF_GC_PRIM_ARRAY_DUMP record for each type array
duke@435	1294	if (o->is_typeArray()) {
duke@435	1295	DumperSupport::dump_prim_array(writer(), typeArrayOop(o));
duke@435	1296	mark_end_of_record();
duke@435	1297	}
duke@435	1298	}
duke@435	1299	}
duke@435	1300	}
duke@435	1301
duke@435	1302	// The VM operation that performs the heap dump
duke@435	1303	class VM_HeapDumper : public VM_GC_Operation {
duke@435	1304	private:
ysr@1050	1305	static VM_HeapDumper* _global_dumper;
ysr@1050	1306	static DumpWriter* _global_writer;
ysr@1050	1307	DumpWriter* _local_writer;
duke@435	1308	bool _gc_before_heap_dump;
duke@435	1309	bool _is_segmented_dump;
duke@435	1310	jlong _dump_start;
mchung@831	1311	GrowableArray<Klass*>* _klass_map;
mchung@831	1312	ThreadStackTrace** _stack_traces;
mchung@831	1313	int _num_threads;
duke@435	1314
ysr@1050	1315	// accessors and setters
ysr@1050	1316	static VM_HeapDumper* dumper() { assert(_global_dumper != NULL, "Error"); return _global_dumper; }
ysr@1050	1317	static DumpWriter* writer() { assert(_global_writer != NULL, "Error"); return _global_writer; }
ysr@1050	1318	void set_global_dumper() {
ysr@1050	1319	assert(_global_dumper == NULL, "Error");
ysr@1050	1320	_global_dumper = this;
ysr@1050	1321	}
ysr@1050	1322	void set_global_writer() {
ysr@1050	1323	assert(_global_writer == NULL, "Error");
ysr@1050	1324	_global_writer = _local_writer;
ysr@1050	1325	}
ysr@1050	1326	void clear_global_dumper() { _global_dumper = NULL; }
ysr@1050	1327	void clear_global_writer() { _global_writer = NULL; }
ysr@1050	1328
duke@435	1329	bool is_segmented_dump() const { return _is_segmented_dump; }
duke@435	1330	void set_segmented_dump() { _is_segmented_dump = true; }
duke@435	1331	jlong dump_start() const { return _dump_start; }
duke@435	1332	void set_dump_start(jlong pos);
duke@435	1333
duke@435	1334	bool skip_operation() const;
duke@435	1335
duke@435	1336	// writes a HPROF_LOAD_CLASS record
duke@435	1337	static void do_load_class(klassOop k);
duke@435	1338
duke@435	1339	// writes a HPROF_GC_CLASS_DUMP record for the given class
duke@435	1340	// (and each array class too)
duke@435	1341	static void do_class_dump(klassOop k);
duke@435	1342
duke@435	1343	// writes a HPROF_GC_CLASS_DUMP records for a given basic type
duke@435	1344	// array (and each multi-dimensional array too)
duke@435	1345	static void do_basic_type_array_class_dump(klassOop k);
duke@435	1346
duke@435	1347	// HPROF_GC_ROOT_THREAD_OBJ records
mchung@831	1348	int do_thread(JavaThread* thread, u4 thread_serial_num);
duke@435	1349	void do_threads();
duke@435	1350
mchung@831	1351	void add_class_serial_number(Klass* k, int serial_num) {
mchung@831	1352	_klass_map->at_put_grow(serial_num, k);
mchung@831	1353	}
mchung@831	1354
mchung@831	1355	// HPROF_TRACE and HPROF_FRAME records
mchung@831	1356	void dump_stack_traces();
mchung@831	1357
duke@435	1358	// writes a HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT record
duke@435	1359	void write_dump_header();
duke@435	1360
duke@435	1361	// fixes up the length of the current dump record
duke@435	1362	void write_current_dump_record_length();
duke@435	1363
duke@435	1364	// fixes up the current dump record )and writes HPROF_HEAP_DUMP_END
duke@435	1365	// record in the case of a segmented heap dump)
duke@435	1366	void end_of_dump();
duke@435	1367
duke@435	1368	public:
duke@435	1369	VM_HeapDumper(DumpWriter* writer, bool gc_before_heap_dump) :
duke@435	1370	VM_GC_Operation(0 /* total collections, dummy, ignored */,
duke@435	1371	0 /* total full collections, dummy, ignored */,
duke@435	1372	gc_before_heap_dump) {
ysr@1050	1373	_local_writer = writer;
duke@435	1374	_gc_before_heap_dump = gc_before_heap_dump;
duke@435	1375	_is_segmented_dump = false;
duke@435	1376	_dump_start = (jlong)-1;
mchung@831	1377	_klass_map = new (ResourceObj::C_HEAP) GrowableArray<Klass*>(INITIAL_CLASS_COUNT, true);
mchung@831	1378	_stack_traces = NULL;
mchung@831	1379	_num_threads = 0;
mchung@831	1380	}
mchung@831	1381	~VM_HeapDumper() {
mchung@831	1382	if (_stack_traces != NULL) {
mchung@831	1383	for (int i=0; i < _num_threads; i++) {
mchung@831	1384	delete _stack_traces[i];
mchung@831	1385	}
mchung@831	1386	FREE_C_HEAP_ARRAY(ThreadStackTrace*, _stack_traces);
mchung@831	1387	}
mchung@831	1388	delete _klass_map;
duke@435	1389	}
duke@435	1390
duke@435	1391	VMOp_Type type() const { return VMOp_HeapDumper; }
duke@435	1392	// used to mark sub-record boundary
duke@435	1393	void check_segment_length();
duke@435	1394	void doit();
duke@435	1395	};
duke@435	1396
ysr@1050	1397	VM_HeapDumper* VM_HeapDumper::_global_dumper = NULL;
ysr@1050	1398	DumpWriter* VM_HeapDumper::_global_writer = NULL;
ysr@1050	1399
duke@435	1400	bool VM_HeapDumper::skip_operation() const {
duke@435	1401	return false;
duke@435	1402	}
duke@435	1403
duke@435	1404	// sets the dump starting position
duke@435	1405	void VM_HeapDumper::set_dump_start(jlong pos) {
duke@435	1406	_dump_start = pos;
duke@435	1407	}
duke@435	1408
duke@435	1409	// writes a HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT record
duke@435	1410	void VM_HeapDumper::write_dump_header() {
duke@435	1411	if (writer()->is_open()) {
duke@435	1412	if (is_segmented_dump()) {
duke@435	1413	writer()->write_u1(HPROF_HEAP_DUMP_SEGMENT);
duke@435	1414	} else {
duke@435	1415	writer()->write_u1(HPROF_HEAP_DUMP);
duke@435	1416	}
duke@435	1417	writer()->write_u4(0); // current ticks
duke@435	1418
duke@435	1419	// record the starting position for the dump (its length will be fixed up later)
duke@435	1420	set_dump_start(writer()->current_offset());
duke@435	1421	writer()->write_u4(0);
duke@435	1422	}
duke@435	1423	}
duke@435	1424
duke@435	1425	// fixes up the length of the current dump record
duke@435	1426	void VM_HeapDumper::write_current_dump_record_length() {
duke@435	1427	if (writer()->is_open()) {
duke@435	1428	assert(dump_start() >= 0, "no dump start recorded");
duke@435	1429
duke@435	1430	// calculate the size of the dump record
duke@435	1431	jlong dump_end = writer()->current_offset();
duke@435	1432	jlong dump_len = (dump_end - dump_start() - 4);
duke@435	1433
duke@435	1434	// record length must fit in a u4
duke@435	1435	if (dump_len > (jlong)(4L*(jlong)G)) {
duke@435	1436	warning("record is too large");
duke@435	1437	}
duke@435	1438
duke@435	1439	// seek to the dump start and fix-up the length
duke@435	1440	writer()->seek_to_offset(dump_start());
duke@435	1441	writer()->write_u4((u4)dump_len);
duke@435	1442
duke@435	1443	// adjust the total size written to keep the bytes written correct.
duke@435	1444	writer()->adjust_bytes_written(-((long) sizeof(u4)));
duke@435	1445
duke@435	1446	// seek to dump end so we can continue
duke@435	1447	writer()->seek_to_offset(dump_end);
duke@435	1448
duke@435	1449	// no current dump record
duke@435	1450	set_dump_start((jlong)-1);
duke@435	1451	}
duke@435	1452	}
duke@435	1453
duke@435	1454	// used on a sub-record boundary to check if we need to start a
duke@435	1455	// new segment.
duke@435	1456	void VM_HeapDumper::check_segment_length() {
duke@435	1457	if (writer()->is_open()) {
duke@435	1458	if (is_segmented_dump()) {
duke@435	1459	// don't use current_offset that would be too expensive on a per record basis
duke@435	1460	jlong dump_end = writer()->bytes_written() + writer()->bytes_unwritten();
duke@435	1461	assert(dump_end == writer()->current_offset(), "checking");
duke@435	1462	jlong dump_len = (dump_end - dump_start() - 4);
duke@435	1463	assert(dump_len >= 0 && dump_len <= max_juint, "bad dump length");
duke@435	1464
duke@435	1465	if (dump_len > (jlong)HeapDumpSegmentSize) {
duke@435	1466	write_current_dump_record_length();
duke@435	1467	write_dump_header();
duke@435	1468	}
duke@435	1469	}
duke@435	1470	}
duke@435	1471	}
duke@435	1472
duke@435	1473	// fixes up the current dump record )and writes HPROF_HEAP_DUMP_END
duke@435	1474	// record in the case of a segmented heap dump)
duke@435	1475	void VM_HeapDumper::end_of_dump() {
duke@435	1476	if (writer()->is_open()) {
duke@435	1477	write_current_dump_record_length();
duke@435	1478
duke@435	1479	// for segmented dump we write the end record
duke@435	1480	if (is_segmented_dump()) {
duke@435	1481	writer()->write_u1(HPROF_HEAP_DUMP_END);
duke@435	1482	writer()->write_u4(0);
duke@435	1483	writer()->write_u4(0);
duke@435	1484	}
duke@435	1485	}
duke@435	1486	}
duke@435	1487
duke@435	1488	// marks sub-record boundary
duke@435	1489	void HeapObjectDumper::mark_end_of_record() {
duke@435	1490	dumper()->check_segment_length();
duke@435	1491	}
duke@435	1492
duke@435	1493	// writes a HPROF_LOAD_CLASS record for the class (and each of its
duke@435	1494	// array classes)
duke@435	1495	void VM_HeapDumper::do_load_class(klassOop k) {
duke@435	1496	static u4 class_serial_num = 0;
duke@435	1497
duke@435	1498	// len of HPROF_LOAD_CLASS record
duke@435	1499	u4 remaining = 2*oopSize + 2*sizeof(u4);
duke@435	1500
duke@435	1501	// write a HPROF_LOAD_CLASS for the class and each array class
duke@435	1502	do {
ysr@1050	1503	DumperSupport::write_header(writer(), HPROF_LOAD_CLASS, remaining);
duke@435	1504
duke@435	1505	// class serial number is just a number
ysr@1050	1506	writer()->write_u4(++class_serial_num);
duke@435	1507
duke@435	1508	// class ID
duke@435	1509	Klass* klass = Klass::cast(k);
ysr@1050	1510	writer()->write_classID(klass);
duke@435	1511
mchung@831	1512	// add the klassOop and class serial number pair
ysr@1050	1513	dumper()->add_class_serial_number(klass, class_serial_num);
mchung@831	1514
ysr@1050	1515	writer()->write_u4(STACK_TRACE_ID);
duke@435	1516
duke@435	1517	// class name ID
duke@435	1518	symbolOop name = klass->name();
ysr@1050	1519	writer()->write_objectID(name);
duke@435	1520
duke@435	1521	// write a LOAD_CLASS record for the array type (if it exists)
duke@435	1522	k = klass->array_klass_or_null();
duke@435	1523	} while (k != NULL);
duke@435	1524	}
duke@435	1525
duke@435	1526	// writes a HPROF_GC_CLASS_DUMP record for the given class
duke@435	1527	void VM_HeapDumper::do_class_dump(klassOop k) {
ysr@1050	1528	DumperSupport::dump_class_and_array_classes(writer(), k);
duke@435	1529	}
duke@435	1530
duke@435	1531	// writes a HPROF_GC_CLASS_DUMP records for a given basic type
duke@435	1532	// array (and each multi-dimensional array too)
duke@435	1533	void VM_HeapDumper::do_basic_type_array_class_dump(klassOop k) {
ysr@1050	1534	DumperSupport::dump_basic_type_array_class(writer(), k);
duke@435	1535	}
duke@435	1536
duke@435	1537	// Walk the stack of the given thread.
duke@435	1538	// Dumps a HPROF_GC_ROOT_JAVA_FRAME record for each local
duke@435	1539	// Dumps a HPROF_GC_ROOT_JNI_LOCAL record for each JNI local
mchung@831	1540	//
mchung@831	1541	// It returns the number of Java frames in this thread stack
mchung@831	1542	int VM_HeapDumper::do_thread(JavaThread* java_thread, u4 thread_serial_num) {
duke@435	1543	JNILocalsDumper blk(writer(), thread_serial_num);
duke@435	1544
duke@435	1545	oop threadObj = java_thread->threadObj();
duke@435	1546	assert(threadObj != NULL, "sanity check");
duke@435	1547
mchung@831	1548	int stack_depth = 0;
duke@435	1549	if (java_thread->has_last_Java_frame()) {
duke@435	1550
duke@435	1551	// vframes are resource allocated
duke@435	1552	Thread* current_thread = Thread::current();
duke@435	1553	ResourceMark rm(current_thread);
duke@435	1554	HandleMark hm(current_thread);
duke@435	1555
duke@435	1556	RegisterMap reg_map(java_thread);
duke@435	1557	frame f = java_thread->last_frame();
duke@435	1558	vframe* vf = vframe::new_vframe(&f, &reg_map, java_thread);
mchung@831	1559	frame* last_entry_frame = NULL;
duke@435	1560
duke@435	1561	while (vf != NULL) {
mchung@831	1562	blk.set_frame_number(stack_depth);
duke@435	1563	if (vf->is_java_frame()) {
duke@435	1564
duke@435	1565	// java frame (interpreted, compiled, ...)
duke@435	1566	javaVFrame *jvf = javaVFrame::cast(vf);
duke@435	1567	if (!(jvf->method()->is_native())) {
duke@435	1568	StackValueCollection* locals = jvf->locals();
duke@435	1569	for (int slot=0; slot<locals->size(); slot++) {
duke@435	1570	if (locals->at(slot)->type() == T_OBJECT) {
duke@435	1571	oop o = locals->obj_at(slot)();
duke@435	1572
duke@435	1573	if (o != NULL) {
duke@435	1574	writer()->write_u1(HPROF_GC_ROOT_JAVA_FRAME);
duke@435	1575	writer()->write_objectID(o);
duke@435	1576	writer()->write_u4(thread_serial_num);
mchung@831	1577	writer()->write_u4((u4) stack_depth);
duke@435	1578	}
duke@435	1579	}
duke@435	1580	}
mchung@831	1581	} else {
mchung@831	1582	// native frame
mchung@831	1583	if (stack_depth == 0) {
mchung@831	1584	// JNI locals for the top frame.
mchung@831	1585	java_thread->active_handles()->oops_do(&blk);
mchung@831	1586	} else {
mchung@831	1587	if (last_entry_frame != NULL) {
mchung@831	1588	// JNI locals for the entry frame
mchung@831	1589	assert(last_entry_frame->is_entry_frame(), "checking");
mchung@831	1590	last_entry_frame->entry_frame_call_wrapper()->handles()->oops_do(&blk);
mchung@831	1591	}
mchung@831	1592	}
duke@435	1593	}
mchung@831	1594	// increment only for Java frames
mchung@831	1595	stack_depth++;
mchung@831	1596	last_entry_frame = NULL;
mchung@831	1597
duke@435	1598	} else {
duke@435	1599	// externalVFrame - if it's an entry frame then report any JNI locals
mchung@831	1600	// as roots when we find the corresponding native javaVFrame
duke@435	1601	frame* fr = vf->frame_pointer();
duke@435	1602	assert(fr != NULL, "sanity check");
duke@435	1603	if (fr->is_entry_frame()) {
mchung@831	1604	last_entry_frame = fr;
duke@435	1605	}
duke@435	1606	}
duke@435	1607	vf = vf->sender();
duke@435	1608	}
mchung@831	1609	} else {
mchung@831	1610	// no last java frame but there may be JNI locals
mchung@831	1611	java_thread->active_handles()->oops_do(&blk);
duke@435	1612	}
mchung@831	1613	return stack_depth;
duke@435	1614	}
duke@435	1615
duke@435	1616
duke@435	1617	// write a HPROF_GC_ROOT_THREAD_OBJ record for each java thread. Then walk
duke@435	1618	// the stack so that locals and JNI locals are dumped.
duke@435	1619	void VM_HeapDumper::do_threads() {
mchung@831	1620	for (int i=0; i < _num_threads; i++) {
mchung@831	1621	JavaThread* thread = _stack_traces[i]->thread();
duke@435	1622	oop threadObj = thread->threadObj();
mchung@831	1623	u4 thread_serial_num = i+1;
mchung@831	1624	u4 stack_serial_num = thread_serial_num + STACK_TRACE_ID;
mchung@831	1625	writer()->write_u1(HPROF_GC_ROOT_THREAD_OBJ);
mchung@831	1626	writer()->write_objectID(threadObj);
mchung@831	1627	writer()->write_u4(thread_serial_num); // thread number
mchung@831	1628	writer()->write_u4(stack_serial_num); // stack trace serial number
mchung@831	1629	int num_frames = do_thread(thread, thread_serial_num);
mchung@831	1630	assert(num_frames == _stack_traces[i]->get_stack_depth(),
mchung@831	1631	"total number of Java frames not matched");
duke@435	1632	}
duke@435	1633	}
duke@435	1634
duke@435	1635
duke@435	1636	// The VM operation that dumps the heap. The dump consists of the following
duke@435	1637	// records:
duke@435	1638	//
duke@435	1639	// HPROF_HEADER
duke@435	1640	// [HPROF_UTF8]*
duke@435	1641	// [HPROF_LOAD_CLASS]*
mchung@831	1642	// [[HPROF_FRAME]*|HPROF_TRACE]*
duke@435	1643	// [HPROF_GC_CLASS_DUMP]*
duke@435	1644	// HPROF_HEAP_DUMP
duke@435	1645	//
mchung@831	1646	// The HPROF_TRACE records represent the stack traces where the heap dump
mchung@831	1647	// is generated and a "dummy trace" record which does not include
mchung@831	1648	// any frames. The dummy trace record is used to be referenced as the
mchung@831	1649	// unknown object alloc site.
duke@435	1650	//
duke@435	1651	// The HPROF_HEAP_DUMP record has a length following by sub-records. To allow
duke@435	1652	// the heap dump be generated in a single pass we remember the position of
duke@435	1653	// the dump length and fix it up after all sub-records have been written.
duke@435	1654	// To generate the sub-records we iterate over the heap, writing
duke@435	1655	// HPROF_GC_INSTANCE_DUMP, HPROF_GC_OBJ_ARRAY_DUMP, and HPROF_GC_PRIM_ARRAY_DUMP
duke@435	1656	// records as we go. Once that is done we write records for some of the GC
duke@435	1657	// roots.
duke@435	1658
duke@435	1659	void VM_HeapDumper::doit() {
duke@435	1660
duke@435	1661	HandleMark hm;
duke@435	1662	CollectedHeap* ch = Universe::heap();
duke@435	1663	if (_gc_before_heap_dump) {
duke@435	1664	ch->collect_as_vm_thread(GCCause::_heap_dump);
duke@435	1665	} else {
duke@435	1666	// make the heap parsable (no need to retire TLABs)
duke@435	1667	ch->ensure_parsability(false);
duke@435	1668	}
duke@435	1669
ysr@1050	1670	// At this point we should be the only dumper active, so
ysr@1050	1671	// the following should be safe.
ysr@1050	1672	set_global_dumper();
ysr@1050	1673	set_global_writer();
ysr@1050	1674
duke@435	1675	// Write the file header - use 1.0.2 for large heaps, otherwise 1.0.1
ysr@777	1676	size_t used = ch->used();
duke@435	1677	const char* header;
duke@435	1678	if (used > (size_t)SegmentedHeapDumpThreshold) {
duke@435	1679	set_segmented_dump();
duke@435	1680	header = "JAVA PROFILE 1.0.2";
duke@435	1681	} else {
duke@435	1682	header = "JAVA PROFILE 1.0.1";
duke@435	1683	}
ysr@1050	1684
duke@435	1685	// header is few bytes long - no chance to overflow int
duke@435	1686	writer()->write_raw((void*)header, (int)strlen(header));
duke@435	1687	writer()->write_u1(0); // terminator
duke@435	1688	writer()->write_u4(oopSize);
duke@435	1689	writer()->write_u8(os::javaTimeMillis());
duke@435	1690
duke@435	1691	// HPROF_UTF8 records
duke@435	1692	SymbolTableDumper sym_dumper(writer());
duke@435	1693	SymbolTable::oops_do(&sym_dumper);
duke@435	1694
duke@435	1695	// write HPROF_LOAD_CLASS records
duke@435	1696	SystemDictionary::classes_do(&do_load_class);
duke@435	1697	Universe::basic_type_classes_do(&do_load_class);
duke@435	1698
mchung@831	1699	// write HPROF_FRAME and HPROF_TRACE records
mchung@831	1700	// this must be called after _klass_map is built when iterating the classes above.
mchung@831	1701	dump_stack_traces();
mchung@831	1702
duke@435	1703	// write HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT
duke@435	1704	write_dump_header();
duke@435	1705
duke@435	1706	// Writes HPROF_GC_CLASS_DUMP records
duke@435	1707	SystemDictionary::classes_do(&do_class_dump);
duke@435	1708	Universe::basic_type_classes_do(&do_basic_type_array_class_dump);
duke@435	1709	check_segment_length();
duke@435	1710
duke@435	1711	// writes HPROF_GC_INSTANCE_DUMP records.
duke@435	1712	// After each sub-record is written check_segment_length will be invoked. When
duke@435	1713	// generated a segmented heap dump this allows us to check if the current
duke@435	1714	// segment exceeds a threshold and if so, then a new segment is started.
duke@435	1715	// The HPROF_GC_CLASS_DUMP and HPROF_GC_INSTANCE_DUMP are the vast bulk
duke@435	1716	// of the heap dump.
duke@435	1717	HeapObjectDumper obj_dumper(this, writer());
jmasa@952	1718	Universe::heap()->safe_object_iterate(&obj_dumper);
duke@435	1719
duke@435	1720	// HPROF_GC_ROOT_THREAD_OBJ + frames + jni locals
duke@435	1721	do_threads();
duke@435	1722	check_segment_length();
duke@435	1723
duke@435	1724	// HPROF_GC_ROOT_MONITOR_USED
duke@435	1725	MonitorUsedDumper mon_dumper(writer());
duke@435	1726	ObjectSynchronizer::oops_do(&mon_dumper);
duke@435	1727	check_segment_length();
duke@435	1728
duke@435	1729	// HPROF_GC_ROOT_JNI_GLOBAL
duke@435	1730	JNIGlobalsDumper jni_dumper(writer());
duke@435	1731	JNIHandles::oops_do(&jni_dumper);
duke@435	1732	check_segment_length();
duke@435	1733
duke@435	1734	// HPROF_GC_ROOT_STICKY_CLASS
duke@435	1735	StickyClassDumper class_dumper(writer());
duke@435	1736	SystemDictionary::always_strong_oops_do(&class_dumper);
duke@435	1737
duke@435	1738	// fixes up the length of the dump record. In the case of a segmented
duke@435	1739	// heap then the HPROF_HEAP_DUMP_END record is also written.
duke@435	1740	end_of_dump();
ysr@1050	1741
ysr@1050	1742	// Now we clear the global variables, so that a future dumper might run.
ysr@1050	1743	clear_global_dumper();
ysr@1050	1744	clear_global_writer();
duke@435	1745	}
duke@435	1746
mchung@831	1747	void VM_HeapDumper::dump_stack_traces() {
mchung@831	1748	// write a HPROF_TRACE record without any frames to be referenced as object alloc sites
mchung@831	1749	DumperSupport::write_header(writer(), HPROF_TRACE, 3*sizeof(u4));
mchung@831	1750	writer()->write_u4((u4) STACK_TRACE_ID);
mchung@831	1751	writer()->write_u4(0); // thread number
mchung@831	1752	writer()->write_u4(0); // frame count
mchung@831	1753
mchung@831	1754	_stack_traces = NEW_C_HEAP_ARRAY(ThreadStackTrace*, Threads::number_of_threads());
mchung@831	1755	int frame_serial_num = 0;
mchung@831	1756	for (JavaThread* thread = Threads::first(); thread != NULL ; thread = thread->next()) {
mchung@831	1757	oop threadObj = thread->threadObj();
mchung@831	1758	if (threadObj != NULL && !thread->is_exiting() && !thread->is_hidden_from_external_view()) {
mchung@831	1759	// dump thread stack trace
mchung@831	1760	ThreadStackTrace* stack_trace = new ThreadStackTrace(thread, false);
mchung@831	1761	stack_trace->dump_stack_at_safepoint(-1);
mchung@831	1762	_stack_traces[_num_threads++] = stack_trace;
mchung@831	1763
mchung@831	1764	// write HPROF_FRAME records for this thread's stack trace
mchung@831	1765	int depth = stack_trace->get_stack_depth();
mchung@831	1766	int thread_frame_start = frame_serial_num;
mchung@831	1767	for (int j=0; j < depth; j++) {
mchung@831	1768	StackFrameInfo* frame = stack_trace->stack_frame_at(j);
mchung@831	1769	methodOop m = frame->method();
mchung@831	1770	int class_serial_num = _klass_map->find(Klass::cast(m->method_holder()));
mchung@831	1771	// the class serial number starts from 1
mchung@831	1772	assert(class_serial_num > 0, "class not found");
mchung@831	1773	DumperSupport::dump_stack_frame(writer(), ++frame_serial_num, class_serial_num, m, frame->bci());
mchung@831	1774	}
mchung@831	1775
mchung@831	1776	// write HPROF_TRACE record for one thread
mchung@831	1777	DumperSupport::write_header(writer(), HPROF_TRACE, 3*sizeof(u4) + depth*oopSize);
mchung@831	1778	int stack_serial_num = _num_threads + STACK_TRACE_ID;
mchung@831	1779	writer()->write_u4(stack_serial_num); // stack trace serial number
mchung@831	1780	writer()->write_u4((u4) _num_threads); // thread serial number
mchung@831	1781	writer()->write_u4(depth); // frame count
mchung@831	1782	for (int j=1; j <= depth; j++) {
mchung@831	1783	writer()->write_id(thread_frame_start + j);
mchung@831	1784	}
mchung@831	1785	}
mchung@831	1786	}
mchung@831	1787	}
duke@435	1788
duke@435	1789	// dump the heap to given path.
duke@435	1790	int HeapDumper::dump(const char* path) {
duke@435	1791	assert(path != NULL && strlen(path) > 0, "path missing");
duke@435	1792
duke@435	1793	// print message in interactive case
duke@435	1794	if (print_to_tty()) {
duke@435	1795	tty->print_cr("Dumping heap to %s ...", path);
duke@435	1796	timer()->start();
duke@435	1797	}
duke@435	1798
duke@435	1799	// create the dump writer. If the file can be opened then bail
duke@435	1800	DumpWriter writer(path);
duke@435	1801	if (!writer.is_open()) {
duke@435	1802	set_error(writer.error());
duke@435	1803	if (print_to_tty()) {
duke@435	1804	tty->print_cr("Unable to create %s: %s", path,
duke@435	1805	(error() != NULL) ? error() : "reason unknown");
duke@435	1806	}
duke@435	1807	return -1;
duke@435	1808	}
duke@435	1809
duke@435	1810	// generate the dump
duke@435	1811	VM_HeapDumper dumper(&writer, _gc_before_heap_dump);
ysr@1050	1812	if (Thread::current()->is_VM_thread()) {
ysr@1050	1813	assert(SafepointSynchronize::is_at_safepoint(), "Expected to be called at a safepoint");
ysr@1050	1814	dumper.doit();
ysr@1050	1815	} else {
ysr@1050	1816	VMThread::execute(&dumper);
ysr@1050	1817	}
duke@435	1818
duke@435	1819	// close dump file and record any error that the writer may have encountered
duke@435	1820	writer.close();
duke@435	1821	set_error(writer.error());
duke@435	1822
duke@435	1823	// print message in interactive case
duke@435	1824	if (print_to_tty()) {
duke@435	1825	timer()->stop();
duke@435	1826	if (error() == NULL) {
duke@435	1827	char msg[256];
duke@435	1828	sprintf(msg, "Heap dump file created [%s bytes in %3.3f secs]",
duke@435	1829	os::jlong_format_specifier(), timer()->seconds());
duke@435	1830	tty->print_cr(msg, writer.bytes_written());
duke@435	1831	} else {
duke@435	1832	tty->print_cr("Dump file is incomplete: %s", writer.error());
duke@435	1833	}
duke@435	1834	}
duke@435	1835
duke@435	1836	return (writer.error() == NULL) ? 0 : -1;
duke@435	1837	}
duke@435	1838
duke@435	1839	// stop timer (if still active), and free any error string we might be holding
duke@435	1840	HeapDumper::~HeapDumper() {
duke@435	1841	if (timer()->is_active()) {
duke@435	1842	timer()->stop();
duke@435	1843	}
duke@435	1844	set_error(NULL);
duke@435	1845	}
duke@435	1846
duke@435	1847
duke@435	1848	// returns the error string (resource allocated), or NULL
duke@435	1849	char* HeapDumper::error_as_C_string() const {
duke@435	1850	if (error() != NULL) {
duke@435	1851	char* str = NEW_RESOURCE_ARRAY(char, strlen(error())+1);
duke@435	1852	strcpy(str, error());
duke@435	1853	return str;
duke@435	1854	} else {
duke@435	1855	return NULL;
duke@435	1856	}
duke@435	1857	}
duke@435	1858
duke@435	1859	// set the error string
duke@435	1860	void HeapDumper::set_error(char* error) {
duke@435	1861	if (_error != NULL) {
duke@435	1862	os::free(_error);
duke@435	1863	}
duke@435	1864	if (error == NULL) {
duke@435	1865	_error = NULL;
duke@435	1866	} else {
duke@435	1867	_error = os::strdup(error);
duke@435	1868	assert(_error != NULL, "allocation failure");
duke@435	1869	}
duke@435	1870	}
duke@435	1871
ysr@1050	1872	// Called by error reporting by a single Java thread outside of a JVM safepoint,
ysr@1050	1873	// or by heap dumping by the VM thread during a (GC) safepoint. Thus, these various
ysr@1050	1874	// callers are strictly serialized and guaranteed not to interfere below. For more
ysr@1050	1875	// general use, however, this method will need modification to prevent
ysr@1050	1876	// inteference when updating the static variables base_path and dump_file_seq below.
duke@435	1877	void HeapDumper::dump_heap() {
ysr@1050	1878	static char base_path[JVM_MAXPATHLEN] = {'\0'};
ysr@1050	1879	static uint dump_file_seq = 0;
ysr@1050	1880	char my_path[JVM_MAXPATHLEN] = {'\0'};
duke@435	1881
duke@435	1882	// The dump file defaults to java_pid<pid>.hprof in the current working
duke@435	1883	// directory. HeapDumpPath=<file> can be used to specify an alternative
duke@435	1884	// dump file name or a directory where dump file is created.
ysr@1050	1885	if (dump_file_seq == 0) { // first time in, we initialize base_path
ysr@1050	1886	bool use_default_filename = true;
ysr@1050	1887	if (HeapDumpPath == NULL || HeapDumpPath[0] == '\0') {
ysr@1050	1888	// HeapDumpPath=<file> not specified
duke@435	1889	} else {
ysr@1050	1890	assert(strlen(HeapDumpPath) < sizeof(base_path), "HeapDumpPath too long");
ysr@1050	1891	strcpy(base_path, HeapDumpPath);
ysr@1050	1892	// check if the path is a directory (must exist)
ysr@1050	1893	DIR* dir = os::opendir(base_path);
ysr@1050	1894	if (dir == NULL) {
ysr@1050	1895	use_default_filename = false;
ysr@1050	1896	} else {
ysr@1050	1897	// HeapDumpPath specified a directory. We append a file separator
ysr@1050	1898	// (if needed).
ysr@1050	1899	os::closedir(dir);
ysr@1050	1900	size_t fs_len = strlen(os::file_separator());
ysr@1050	1901	if (strlen(base_path) >= fs_len) {
ysr@1050	1902	char* end = base_path;
ysr@1050	1903	end += (strlen(base_path) - fs_len);
ysr@1050	1904	if (strcmp(end, os::file_separator()) != 0) {
ysr@1050	1905	assert(strlen(base_path) + strlen(os::file_separator()) < sizeof(base_path),
ysr@1050	1906	"HeapDumpPath too long");
ysr@1050	1907	strcat(base_path, os::file_separator());
ysr@1050	1908	}
duke@435	1909	}
duke@435	1910	}
duke@435	1911	}
ysr@1050	1912	// If HeapDumpPath wasn't a file name then we append the default name
ysr@1050	1913	if (use_default_filename) {
ysr@1050	1914	char fn[32];
ysr@1050	1915	sprintf(fn, "java_pid%d", os::current_process_id());
ysr@1481	1916	assert(strlen(base_path) + strlen(fn) + strlen(".hprof") < sizeof(base_path), "HeapDumpPath too long");
ysr@1050	1917	strcat(base_path, fn);
ysr@1481	1918	strcat(base_path, ".hprof");
ysr@1050	1919	}
ysr@1050	1920	assert(strlen(base_path) < sizeof(my_path), "Buffer too small");
ysr@1050	1921	strcpy(my_path, base_path);
ysr@1050	1922	} else {
ysr@1050	1923	// Append a sequence number id for dumps following the first
ysr@1050	1924	char fn[33];
ysr@1050	1925	sprintf(fn, ".%d", dump_file_seq);
ysr@1050	1926	assert(strlen(base_path) + strlen(fn) < sizeof(my_path), "HeapDumpPath too long");
ysr@1050	1927	strcpy(my_path, base_path);
ysr@1050	1928	strcat(my_path, fn);
duke@435	1929	}
ysr@1050	1930	dump_file_seq++; // increment seq number for next time we dump
duke@435	1931
duke@435	1932	HeapDumper dumper(false /* no GC before heap dump */,
duke@435	1933	true /* send to tty */);
ysr@1050	1934	dumper.dump(my_path);
duke@435	1935	}