65 inline void Thread::clear_trace_flag() { |
65 inline void Thread::clear_trace_flag() { |
66 clear_suspend_flag(_trace_flag); |
66 clear_suspend_flag(_trace_flag); |
67 } |
67 } |
68 |
68 |
69 inline jlong Thread::cooked_allocated_bytes() { |
69 inline jlong Thread::cooked_allocated_bytes() { |
70 jlong allocated_bytes = OrderAccess::load_acquire(&_allocated_bytes); |
70 jlong allocated_bytes = Atomic::load_acquire(&_allocated_bytes); |
71 if (UseTLAB) { |
71 if (UseTLAB) { |
72 size_t used_bytes = tlab().used_bytes(); |
72 size_t used_bytes = tlab().used_bytes(); |
73 if (used_bytes <= ThreadLocalAllocBuffer::max_size_in_bytes()) { |
73 if (used_bytes <= ThreadLocalAllocBuffer::max_size_in_bytes()) { |
74 // Comparing used_bytes with the maximum allowed size will ensure |
74 // Comparing used_bytes with the maximum allowed size will ensure |
75 // that we don't add the used bytes from a semi-initialized TLAB |
75 // that we don't add the used bytes from a semi-initialized TLAB |
85 inline ThreadsList* Thread::cmpxchg_threads_hazard_ptr(ThreadsList* exchange_value, ThreadsList* compare_value) { |
85 inline ThreadsList* Thread::cmpxchg_threads_hazard_ptr(ThreadsList* exchange_value, ThreadsList* compare_value) { |
86 return (ThreadsList*)Atomic::cmpxchg(exchange_value, &_threads_hazard_ptr, compare_value); |
86 return (ThreadsList*)Atomic::cmpxchg(exchange_value, &_threads_hazard_ptr, compare_value); |
87 } |
87 } |
88 |
88 |
89 inline ThreadsList* Thread::get_threads_hazard_ptr() { |
89 inline ThreadsList* Thread::get_threads_hazard_ptr() { |
90 return (ThreadsList*)OrderAccess::load_acquire(&_threads_hazard_ptr); |
90 return (ThreadsList*)Atomic::load_acquire(&_threads_hazard_ptr); |
91 } |
91 } |
92 |
92 |
93 inline void Thread::set_threads_hazard_ptr(ThreadsList* new_list) { |
93 inline void Thread::set_threads_hazard_ptr(ThreadsList* new_list) { |
94 OrderAccess::release_store_fence(&_threads_hazard_ptr, new_list); |
94 Atomic::release_store_fence(&_threads_hazard_ptr, new_list); |
95 } |
95 } |
96 |
96 |
97 inline void JavaThread::set_ext_suspended() { |
97 inline void JavaThread::set_ext_suspended() { |
98 set_suspend_flag (_ext_suspended); |
98 set_suspend_flag (_ext_suspended); |
99 } |
99 } |
116 |
116 |
117 inline JavaThreadState JavaThread::thread_state() const { |
117 inline JavaThreadState JavaThread::thread_state() const { |
118 #if defined(PPC64) || defined (AARCH64) |
118 #if defined(PPC64) || defined (AARCH64) |
119 // Use membars when accessing volatile _thread_state. See |
119 // Use membars when accessing volatile _thread_state. See |
120 // Threads::create_vm() for size checks. |
120 // Threads::create_vm() for size checks. |
121 return (JavaThreadState) OrderAccess::load_acquire((volatile jint*)&_thread_state); |
121 return (JavaThreadState) Atomic::load_acquire((volatile jint*)&_thread_state); |
122 #else |
122 #else |
123 return _thread_state; |
123 return _thread_state; |
124 #endif |
124 #endif |
125 } |
125 } |
126 |
126 |
127 inline void JavaThread::set_thread_state(JavaThreadState s) { |
127 inline void JavaThread::set_thread_state(JavaThreadState s) { |
128 #if defined(PPC64) || defined (AARCH64) |
128 #if defined(PPC64) || defined (AARCH64) |
129 // Use membars when accessing volatile _thread_state. See |
129 // Use membars when accessing volatile _thread_state. See |
130 // Threads::create_vm() for size checks. |
130 // Threads::create_vm() for size checks. |
131 OrderAccess::release_store((volatile jint*)&_thread_state, (jint)s); |
131 Atomic::release_store((volatile jint*)&_thread_state, (jint)s); |
132 #else |
132 #else |
133 _thread_state = s; |
133 _thread_state = s; |
134 #endif |
134 #endif |
135 } |
135 } |
136 |
136 |
198 } |
198 } |
199 |
199 |
200 // The release make sure this store is done after storing the handshake |
200 // The release make sure this store is done after storing the handshake |
201 // operation or global state |
201 // operation or global state |
202 inline void JavaThread::set_polling_page_release(void* poll_value) { |
202 inline void JavaThread::set_polling_page_release(void* poll_value) { |
203 OrderAccess::release_store(polling_page_addr(), poll_value); |
203 Atomic::release_store(polling_page_addr(), poll_value); |
204 } |
204 } |
205 |
205 |
206 // Caller is responsible for using a memory barrier if needed. |
206 // Caller is responsible for using a memory barrier if needed. |
207 inline void JavaThread::set_polling_page(void* poll_value) { |
207 inline void JavaThread::set_polling_page(void* poll_value) { |
208 *polling_page_addr() = poll_value; |
208 *polling_page_addr() = poll_value; |
209 } |
209 } |
210 |
210 |
211 // The aqcquire make sure reading of polling page is done before |
211 // The aqcquire make sure reading of polling page is done before |
212 // the reading the handshake operation or the global state |
212 // the reading the handshake operation or the global state |
213 inline volatile void* JavaThread::get_polling_page() { |
213 inline volatile void* JavaThread::get_polling_page() { |
214 return OrderAccess::load_acquire(polling_page_addr()); |
214 return Atomic::load_acquire(polling_page_addr()); |
215 } |
215 } |
216 |
216 |
217 inline bool JavaThread::is_exiting() const { |
217 inline bool JavaThread::is_exiting() const { |
218 // Use load-acquire so that setting of _terminated by |
218 // Use load-acquire so that setting of _terminated by |
219 // JavaThread::exit() is seen more quickly. |
219 // JavaThread::exit() is seen more quickly. |
220 TerminatedTypes l_terminated = (TerminatedTypes) |
220 TerminatedTypes l_terminated = (TerminatedTypes) |
221 OrderAccess::load_acquire((volatile jint *) &_terminated); |
221 Atomic::load_acquire((volatile jint *) &_terminated); |
222 return l_terminated == _thread_exiting || check_is_terminated(l_terminated); |
222 return l_terminated == _thread_exiting || check_is_terminated(l_terminated); |
223 } |
223 } |
224 |
224 |
225 inline bool JavaThread::is_terminated() const { |
225 inline bool JavaThread::is_terminated() const { |
226 // Use load-acquire so that setting of _terminated by |
226 // Use load-acquire so that setting of _terminated by |
227 // JavaThread::exit() is seen more quickly. |
227 // JavaThread::exit() is seen more quickly. |
228 TerminatedTypes l_terminated = (TerminatedTypes) |
228 TerminatedTypes l_terminated = (TerminatedTypes) |
229 OrderAccess::load_acquire((volatile jint *) &_terminated); |
229 Atomic::load_acquire((volatile jint *) &_terminated); |
230 return check_is_terminated(l_terminated); |
230 return check_is_terminated(l_terminated); |
231 } |
231 } |
232 |
232 |
233 inline void JavaThread::set_terminated(TerminatedTypes t) { |
233 inline void JavaThread::set_terminated(TerminatedTypes t) { |
234 // use release-store so the setting of _terminated is seen more quickly |
234 // use release-store so the setting of _terminated is seen more quickly |
235 OrderAccess::release_store((volatile jint *) &_terminated, (jint) t); |
235 Atomic::release_store((volatile jint *) &_terminated, (jint) t); |
236 } |
236 } |
237 |
237 |
238 // special for Threads::remove() which is static: |
238 // special for Threads::remove() which is static: |
239 inline void JavaThread::set_terminated_value() { |
239 inline void JavaThread::set_terminated_value() { |
240 // use release-store so the setting of _terminated is seen more quickly |
240 // use release-store so the setting of _terminated is seen more quickly |
241 OrderAccess::release_store((volatile jint *) &_terminated, (jint) _thread_terminated); |
241 Atomic::release_store((volatile jint *) &_terminated, (jint) _thread_terminated); |
242 } |
242 } |
243 |
243 |
244 // Allow tracking of class initialization monitor use |
244 // Allow tracking of class initialization monitor use |
245 inline void JavaThread::set_class_to_be_initialized(InstanceKlass* k) { |
245 inline void JavaThread::set_class_to_be_initialized(InstanceKlass* k) { |
246 assert((k == NULL && _class_to_be_initialized != NULL) || |
246 assert((k == NULL && _class_to_be_initialized != NULL) || |