19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #ifndef SHARE_RUNTIME_THREAD_HPP
27 #define SHARE_RUNTIME_THREAD_HPP
28
29 #include "jni.h"
30 #include "gc/shared/gcThreadLocalData.hpp"
31 #include "gc/shared/threadLocalAllocBuffer.hpp"
32 #include "memory/allocation.hpp"
33 #include "oops/oop.hpp"
34 #include "oops/oopHandle.hpp"
35 #include "runtime/frame.hpp"
36 #include "runtime/globals.hpp"
37 #include "runtime/handshake.hpp"
38 #include "runtime/javaFrameAnchor.hpp"
39 #include "runtime/mutexLocker.hpp"
40 #include "runtime/os.hpp"
41 #include "runtime/park.hpp"
42 #include "runtime/safepointMechanism.hpp"
43 #include "runtime/stackWatermarkSet.hpp"
44 #include "runtime/stackOverflow.hpp"
45 #include "runtime/threadHeapSampler.hpp"
46 #include "runtime/threadLocalStorage.hpp"
47 #include "runtime/threadStatisticalInfo.hpp"
48 #include "runtime/unhandledOops.hpp"
49 #include "utilities/align.hpp"
50 #include "utilities/exceptions.hpp"
51 #include "utilities/globalDefinitions.hpp"
52 #include "utilities/macros.hpp"
53 #if INCLUDE_JFR
54 #include "jfr/support/jfrThreadExtension.hpp"
55 #endif
56
57
58 class SafeThreadsListPtr;
1594 inline void set_done_attaching_via_jni();
1595
1596 // Stack dump assistance:
1597 // Track the class we want to initialize but for which we have to wait
1598 // on its init_lock() because it is already being initialized.
1599 void set_class_to_be_initialized(InstanceKlass* k);
1600 InstanceKlass* class_to_be_initialized() const;
1601
1602 private:
1603 InstanceKlass* _class_to_be_initialized;
1604
1605 // java.lang.Thread.sleep support
1606 ParkEvent * _SleepEvent;
1607 public:
1608 bool sleep(jlong millis);
1609
1610 // java.lang.Thread interruption support
1611 void interrupt();
1612 bool is_interrupted(bool clear_interrupted);
1613
1614 static OopStorage* thread_oop_storage();
1615
1616 static void verify_cross_modify_fence_failure(JavaThread *thread) PRODUCT_RETURN;
1617
1618 // AsyncGetCallTrace support
1619 inline bool in_asgct(void) {return _in_asgct;}
1620 inline void set_in_asgct(bool value) {_in_asgct = value;}
1621 };
1622
1623 // Inline implementation of JavaThread::current
1624 inline JavaThread* JavaThread::current() {
1625 return Thread::current()->as_Java_thread();
1626 }
1627
1628 inline JavaThread* JavaThread::current_or_null() {
1629 Thread* current = Thread::current_or_null();
1630 return current != nullptr ? current->as_Java_thread() : nullptr;
1631 }
1632
1633 inline JavaThread* Thread::as_Java_thread() {
1717 // Verification
1718 static void verify();
1719 static void print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks, bool print_extended_info);
1720 static void print(bool print_stacks, bool internal_format) {
1721 // this function is only used by debug.cpp
1722 print_on(tty, print_stacks, internal_format, false /* no concurrent lock printed */, false /* simple format */);
1723 }
1724 static void print_on_error(outputStream* st, Thread* current, char* buf, int buflen);
1725 static void print_on_error(Thread* this_thread, outputStream* st, Thread* current, char* buf,
1726 int buflen, bool* found_current);
1727 static void print_threads_compiling(outputStream* st, char* buf, int buflen, bool short_form = false);
1728
1729 // Get Java threads that are waiting to enter a monitor.
1730 static GrowableArray<JavaThread*>* get_pending_threads(ThreadsList * t_list,
1731 int count, address monitor);
1732
1733 // Get owning Java thread from the monitor's owner field.
1734 static JavaThread *owning_thread_from_monitor_owner(ThreadsList * t_list,
1735 address owner);
1736
1737 // Number of threads on the active threads list
1738 static int number_of_threads() { return _number_of_threads; }
1739 // Number of non-daemon threads on the active threads list
1740 static int number_of_non_daemon_threads() { return _number_of_non_daemon_threads; }
1741
1742 // Deoptimizes all frames tied to marked nmethods
1743 static void deoptimized_wrt_marked_nmethods();
1744
1745 struct Test; // For private gtest access.
1746 };
1747
1748 class UnlockFlagSaver {
1749 private:
1750 JavaThread* _thread;
1751 bool _do_not_unlock;
1752 public:
1753 UnlockFlagSaver(JavaThread* t) {
1754 _thread = t;
1755 _do_not_unlock = t->do_not_unlock_if_synchronized();
1756 t->set_do_not_unlock_if_synchronized(false);
|
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #ifndef SHARE_RUNTIME_THREAD_HPP
27 #define SHARE_RUNTIME_THREAD_HPP
28
29 #include "jni.h"
30 #include "gc/shared/gcThreadLocalData.hpp"
31 #include "gc/shared/threadLocalAllocBuffer.hpp"
32 #include "memory/allocation.hpp"
33 #include "oops/oop.hpp"
34 #include "oops/oopHandle.hpp"
35 #include "runtime/frame.hpp"
36 #include "runtime/globals.hpp"
37 #include "runtime/handshake.hpp"
38 #include "runtime/javaFrameAnchor.hpp"
39 #include "runtime/lockStack.hpp"
40 #include "runtime/mutexLocker.hpp"
41 #include "runtime/os.hpp"
42 #include "runtime/park.hpp"
43 #include "runtime/safepointMechanism.hpp"
44 #include "runtime/stackWatermarkSet.hpp"
45 #include "runtime/stackOverflow.hpp"
46 #include "runtime/threadHeapSampler.hpp"
47 #include "runtime/threadLocalStorage.hpp"
48 #include "runtime/threadStatisticalInfo.hpp"
49 #include "runtime/unhandledOops.hpp"
50 #include "utilities/align.hpp"
51 #include "utilities/exceptions.hpp"
52 #include "utilities/globalDefinitions.hpp"
53 #include "utilities/macros.hpp"
54 #if INCLUDE_JFR
55 #include "jfr/support/jfrThreadExtension.hpp"
56 #endif
57
58
59 class SafeThreadsListPtr;
1595 inline void set_done_attaching_via_jni();
1596
1597 // Stack dump assistance:
1598 // Track the class we want to initialize but for which we have to wait
1599 // on its init_lock() because it is already being initialized.
1600 void set_class_to_be_initialized(InstanceKlass* k);
1601 InstanceKlass* class_to_be_initialized() const;
1602
1603 private:
1604 InstanceKlass* _class_to_be_initialized;
1605
1606 // java.lang.Thread.sleep support
1607 ParkEvent * _SleepEvent;
1608 public:
1609 bool sleep(jlong millis);
1610
1611 // java.lang.Thread interruption support
1612 void interrupt();
1613 bool is_interrupted(bool clear_interrupted);
1614
1615 private:
1616 LockStack _lock_stack;
1617
1618 public:
1619 LockStack& lock_stack() { return _lock_stack; }
1620
1621 static ByteSize lock_stack_current_offset() { return byte_offset_of(JavaThread, _lock_stack) + LockStack::current_offset(); }
1622 static ByteSize lock_stack_limit_offset() { return byte_offset_of(JavaThread, _lock_stack) + LockStack::limit_offset(); }
1623
1624
1625 static OopStorage* thread_oop_storage();
1626
1627 static void verify_cross_modify_fence_failure(JavaThread *thread) PRODUCT_RETURN;
1628
1629 // AsyncGetCallTrace support
1630 inline bool in_asgct(void) {return _in_asgct;}
1631 inline void set_in_asgct(bool value) {_in_asgct = value;}
1632 };
1633
1634 // Inline implementation of JavaThread::current
1635 inline JavaThread* JavaThread::current() {
1636 return Thread::current()->as_Java_thread();
1637 }
1638
1639 inline JavaThread* JavaThread::current_or_null() {
1640 Thread* current = Thread::current_or_null();
1641 return current != nullptr ? current->as_Java_thread() : nullptr;
1642 }
1643
1644 inline JavaThread* Thread::as_Java_thread() {
1728 // Verification
1729 static void verify();
1730 static void print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks, bool print_extended_info);
1731 static void print(bool print_stacks, bool internal_format) {
1732 // this function is only used by debug.cpp
1733 print_on(tty, print_stacks, internal_format, false /* no concurrent lock printed */, false /* simple format */);
1734 }
1735 static void print_on_error(outputStream* st, Thread* current, char* buf, int buflen);
1736 static void print_on_error(Thread* this_thread, outputStream* st, Thread* current, char* buf,
1737 int buflen, bool* found_current);
1738 static void print_threads_compiling(outputStream* st, char* buf, int buflen, bool short_form = false);
1739
1740 // Get Java threads that are waiting to enter a monitor.
1741 static GrowableArray<JavaThread*>* get_pending_threads(ThreadsList * t_list,
1742 int count, address monitor);
1743
1744 // Get owning Java thread from the monitor's owner field.
1745 static JavaThread *owning_thread_from_monitor_owner(ThreadsList * t_list,
1746 address owner);
1747
1748 static JavaThread* owning_thread_from_object(ThreadsList* t_list, oop obj);
1749 static JavaThread* owning_thread_from_monitor(ThreadsList* t_list, ObjectMonitor* owner);
1750
1751 // Number of threads on the active threads list
1752 static int number_of_threads() { return _number_of_threads; }
1753 // Number of non-daemon threads on the active threads list
1754 static int number_of_non_daemon_threads() { return _number_of_non_daemon_threads; }
1755
1756 // Deoptimizes all frames tied to marked nmethods
1757 static void deoptimized_wrt_marked_nmethods();
1758
1759 struct Test; // For private gtest access.
1760 };
1761
1762 class UnlockFlagSaver {
1763 private:
1764 JavaThread* _thread;
1765 bool _do_not_unlock;
1766 public:
1767 UnlockFlagSaver(JavaThread* t) {
1768 _thread = t;
1769 _do_not_unlock = t->do_not_unlock_if_synchronized();
1770 t->set_do_not_unlock_if_synchronized(false);
|