60 // : // do stuff with 'jt'...
61 //
62 // JVM/TI oop example (this one should be very rare):
63 // oop thread_obj = ...;
64 // :
65 // JavaThread *jt = NULL;
66 // ThreadsListHandle tlh;
67 // jvmtiError err = JvmtiExport::cv_oop_to_JavaThread(tlh.list(), thread_obj, &jt);
68 // if (err != JVMTI_ERROR_NONE) {
69 // return err;
70 // }
71 // : // do stuff with 'jt'...
72 //
73 // A JavaThread * that is included in the ThreadsList that is held by
74 // a ThreadsListHandle is protected as long as the ThreadsListHandle
75 // remains in scope. The target JavaThread * may have logically exited,
76 // but that target JavaThread * will not be deleted until it is no
77 // longer protected by a ThreadsListHandle.
78
79
80 // A fast list of JavaThreads.
81 //
82 class ThreadsList : public CHeapObj<mtThread> {
83 friend class ScanHazardPtrGatherProtectedThreadsClosure;
84 friend class Threads;
85
86 const uint _length;
87 ThreadsList* _next_list;
88 JavaThread *const *const _threads;
89
90 template <class T>
91 void threads_do_dispatch(T *cl, JavaThread *const thread) const;
92
93 ThreadsList *next_list() const { return _next_list; }
94 void set_next_list(ThreadsList *list) { _next_list = list; }
95
96 public:
97 ThreadsList(int entries);
98 ~ThreadsList();
99
100 template <class T>
101 void threads_do(T *cl) const;
102
103 uint length() const { return _length; }
104
|
60 // : // do stuff with 'jt'...
61 //
62 // JVM/TI oop example (this one should be very rare):
63 // oop thread_obj = ...;
64 // :
65 // JavaThread *jt = NULL;
66 // ThreadsListHandle tlh;
67 // jvmtiError err = JvmtiExport::cv_oop_to_JavaThread(tlh.list(), thread_obj, &jt);
68 // if (err != JVMTI_ERROR_NONE) {
69 // return err;
70 // }
71 // : // do stuff with 'jt'...
72 //
73 // A JavaThread * that is included in the ThreadsList that is held by
74 // a ThreadsListHandle is protected as long as the ThreadsListHandle
75 // remains in scope. The target JavaThread * may have logically exited,
76 // but that target JavaThread * will not be deleted until it is no
77 // longer protected by a ThreadsListHandle.
78
79
80 // SMR Support for the Threads class.
81 //
82 class ThreadsSMRSupport : AllStatic {
83 // The coordination between ThreadsSMRSupport::release_stable_list() and
84 // ThreadsSMRSupport::smr_delete() uses the smr_delete_lock in order to
85 // reduce the traffic on the Threads_lock.
86 static Monitor* _smr_delete_lock;
87 // The '_cnt', '_max' and '_times" fields are enabled via
88 // -XX:+EnableThreadSMRStatistics (see thread.cpp for a
89 // description about each field):
90 static uint _smr_delete_lock_wait_cnt;
91 static uint _smr_delete_lock_wait_max;
92 // The smr_delete_notify flag is used for proper double-check
93 // locking in order to reduce the traffic on the smr_delete_lock.
94 static volatile uint _smr_delete_notify;
95 static volatile uint _smr_deleted_thread_cnt;
96 static volatile uint _smr_deleted_thread_time_max;
97 static volatile uint _smr_deleted_thread_times;
98 static ThreadsList* volatile _smr_java_thread_list;
99 static uint64_t _smr_java_thread_list_alloc_cnt;
100 static uint64_t _smr_java_thread_list_free_cnt;
101 static uint _smr_java_thread_list_max;
102 static uint _smr_nested_thread_list_max;
103 static volatile uint _smr_tlh_cnt;
104 static volatile uint _smr_tlh_time_max;
105 static volatile uint _smr_tlh_times;
106 static ThreadsList* _smr_to_delete_list;
107 static uint _smr_to_delete_list_cnt;
108 static uint _smr_to_delete_list_max;
109
110 static ThreadsList *acquire_stable_list_fast_path(Thread *self);
111 static ThreadsList *acquire_stable_list_nested_path(Thread *self);
112 static void add_smr_deleted_thread_times(uint add_value);
113 static void clear_smr_delete_notify();
114 static void inc_smr_deleted_thread_cnt();
115 static bool is_a_protected_JavaThread(JavaThread *thread);
116 static void release_stable_list_fast_path(Thread *self);
117 static void release_stable_list_nested_path(Thread *self);
118 static void release_stable_list_wake_up(char *log_str);
119 static void set_smr_delete_notify();
120 static Monitor* smr_delete_lock() { return _smr_delete_lock; }
121 static bool smr_delete_notify();
122 static void update_smr_deleted_thread_time_max(uint new_value);
123
124 public:
125 static ThreadsList *acquire_stable_list(Thread *self, bool is_ThreadsListSetter);
126 static void add_smr_tlh_times(uint add_value);
127 static ThreadsList* get_smr_java_thread_list();
128 static void inc_smr_java_thread_list_alloc_cnt();
129 static void inc_smr_tlh_cnt();
130 static bool is_a_protected_JavaThread_with_lock(JavaThread *thread) {
131 MutexLockerEx ml(Threads_lock->owned_by_self() ? NULL : Threads_lock);
132 return is_a_protected_JavaThread(thread);
133 }
134 static void release_stable_list(Thread *self);
135 static void smr_delete(JavaThread *thread);
136 static void smr_free_list(ThreadsList* threads);
137 static void update_smr_java_thread_list_max(uint new_value);
138 static void update_smr_tlh_time_max(uint new_value);
139 static ThreadsList* xchg_smr_java_thread_list(ThreadsList* new_list);
140
141 // Logging and printing support:
142 static void log_smr_statistics();
143 static void print_smr_info_elements_on(outputStream* st, ThreadsList* t_list);
144 static void print_smr_info_on(outputStream* st);
145 };
146
147 // A fast list of JavaThreads.
148 //
149 class ThreadsList : public CHeapObj<mtThread> {
150 friend class ThreadsSMRSupport; // for next_list(), set_next_list() access
151
152 const uint _length;
153 ThreadsList* _next_list;
154 JavaThread *const *const _threads;
155
156 template <class T>
157 void threads_do_dispatch(T *cl, JavaThread *const thread) const;
158
159 ThreadsList *next_list() const { return _next_list; }
160 void set_next_list(ThreadsList *list) { _next_list = list; }
161
162 public:
163 ThreadsList(int entries);
164 ~ThreadsList();
165
166 template <class T>
167 void threads_do(T *cl) const;
168
169 uint length() const { return _length; }
170
|