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