Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 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 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_THREAD_INL_H_ |
| 18 | #define ART_RUNTIME_THREAD_INL_H_ |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 19 | |
| 20 | #include "thread.h" |
| 21 | |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 22 | #include "base/casts.h" |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 23 | #include "base/mutex-inl.h" |
Andreas Gampe | d490129 | 2017-05-30 18:41:34 -0700 | [diff] [blame] | 24 | #include "base/time_utils.h" |
Ian Rogers | 68d8b42 | 2014-07-17 11:09:10 -0700 | [diff] [blame] | 25 | #include "jni_env_ext.h" |
Andreas Gampe | 513061a | 2017-06-01 09:17:34 -0700 | [diff] [blame] | 26 | #include "managed_stack-inl.h" |
Andreas Gampe | c73cb64 | 2017-02-22 10:11:30 -0800 | [diff] [blame] | 27 | #include "obj_ptr.h" |
Andreas Gampe | b486a98 | 2017-06-01 13:45:54 -0700 | [diff] [blame] | 28 | #include "thread-current-inl.h" |
Mathieu Chartier | 3cf2253 | 2015-07-09 15:15:09 -0700 | [diff] [blame] | 29 | #include "thread_pool.h" |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 30 | |
| 31 | namespace art { |
| 32 | |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 33 | // Quickly access the current thread from a JNIEnv. |
| 34 | static inline Thread* ThreadForEnv(JNIEnv* env) { |
| 35 | JNIEnvExt* full_env(down_cast<JNIEnvExt*>(env)); |
| 36 | return full_env->self; |
| 37 | } |
| 38 | |
Ian Rogers | 7b078e8 | 2014-09-10 14:44:24 -0700 | [diff] [blame] | 39 | inline void Thread::AllowThreadSuspension() { |
| 40 | DCHECK_EQ(Thread::Current(), this); |
| 41 | if (UNLIKELY(TestAllFlags())) { |
| 42 | CheckSuspend(); |
| 43 | } |
Mathieu Chartier | a59d9b2 | 2016-09-26 18:13:17 -0700 | [diff] [blame] | 44 | // Invalidate the current thread's object pointers (ObjPtr) to catch possible moving GC bugs due |
| 45 | // to missing handles. |
Mathieu Chartier | 3f7f03c | 2016-09-26 11:39:52 -0700 | [diff] [blame] | 46 | PoisonObjectPointers(); |
Ian Rogers | 7b078e8 | 2014-09-10 14:44:24 -0700 | [diff] [blame] | 47 | } |
| 48 | |
| 49 | inline void Thread::CheckSuspend() { |
| 50 | DCHECK_EQ(Thread::Current(), this); |
| 51 | for (;;) { |
| 52 | if (ReadFlag(kCheckpointRequest)) { |
| 53 | RunCheckpointFunction(); |
| 54 | } else if (ReadFlag(kSuspendRequest)) { |
| 55 | FullSuspendCheck(); |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 56 | } else if (ReadFlag(kEmptyCheckpointRequest)) { |
| 57 | RunEmptyCheckpoint(); |
| 58 | } else { |
| 59 | break; |
| 60 | } |
| 61 | } |
| 62 | } |
| 63 | |
Hiroshi Yamauchi | a222404 | 2017-02-08 16:35:45 -0800 | [diff] [blame] | 64 | inline void Thread::CheckEmptyCheckpointFromWeakRefAccess(BaseMutex* cond_var_mutex) { |
| 65 | Thread* self = Thread::Current(); |
| 66 | DCHECK_EQ(self, this); |
| 67 | for (;;) { |
| 68 | if (ReadFlag(kEmptyCheckpointRequest)) { |
| 69 | RunEmptyCheckpoint(); |
| 70 | // Check we hold only an expected mutex when accessing weak ref. |
| 71 | if (kIsDebugBuild) { |
| 72 | for (int i = kLockLevelCount - 1; i >= 0; --i) { |
| 73 | BaseMutex* held_mutex = self->GetHeldMutex(static_cast<LockLevel>(i)); |
| 74 | if (held_mutex != nullptr && |
| 75 | held_mutex != Locks::mutator_lock_ && |
| 76 | held_mutex != cond_var_mutex) { |
Hiroshi Yamauchi | 8a43324 | 2017-03-07 14:39:22 -0800 | [diff] [blame] | 77 | CHECK(Locks::IsExpectedOnWeakRefAccess(held_mutex)) |
Hiroshi Yamauchi | a222404 | 2017-02-08 16:35:45 -0800 | [diff] [blame] | 78 | << "Holding unexpected mutex " << held_mutex->GetName() |
| 79 | << " when accessing weak ref"; |
| 80 | } |
| 81 | } |
| 82 | } |
| 83 | } else { |
| 84 | break; |
| 85 | } |
| 86 | } |
| 87 | } |
| 88 | |
| 89 | inline void Thread::CheckEmptyCheckpointFromMutex() { |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 90 | DCHECK_EQ(Thread::Current(), this); |
| 91 | for (;;) { |
| 92 | if (ReadFlag(kEmptyCheckpointRequest)) { |
| 93 | RunEmptyCheckpoint(); |
Ian Rogers | 7b078e8 | 2014-09-10 14:44:24 -0700 | [diff] [blame] | 94 | } else { |
| 95 | break; |
| 96 | } |
| 97 | } |
| 98 | } |
| 99 | |
Ian Rogers | c0fa3ad | 2013-02-05 00:11:55 -0800 | [diff] [blame] | 100 | inline ThreadState Thread::SetState(ThreadState new_state) { |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 101 | // Should only be used to change between suspended states. |
| 102 | // Cannot use this code to change into or from Runnable as changing to Runnable should |
| 103 | // fail if old_state_and_flags.suspend_request is true and changing from Runnable might |
| 104 | // miss passing an active suspend barrier. |
Ian Rogers | c0fa3ad | 2013-02-05 00:11:55 -0800 | [diff] [blame] | 105 | DCHECK_NE(new_state, kRunnable); |
Andreas Gampe | ef048f6 | 2014-11-25 22:12:27 -0800 | [diff] [blame] | 106 | if (kIsDebugBuild && this != Thread::Current()) { |
| 107 | std::string name; |
| 108 | GetThreadName(name); |
| 109 | LOG(FATAL) << "Thread \"" << name << "\"(" << this << " != Thread::Current()=" |
| 110 | << Thread::Current() << ") changing state to " << new_state; |
| 111 | } |
Chris Dearman | 59cde53 | 2013-12-04 18:53:49 -0800 | [diff] [blame] | 112 | union StateAndFlags old_state_and_flags; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 113 | old_state_and_flags.as_int = tls32_.state_and_flags.as_int; |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 114 | CHECK_NE(old_state_and_flags.as_struct.state, kRunnable); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 115 | tls32_.state_and_flags.as_struct.state = new_state; |
Ian Rogers | c0fa3ad | 2013-02-05 00:11:55 -0800 | [diff] [blame] | 116 | return static_cast<ThreadState>(old_state_and_flags.as_struct.state); |
| 117 | } |
| 118 | |
Mathieu Chartier | 10b218d | 2016-07-25 17:48:52 -0700 | [diff] [blame] | 119 | inline bool Thread::IsThreadSuspensionAllowable() const { |
| 120 | if (tls32_.no_thread_suspension != 0) { |
| 121 | return false; |
| 122 | } |
| 123 | for (int i = kLockLevelCount - 1; i >= 0; --i) { |
Alex Light | 88fd720 | 2017-06-30 08:31:59 -0700 | [diff] [blame] | 124 | if (i != kMutatorLock && |
| 125 | i != kUserCodeSuspensionLock && |
| 126 | GetHeldMutex(static_cast<LockLevel>(i)) != nullptr) { |
Mathieu Chartier | 10b218d | 2016-07-25 17:48:52 -0700 | [diff] [blame] | 127 | return false; |
| 128 | } |
| 129 | } |
Alex Light | 88fd720 | 2017-06-30 08:31:59 -0700 | [diff] [blame] | 130 | // Thread autoanalysis isn't able to understand that the GetHeldMutex(...) or AssertHeld means we |
| 131 | // have the mutex meaning we need to do this hack. |
| 132 | auto is_suspending_for_user_code = [this]() NO_THREAD_SAFETY_ANALYSIS { |
| 133 | return tls32_.user_code_suspend_count != 0; |
| 134 | }; |
| 135 | if (GetHeldMutex(kUserCodeSuspensionLock) != nullptr && is_suspending_for_user_code()) { |
| 136 | return false; |
| 137 | } |
Mathieu Chartier | 10b218d | 2016-07-25 17:48:52 -0700 | [diff] [blame] | 138 | return true; |
| 139 | } |
| 140 | |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 141 | inline void Thread::AssertThreadSuspensionIsAllowable(bool check_locks) const { |
Ian Rogers | f3d874c | 2014-07-17 18:52:42 -0700 | [diff] [blame] | 142 | if (kIsDebugBuild) { |
Nicolas Geoffray | db97871 | 2014-12-09 13:33:38 +0000 | [diff] [blame] | 143 | if (gAborting == 0) { |
| 144 | CHECK_EQ(0u, tls32_.no_thread_suspension) << tlsPtr_.last_no_thread_suspension_cause; |
| 145 | } |
Ian Rogers | f3d874c | 2014-07-17 18:52:42 -0700 | [diff] [blame] | 146 | if (check_locks) { |
| 147 | bool bad_mutexes_held = false; |
| 148 | for (int i = kLockLevelCount - 1; i >= 0; --i) { |
Alex Light | 88fd720 | 2017-06-30 08:31:59 -0700 | [diff] [blame] | 149 | // We expect no locks except the mutator_lock_. User code suspension lock is OK as long as |
| 150 | // we aren't going to be held suspended due to SuspendReason::kForUserCode. |
| 151 | if (i != kMutatorLock && i != kUserCodeSuspensionLock) { |
Ian Rogers | f3d874c | 2014-07-17 18:52:42 -0700 | [diff] [blame] | 152 | BaseMutex* held_mutex = GetHeldMutex(static_cast<LockLevel>(i)); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 153 | if (held_mutex != nullptr) { |
Ian Rogers | f3d874c | 2014-07-17 18:52:42 -0700 | [diff] [blame] | 154 | LOG(ERROR) << "holding \"" << held_mutex->GetName() |
| 155 | << "\" at point where thread suspension is expected"; |
| 156 | bad_mutexes_held = true; |
| 157 | } |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 158 | } |
| 159 | } |
Alex Light | 88fd720 | 2017-06-30 08:31:59 -0700 | [diff] [blame] | 160 | // Make sure that if we hold the user_code_suspension_lock_ we aren't suspending due to |
| 161 | // user_code_suspend_count which would prevent the thread from ever waking up. Thread |
| 162 | // autoanalysis isn't able to understand that the GetHeldMutex(...) or AssertHeld means we |
| 163 | // have the mutex meaning we need to do this hack. |
| 164 | auto is_suspending_for_user_code = [this]() NO_THREAD_SAFETY_ANALYSIS { |
| 165 | return tls32_.user_code_suspend_count != 0; |
| 166 | }; |
| 167 | if (GetHeldMutex(kUserCodeSuspensionLock) != nullptr && is_suspending_for_user_code()) { |
| 168 | LOG(ERROR) << "suspending due to user-code while holding \"" |
| 169 | << Locks::user_code_suspension_lock_->GetName() << "\"! Thread would never " |
| 170 | << "wake up."; |
| 171 | bad_mutexes_held = true; |
| 172 | } |
Nicolas Geoffray | db97871 | 2014-12-09 13:33:38 +0000 | [diff] [blame] | 173 | if (gAborting == 0) { |
| 174 | CHECK(!bad_mutexes_held); |
| 175 | } |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 176 | } |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 177 | } |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 178 | } |
| 179 | |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 180 | inline void Thread::TransitionToSuspendedAndRunCheckpoints(ThreadState new_state) { |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 181 | DCHECK_NE(new_state, kRunnable); |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 182 | DCHECK_EQ(GetState(), kRunnable); |
| 183 | union StateAndFlags old_state_and_flags; |
| 184 | union StateAndFlags new_state_and_flags; |
Dave Allison | 0f5f6bb | 2013-11-22 17:39:19 -0800 | [diff] [blame] | 185 | while (true) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 186 | old_state_and_flags.as_int = tls32_.state_and_flags.as_int; |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 187 | if (UNLIKELY((old_state_and_flags.as_struct.flags & kCheckpointRequest) != 0)) { |
| 188 | RunCheckpointFunction(); |
| 189 | continue; |
| 190 | } |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 191 | if (UNLIKELY((old_state_and_flags.as_struct.flags & kEmptyCheckpointRequest) != 0)) { |
| 192 | RunEmptyCheckpoint(); |
| 193 | continue; |
| 194 | } |
Dave Allison | 0f5f6bb | 2013-11-22 17:39:19 -0800 | [diff] [blame] | 195 | // Change the state but keep the current flags (kCheckpointRequest is clear). |
| 196 | DCHECK_EQ((old_state_and_flags.as_struct.flags & kCheckpointRequest), 0); |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 197 | DCHECK_EQ((old_state_and_flags.as_struct.flags & kEmptyCheckpointRequest), 0); |
Dave Allison | 0f5f6bb | 2013-11-22 17:39:19 -0800 | [diff] [blame] | 198 | new_state_and_flags.as_struct.flags = old_state_and_flags.as_struct.flags; |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 199 | new_state_and_flags.as_struct.state = new_state; |
Ian Rogers | b8e087e | 2014-07-09 21:12:06 -0700 | [diff] [blame] | 200 | |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 201 | // CAS the value with a memory ordering. |
Ian Rogers | b8e087e | 2014-07-09 21:12:06 -0700 | [diff] [blame] | 202 | bool done = |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 203 | tls32_.state_and_flags.as_atomic_int.CompareExchangeWeakRelease(old_state_and_flags.as_int, |
Ian Rogers | b8e087e | 2014-07-09 21:12:06 -0700 | [diff] [blame] | 204 | new_state_and_flags.as_int); |
| 205 | if (LIKELY(done)) { |
Dave Allison | 0f5f6bb | 2013-11-22 17:39:19 -0800 | [diff] [blame] | 206 | break; |
| 207 | } |
| 208 | } |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 209 | } |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 210 | |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 211 | inline void Thread::PassActiveSuspendBarriers() { |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 212 | while (true) { |
| 213 | uint16_t current_flags = tls32_.state_and_flags.as_struct.flags; |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 214 | if (LIKELY((current_flags & |
| 215 | (kCheckpointRequest | kEmptyCheckpointRequest | kActiveSuspendBarrier)) == 0)) { |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 216 | break; |
| 217 | } else if ((current_flags & kActiveSuspendBarrier) != 0) { |
| 218 | PassActiveSuspendBarriers(this); |
| 219 | } else { |
| 220 | // Impossible |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 221 | LOG(FATAL) << "Fatal, thread transitioned into suspended without running the checkpoint"; |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 222 | } |
| 223 | } |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 224 | } |
| 225 | |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 226 | inline void Thread::TransitionFromRunnableToSuspended(ThreadState new_state) { |
| 227 | AssertThreadSuspensionIsAllowable(); |
Mathieu Chartier | 3398c78 | 2016-09-30 10:27:43 -0700 | [diff] [blame] | 228 | PoisonObjectPointersIfDebug(); |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 229 | DCHECK_EQ(this, Thread::Current()); |
| 230 | // Change to non-runnable state, thereby appearing suspended to the system. |
| 231 | TransitionToSuspendedAndRunCheckpoints(new_state); |
| 232 | // Mark the release of the share of the mutator_lock_. |
| 233 | Locks::mutator_lock_->TransitionFromRunnableToSuspended(this); |
| 234 | // Once suspended - check the active suspend barrier flag |
| 235 | PassActiveSuspendBarriers(); |
| 236 | } |
| 237 | |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 238 | inline ThreadState Thread::TransitionFromSuspendedToRunnable() { |
Chris Dearman | 59cde53 | 2013-12-04 18:53:49 -0800 | [diff] [blame] | 239 | union StateAndFlags old_state_and_flags; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 240 | old_state_and_flags.as_int = tls32_.state_and_flags.as_int; |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 241 | int16_t old_state = old_state_and_flags.as_struct.state; |
| 242 | DCHECK_NE(static_cast<ThreadState>(old_state), kRunnable); |
| 243 | do { |
| 244 | Locks::mutator_lock_->AssertNotHeld(this); // Otherwise we starve GC.. |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 245 | old_state_and_flags.as_int = tls32_.state_and_flags.as_int; |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 246 | DCHECK_EQ(old_state_and_flags.as_struct.state, old_state); |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 247 | if (LIKELY(old_state_and_flags.as_struct.flags == 0)) { |
| 248 | // Optimize for the return from native code case - this is the fast path. |
| 249 | // Atomically change from suspended to runnable if no suspend request pending. |
| 250 | union StateAndFlags new_state_and_flags; |
| 251 | new_state_and_flags.as_int = old_state_and_flags.as_int; |
| 252 | new_state_and_flags.as_struct.state = kRunnable; |
| 253 | // CAS the value with a memory barrier. |
| 254 | if (LIKELY(tls32_.state_and_flags.as_atomic_int.CompareExchangeWeakAcquire( |
| 255 | old_state_and_flags.as_int, |
| 256 | new_state_and_flags.as_int))) { |
| 257 | // Mark the acquisition of a share of the mutator_lock_. |
| 258 | Locks::mutator_lock_->TransitionFromSuspendedToRunnable(this); |
| 259 | break; |
| 260 | } |
| 261 | } else if ((old_state_and_flags.as_struct.flags & kActiveSuspendBarrier) != 0) { |
| 262 | PassActiveSuspendBarriers(this); |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 263 | } else if ((old_state_and_flags.as_struct.flags & |
| 264 | (kCheckpointRequest | kEmptyCheckpointRequest)) != 0) { |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 265 | // Impossible |
Mathieu Chartier | dabdccc | 2015-10-01 14:46:29 -0700 | [diff] [blame] | 266 | LOG(FATAL) << "Transitioning to runnable with checkpoint flag, " |
| 267 | << " flags=" << old_state_and_flags.as_struct.flags |
| 268 | << " state=" << old_state_and_flags.as_struct.state; |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 269 | } else if ((old_state_and_flags.as_struct.flags & kSuspendRequest) != 0) { |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 270 | // Wait while our suspend count is non-zero. |
Nicolas Geoffray | 9f5f8ac | 2016-06-29 14:39:59 +0100 | [diff] [blame] | 271 | |
| 272 | // We pass null to the MutexLock as we may be in a situation where the |
| 273 | // runtime is shutting down. Guarding ourselves from that situation |
| 274 | // requires to take the shutdown lock, which is undesirable here. |
| 275 | Thread* thread_to_pass = nullptr; |
| 276 | if (kIsDebugBuild && !IsDaemon()) { |
| 277 | // We know we can make our debug locking checks on non-daemon threads, |
| 278 | // so re-enable them on debug builds. |
| 279 | thread_to_pass = this; |
| 280 | } |
| 281 | MutexLock mu(thread_to_pass, *Locks::thread_suspend_count_lock_); |
Hiroshi Yamauchi | ee23582 | 2016-08-19 17:03:27 -0700 | [diff] [blame] | 282 | ScopedTransitioningToRunnable scoped_transitioning_to_runnable(this); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 283 | old_state_and_flags.as_int = tls32_.state_and_flags.as_int; |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 284 | DCHECK_EQ(old_state_and_flags.as_struct.state, old_state); |
| 285 | while ((old_state_and_flags.as_struct.flags & kSuspendRequest) != 0) { |
| 286 | // Re-check when Thread::resume_cond_ is notified. |
Nicolas Geoffray | 9f5f8ac | 2016-06-29 14:39:59 +0100 | [diff] [blame] | 287 | Thread::resume_cond_->Wait(thread_to_pass); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 288 | old_state_and_flags.as_int = tls32_.state_and_flags.as_int; |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 289 | DCHECK_EQ(old_state_and_flags.as_struct.state, old_state); |
| 290 | } |
| 291 | DCHECK_EQ(GetSuspendCount(), 0); |
| 292 | } |
Ian Rogers | 719d1a3 | 2014-03-06 12:13:39 -0800 | [diff] [blame] | 293 | } while (true); |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 294 | // Run the flip function, if set. |
| 295 | Closure* flip_func = GetFlipFunction(); |
| 296 | if (flip_func != nullptr) { |
| 297 | flip_func->Run(this); |
| 298 | } |
| 299 | return static_cast<ThreadState>(old_state); |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 300 | } |
| 301 | |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 302 | inline mirror::Object* Thread::AllocTlab(size_t bytes) { |
| 303 | DCHECK_GE(TlabSize(), bytes); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 304 | ++tlsPtr_.thread_local_objects; |
| 305 | mirror::Object* ret = reinterpret_cast<mirror::Object*>(tlsPtr_.thread_local_pos); |
| 306 | tlsPtr_.thread_local_pos += bytes; |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 307 | return ret; |
| 308 | } |
| 309 | |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 310 | inline bool Thread::PushOnThreadLocalAllocationStack(mirror::Object* obj) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 311 | DCHECK_LE(tlsPtr_.thread_local_alloc_stack_top, tlsPtr_.thread_local_alloc_stack_end); |
| 312 | if (tlsPtr_.thread_local_alloc_stack_top < tlsPtr_.thread_local_alloc_stack_end) { |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 313 | // There's room. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 314 | DCHECK_LE(reinterpret_cast<uint8_t*>(tlsPtr_.thread_local_alloc_stack_top) + |
Mathieu Chartier | cb535da | 2015-01-23 13:50:03 -0800 | [diff] [blame] | 315 | sizeof(StackReference<mirror::Object>), |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 316 | reinterpret_cast<uint8_t*>(tlsPtr_.thread_local_alloc_stack_end)); |
Mathieu Chartier | cb535da | 2015-01-23 13:50:03 -0800 | [diff] [blame] | 317 | DCHECK(tlsPtr_.thread_local_alloc_stack_top->AsMirrorPtr() == nullptr); |
| 318 | tlsPtr_.thread_local_alloc_stack_top->Assign(obj); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 319 | ++tlsPtr_.thread_local_alloc_stack_top; |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 320 | return true; |
| 321 | } |
| 322 | return false; |
| 323 | } |
| 324 | |
Mathieu Chartier | cb535da | 2015-01-23 13:50:03 -0800 | [diff] [blame] | 325 | inline void Thread::SetThreadLocalAllocationStack(StackReference<mirror::Object>* start, |
| 326 | StackReference<mirror::Object>* end) { |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 327 | DCHECK(Thread::Current() == this) << "Should be called by self"; |
| 328 | DCHECK(start != nullptr); |
| 329 | DCHECK(end != nullptr); |
Mathieu Chartier | cb535da | 2015-01-23 13:50:03 -0800 | [diff] [blame] | 330 | DCHECK_ALIGNED(start, sizeof(StackReference<mirror::Object>)); |
| 331 | DCHECK_ALIGNED(end, sizeof(StackReference<mirror::Object>)); |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 332 | DCHECK_LT(start, end); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 333 | tlsPtr_.thread_local_alloc_stack_end = end; |
| 334 | tlsPtr_.thread_local_alloc_stack_top = start; |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 335 | } |
| 336 | |
| 337 | inline void Thread::RevokeThreadLocalAllocationStack() { |
| 338 | if (kIsDebugBuild) { |
| 339 | // Note: self is not necessarily equal to this thread since thread may be suspended. |
| 340 | Thread* self = Thread::Current(); |
| 341 | DCHECK(this == self || IsSuspended() || GetState() == kWaitingPerformingGc) |
| 342 | << GetState() << " thread " << this << " self " << self; |
| 343 | } |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 344 | tlsPtr_.thread_local_alloc_stack_end = nullptr; |
| 345 | tlsPtr_.thread_local_alloc_stack_top = nullptr; |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 346 | } |
| 347 | |
Mathieu Chartier | a59d9b2 | 2016-09-26 18:13:17 -0700 | [diff] [blame] | 348 | inline void Thread::PoisonObjectPointersIfDebug() { |
Andreas Gampe | c73cb64 | 2017-02-22 10:11:30 -0800 | [diff] [blame] | 349 | if (kObjPtrPoisoning) { |
Mathieu Chartier | a59d9b2 | 2016-09-26 18:13:17 -0700 | [diff] [blame] | 350 | Thread::Current()->PoisonObjectPointers(); |
| 351 | } |
| 352 | } |
| 353 | |
Hiroshi Yamauchi | 02e7f1a | 2016-10-03 15:32:01 -0700 | [diff] [blame] | 354 | inline bool Thread::ModifySuspendCount(Thread* self, |
| 355 | int delta, |
| 356 | AtomicInteger* suspend_barrier, |
Alex Light | 46f9340 | 2017-06-29 11:59:50 -0700 | [diff] [blame] | 357 | SuspendReason reason) { |
Hiroshi Yamauchi | 02e7f1a | 2016-10-03 15:32:01 -0700 | [diff] [blame] | 358 | if (delta > 0 && ((kUseReadBarrier && this != self) || suspend_barrier != nullptr)) { |
| 359 | // When delta > 0 (requesting a suspend), ModifySuspendCountInternal() may fail either if |
| 360 | // active_suspend_barriers is full or we are in the middle of a thread flip. Retry in a loop. |
| 361 | while (true) { |
Alex Light | 46f9340 | 2017-06-29 11:59:50 -0700 | [diff] [blame] | 362 | if (LIKELY(ModifySuspendCountInternal(self, delta, suspend_barrier, reason))) { |
Hiroshi Yamauchi | 02e7f1a | 2016-10-03 15:32:01 -0700 | [diff] [blame] | 363 | return true; |
| 364 | } else { |
| 365 | // Failure means the list of active_suspend_barriers is full or we are in the middle of a |
| 366 | // thread flip, we should release the thread_suspend_count_lock_ (to avoid deadlock) and |
| 367 | // wait till the target thread has executed or Thread::PassActiveSuspendBarriers() or the |
| 368 | // flip function. Note that we could not simply wait for the thread to change to a suspended |
| 369 | // state, because it might need to run checkpoint function before the state change or |
| 370 | // resumes from the resume_cond_, which also needs thread_suspend_count_lock_. |
| 371 | // |
| 372 | // The list of active_suspend_barriers is very unlikely to be full since more than |
| 373 | // kMaxSuspendBarriers threads need to execute SuspendAllInternal() simultaneously, and |
| 374 | // target thread stays in kRunnable in the mean time. |
| 375 | Locks::thread_suspend_count_lock_->ExclusiveUnlock(self); |
| 376 | NanoSleep(100000); |
| 377 | Locks::thread_suspend_count_lock_->ExclusiveLock(self); |
| 378 | } |
| 379 | } |
| 380 | } else { |
Alex Light | 46f9340 | 2017-06-29 11:59:50 -0700 | [diff] [blame] | 381 | return ModifySuspendCountInternal(self, delta, suspend_barrier, reason); |
Hiroshi Yamauchi | 02e7f1a | 2016-10-03 15:32:01 -0700 | [diff] [blame] | 382 | } |
| 383 | } |
| 384 | |
Andreas Gampe | 513061a | 2017-06-01 09:17:34 -0700 | [diff] [blame] | 385 | inline ShadowFrame* Thread::PushShadowFrame(ShadowFrame* new_top_frame) { |
| 386 | return tlsPtr_.managed_stack.PushShadowFrame(new_top_frame); |
| 387 | } |
| 388 | |
| 389 | inline ShadowFrame* Thread::PopShadowFrame() { |
| 390 | return tlsPtr_.managed_stack.PopShadowFrame(); |
| 391 | } |
| 392 | |
Ian Rogers | 693ff61 | 2013-02-01 10:56:12 -0800 | [diff] [blame] | 393 | } // namespace art |
| 394 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 395 | #endif // ART_RUNTIME_THREAD_INL_H_ |