1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef ART_RUNTIME_THREAD_INL_H_
18 #define ART_RUNTIME_THREAD_INL_H_
19
20 #include "thread.h"
21
22 #ifdef __ANDROID__
23 #include <bionic_tls.h> // Access to our own TLS slot.
24 #endif
25
26 #include <pthread.h>
27
28 #include "base/casts.h"
29 #include "base/mutex-inl.h"
30 #include "gc/heap.h"
31 #include "jni_env_ext.h"
32 #include "thread_pool.h"
33
34 namespace art {
35
36 // Quickly access the current thread from a JNIEnv.
ThreadForEnv(JNIEnv * env)37 static inline Thread* ThreadForEnv(JNIEnv* env) {
38 JNIEnvExt* full_env(down_cast<JNIEnvExt*>(env));
39 return full_env->self;
40 }
41
Current()42 inline Thread* Thread::Current() {
43 // We rely on Thread::Current returning null for a detached thread, so it's not obvious
44 // that we can replace this with a direct %fs access on x86.
45 if (!is_started_) {
46 return nullptr;
47 } else {
48 #ifdef __ANDROID__
49 void* thread = __get_tls()[TLS_SLOT_ART_THREAD_SELF];
50 #else
51 void* thread = pthread_getspecific(Thread::pthread_key_self_);
52 #endif
53 return reinterpret_cast<Thread*>(thread);
54 }
55 }
56
AllowThreadSuspension()57 inline void Thread::AllowThreadSuspension() {
58 DCHECK_EQ(Thread::Current(), this);
59 if (UNLIKELY(TestAllFlags())) {
60 CheckSuspend();
61 }
62 }
63
CheckSuspend()64 inline void Thread::CheckSuspend() {
65 DCHECK_EQ(Thread::Current(), this);
66 for (;;) {
67 if (ReadFlag(kCheckpointRequest)) {
68 RunCheckpointFunction();
69 } else if (ReadFlag(kSuspendRequest)) {
70 FullSuspendCheck();
71 } else {
72 break;
73 }
74 }
75 }
76
SetState(ThreadState new_state)77 inline ThreadState Thread::SetState(ThreadState new_state) {
78 // Should only be used to change between suspended states.
79 // Cannot use this code to change into or from Runnable as changing to Runnable should
80 // fail if old_state_and_flags.suspend_request is true and changing from Runnable might
81 // miss passing an active suspend barrier.
82 DCHECK_NE(new_state, kRunnable);
83 if (kIsDebugBuild && this != Thread::Current()) {
84 std::string name;
85 GetThreadName(name);
86 LOG(FATAL) << "Thread \"" << name << "\"(" << this << " != Thread::Current()="
87 << Thread::Current() << ") changing state to " << new_state;
88 }
89 union StateAndFlags old_state_and_flags;
90 old_state_and_flags.as_int = tls32_.state_and_flags.as_int;
91 CHECK_NE(old_state_and_flags.as_struct.state, kRunnable);
92 tls32_.state_and_flags.as_struct.state = new_state;
93 return static_cast<ThreadState>(old_state_and_flags.as_struct.state);
94 }
95
AssertThreadSuspensionIsAllowable(bool check_locks)96 inline void Thread::AssertThreadSuspensionIsAllowable(bool check_locks) const {
97 if (kIsDebugBuild) {
98 if (gAborting == 0) {
99 CHECK_EQ(0u, tls32_.no_thread_suspension) << tlsPtr_.last_no_thread_suspension_cause;
100 }
101 if (check_locks) {
102 bool bad_mutexes_held = false;
103 for (int i = kLockLevelCount - 1; i >= 0; --i) {
104 // We expect no locks except the mutator_lock_ or thread list suspend thread lock.
105 if (i != kMutatorLock) {
106 BaseMutex* held_mutex = GetHeldMutex(static_cast<LockLevel>(i));
107 if (held_mutex != nullptr) {
108 LOG(ERROR) << "holding \"" << held_mutex->GetName()
109 << "\" at point where thread suspension is expected";
110 bad_mutexes_held = true;
111 }
112 }
113 }
114 if (gAborting == 0) {
115 CHECK(!bad_mutexes_held);
116 }
117 }
118 }
119 }
120
TransitionToSuspendedAndRunCheckpoints(ThreadState new_state)121 inline void Thread::TransitionToSuspendedAndRunCheckpoints(ThreadState new_state) {
122 DCHECK_NE(new_state, kRunnable);
123 DCHECK_EQ(GetState(), kRunnable);
124 union StateAndFlags old_state_and_flags;
125 union StateAndFlags new_state_and_flags;
126 while (true) {
127 old_state_and_flags.as_int = tls32_.state_and_flags.as_int;
128 if (UNLIKELY((old_state_and_flags.as_struct.flags & kCheckpointRequest) != 0)) {
129 RunCheckpointFunction();
130 continue;
131 }
132 // Change the state but keep the current flags (kCheckpointRequest is clear).
133 DCHECK_EQ((old_state_and_flags.as_struct.flags & kCheckpointRequest), 0);
134 new_state_and_flags.as_struct.flags = old_state_and_flags.as_struct.flags;
135 new_state_and_flags.as_struct.state = new_state;
136
137 // CAS the value with a memory ordering.
138 bool done =
139 tls32_.state_and_flags.as_atomic_int.CompareExchangeWeakRelease(old_state_and_flags.as_int,
140 new_state_and_flags.as_int);
141 if (LIKELY(done)) {
142 break;
143 }
144 }
145 }
146
PassActiveSuspendBarriers()147 inline void Thread::PassActiveSuspendBarriers() {
148 while (true) {
149 uint16_t current_flags = tls32_.state_and_flags.as_struct.flags;
150 if (LIKELY((current_flags & (kCheckpointRequest | kActiveSuspendBarrier)) == 0)) {
151 break;
152 } else if ((current_flags & kActiveSuspendBarrier) != 0) {
153 PassActiveSuspendBarriers(this);
154 } else {
155 // Impossible
156 LOG(FATAL) << "Fatal, thread transitioned into suspended without running the checkpoint";
157 }
158 }
159 }
160
TransitionFromRunnableToSuspended(ThreadState new_state)161 inline void Thread::TransitionFromRunnableToSuspended(ThreadState new_state) {
162 AssertThreadSuspensionIsAllowable();
163 DCHECK_EQ(this, Thread::Current());
164 // Change to non-runnable state, thereby appearing suspended to the system.
165 TransitionToSuspendedAndRunCheckpoints(new_state);
166 // Mark the release of the share of the mutator_lock_.
167 Locks::mutator_lock_->TransitionFromRunnableToSuspended(this);
168 // Once suspended - check the active suspend barrier flag
169 PassActiveSuspendBarriers();
170 }
171
TransitionFromSuspendedToRunnable()172 inline ThreadState Thread::TransitionFromSuspendedToRunnable() {
173 union StateAndFlags old_state_and_flags;
174 old_state_and_flags.as_int = tls32_.state_and_flags.as_int;
175 int16_t old_state = old_state_and_flags.as_struct.state;
176 DCHECK_NE(static_cast<ThreadState>(old_state), kRunnable);
177 do {
178 Locks::mutator_lock_->AssertNotHeld(this); // Otherwise we starve GC..
179 old_state_and_flags.as_int = tls32_.state_and_flags.as_int;
180 DCHECK_EQ(old_state_and_flags.as_struct.state, old_state);
181 if (LIKELY(old_state_and_flags.as_struct.flags == 0)) {
182 // Optimize for the return from native code case - this is the fast path.
183 // Atomically change from suspended to runnable if no suspend request pending.
184 union StateAndFlags new_state_and_flags;
185 new_state_and_flags.as_int = old_state_and_flags.as_int;
186 new_state_and_flags.as_struct.state = kRunnable;
187 // CAS the value with a memory barrier.
188 if (LIKELY(tls32_.state_and_flags.as_atomic_int.CompareExchangeWeakAcquire(
189 old_state_and_flags.as_int,
190 new_state_and_flags.as_int))) {
191 // Mark the acquisition of a share of the mutator_lock_.
192 Locks::mutator_lock_->TransitionFromSuspendedToRunnable(this);
193 break;
194 }
195 } else if ((old_state_and_flags.as_struct.flags & kActiveSuspendBarrier) != 0) {
196 PassActiveSuspendBarriers(this);
197 } else if ((old_state_and_flags.as_struct.flags & kCheckpointRequest) != 0) {
198 // Impossible
199 LOG(FATAL) << "Transitioning to runnable with checkpoint flag, "
200 << " flags=" << old_state_and_flags.as_struct.flags
201 << " state=" << old_state_and_flags.as_struct.state;
202 } else if ((old_state_and_flags.as_struct.flags & kSuspendRequest) != 0) {
203 // Wait while our suspend count is non-zero.
204 MutexLock mu(this, *Locks::thread_suspend_count_lock_);
205 old_state_and_flags.as_int = tls32_.state_and_flags.as_int;
206 DCHECK_EQ(old_state_and_flags.as_struct.state, old_state);
207 while ((old_state_and_flags.as_struct.flags & kSuspendRequest) != 0) {
208 // Re-check when Thread::resume_cond_ is notified.
209 Thread::resume_cond_->Wait(this);
210 old_state_and_flags.as_int = tls32_.state_and_flags.as_int;
211 DCHECK_EQ(old_state_and_flags.as_struct.state, old_state);
212 }
213 DCHECK_EQ(GetSuspendCount(), 0);
214 }
215 } while (true);
216 // Run the flip function, if set.
217 Closure* flip_func = GetFlipFunction();
218 if (flip_func != nullptr) {
219 flip_func->Run(this);
220 }
221 return static_cast<ThreadState>(old_state);
222 }
223
VerifyStack()224 inline void Thread::VerifyStack() {
225 if (kVerifyStack) {
226 if (Runtime::Current()->GetHeap()->IsObjectValidationEnabled()) {
227 VerifyStackImpl();
228 }
229 }
230 }
231
TlabSize()232 inline size_t Thread::TlabSize() const {
233 return tlsPtr_.thread_local_end - tlsPtr_.thread_local_pos;
234 }
235
AllocTlab(size_t bytes)236 inline mirror::Object* Thread::AllocTlab(size_t bytes) {
237 DCHECK_GE(TlabSize(), bytes);
238 ++tlsPtr_.thread_local_objects;
239 mirror::Object* ret = reinterpret_cast<mirror::Object*>(tlsPtr_.thread_local_pos);
240 tlsPtr_.thread_local_pos += bytes;
241 return ret;
242 }
243
PushOnThreadLocalAllocationStack(mirror::Object * obj)244 inline bool Thread::PushOnThreadLocalAllocationStack(mirror::Object* obj) {
245 DCHECK_LE(tlsPtr_.thread_local_alloc_stack_top, tlsPtr_.thread_local_alloc_stack_end);
246 if (tlsPtr_.thread_local_alloc_stack_top < tlsPtr_.thread_local_alloc_stack_end) {
247 // There's room.
248 DCHECK_LE(reinterpret_cast<uint8_t*>(tlsPtr_.thread_local_alloc_stack_top) +
249 sizeof(StackReference<mirror::Object>),
250 reinterpret_cast<uint8_t*>(tlsPtr_.thread_local_alloc_stack_end));
251 DCHECK(tlsPtr_.thread_local_alloc_stack_top->AsMirrorPtr() == nullptr);
252 tlsPtr_.thread_local_alloc_stack_top->Assign(obj);
253 ++tlsPtr_.thread_local_alloc_stack_top;
254 return true;
255 }
256 return false;
257 }
258
SetThreadLocalAllocationStack(StackReference<mirror::Object> * start,StackReference<mirror::Object> * end)259 inline void Thread::SetThreadLocalAllocationStack(StackReference<mirror::Object>* start,
260 StackReference<mirror::Object>* end) {
261 DCHECK(Thread::Current() == this) << "Should be called by self";
262 DCHECK(start != nullptr);
263 DCHECK(end != nullptr);
264 DCHECK_ALIGNED(start, sizeof(StackReference<mirror::Object>));
265 DCHECK_ALIGNED(end, sizeof(StackReference<mirror::Object>));
266 DCHECK_LT(start, end);
267 tlsPtr_.thread_local_alloc_stack_end = end;
268 tlsPtr_.thread_local_alloc_stack_top = start;
269 }
270
RevokeThreadLocalAllocationStack()271 inline void Thread::RevokeThreadLocalAllocationStack() {
272 if (kIsDebugBuild) {
273 // Note: self is not necessarily equal to this thread since thread may be suspended.
274 Thread* self = Thread::Current();
275 DCHECK(this == self || IsSuspended() || GetState() == kWaitingPerformingGc)
276 << GetState() << " thread " << this << " self " << self;
277 }
278 tlsPtr_.thread_local_alloc_stack_end = nullptr;
279 tlsPtr_.thread_local_alloc_stack_top = nullptr;
280 }
281
282 } // namespace art
283
284 #endif // ART_RUNTIME_THREAD_INL_H_
285