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 add_smr_tlh_times(uint add_value);
114 static void clear_smr_delete_notify();
115 static void inc_smr_deleted_thread_cnt();
116 static void inc_smr_java_thread_list_alloc_cnt();
117 static void inc_smr_tlh_cnt();
118 static bool is_a_protected_JavaThread(JavaThread *thread);
119 static void release_stable_list_fast_path(Thread *self);
120 static void release_stable_list_nested_path(Thread *self);
121 static void release_stable_list_wake_up(char *log_str);
122 static void set_smr_delete_notify();
123 static Monitor* smr_delete_lock() { return _smr_delete_lock; }
124 static bool smr_delete_notify();
125 static void smr_free_list(ThreadsList* threads);
126 static void update_smr_deleted_thread_time_max(uint new_value);
127 static void update_smr_java_thread_list_max(uint new_value);
128 static void update_smr_tlh_time_max(uint new_value);
129 static ThreadsList* xchg_smr_java_thread_list(ThreadsList* new_list);
130
131 public:
132 static ThreadsList *acquire_stable_list(Thread *self, bool is_ThreadsListSetter);
133 static void add_thread(JavaThread *thread);
134 static ThreadsList* get_smr_java_thread_list();
135 static bool is_a_protected_JavaThread_with_lock(JavaThread *thread);
136 static void release_stable_list(Thread *self);
137 static void remove_thread(JavaThread *thread);
138 static void smr_delete(JavaThread *thread);
139 static void update_smr_tlh_stats(uint millis);
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 static ThreadsList* add_thread(ThreadsList* list, JavaThread* java_thread);
163 static ThreadsList* remove_thread(ThreadsList* list, JavaThread* java_thread);
164
|
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 delete_lock in order to
85 // reduce the traffic on the Threads_lock.
86 static Monitor* _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 _delete_lock_wait_cnt;
91 static uint _delete_lock_wait_max;
92 // The delete_notify flag is used for proper double-check
93 // locking in order to reduce the traffic on the system wide
94 // Thread-SMR delete_lock.
95 static volatile uint _delete_notify;
96 static volatile uint _deleted_thread_cnt;
97 static volatile uint _deleted_thread_time_max;
98 static volatile uint _deleted_thread_times;
99 static ThreadsList* volatile _java_thread_list;
100 static uint64_t _java_thread_list_alloc_cnt;
101 static uint64_t _java_thread_list_free_cnt;
102 static uint _java_thread_list_max;
103 static uint _nested_thread_list_max;
104 static volatile uint _tlh_cnt;
105 static volatile uint _tlh_time_max;
106 static volatile uint _tlh_times;
107 static ThreadsList* _to_delete_list;
108 static uint _to_delete_list_cnt;
109 static uint _to_delete_list_max;
110
111 static ThreadsList *acquire_stable_list_fast_path(Thread *self);
112 static ThreadsList *acquire_stable_list_nested_path(Thread *self);
113 static void add_deleted_thread_times(uint add_value);
114 static void add_tlh_times(uint add_value);
115 static void clear_delete_notify();
116 static Monitor* delete_lock() { return _delete_lock; }
117 static bool delete_notify();
118 static void free_list(ThreadsList* threads);
119 static void inc_deleted_thread_cnt();
120 static void inc_java_thread_list_alloc_cnt();
121 static void inc_tlh_cnt();
122 static bool is_a_protected_JavaThread(JavaThread *thread);
123 static void release_stable_list_fast_path(Thread *self);
124 static void release_stable_list_nested_path(Thread *self);
125 static void release_stable_list_wake_up(char *log_str);
126 static void set_delete_notify();
127 static void update_deleted_thread_time_max(uint new_value);
128 static void update_java_thread_list_max(uint new_value);
129 static void update_tlh_time_max(uint new_value);
130 static ThreadsList* xchg_java_thread_list(ThreadsList* new_list);
131
132 public:
133 static ThreadsList *acquire_stable_list(Thread *self, bool is_ThreadsListSetter);
134 static void add_thread(JavaThread *thread);
135 static ThreadsList* get_java_thread_list();
136 static bool is_a_protected_JavaThread_with_lock(JavaThread *thread);
137 static void release_stable_list(Thread *self);
138 static void remove_thread(JavaThread *thread);
139 static void smr_delete(JavaThread *thread);
140 static void update_tlh_stats(uint millis);
141
142 // Logging and printing support:
143 static void log_statistics();
144 static void print_info_elements_on(outputStream* st, ThreadsList* t_list);
145 static void print_info_on(outputStream* st);
146 };
147
148 // A fast list of JavaThreads.
149 //
150 class ThreadsList : public CHeapObj<mtThread> {
151 friend class ThreadsSMRSupport; // for next_list(), set_next_list() access
152
153 const uint _length;
154 ThreadsList* _next_list;
155 JavaThread *const *const _threads;
156
157 template <class T>
158 void threads_do_dispatch(T *cl, JavaThread *const thread) const;
159
160 ThreadsList *next_list() const { return _next_list; }
161 void set_next_list(ThreadsList *list) { _next_list = list; }
162
163 static ThreadsList* add_thread(ThreadsList* list, JavaThread* java_thread);
164 static ThreadsList* remove_thread(ThreadsList* list, JavaThread* java_thread);
165
|