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

src/share/vm/utilities/events.hpp@c6211b707068 (annotated)

src/share/vm/utilities/events.hpp

Tue, 19 Aug 2014 08:34:25 -0400

author

zgu

date

Tue, 19 Aug 2014 08:34:25 -0400

changeset 7078

c6211b707068

parent 6680

78bbf4d43a14

child 6876

710a3c8b516e

child 8720

6bed084fd02f

permissions

-rw-r--r--

8055007: NMT2: emptyStack missing in minimal build
Summary: Refactored emptyStack to a static member of NativeCallStack, which is accessible in minimal build.
Reviewed-by: coleenp, dholmes

duke@435	1	/*
drchase@6680	2	* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#ifndef SHARE_VM_UTILITIES_EVENTS_HPP
stefank@2314	26	#define SHARE_VM_UTILITIES_EVENTS_HPP
stefank@2314	27
stefank@2314	28	#include "memory/allocation.hpp"
never@3499	29	#include "runtime/mutexLocker.hpp"
never@3499	30	#include "runtime/thread.hpp"
stefank@2314	31	#include "utilities/top.hpp"
never@3499	32	#include "utilities/vmError.hpp"
stefank@2314	33
duke@435	34	// Events and EventMark provide interfaces to log events taking place in the vm.
duke@435	35	// This facility is extremly useful for post-mortem debugging. The eventlog
duke@435	36	// often provides crucial information about events leading up to the crash.
duke@435	37	//
never@3571	38	// Abstractly the logs can record whatever they way but normally they
never@3571	39	// would record at least a timestamp and the current Thread, along
never@3571	40	// with whatever data they need in a ring buffer. Commonly fixed
never@3571	41	// length text messages are recorded for simplicity but other
never@3571	42	// strategies could be used. Several logs are provided by default but
never@3571	43	// new instances can be created as needed.
duke@435	44
never@3499	45	// The base event log dumping class that is registered for dumping at
never@3499	46	// crash time. This is a very generic interface that is mainly here
never@3499	47	// for completeness. Normally the templated EventLogBase would be
never@3499	48	// subclassed to provide different log types.
zgu@3900	49	class EventLog : public CHeapObj<mtInternal> {
never@3499	50	friend class Events;
never@3499	51
never@3499	52	private:
never@3499	53	EventLog* _next;
never@3499	54
never@3499	55	EventLog* next() const { return _next; }
never@3499	56
duke@435	57	public:
never@3499	58	// Automatically registers the log so that it will be printed during
never@3499	59	// crashes.
never@3499	60	EventLog();
duke@435	61
never@3499	62	virtual void print_log_on(outputStream* out) = 0;
duke@435	63	};
duke@435	64
never@3499	65
never@3499	66	// A templated subclass of EventLog that provides basic ring buffer
never@3499	67	// functionality. Most event loggers should subclass this, possibly
never@3499	68	// providing a more featureful log function if the existing copy
never@3499	69	// semantics aren't appropriate. The name is used as the label of the
never@3499	70	// log when it is dumped during a crash.
never@3499	71	template <class T> class EventLogBase : public EventLog {
minqi@5103	72	template <class X> class EventRecord : public CHeapObj<mtInternal> {
never@3499	73	public:
never@3571	74	double timestamp;
never@3499	75	Thread* thread;
never@3499	76	X data;
never@3499	77	};
never@3499	78
never@3499	79	protected:
never@3499	80	Mutex _mutex;
never@3499	81	const char* _name;
never@3499	82	int _length;
never@3499	83	int _index;
never@3499	84	int _count;
never@3499	85	EventRecord<T>* _records;
never@3499	86
never@3499	87	public:
never@3499	88	EventLogBase<T>(const char* name, int length = LogEventsBufferEntries):
never@3499	89	_name(name),
never@3499	90	_length(length),
never@3499	91	_count(0),
never@3499	92	_index(0),
never@3499	93	_mutex(Mutex::event, name) {
never@3499	94	_records = new EventRecord<T>[length];
never@3499	95	}
never@3499	96
never@3571	97	double fetch_timestamp() {
never@3578	98	return os::elapsedTime();
never@3571	99	}
never@3571	100
never@3499	101	// move the ring buffer to next open slot and return the index of
never@3499	102	// the slot to use for the current message. Should only be called
never@3499	103	// while mutex is held.
never@3499	104	int compute_log_index() {
never@3499	105	int index = _index;
never@3499	106	if (_count < _length) _count++;
never@3499	107	_index++;
never@3499	108	if (_index >= _length) _index = 0;
never@3499	109	return index;
never@3499	110	}
never@3499	111
never@3499	112	bool should_log() {
never@3499	113	// Don't bother adding new entries when we're crashing. This also
never@3499	114	// avoids mutating the ring buffer when printing the log.
never@3499	115	return !VMError::fatal_error_in_progress();
never@3499	116	}
never@3499	117
never@3499	118	// Print the contents of the log
never@3499	119	void print_log_on(outputStream* out);
never@3499	120
never@3499	121	private:
never@3499	122	void print_log_impl(outputStream* out);
never@3499	123
never@3499	124	// Print a single element. A templated implementation might need to
never@3499	125	// be declared by subclasses.
never@3499	126	void print(outputStream* out, T& e);
never@3499	127
never@3499	128	void print(outputStream* out, EventRecord<T>& e) {
never@3571	129	out->print("Event: %.3f ", e.timestamp);
never@3499	130	if (e.thread != NULL) {
drchase@6680	131	out->print("Thread " INTPTR_FORMAT " ", p2i(e.thread));
never@3499	132	}
never@3499	133	print(out, e.data);
never@3499	134	}
never@3499	135	};
never@3499	136
never@3499	137	// A simple wrapper class for fixed size text messages.
vlivanov@4312	138	class StringLogMessage : public FormatBuffer<256> {
never@3499	139	public:
never@3499	140	// Wrap this buffer in a stringStream.
never@3499	141	stringStream stream() {
vlivanov@4312	142	return stringStream(_buf, size());
never@3499	143	}
never@3499	144	};
never@3499	145
never@3499	146	// A simple ring buffer of fixed size text messages.
never@3499	147	class StringEventLog : public EventLogBase<StringLogMessage> {
never@3499	148	public:
never@3499	149	StringEventLog(const char* name, int count = LogEventsBufferEntries) : EventLogBase<StringLogMessage>(name, count) {}
never@3499	150
drchase@6680	151	void logv(Thread* thread, const char* format, va_list ap) ATTRIBUTE_PRINTF(3, 0) {
never@3499	152	if (!should_log()) return;
never@3499	153
never@3571	154	double timestamp = fetch_timestamp();
never@3499	155	MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);
never@3499	156	int index = compute_log_index();
never@3499	157	_records[index].thread = thread;
never@3499	158	_records[index].timestamp = timestamp;
never@3499	159	_records[index].data.printv(format, ap);
never@3499	160	}
never@3499	161
drchase@6680	162	void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(3, 4) {
never@3499	163	va_list ap;
never@3499	164	va_start(ap, format);
never@3499	165	logv(thread, format, ap);
never@3499	166	va_end(ap);
never@3499	167	}
never@3499	168
never@3499	169	};
never@3499	170
never@3499	171
never@3499	172
never@3499	173	class Events : AllStatic {
never@3499	174	friend class EventLog;
never@3499	175
never@3499	176	private:
never@3499	177	static EventLog* _logs;
never@3499	178
never@3499	179	// A log for generic messages that aren't well categorized.
never@3499	180	static StringEventLog* _messages;
never@3499	181
never@3499	182	// A log for internal exception related messages, like internal
never@3499	183	// throws and implicit exceptions.
never@3499	184	static StringEventLog* _exceptions;
never@3499	185
never@3499	186	// Deoptization related messages
never@3499	187	static StringEventLog* _deopt_messages;
never@3499	188
never@3499	189	public:
never@3499	190	static void print_all(outputStream* out);
never@3499	191
never@3571	192	// Dump all events to the tty
never@3571	193	static void print();
never@3499	194
never@3499	195	// Logs a generic message with timestamp and format as printf.
drchase@6680	196	static void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
never@3499	197
never@3499	198	// Log exception related message
drchase@6680	199	static void log_exception(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
never@3499	200
drchase@6680	201	static void log_deopt_message(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
never@3499	202
never@3499	203	// Register default loggers
never@3499	204	static void init();
never@3499	205	};
never@3499	206
never@3499	207	inline void Events::log(Thread* thread, const char* format, ...) {
never@3499	208	if (LogEvents) {
never@3499	209	va_list ap;
never@3499	210	va_start(ap, format);
never@3499	211	_messages->logv(thread, format, ap);
never@3499	212	va_end(ap);
never@3499	213	}
never@3499	214	}
never@3499	215
never@3499	216	inline void Events::log_exception(Thread* thread, const char* format, ...) {
never@3499	217	if (LogEvents) {
never@3499	218	va_list ap;
never@3499	219	va_start(ap, format);
never@3499	220	_exceptions->logv(thread, format, ap);
never@3499	221	va_end(ap);
never@3499	222	}
never@3499	223	}
never@3499	224
never@3499	225	inline void Events::log_deopt_message(Thread* thread, const char* format, ...) {
never@3499	226	if (LogEvents) {
never@3499	227	va_list ap;
never@3499	228	va_start(ap, format);
never@3499	229	_deopt_messages->logv(thread, format, ap);
never@3499	230	va_end(ap);
never@3499	231	}
never@3499	232	}
never@3499	233
never@3499	234
never@3499	235	template <class T>
never@3499	236	inline void EventLogBase<T>::print_log_on(outputStream* out) {
never@3499	237	if (ThreadLocalStorage::get_thread_slow() == NULL) {
never@3499	238	// Not a regular Java thread so don't bother locking
never@3499	239	print_log_impl(out);
never@3499	240	} else {
never@3499	241	MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);
never@3499	242	print_log_impl(out);
never@3499	243	}
never@3499	244	}
never@3499	245
never@3499	246	// Dump the ring buffer entries that current have entries.
never@3499	247	template <class T>
never@3499	248	inline void EventLogBase<T>::print_log_impl(outputStream* out) {
never@3499	249	out->print_cr("%s (%d events):", _name, _count);
never@3499	250	if (_count == 0) {
never@3499	251	out->print_cr("No events");
never@3571	252	out->cr();
never@3499	253	return;
never@3499	254	}
never@3499	255
never@3499	256	if (_count < _length) {
never@3499	257	for (int i = 0; i < _count; i++) {
never@3499	258	print(out, _records[i]);
never@3499	259	}
never@3499	260	} else {
never@3499	261	for (int i = _index; i < _length; i++) {
never@3499	262	print(out, _records[i]);
never@3499	263	}
never@3499	264	for (int i = 0; i < _index; i++) {
never@3499	265	print(out, _records[i]);
never@3499	266	}
never@3499	267	}
never@3499	268	out->cr();
never@3499	269	}
never@3499	270
never@3499	271	// Implement a printing routine for the StringLogMessage
never@3499	272	template <>
never@3499	273	inline void EventLogBase<StringLogMessage>::print(outputStream* out, StringLogMessage& lm) {
never@3499	274	out->print_raw(lm);
never@3499	275	out->cr();
never@3499	276	}
never@3499	277
never@3499	278	// Place markers for the beginning and end up of a set of events.
never@3499	279	// These end up in the default log.
duke@435	280	class EventMark : public StackObj {
never@3499	281	StringLogMessage _buffer;
never@3499	282
duke@435	283	public:
duke@435	284	// log a begin event, format as printf
drchase@6680	285	EventMark(const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
duke@435	286	// log an end event
never@3499	287	~EventMark();
duke@435	288	};
duke@435	289
stefank@2314	290	#endif // SHARE_VM_UTILITIES_EVENTS_HPP