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

src/share/vm/services/threadService.hpp@6a93908f268f (annotated)

src/share/vm/services/threadService.hpp

Fri, 10 Jul 2009 11:10:00 -0700

author

mchung

date

Fri, 10 Jul 2009 11:10:00 -0700

changeset 1310

6a93908f268f

parent 905

ad8c8ca4ab0f

child 1383

89e0543e1737

permissions

-rw-r--r--

6857194: Add hotspot perf counters to aid class loading performance measurement
Summary: Add new jvmstat counters to measure detailed class loading time
Reviewed-by: acorn, kamg

duke@435	1	/*
xdono@905	2	* Copyright 2003-2008 Sun Microsystems, Inc. All Rights Reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
duke@435	19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435	20	* CA 95054 USA or visit www.sun.com if you need additional information or
duke@435	21	* have any questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	class OopClosure;
duke@435	26	class ThreadDumpResult;
duke@435	27	class ThreadStackTrace;
duke@435	28	class ThreadSnapshot;
duke@435	29	class StackFrameInfo;
duke@435	30	class ThreadConcurrentLocks;
duke@435	31	class DeadlockCycle;
duke@435	32
duke@435	33	// VM monitoring and management support for the thread and
duke@435	34	// synchronization subsystem
duke@435	35	//
duke@435	36	// Thread contention monitoring is disabled by default.
duke@435	37	// When enabled, the VM will begin measuring the accumulated
duke@435	38	// elapsed time a thread blocked on synchronization.
duke@435	39	//
duke@435	40	class ThreadService : public AllStatic {
duke@435	41	private:
duke@435	42	// These counters could be moved to Threads class
duke@435	43	static PerfCounter* _total_threads_count;
duke@435	44	static PerfVariable* _live_threads_count;
duke@435	45	static PerfVariable* _peak_threads_count;
duke@435	46	static PerfVariable* _daemon_threads_count;
duke@435	47
duke@435	48	// These 2 counters are atomically incremented once the thread is exiting.
duke@435	49	// They will be atomically decremented when ThreadService::remove_thread is called.
duke@435	50	static volatile int _exiting_threads_count;
duke@435	51	static volatile int _exiting_daemon_threads_count;
duke@435	52
duke@435	53	static bool _thread_monitoring_contention_enabled;
duke@435	54	static bool _thread_cpu_time_enabled;
duke@435	55
duke@435	56	// Need to keep the list of thread dump result that
duke@435	57	// keep references to methodOop since thread dump can be
duke@435	58	// requested by multiple threads concurrently.
duke@435	59	static ThreadDumpResult* _threaddump_list;
duke@435	60
duke@435	61	public:
duke@435	62	static void init();
duke@435	63	static void add_thread(JavaThread* thread, bool daemon);
duke@435	64	static void remove_thread(JavaThread* thread, bool daemon);
duke@435	65	static void current_thread_exiting(JavaThread* jt);
duke@435	66
duke@435	67	static bool set_thread_monitoring_contention(bool flag);
duke@435	68	static bool is_thread_monitoring_contention() { return _thread_monitoring_contention_enabled; }
duke@435	69
duke@435	70	static bool set_thread_cpu_time_enabled(bool flag);
duke@435	71	static bool is_thread_cpu_time_enabled() { return _thread_cpu_time_enabled; }
duke@435	72
duke@435	73	static jlong get_total_thread_count() { return _total_threads_count->get_value(); }
duke@435	74	static jlong get_peak_thread_count() { return _peak_threads_count->get_value(); }
duke@435	75	static jlong get_live_thread_count() { return _live_threads_count->get_value() - _exiting_threads_count; }
duke@435	76	static jlong get_daemon_thread_count() { return _daemon_threads_count->get_value() - _exiting_daemon_threads_count; }
duke@435	77
duke@435	78	static int exiting_threads_count() { return _exiting_threads_count; }
duke@435	79	static int exiting_daemon_threads_count() { return _exiting_daemon_threads_count; }
duke@435	80
duke@435	81	// Support for thread dump
duke@435	82	static void add_thread_dump(ThreadDumpResult* dump);
duke@435	83	static void remove_thread_dump(ThreadDumpResult* dump);
duke@435	84
duke@435	85	static Handle get_current_contended_monitor(JavaThread* thread);
duke@435	86
duke@435	87	// This function is called by JVM_DumpThreads.
duke@435	88	static Handle dump_stack_traces(GrowableArray<instanceHandle>* threads,
duke@435	89	int num_threads, TRAPS);
duke@435	90
duke@435	91	static void reset_peak_thread_count();
duke@435	92	static void reset_contention_count_stat(JavaThread* thread);
duke@435	93	static void reset_contention_time_stat(JavaThread* thread);
duke@435	94
duke@435	95	static DeadlockCycle* find_deadlocks_at_safepoint(bool object_monitors_only);
duke@435	96
duke@435	97	// GC support
duke@435	98	static void oops_do(OopClosure* f);
duke@435	99	};
duke@435	100
duke@435	101	// Per-thread Statistics for synchronization
duke@435	102	class ThreadStatistics : public CHeapObj {
duke@435	103	private:
duke@435	104	// The following contention statistics are only updated by
duke@435	105	// the thread owning these statistics when contention occurs.
duke@435	106
duke@435	107	jlong _contended_enter_count;
duke@435	108	elapsedTimer _contended_enter_timer;
duke@435	109	jlong _monitor_wait_count;
duke@435	110	elapsedTimer _monitor_wait_timer;
duke@435	111	jlong _sleep_count;
duke@435	112	elapsedTimer _sleep_timer;
duke@435	113
duke@435	114
duke@435	115	// These two reset flags are set to true when another thread
duke@435	116	// requests to reset the statistics. The actual statistics
duke@435	117	// are reset when the thread contention occurs and attempts
duke@435	118	// to update the statistics.
duke@435	119	bool _count_pending_reset;
duke@435	120	bool _timer_pending_reset;
duke@435	121
duke@435	122	// Keep accurate times for potentially recursive class operations
mchung@1310	123	int _perf_recursion_counts[6];
mchung@1310	124	elapsedTimer _perf_timers[6];
duke@435	125
duke@435	126	// utility functions
duke@435	127	void check_and_reset_count() {
duke@435	128	if (!_count_pending_reset) return;
duke@435	129	_contended_enter_count = 0;
duke@435	130	_monitor_wait_count = 0;
duke@435	131	_sleep_count = 0;
duke@435	132	_count_pending_reset = 0;
duke@435	133	}
duke@435	134	void check_and_reset_timer() {
duke@435	135	if (!_timer_pending_reset) return;
duke@435	136	_contended_enter_timer.reset();
duke@435	137	_monitor_wait_timer.reset();
duke@435	138	_sleep_timer.reset();
duke@435	139	_timer_pending_reset = 0;
duke@435	140	}
duke@435	141
duke@435	142	public:
duke@435	143	ThreadStatistics();
duke@435	144
duke@435	145	jlong contended_enter_count() { return (_count_pending_reset ? 0 : _contended_enter_count); }
duke@435	146	jlong contended_enter_ticks() { return (_timer_pending_reset ? 0 : _contended_enter_timer.active_ticks()); }
duke@435	147	jlong monitor_wait_count() { return (_count_pending_reset ? 0 : _monitor_wait_count); }
duke@435	148	jlong monitor_wait_ticks() { return (_timer_pending_reset ? 0 : _monitor_wait_timer.active_ticks()); }
duke@435	149	jlong sleep_count() { return (_count_pending_reset ? 0 : _sleep_count); }
duke@435	150	jlong sleep_ticks() { return (_timer_pending_reset ? 0 : _sleep_timer.active_ticks()); }
duke@435	151
duke@435	152	void monitor_wait() { check_and_reset_count(); _monitor_wait_count++; }
duke@435	153	void monitor_wait_begin() { check_and_reset_timer(); _monitor_wait_timer.start(); }
duke@435	154	void monitor_wait_end() { _monitor_wait_timer.stop(); check_and_reset_timer(); }
duke@435	155
duke@435	156	void thread_sleep() { check_and_reset_count(); _sleep_count++; }
duke@435	157	void thread_sleep_begin() { check_and_reset_timer(); _sleep_timer.start(); }
duke@435	158	void thread_sleep_end() { _sleep_timer.stop(); check_and_reset_timer(); }
duke@435	159
duke@435	160	void contended_enter() { check_and_reset_count(); _contended_enter_count++; }
duke@435	161	void contended_enter_begin() { check_and_reset_timer(); _contended_enter_timer.start(); }
duke@435	162	void contended_enter_end() { _contended_enter_timer.stop(); check_and_reset_timer(); }
duke@435	163
duke@435	164	void reset_count_stat() { _count_pending_reset = true; }
duke@435	165	void reset_time_stat() { _timer_pending_reset = true; }
duke@435	166
mchung@1310	167	int* perf_recursion_counts_addr() { return _perf_recursion_counts; }
mchung@1310	168	elapsedTimer* perf_timers_addr() { return _perf_timers; }
duke@435	169	};
duke@435	170
duke@435	171	// Thread snapshot to represent the thread state and statistics
duke@435	172	class ThreadSnapshot : public CHeapObj {
duke@435	173	private:
duke@435	174	JavaThread* _thread;
duke@435	175	oop _threadObj;
duke@435	176	java_lang_Thread::ThreadStatus _thread_status;
duke@435	177
duke@435	178	bool _is_ext_suspended;
duke@435	179	bool _is_in_native;
duke@435	180
duke@435	181	jlong _contended_enter_ticks;
duke@435	182	jlong _contended_enter_count;
duke@435	183	jlong _monitor_wait_ticks;
duke@435	184	jlong _monitor_wait_count;
duke@435	185	jlong _sleep_ticks;
duke@435	186	jlong _sleep_count;
duke@435	187	oop _blocker_object;
duke@435	188	oop _blocker_object_owner;
duke@435	189
duke@435	190	ThreadStackTrace* _stack_trace;
duke@435	191	ThreadConcurrentLocks* _concurrent_locks;
duke@435	192	ThreadSnapshot* _next;
duke@435	193
duke@435	194	public:
duke@435	195	// Dummy snapshot
duke@435	196	ThreadSnapshot() : _thread(NULL), _threadObj(NULL), _stack_trace(NULL), _concurrent_locks(NULL), _next(NULL),
duke@435	197	_blocker_object(NULL), _blocker_object_owner(NULL) {};
duke@435	198	ThreadSnapshot(JavaThread* thread);
duke@435	199	~ThreadSnapshot();
duke@435	200
duke@435	201	java_lang_Thread::ThreadStatus thread_status() { return _thread_status; }
duke@435	202
duke@435	203	oop threadObj() const { return _threadObj; }
duke@435	204
duke@435	205	void set_next(ThreadSnapshot* n) { _next = n; }
duke@435	206
duke@435	207	bool is_ext_suspended() { return _is_ext_suspended; }
duke@435	208	bool is_in_native() { return _is_in_native; }
duke@435	209
duke@435	210	jlong contended_enter_count() { return _contended_enter_count; }
duke@435	211	jlong contended_enter_ticks() { return _contended_enter_ticks; }
duke@435	212	jlong monitor_wait_count() { return _monitor_wait_count; }
duke@435	213	jlong monitor_wait_ticks() { return _monitor_wait_ticks; }
duke@435	214	jlong sleep_count() { return _sleep_count; }
duke@435	215	jlong sleep_ticks() { return _sleep_ticks; }
duke@435	216
duke@435	217
duke@435	218	oop blocker_object() { return _blocker_object; }
duke@435	219	oop blocker_object_owner() { return _blocker_object_owner; }
duke@435	220
duke@435	221	ThreadSnapshot* next() const { return _next; }
duke@435	222	ThreadStackTrace* get_stack_trace() { return _stack_trace; }
duke@435	223	ThreadConcurrentLocks* get_concurrent_locks() { return _concurrent_locks; }
duke@435	224
duke@435	225	void dump_stack_at_safepoint(int max_depth, bool with_locked_monitors);
duke@435	226	void set_concurrent_locks(ThreadConcurrentLocks* l) { _concurrent_locks = l; }
duke@435	227	void oops_do(OopClosure* f);
duke@435	228	};
duke@435	229
duke@435	230	class ThreadStackTrace : public CHeapObj {
duke@435	231	private:
duke@435	232	JavaThread* _thread;
duke@435	233	int _depth; // number of stack frames added
duke@435	234	bool _with_locked_monitors;
duke@435	235	GrowableArray<StackFrameInfo*>* _frames;
duke@435	236	GrowableArray<oop>* _jni_locked_monitors;
duke@435	237
duke@435	238	public:
duke@435	239
duke@435	240	ThreadStackTrace(JavaThread* thread, bool with_locked_monitors);
duke@435	241	~ThreadStackTrace();
duke@435	242
mchung@831	243	JavaThread* thread() { return _thread; }
duke@435	244	StackFrameInfo* stack_frame_at(int i) { return _frames->at(i); }
duke@435	245	int get_stack_depth() { return _depth; }
duke@435	246
duke@435	247	void add_stack_frame(javaVFrame* jvf);
duke@435	248	void dump_stack_at_safepoint(int max_depth);
duke@435	249	Handle allocate_fill_stack_trace_element_array(TRAPS);
duke@435	250	void oops_do(OopClosure* f);
duke@435	251	GrowableArray<oop>* jni_locked_monitors() { return _jni_locked_monitors; }
duke@435	252	int num_jni_locked_monitors() { return (_jni_locked_monitors != NULL ? _jni_locked_monitors->length() : 0); }
duke@435	253
duke@435	254	bool is_owned_monitor_on_stack(oop object);
duke@435	255	void add_jni_locked_monitor(oop object) { _jni_locked_monitors->append(object); }
duke@435	256	};
duke@435	257
duke@435	258	// StackFrameInfo for keeping methodOop and bci during
duke@435	259	// stack walking for later construction of StackTraceElement[]
duke@435	260	// Java instances
duke@435	261	class StackFrameInfo : public CHeapObj {
duke@435	262	private:
duke@435	263	methodOop _method;
duke@435	264	int _bci;
duke@435	265	GrowableArray<oop>* _locked_monitors; // list of object monitors locked by this frame
duke@435	266
duke@435	267	public:
duke@435	268
duke@435	269	StackFrameInfo(javaVFrame* jvf, bool with_locked_monitors);
duke@435	270	~StackFrameInfo() {
duke@435	271	if (_locked_monitors != NULL) {
duke@435	272	delete _locked_monitors;
duke@435	273	}
duke@435	274	};
duke@435	275	methodOop method() const { return _method; }
duke@435	276	int bci() const { return _bci; }
duke@435	277	void oops_do(OopClosure* f);
duke@435	278
duke@435	279	int num_locked_monitors() { return (_locked_monitors != NULL ? _locked_monitors->length() : 0); }
duke@435	280	GrowableArray<oop>* locked_monitors() { return _locked_monitors; }
duke@435	281
duke@435	282	void print_on(outputStream* st) const;
duke@435	283	};
duke@435	284
duke@435	285	class ThreadConcurrentLocks : public CHeapObj {
duke@435	286	private:
duke@435	287	GrowableArray<instanceOop>* _owned_locks;
duke@435	288	ThreadConcurrentLocks* _next;
duke@435	289	JavaThread* _thread;
duke@435	290	public:
duke@435	291	ThreadConcurrentLocks(JavaThread* thread);
duke@435	292	~ThreadConcurrentLocks();
duke@435	293
duke@435	294	void add_lock(instanceOop o);
duke@435	295	void set_next(ThreadConcurrentLocks* n) { _next = n; }
duke@435	296	ThreadConcurrentLocks* next() { return _next; }
duke@435	297	JavaThread* java_thread() { return _thread; }
duke@435	298	GrowableArray<instanceOop>* owned_locks() { return _owned_locks; }
duke@435	299	void oops_do(OopClosure* f);
duke@435	300	};
duke@435	301
duke@435	302	class ConcurrentLocksDump : public StackObj {
duke@435	303	private:
duke@435	304	ThreadConcurrentLocks* _map;
duke@435	305	ThreadConcurrentLocks* _last; // Last ThreadConcurrentLocks in the map
duke@435	306	bool _retain_map_on_free;
duke@435	307
duke@435	308	void build_map(GrowableArray<oop>* aos_objects);
duke@435	309	void add_lock(JavaThread* thread, instanceOop o);
duke@435	310
duke@435	311	public:
duke@435	312	ConcurrentLocksDump(bool retain_map_on_free) : _map(NULL), _last(NULL), _retain_map_on_free(retain_map_on_free) {};
duke@435	313	ConcurrentLocksDump() : _map(NULL), _last(NULL), _retain_map_on_free(false) {};
duke@435	314	~ConcurrentLocksDump();
duke@435	315
duke@435	316	void dump_at_safepoint();
duke@435	317	ThreadConcurrentLocks* thread_concurrent_locks(JavaThread* thread);
duke@435	318	void print_locks_on(JavaThread* t, outputStream* st);
duke@435	319	};
duke@435	320
duke@435	321	class ThreadDumpResult : public StackObj {
duke@435	322	private:
duke@435	323	int _num_threads;
duke@435	324	int _num_snapshots;
duke@435	325	ThreadSnapshot* _snapshots;
duke@435	326	ThreadSnapshot* _last;
duke@435	327	ThreadDumpResult* _next;
duke@435	328	public:
duke@435	329	ThreadDumpResult();
duke@435	330	ThreadDumpResult(int num_threads);
duke@435	331	~ThreadDumpResult();
duke@435	332
duke@435	333	void add_thread_snapshot(ThreadSnapshot* ts);
duke@435	334	void set_next(ThreadDumpResult* next) { _next = next; }
duke@435	335	ThreadDumpResult* next() { return _next; }
duke@435	336	int num_threads() { return _num_threads; }
duke@435	337	int num_snapshots() { return _num_snapshots; }
duke@435	338	ThreadSnapshot* snapshots() { return _snapshots; }
duke@435	339	void oops_do(OopClosure* f);
duke@435	340	};
duke@435	341
duke@435	342	class DeadlockCycle : public CHeapObj {
duke@435	343	private:
duke@435	344	bool _is_deadlock;
duke@435	345	GrowableArray<JavaThread*>* _threads;
duke@435	346	DeadlockCycle* _next;
duke@435	347	public:
duke@435	348	DeadlockCycle();
duke@435	349	~DeadlockCycle();
duke@435	350
duke@435	351	DeadlockCycle* next() { return _next; }
duke@435	352	void set_next(DeadlockCycle* d) { _next = d; }
duke@435	353	void add_thread(JavaThread* t) { _threads->append(t); }
duke@435	354	void reset() { _is_deadlock = false; _threads->clear(); }
duke@435	355	void set_deadlock(bool value) { _is_deadlock = value; }
duke@435	356	bool is_deadlock() { return _is_deadlock; }
duke@435	357	int num_threads() { return _threads->length(); }
duke@435	358	GrowableArray<JavaThread*>* threads() { return _threads; }
duke@435	359	void print_on(outputStream* st) const;
duke@435	360	};
duke@435	361
duke@435	362	// Utility class to get list of java threads.
duke@435	363	class ThreadsListEnumerator : public StackObj {
duke@435	364	private:
duke@435	365	GrowableArray<instanceHandle>* _threads_array;
duke@435	366	public:
duke@435	367	ThreadsListEnumerator(Thread* cur_thread,
duke@435	368	bool include_jvmti_agent_threads = false,
duke@435	369	bool include_jni_attaching_threads = true);
duke@435	370	int num_threads() { return _threads_array->length(); }
duke@435	371	instanceHandle get_threadObj(int index) { return _threads_array->at(index); }
duke@435	372	};
duke@435	373
duke@435	374
duke@435	375	// abstract utility class to set new thread states, and restore previous after the block exits
duke@435	376	class JavaThreadStatusChanger : public StackObj {
duke@435	377	private:
duke@435	378	java_lang_Thread::ThreadStatus _old_state;
duke@435	379	JavaThread* _java_thread;
duke@435	380	bool _is_alive;
duke@435	381
duke@435	382	void save_old_state(JavaThread* java_thread) {
duke@435	383	_java_thread = java_thread;
duke@435	384	_is_alive = is_alive(java_thread);
duke@435	385	if (is_alive()) {
duke@435	386	_old_state = java_lang_Thread::get_thread_status(_java_thread->threadObj());
duke@435	387	}
duke@435	388	}
duke@435	389
duke@435	390	public:
duke@435	391	static void set_thread_status(JavaThread* java_thread,
duke@435	392	java_lang_Thread::ThreadStatus state) {
duke@435	393	java_lang_Thread::set_thread_status(java_thread->threadObj(), state);
duke@435	394	}
duke@435	395
duke@435	396	void set_thread_status(java_lang_Thread::ThreadStatus state) {
duke@435	397	if (is_alive()) {
duke@435	398	set_thread_status(_java_thread, state);
duke@435	399	}
duke@435	400	}
duke@435	401
duke@435	402	JavaThreadStatusChanger(JavaThread* java_thread,
duke@435	403	java_lang_Thread::ThreadStatus state) {
duke@435	404	save_old_state(java_thread);
duke@435	405	set_thread_status(state);
duke@435	406	}
duke@435	407
duke@435	408	JavaThreadStatusChanger(JavaThread* java_thread) {
duke@435	409	save_old_state(java_thread);
duke@435	410	}
duke@435	411
duke@435	412	~JavaThreadStatusChanger() {
duke@435	413	set_thread_status(_old_state);
duke@435	414	}
duke@435	415
duke@435	416	static bool is_alive(JavaThread* java_thread) {
duke@435	417	return java_thread != NULL && java_thread->threadObj() != NULL;
duke@435	418	}
duke@435	419
duke@435	420	bool is_alive() {
duke@435	421	return _is_alive;
duke@435	422	}
duke@435	423	};
duke@435	424
duke@435	425	// Change status to waiting on an object (timed or indefinite)
duke@435	426	class JavaThreadInObjectWaitState : public JavaThreadStatusChanger {
duke@435	427	private:
duke@435	428	ThreadStatistics* _stat;
duke@435	429	bool _active;
duke@435	430
duke@435	431	public:
duke@435	432	JavaThreadInObjectWaitState(JavaThread *java_thread, bool timed) :
duke@435	433	JavaThreadStatusChanger(java_thread,
duke@435	434	timed ? java_lang_Thread::IN_OBJECT_WAIT_TIMED : java_lang_Thread::IN_OBJECT_WAIT) {
duke@435	435	if (is_alive()) {
duke@435	436	_stat = java_thread->get_thread_stat();
duke@435	437	_active = ThreadService::is_thread_monitoring_contention();
duke@435	438	_stat->monitor_wait();
duke@435	439	if (_active) {
duke@435	440	_stat->monitor_wait_begin();
duke@435	441	}
duke@435	442	} else {
duke@435	443	_active = false;
duke@435	444	}
duke@435	445	}
duke@435	446
duke@435	447	~JavaThreadInObjectWaitState() {
duke@435	448	if (_active) {
duke@435	449	_stat->monitor_wait_end();
duke@435	450	}
duke@435	451	}
duke@435	452	};
duke@435	453
duke@435	454	// Change status to parked (timed or indefinite)
duke@435	455	class JavaThreadParkedState : public JavaThreadStatusChanger {
duke@435	456	private:
duke@435	457	ThreadStatistics* _stat;
duke@435	458	bool _active;
duke@435	459
duke@435	460	public:
duke@435	461	JavaThreadParkedState(JavaThread *java_thread, bool timed) :
duke@435	462	JavaThreadStatusChanger(java_thread,
duke@435	463	timed ? java_lang_Thread::PARKED_TIMED : java_lang_Thread::PARKED) {
duke@435	464	if (is_alive()) {
duke@435	465	_stat = java_thread->get_thread_stat();
duke@435	466	_active = ThreadService::is_thread_monitoring_contention();
duke@435	467	_stat->monitor_wait();
duke@435	468	if (_active) {
duke@435	469	_stat->monitor_wait_begin();
duke@435	470	}
duke@435	471	} else {
duke@435	472	_active = false;
duke@435	473	}
duke@435	474	}
duke@435	475
duke@435	476	~JavaThreadParkedState() {
duke@435	477	if (_active) {
duke@435	478	_stat->monitor_wait_end();
duke@435	479	}
duke@435	480	}
duke@435	481	};
duke@435	482
duke@435	483	// Change status to blocked on (re-)entering a synchronization block
duke@435	484	class JavaThreadBlockedOnMonitorEnterState : public JavaThreadStatusChanger {
duke@435	485	private:
duke@435	486	ThreadStatistics* _stat;
duke@435	487	bool _active;
duke@435	488
duke@435	489	static bool contended_enter_begin(JavaThread *java_thread) {
duke@435	490	set_thread_status(java_thread, java_lang_Thread::BLOCKED_ON_MONITOR_ENTER);
duke@435	491	ThreadStatistics* stat = java_thread->get_thread_stat();
duke@435	492	stat->contended_enter();
duke@435	493	bool active = ThreadService::is_thread_monitoring_contention();
duke@435	494	if (active) {
duke@435	495	stat->contended_enter_begin();
duke@435	496	}
duke@435	497	return active;
duke@435	498	}
duke@435	499
duke@435	500	public:
duke@435	501	// java_thread is waiting thread being blocked on monitor reenter.
duke@435	502	// Current thread is the notifying thread which holds the monitor.
duke@435	503	static bool wait_reenter_begin(JavaThread *java_thread, ObjectMonitor *obj_m) {
duke@435	504	assert((java_thread != NULL), "Java thread should not be null here");
duke@435	505	bool active = false;
duke@435	506	if (is_alive(java_thread) && ServiceUtil::visible_oop((oop)obj_m->object())) {
duke@435	507	active = contended_enter_begin(java_thread);
duke@435	508	}
duke@435	509	return active;
duke@435	510	}
duke@435	511
duke@435	512	static void wait_reenter_end(JavaThread *java_thread, bool active) {
duke@435	513	if (active) {
duke@435	514	java_thread->get_thread_stat()->contended_enter_end();
duke@435	515	}
duke@435	516	set_thread_status(java_thread, java_lang_Thread::RUNNABLE);
duke@435	517	}
duke@435	518
duke@435	519	JavaThreadBlockedOnMonitorEnterState(JavaThread *java_thread, ObjectMonitor *obj_m) :
duke@435	520	JavaThreadStatusChanger(java_thread) {
duke@435	521	assert((java_thread != NULL), "Java thread should not be null here");
duke@435	522	// Change thread status and collect contended enter stats for monitor contended
duke@435	523	// enter done for external java world objects and it is contended. All other cases
duke@435	524	// like for vm internal objects and for external objects which are not contended
duke@435	525	// thread status is not changed and contended enter stat is not collected.
duke@435	526	_active = false;
duke@435	527	if (is_alive() && ServiceUtil::visible_oop((oop)obj_m->object()) && obj_m->contentions() > 0) {
duke@435	528	_stat = java_thread->get_thread_stat();
duke@435	529	_active = contended_enter_begin(java_thread);
duke@435	530	}
duke@435	531	}
duke@435	532
duke@435	533	~JavaThreadBlockedOnMonitorEnterState() {
duke@435	534	if (_active) {
duke@435	535	_stat->contended_enter_end();
duke@435	536	}
duke@435	537	}
duke@435	538	};
duke@435	539
duke@435	540	// Change status to sleeping
duke@435	541	class JavaThreadSleepState : public JavaThreadStatusChanger {
duke@435	542	private:
duke@435	543	ThreadStatistics* _stat;
duke@435	544	bool _active;
duke@435	545	public:
duke@435	546	JavaThreadSleepState(JavaThread *java_thread) :
duke@435	547	JavaThreadStatusChanger(java_thread, java_lang_Thread::SLEEPING) {
duke@435	548	if (is_alive()) {
duke@435	549	_stat = java_thread->get_thread_stat();
duke@435	550	_active = ThreadService::is_thread_monitoring_contention();
duke@435	551	_stat->thread_sleep();
duke@435	552	if (_active) {
duke@435	553	_stat->thread_sleep_begin();
duke@435	554	}
duke@435	555	} else {
duke@435	556	_active = false;
duke@435	557	}
duke@435	558	}
duke@435	559
duke@435	560	~JavaThreadSleepState() {
duke@435	561	if (_active) {
duke@435	562	_stat->thread_sleep_end();
duke@435	563	}
duke@435	564	}
duke@435	565	};