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 #include "base/mutex-inl.h"
23 #include "cutils/atomic-inline.h"
24
25 namespace art {
26
SetState(ThreadState new_state)27 inline ThreadState Thread::SetState(ThreadState new_state) {
28 // Cannot use this code to change into Runnable as changing to Runnable should fail if
29 // old_state_and_flags.suspend_request is true.
30 DCHECK_NE(new_state, kRunnable);
31 DCHECK_EQ(this, Thread::Current());
32 union StateAndFlags old_state_and_flags = state_and_flags_;
33 state_and_flags_.as_struct.state = new_state;
34 return static_cast<ThreadState>(old_state_and_flags.as_struct.state);
35 }
36
AssertThreadSuspensionIsAllowable(bool check_locks)37 inline void Thread::AssertThreadSuspensionIsAllowable(bool check_locks) const {
38 #ifdef NDEBUG
39 UNUSED(check_locks); // Keep GCC happy about unused parameters.
40 #else
41 CHECK_EQ(0u, no_thread_suspension_) << last_no_thread_suspension_cause_;
42 if (check_locks) {
43 bool bad_mutexes_held = false;
44 for (int i = kLockLevelCount - 1; i >= 0; --i) {
45 // We expect no locks except the mutator_lock_.
46 if (i != kMutatorLock) {
47 BaseMutex* held_mutex = GetHeldMutex(static_cast<LockLevel>(i));
48 if (held_mutex != NULL) {
49 LOG(ERROR) << "holding \"" << held_mutex->GetName()
50 << "\" at point where thread suspension is expected";
51 bad_mutexes_held = true;
52 }
53 }
54 }
55 CHECK(!bad_mutexes_held);
56 }
57 #endif
58 }
59
TransitionFromRunnableToSuspended(ThreadState new_state)60 inline void Thread::TransitionFromRunnableToSuspended(ThreadState new_state) {
61 AssertThreadSuspensionIsAllowable();
62 DCHECK_NE(new_state, kRunnable);
63 DCHECK_EQ(this, Thread::Current());
64 // Change to non-runnable state, thereby appearing suspended to the system.
65 DCHECK_EQ(GetState(), kRunnable);
66 union StateAndFlags old_state_and_flags;
67 union StateAndFlags new_state_and_flags;
68 do {
69 old_state_and_flags = state_and_flags_;
70 // Copy over flags and try to clear the checkpoint bit if it is set.
71 new_state_and_flags.as_struct.flags = old_state_and_flags.as_struct.flags & ~kCheckpointRequest;
72 new_state_and_flags.as_struct.state = new_state;
73 // CAS the value without a memory barrier, that will occur in the unlock below.
74 } while (UNLIKELY(android_atomic_cas(old_state_and_flags.as_int, new_state_and_flags.as_int,
75 &state_and_flags_.as_int) != 0));
76 // If we toggled the checkpoint flag we must have cleared it.
77 uint16_t flag_change = new_state_and_flags.as_struct.flags ^ old_state_and_flags.as_struct.flags;
78 if (UNLIKELY((flag_change & kCheckpointRequest) != 0)) {
79 RunCheckpointFunction();
80 }
81 // Release share on mutator_lock_.
82 Locks::mutator_lock_->SharedUnlock(this);
83 }
84
TransitionFromSuspendedToRunnable()85 inline ThreadState Thread::TransitionFromSuspendedToRunnable() {
86 bool done = false;
87 union StateAndFlags old_state_and_flags = state_and_flags_;
88 int16_t old_state = old_state_and_flags.as_struct.state;
89 DCHECK_NE(static_cast<ThreadState>(old_state), kRunnable);
90 do {
91 Locks::mutator_lock_->AssertNotHeld(this); // Otherwise we starve GC..
92 old_state_and_flags = state_and_flags_;
93 DCHECK_EQ(old_state_and_flags.as_struct.state, old_state);
94 if (UNLIKELY((old_state_and_flags.as_struct.flags & kSuspendRequest) != 0)) {
95 // Wait while our suspend count is non-zero.
96 MutexLock mu(this, *Locks::thread_suspend_count_lock_);
97 old_state_and_flags = state_and_flags_;
98 DCHECK_EQ(old_state_and_flags.as_struct.state, old_state);
99 while ((old_state_and_flags.as_struct.flags & kSuspendRequest) != 0) {
100 // Re-check when Thread::resume_cond_ is notified.
101 Thread::resume_cond_->Wait(this);
102 old_state_and_flags = state_and_flags_;
103 DCHECK_EQ(old_state_and_flags.as_struct.state, old_state);
104 }
105 DCHECK_EQ(GetSuspendCount(), 0);
106 }
107 // Re-acquire shared mutator_lock_ access.
108 Locks::mutator_lock_->SharedLock(this);
109 // Atomically change from suspended to runnable if no suspend request pending.
110 old_state_and_flags = state_and_flags_;
111 DCHECK_EQ(old_state_and_flags.as_struct.state, old_state);
112 if (LIKELY((old_state_and_flags.as_struct.flags & kSuspendRequest) == 0)) {
113 union StateAndFlags new_state_and_flags = old_state_and_flags;
114 new_state_and_flags.as_struct.state = kRunnable;
115 // CAS the value without a memory barrier, that occurred in the lock above.
116 done = android_atomic_cas(old_state_and_flags.as_int, new_state_and_flags.as_int,
117 &state_and_flags_.as_int) == 0;
118 }
119 if (UNLIKELY(!done)) {
120 // Failed to transition to Runnable. Release shared mutator_lock_ access and try again.
121 Locks::mutator_lock_->SharedUnlock(this);
122 }
123 } while (UNLIKELY(!done));
124 return static_cast<ThreadState>(old_state);
125 }
126
VerifyStack()127 inline void Thread::VerifyStack() {
128 gc::Heap* heap = Runtime::Current()->GetHeap();
129 if (heap->IsObjectValidationEnabled()) {
130 VerifyStackImpl();
131 }
132 }
133
134 } // namespace art
135
136 #endif // ART_RUNTIME_THREAD_INL_H_
137