runtime/thread-inl.h

   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.
  37 static inline Thread* ThreadForEnv(JNIEnv* env) {
  38   JNIEnvExt* full_env(down_cast<JNIEnvExt*>(env));
  39   return full_env->self;
  40 }
  41
  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
  57 inline void Thread::AllowThreadSuspension() {
  58   DCHECK_EQ(Thread::Current(), this);
  59   if (UNLIKELY(TestAllFlags())) {
  60     CheckSuspend();
  61   }
  62 }
  63
  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
  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
  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
 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
 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
 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
 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
 224 inline void Thread::VerifyStack() {
 225   if (kVerifyStack) {
 226     if (Runtime::Current()->GetHeap()->IsObjectValidationEnabled()) {
 227       VerifyStackImpl();
 228     }
 229   }
 230 }
 231
 232 inline size_t Thread::TlabSize() const {
 233   return tlsPtr_.thread_local_end - tlsPtr_.thread_local_pos;
 234 }
 235
 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
 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
 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
 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_