blob: 49579886fd6945e1afea3150a854b2296c02777b [file] [log] [blame]
Elliott Hughes8daa0922011-09-11 13:46:25 -07001/*
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#include "mutex.h"
18
19#include <errno.h>
Ian Rogersc604d732012-10-14 16:09:54 -070020#include <sys/time.h>
Elliott Hughes8daa0922011-09-11 13:46:25 -070021
Ian Rogerscf7f1912014-10-22 22:06:39 -070022#define ATRACE_TAG ATRACE_TAG_DALVIK
23#include "cutils/trace.h"
24
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -070025#include "atomic.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080026#include "base/logging.h"
Ian Rogerscf7f1912014-10-22 22:06:39 -070027#include "base/value_object.h"
Ian Rogers693ff612013-02-01 10:56:12 -080028#include "mutex-inl.h"
Elliott Hughes6b355752012-01-13 16:49:08 -080029#include "runtime.h"
Ian Rogersc604d732012-10-14 16:09:54 -070030#include "scoped_thread_state_change.h"
Ian Rogers04d7aa92013-03-16 14:29:17 -070031#include "thread-inl.h"
Elliott Hughesffb465f2012-03-01 18:46:05 -080032#include "utils.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -070033
34namespace art {
35
Ian Rogers719d1a32014-03-06 12:13:39 -080036Mutex* Locks::abort_lock_ = nullptr;
Brian Carlstrom306db812014-09-05 13:01:41 -070037Mutex* Locks::alloc_tracker_lock_ = nullptr;
Andreas Gampe74240812014-04-17 10:35:09 -070038Mutex* Locks::allocated_monitor_ids_lock_ = nullptr;
Chao-ying Fu9e369312014-05-21 11:20:52 -070039Mutex* Locks::allocated_thread_ids_lock_ = nullptr;
Sebastien Hertzed2be172014-08-19 15:33:43 +020040ReaderWriterMutex* Locks::breakpoint_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080041ReaderWriterMutex* Locks::classlinker_classes_lock_ = nullptr;
Brian Carlstrom306db812014-09-05 13:01:41 -070042Mutex* Locks::deoptimization_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080043ReaderWriterMutex* Locks::heap_bitmap_lock_ = nullptr;
Mathieu Chartier9ef78b52014-09-25 17:03:12 -070044Mutex* Locks::instrument_entrypoints_lock_ = nullptr;
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070045Mutex* Locks::intern_table_lock_ = nullptr;
Ian Rogers68d8b422014-07-17 11:09:10 -070046Mutex* Locks::jni_libraries_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080047Mutex* Locks::logging_lock_ = nullptr;
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -070048Mutex* Locks::mem_maps_lock_ = nullptr;
Chao-ying Fu9e369312014-05-21 11:20:52 -070049Mutex* Locks::modify_ldt_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080050ReaderWriterMutex* Locks::mutator_lock_ = nullptr;
Brian Carlstrom306db812014-09-05 13:01:41 -070051Mutex* Locks::profiler_lock_ = nullptr;
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070052Mutex* Locks::reference_processor_lock_ = nullptr;
53Mutex* Locks::reference_queue_cleared_references_lock_ = nullptr;
54Mutex* Locks::reference_queue_finalizer_references_lock_ = nullptr;
55Mutex* Locks::reference_queue_phantom_references_lock_ = nullptr;
56Mutex* Locks::reference_queue_soft_references_lock_ = nullptr;
57Mutex* Locks::reference_queue_weak_references_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080058Mutex* Locks::runtime_shutdown_lock_ = nullptr;
59Mutex* Locks::thread_list_lock_ = nullptr;
60Mutex* Locks::thread_suspend_count_lock_ = nullptr;
61Mutex* Locks::trace_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080062Mutex* Locks::unexpected_signal_lock_ = nullptr;
Ian Rogers719d1a32014-03-06 12:13:39 -080063
64struct AllMutexData {
65 // A guard for all_mutexes_ that's not a mutex (Mutexes must CAS to acquire and busy wait).
66 Atomic<const BaseMutex*> all_mutexes_guard;
67 // All created mutexes guarded by all_mutexes_guard_.
68 std::set<BaseMutex*>* all_mutexes;
69 AllMutexData() : all_mutexes(NULL) {}
70};
71static struct AllMutexData gAllMutexData[kAllMutexDataSize];
72
Ian Rogersc604d732012-10-14 16:09:54 -070073#if ART_USE_FUTEXES
74static bool ComputeRelativeTimeSpec(timespec* result_ts, const timespec& lhs, const timespec& rhs) {
Brian Carlstromfb6996f2013-07-18 18:21:14 -070075 const int32_t one_sec = 1000 * 1000 * 1000; // one second in nanoseconds.
Ian Rogersc604d732012-10-14 16:09:54 -070076 result_ts->tv_sec = lhs.tv_sec - rhs.tv_sec;
77 result_ts->tv_nsec = lhs.tv_nsec - rhs.tv_nsec;
78 if (result_ts->tv_nsec < 0) {
79 result_ts->tv_sec--;
80 result_ts->tv_nsec += one_sec;
81 } else if (result_ts->tv_nsec > one_sec) {
82 result_ts->tv_sec++;
83 result_ts->tv_nsec -= one_sec;
84 }
85 return result_ts->tv_sec < 0;
86}
87#endif
88
Ian Rogers6f3dbba2014-10-14 17:41:57 -070089class ScopedAllMutexesLock FINAL {
Ian Rogers56edc432013-01-18 16:51:51 -080090 public:
Brian Carlstrom93ba8932013-07-17 21:31:49 -070091 explicit ScopedAllMutexesLock(const BaseMutex* mutex) : mutex_(mutex) {
Ian Rogers3e5cf302014-05-20 16:40:37 -070092 while (!gAllMutexData->all_mutexes_guard.CompareExchangeWeakAcquire(0, mutex)) {
Ian Rogers56edc432013-01-18 16:51:51 -080093 NanoSleep(100);
94 }
95 }
Ian Rogers6f3dbba2014-10-14 17:41:57 -070096
Ian Rogers56edc432013-01-18 16:51:51 -080097 ~ScopedAllMutexesLock() {
Ian Rogers6f3dbba2014-10-14 17:41:57 -070098#if !defined(__clang__)
99 // TODO: remove this workaround target GCC/libc++/bionic bug "invalid failure memory model".
100 while (!gAllMutexData->all_mutexes_guard.CompareExchangeWeakSequentiallyConsistent(mutex_, 0)) {
101#else
Ian Rogers3e5cf302014-05-20 16:40:37 -0700102 while (!gAllMutexData->all_mutexes_guard.CompareExchangeWeakRelease(mutex_, 0)) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700103#endif
Ian Rogers56edc432013-01-18 16:51:51 -0800104 NanoSleep(100);
105 }
106 }
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700107
Ian Rogers56edc432013-01-18 16:51:51 -0800108 private:
109 const BaseMutex* const mutex_;
110};
Ian Rogers56edc432013-01-18 16:51:51 -0800111
Ian Rogerscf7f1912014-10-22 22:06:39 -0700112// Scoped class that generates events at the beginning and end of lock contention.
113class ScopedContentionRecorder FINAL : public ValueObject {
114 public:
115 ScopedContentionRecorder(BaseMutex* mutex, uint64_t blocked_tid, uint64_t owner_tid)
116 : mutex_(kLogLockContentions ? mutex : NULL),
117 blocked_tid_(kLogLockContentions ? blocked_tid : 0),
118 owner_tid_(kLogLockContentions ? owner_tid : 0),
119 start_nano_time_(kLogLockContentions ? NanoTime() : 0) {
120 if (ATRACE_ENABLED()) {
121 std::string msg = StringPrintf("Lock contention on %s (owner tid: %" PRIu64 ")",
122 mutex->GetName(), owner_tid);
123 ATRACE_BEGIN(msg.c_str());
124 }
125 }
126
127 ~ScopedContentionRecorder() {
128 ATRACE_END();
129 if (kLogLockContentions) {
130 uint64_t end_nano_time = NanoTime();
131 mutex_->RecordContention(blocked_tid_, owner_tid_, end_nano_time - start_nano_time_);
132 }
133 }
134
135 private:
136 BaseMutex* const mutex_;
137 const uint64_t blocked_tid_;
138 const uint64_t owner_tid_;
139 const uint64_t start_nano_time_;
140};
141
Ian Rogers56edc432013-01-18 16:51:51 -0800142BaseMutex::BaseMutex(const char* name, LockLevel level) : level_(level), name_(name) {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700143 if (kLogLockContentions) {
144 ScopedAllMutexesLock mu(this);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700145 std::set<BaseMutex*>** all_mutexes_ptr = &gAllMutexData->all_mutexes;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700146 if (*all_mutexes_ptr == NULL) {
147 // We leak the global set of all mutexes to avoid ordering issues in global variable
148 // construction/destruction.
149 *all_mutexes_ptr = new std::set<BaseMutex*>();
150 }
151 (*all_mutexes_ptr)->insert(this);
Ian Rogers56edc432013-01-18 16:51:51 -0800152 }
Ian Rogers56edc432013-01-18 16:51:51 -0800153}
154
155BaseMutex::~BaseMutex() {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700156 if (kLogLockContentions) {
157 ScopedAllMutexesLock mu(this);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700158 gAllMutexData->all_mutexes->erase(this);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700159 }
Ian Rogers56edc432013-01-18 16:51:51 -0800160}
161
162void BaseMutex::DumpAll(std::ostream& os) {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700163 if (kLogLockContentions) {
164 os << "Mutex logging:\n";
165 ScopedAllMutexesLock mu(reinterpret_cast<const BaseMutex*>(-1));
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700166 std::set<BaseMutex*>* all_mutexes = gAllMutexData->all_mutexes;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700167 if (all_mutexes == NULL) {
168 // No mutexes have been created yet during at startup.
169 return;
170 }
171 typedef std::set<BaseMutex*>::const_iterator It;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700172 os << "(Contended)\n";
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700173 for (It it = all_mutexes->begin(); it != all_mutexes->end(); ++it) {
174 BaseMutex* mutex = *it;
175 if (mutex->HasEverContended()) {
176 mutex->Dump(os);
177 os << "\n";
178 }
179 }
180 os << "(Never contented)\n";
181 for (It it = all_mutexes->begin(); it != all_mutexes->end(); ++it) {
182 BaseMutex* mutex = *it;
183 if (!mutex->HasEverContended()) {
184 mutex->Dump(os);
185 os << "\n";
186 }
187 }
Ian Rogers56edc432013-01-18 16:51:51 -0800188 }
Ian Rogers56edc432013-01-18 16:51:51 -0800189}
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700190
Ian Rogers81d425b2012-09-27 16:03:43 -0700191void BaseMutex::CheckSafeToWait(Thread* self) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700192 if (self == NULL) {
193 CheckUnattachedThread(level_);
194 return;
195 }
Ian Rogers25fd14b2012-09-05 10:56:38 -0700196 if (kDebugLocking) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700197 CHECK(self->GetHeldMutex(level_) == this || level_ == kMonitorLock)
198 << "Waiting on unacquired mutex: " << name_;
Ian Rogers25fd14b2012-09-05 10:56:38 -0700199 bool bad_mutexes_held = false;
Elliott Hughes0f827162013-02-26 12:12:58 -0800200 for (int i = kLockLevelCount - 1; i >= 0; --i) {
Ian Rogers25fd14b2012-09-05 10:56:38 -0700201 if (i != level_) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700202 BaseMutex* held_mutex = self->GetHeldMutex(static_cast<LockLevel>(i));
Ian Rogersf3d874c2014-07-17 18:52:42 -0700203 // We expect waits to happen while holding the thread list suspend thread lock.
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800204 if (held_mutex != NULL) {
Elliott Hughes0f827162013-02-26 12:12:58 -0800205 LOG(ERROR) << "Holding \"" << held_mutex->name_ << "\" "
206 << "(level " << LockLevel(i) << ") while performing wait on "
207 << "\"" << name_ << "\" (level " << level_ << ")";
Ian Rogers25fd14b2012-09-05 10:56:38 -0700208 bad_mutexes_held = true;
209 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700210 }
211 }
Ian Rogers25fd14b2012-09-05 10:56:38 -0700212 CHECK(!bad_mutexes_held);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700213 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700214}
215
Ian Rogers37f3c962014-07-17 11:25:30 -0700216void BaseMutex::ContentionLogData::AddToWaitTime(uint64_t value) {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700217 if (kLogLockContentions) {
218 // Atomically add value to wait_time.
Ian Rogers37f3c962014-07-17 11:25:30 -0700219 wait_time.FetchAndAddSequentiallyConsistent(value);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700220 }
221}
222
Brian Carlstrom0de79852013-07-25 22:29:58 -0700223void BaseMutex::RecordContention(uint64_t blocked_tid,
224 uint64_t owner_tid,
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700225 uint64_t nano_time_blocked) {
226 if (kLogLockContentions) {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700227 ContentionLogData* data = contention_log_data_;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700228 ++(data->contention_count);
229 data->AddToWaitTime(nano_time_blocked);
230 ContentionLogEntry* log = data->contention_log;
231 // This code is intentionally racy as it is only used for diagnostics.
Ian Rogers3e5cf302014-05-20 16:40:37 -0700232 uint32_t slot = data->cur_content_log_entry.LoadRelaxed();
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700233 if (log[slot].blocked_tid == blocked_tid &&
234 log[slot].owner_tid == blocked_tid) {
235 ++log[slot].count;
236 } else {
237 uint32_t new_slot;
238 do {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700239 slot = data->cur_content_log_entry.LoadRelaxed();
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700240 new_slot = (slot + 1) % kContentionLogSize;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700241 } while (!data->cur_content_log_entry.CompareExchangeWeakRelaxed(slot, new_slot));
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700242 log[new_slot].blocked_tid = blocked_tid;
243 log[new_slot].owner_tid = owner_tid;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700244 log[new_slot].count.StoreRelaxed(1);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700245 }
Ian Rogers56edc432013-01-18 16:51:51 -0800246 }
Ian Rogers56edc432013-01-18 16:51:51 -0800247}
248
Ian Rogers56edc432013-01-18 16:51:51 -0800249void BaseMutex::DumpContention(std::ostream& os) const {
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700250 if (kLogLockContentions) {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700251 const ContentionLogData* data = contention_log_data_;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700252 const ContentionLogEntry* log = data->contention_log;
Ian Rogers37f3c962014-07-17 11:25:30 -0700253 uint64_t wait_time = data->wait_time.LoadRelaxed();
Ian Rogers3e5cf302014-05-20 16:40:37 -0700254 uint32_t contention_count = data->contention_count.LoadRelaxed();
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700255 if (contention_count == 0) {
256 os << "never contended";
257 } else {
258 os << "contended " << contention_count
Mathieu Chartier73d1e172014-04-11 17:53:48 -0700259 << " total wait of contender " << PrettyDuration(wait_time)
260 << " average " << PrettyDuration(wait_time / contention_count);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700261 SafeMap<uint64_t, size_t> most_common_blocker;
262 SafeMap<uint64_t, size_t> most_common_blocked;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700263 for (size_t i = 0; i < kContentionLogSize; ++i) {
264 uint64_t blocked_tid = log[i].blocked_tid;
265 uint64_t owner_tid = log[i].owner_tid;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700266 uint32_t count = log[i].count.LoadRelaxed();
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700267 if (count > 0) {
Mathieu Chartier73d1e172014-04-11 17:53:48 -0700268 auto it = most_common_blocked.find(blocked_tid);
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700269 if (it != most_common_blocked.end()) {
270 most_common_blocked.Overwrite(blocked_tid, it->second + count);
271 } else {
272 most_common_blocked.Put(blocked_tid, count);
273 }
274 it = most_common_blocker.find(owner_tid);
275 if (it != most_common_blocker.end()) {
276 most_common_blocker.Overwrite(owner_tid, it->second + count);
277 } else {
278 most_common_blocker.Put(owner_tid, count);
279 }
Ian Rogers56edc432013-01-18 16:51:51 -0800280 }
281 }
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700282 uint64_t max_tid = 0;
283 size_t max_tid_count = 0;
Mathieu Chartier73d1e172014-04-11 17:53:48 -0700284 for (const auto& pair : most_common_blocked) {
285 if (pair.second > max_tid_count) {
286 max_tid = pair.first;
287 max_tid_count = pair.second;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700288 }
Ian Rogers56edc432013-01-18 16:51:51 -0800289 }
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700290 if (max_tid != 0) {
291 os << " sample shows most blocked tid=" << max_tid;
Ian Rogers56edc432013-01-18 16:51:51 -0800292 }
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700293 max_tid = 0;
294 max_tid_count = 0;
Mathieu Chartier73d1e172014-04-11 17:53:48 -0700295 for (const auto& pair : most_common_blocker) {
296 if (pair.second > max_tid_count) {
297 max_tid = pair.first;
298 max_tid_count = pair.second;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700299 }
300 }
301 if (max_tid != 0) {
302 os << " sample shows tid=" << max_tid << " owning during this time";
303 }
Ian Rogers56edc432013-01-18 16:51:51 -0800304 }
305 }
Ian Rogers56edc432013-01-18 16:51:51 -0800306}
307
308
Ian Rogers81d425b2012-09-27 16:03:43 -0700309Mutex::Mutex(const char* name, LockLevel level, bool recursive)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700310 : BaseMutex(name, level), recursive_(recursive), recursion_count_(0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700311#if ART_USE_FUTEXES
Ian Rogersc7190692014-07-08 23:50:26 -0700312 DCHECK_EQ(0, state_.LoadRelaxed());
Ian Rogers3e5cf302014-05-20 16:40:37 -0700313 DCHECK_EQ(0, num_contenders_.LoadRelaxed());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700314#else
Ian Rogersc5f17732014-06-05 20:48:42 -0700315 CHECK_MUTEX_CALL(pthread_mutex_init, (&mutex_, nullptr));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700316#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700317 exclusive_owner_ = 0;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700318}
319
320Mutex::~Mutex() {
Ian Rogersc604d732012-10-14 16:09:54 -0700321#if ART_USE_FUTEXES
Ian Rogersc7190692014-07-08 23:50:26 -0700322 if (state_.LoadRelaxed() != 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700323 Runtime* runtime = Runtime::Current();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700324 bool shutting_down = runtime == nullptr || runtime->IsShuttingDown(Thread::Current());
Ian Rogersc604d732012-10-14 16:09:54 -0700325 LOG(shutting_down ? WARNING : FATAL) << "destroying mutex with owner: " << exclusive_owner_;
326 } else {
327 CHECK_EQ(exclusive_owner_, 0U) << "unexpectedly found an owner on unlocked mutex " << name_;
Ian Rogersc7190692014-07-08 23:50:26 -0700328 CHECK_EQ(num_contenders_.LoadSequentiallyConsistent(), 0)
Ian Rogers3e5cf302014-05-20 16:40:37 -0700329 << "unexpectedly found a contender on mutex " << name_;
Ian Rogersc604d732012-10-14 16:09:54 -0700330 }
331#else
Elliott Hughese62934d2012-04-09 11:24:29 -0700332 // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
333 // may still be using locks.
Elliott Hughes6b355752012-01-13 16:49:08 -0800334 int rc = pthread_mutex_destroy(&mutex_);
335 if (rc != 0) {
336 errno = rc;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800337 // TODO: should we just not log at all if shutting down? this could be the logging mutex!
Ian Rogers50b35e22012-10-04 10:09:15 -0700338 MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
Ian Rogers120f1c72012-09-28 17:17:10 -0700339 Runtime* runtime = Runtime::Current();
Mathieu Chartier34e82932013-11-12 18:22:47 -0800340 bool shutting_down = (runtime == NULL) || runtime->IsShuttingDownLocked();
Elliott Hughes6b355752012-01-13 16:49:08 -0800341 PLOG(shutting_down ? WARNING : FATAL) << "pthread_mutex_destroy failed for " << name_;
342 }
Ian Rogersc604d732012-10-14 16:09:54 -0700343#endif
Elliott Hughes8daa0922011-09-11 13:46:25 -0700344}
345
Ian Rogers81d425b2012-09-27 16:03:43 -0700346void Mutex::ExclusiveLock(Thread* self) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700347 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers25fd14b2012-09-05 10:56:38 -0700348 if (kDebugLocking && !recursive_) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700349 AssertNotHeld(self);
Ian Rogers25fd14b2012-09-05 10:56:38 -0700350 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700351 if (!recursive_ || !IsExclusiveHeld(self)) {
Ian Rogersc604d732012-10-14 16:09:54 -0700352#if ART_USE_FUTEXES
353 bool done = false;
354 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700355 int32_t cur_state = state_.LoadRelaxed();
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -0700356 if (LIKELY(cur_state == 0)) {
Ian Rogersc7190692014-07-08 23:50:26 -0700357 // Change state from 0 to 1 and impose load/store ordering appropriate for lock acquisition.
358 done = state_.CompareExchangeWeakAcquire(0 /* cur_state */, 1 /* new state */);
Ian Rogersc604d732012-10-14 16:09:54 -0700359 } else {
360 // Failed to acquire, hang up.
Hiroshi Yamauchib3733082013-08-12 17:28:49 -0700361 ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
Ian Rogersb122a4b2013-11-19 18:00:50 -0800362 num_contenders_++;
Ian Rogersc7190692014-07-08 23:50:26 -0700363 if (futex(state_.Address(), FUTEX_WAIT, 1, NULL, NULL, 0) != 0) {
Brian Carlstrom0de79852013-07-25 22:29:58 -0700364 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
365 // We don't use TEMP_FAILURE_RETRY so we can intentionally retry to acquire the lock.
366 if ((errno != EAGAIN) && (errno != EINTR)) {
Ian Rogersc604d732012-10-14 16:09:54 -0700367 PLOG(FATAL) << "futex wait failed for " << name_;
368 }
369 }
Ian Rogersb122a4b2013-11-19 18:00:50 -0800370 num_contenders_--;
Ian Rogersc604d732012-10-14 16:09:54 -0700371 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700372 } while (!done);
Ian Rogersc7190692014-07-08 23:50:26 -0700373 DCHECK_EQ(state_.LoadRelaxed(), 1);
Ian Rogersc604d732012-10-14 16:09:54 -0700374#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700375 CHECK_MUTEX_CALL(pthread_mutex_lock, (&mutex_));
Ian Rogersc604d732012-10-14 16:09:54 -0700376#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700377 DCHECK_EQ(exclusive_owner_, 0U);
378 exclusive_owner_ = SafeGetTid(self);
Ian Rogers81d425b2012-09-27 16:03:43 -0700379 RegisterAsLocked(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700380 }
381 recursion_count_++;
Ian Rogers25fd14b2012-09-05 10:56:38 -0700382 if (kDebugLocking) {
383 CHECK(recursion_count_ == 1 || recursive_) << "Unexpected recursion count on mutex: "
384 << name_ << " " << recursion_count_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700385 AssertHeld(self);
Ian Rogers25fd14b2012-09-05 10:56:38 -0700386 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700387}
388
Ian Rogers81d425b2012-09-27 16:03:43 -0700389bool Mutex::ExclusiveTryLock(Thread* self) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700390 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers25fd14b2012-09-05 10:56:38 -0700391 if (kDebugLocking && !recursive_) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700392 AssertNotHeld(self);
Ian Rogers25fd14b2012-09-05 10:56:38 -0700393 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700394 if (!recursive_ || !IsExclusiveHeld(self)) {
Ian Rogersc604d732012-10-14 16:09:54 -0700395#if ART_USE_FUTEXES
396 bool done = false;
397 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700398 int32_t cur_state = state_.LoadRelaxed();
Ian Rogersc604d732012-10-14 16:09:54 -0700399 if (cur_state == 0) {
Ian Rogersc7190692014-07-08 23:50:26 -0700400 // Change state from 0 to 1 and impose load/store ordering appropriate for lock acquisition.
401 done = state_.CompareExchangeWeakAcquire(0 /* cur_state */, 1 /* new state */);
Ian Rogersc604d732012-10-14 16:09:54 -0700402 } else {
403 return false;
404 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700405 } while (!done);
Ian Rogersc7190692014-07-08 23:50:26 -0700406 DCHECK_EQ(state_.LoadRelaxed(), 1);
Ian Rogersc604d732012-10-14 16:09:54 -0700407#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700408 int result = pthread_mutex_trylock(&mutex_);
409 if (result == EBUSY) {
410 return false;
411 }
412 if (result != 0) {
413 errno = result;
414 PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
415 }
Ian Rogersc604d732012-10-14 16:09:54 -0700416#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700417 DCHECK_EQ(exclusive_owner_, 0U);
418 exclusive_owner_ = SafeGetTid(self);
Ian Rogers81d425b2012-09-27 16:03:43 -0700419 RegisterAsLocked(self);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700420 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700421 recursion_count_++;
Ian Rogers25fd14b2012-09-05 10:56:38 -0700422 if (kDebugLocking) {
423 CHECK(recursion_count_ == 1 || recursive_) << "Unexpected recursion count on mutex: "
424 << name_ << " " << recursion_count_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700425 AssertHeld(self);
Ian Rogers25fd14b2012-09-05 10:56:38 -0700426 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700427 return true;
428}
429
Ian Rogers81d425b2012-09-27 16:03:43 -0700430void Mutex::ExclusiveUnlock(Thread* self) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700431 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700432 AssertHeld(self);
Ian Rogersc5f17732014-06-05 20:48:42 -0700433 DCHECK_NE(exclusive_owner_, 0U);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700434 recursion_count_--;
435 if (!recursive_ || recursion_count_ == 0) {
Ian Rogers25fd14b2012-09-05 10:56:38 -0700436 if (kDebugLocking) {
437 CHECK(recursion_count_ == 0 || recursive_) << "Unexpected recursion count on mutex: "
438 << name_ << " " << recursion_count_;
439 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700440 RegisterAsUnlocked(self);
Ian Rogersc604d732012-10-14 16:09:54 -0700441#if ART_USE_FUTEXES
Ian Rogersc5f17732014-06-05 20:48:42 -0700442 bool done = false;
443 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700444 int32_t cur_state = state_.LoadRelaxed();
Ian Rogersc5f17732014-06-05 20:48:42 -0700445 if (LIKELY(cur_state == 1)) {
Ian Rogersc5f17732014-06-05 20:48:42 -0700446 // We're no longer the owner.
447 exclusive_owner_ = 0;
Ian Rogersc7190692014-07-08 23:50:26 -0700448 // Change state to 0 and impose load/store ordering appropriate for lock release.
449 // Note, the relaxed loads below musn't reorder before the CompareExchange.
450 // TODO: the ordering here is non-trivial as state is split across 3 fields, fix by placing
451 // a status bit into the state on contention.
452 done = state_.CompareExchangeWeakSequentiallyConsistent(cur_state, 0 /* new state */);
Ian Rogersc5f17732014-06-05 20:48:42 -0700453 if (LIKELY(done)) { // Spurious fail?
Ian Rogersc7190692014-07-08 23:50:26 -0700454 // Wake a contender.
Ian Rogersc5f17732014-06-05 20:48:42 -0700455 if (UNLIKELY(num_contenders_.LoadRelaxed() > 0)) {
Ian Rogersc7190692014-07-08 23:50:26 -0700456 futex(state_.Address(), FUTEX_WAKE, 1, NULL, NULL, 0);
Ian Rogersc5f17732014-06-05 20:48:42 -0700457 }
458 }
459 } else {
460 // Logging acquires the logging lock, avoid infinite recursion in that case.
461 if (this != Locks::logging_lock_) {
462 LOG(FATAL) << "Unexpected state_ in unlock " << cur_state << " for " << name_;
463 } else {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700464 LogMessage::LogLine(__FILE__, __LINE__, INTERNAL_FATAL,
465 StringPrintf("Unexpected state_ %d in unlock for %s",
466 cur_state, name_).c_str());
Ian Rogersc5f17732014-06-05 20:48:42 -0700467 _exit(1);
Ian Rogersc604d732012-10-14 16:09:54 -0700468 }
469 }
Ian Rogersc5f17732014-06-05 20:48:42 -0700470 } while (!done);
Ian Rogersc604d732012-10-14 16:09:54 -0700471#else
Ian Rogersc5f17732014-06-05 20:48:42 -0700472 exclusive_owner_ = 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700473 CHECK_MUTEX_CALL(pthread_mutex_unlock, (&mutex_));
Ian Rogersc604d732012-10-14 16:09:54 -0700474#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700475 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700476}
477
Ian Rogers56edc432013-01-18 16:51:51 -0800478void Mutex::Dump(std::ostream& os) const {
479 os << (recursive_ ? "recursive " : "non-recursive ")
480 << name_
481 << " level=" << static_cast<int>(level_)
482 << " rec=" << recursion_count_
483 << " owner=" << GetExclusiveOwnerTid() << " ";
484 DumpContention(os);
Ian Rogers01ae5802012-09-28 16:14:01 -0700485}
486
487std::ostream& operator<<(std::ostream& os, const Mutex& mu) {
Ian Rogers56edc432013-01-18 16:51:51 -0800488 mu.Dump(os);
489 return os;
Ian Rogers01ae5802012-09-28 16:14:01 -0700490}
491
Brian Carlstrom02c8cc62013-07-18 15:54:44 -0700492ReaderWriterMutex::ReaderWriterMutex(const char* name, LockLevel level)
493 : BaseMutex(name, level)
Ian Rogers81d425b2012-09-27 16:03:43 -0700494#if ART_USE_FUTEXES
Ian Rogersc5f17732014-06-05 20:48:42 -0700495 , state_(0), num_pending_readers_(0), num_pending_writers_(0)
Ian Rogers81d425b2012-09-27 16:03:43 -0700496#endif
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700497{ // NOLINT(whitespace/braces)
Ian Rogers81d425b2012-09-27 16:03:43 -0700498#if !ART_USE_FUTEXES
Ian Rogersc5f17732014-06-05 20:48:42 -0700499 CHECK_MUTEX_CALL(pthread_rwlock_init, (&rwlock_, nullptr));
Ian Rogers81d425b2012-09-27 16:03:43 -0700500#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700501 exclusive_owner_ = 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700502}
503
504ReaderWriterMutex::~ReaderWriterMutex() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700505#if ART_USE_FUTEXES
Ian Rogersc7190692014-07-08 23:50:26 -0700506 CHECK_EQ(state_.LoadRelaxed(), 0);
Ian Rogers81d425b2012-09-27 16:03:43 -0700507 CHECK_EQ(exclusive_owner_, 0U);
Ian Rogersc7190692014-07-08 23:50:26 -0700508 CHECK_EQ(num_pending_readers_.LoadRelaxed(), 0);
Ian Rogers3e5cf302014-05-20 16:40:37 -0700509 CHECK_EQ(num_pending_writers_.LoadRelaxed(), 0);
Ian Rogers81d425b2012-09-27 16:03:43 -0700510#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700511 // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
512 // may still be using locks.
513 int rc = pthread_rwlock_destroy(&rwlock_);
514 if (rc != 0) {
515 errno = rc;
516 // TODO: should we just not log at all if shutting down? this could be the logging mutex!
Ian Rogers50b35e22012-10-04 10:09:15 -0700517 MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
Ian Rogers120f1c72012-09-28 17:17:10 -0700518 Runtime* runtime = Runtime::Current();
Mathieu Chartier34e82932013-11-12 18:22:47 -0800519 bool shutting_down = runtime == NULL || runtime->IsShuttingDownLocked();
Ian Rogers120f1c72012-09-28 17:17:10 -0700520 PLOG(shutting_down ? WARNING : FATAL) << "pthread_rwlock_destroy failed for " << name_;
Brian Carlstromcd74c4b2012-01-23 13:21:00 -0800521 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700522#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700523}
524
Ian Rogers81d425b2012-09-27 16:03:43 -0700525void ReaderWriterMutex::ExclusiveLock(Thread* self) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700526 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700527 AssertNotExclusiveHeld(self);
528#if ART_USE_FUTEXES
529 bool done = false;
530 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700531 int32_t cur_state = state_.LoadRelaxed();
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -0700532 if (LIKELY(cur_state == 0)) {
Ian Rogersc7190692014-07-08 23:50:26 -0700533 // Change state from 0 to -1 and impose load/store ordering appropriate for lock acquisition.
534 done = state_.CompareExchangeWeakAcquire(0 /* cur_state*/, -1 /* new state */);
Ian Rogers81d425b2012-09-27 16:03:43 -0700535 } else {
536 // Failed to acquire, hang up.
Hiroshi Yamauchib3733082013-08-12 17:28:49 -0700537 ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
Ian Rogersc7190692014-07-08 23:50:26 -0700538 ++num_pending_writers_;
539 if (futex(state_.Address(), FUTEX_WAIT, cur_state, NULL, NULL, 0) != 0) {
Brian Carlstrom0de79852013-07-25 22:29:58 -0700540 // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
541 // We don't use TEMP_FAILURE_RETRY so we can intentionally retry to acquire the lock.
542 if ((errno != EAGAIN) && (errno != EINTR)) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700543 PLOG(FATAL) << "futex wait failed for " << name_;
544 }
545 }
Ian Rogersc7190692014-07-08 23:50:26 -0700546 --num_pending_writers_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700547 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700548 } while (!done);
Ian Rogersc7190692014-07-08 23:50:26 -0700549 DCHECK_EQ(state_.LoadRelaxed(), -1);
Ian Rogers81d425b2012-09-27 16:03:43 -0700550#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700551 CHECK_MUTEX_CALL(pthread_rwlock_wrlock, (&rwlock_));
Ian Rogers81d425b2012-09-27 16:03:43 -0700552#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700553 DCHECK_EQ(exclusive_owner_, 0U);
554 exclusive_owner_ = SafeGetTid(self);
Ian Rogers81d425b2012-09-27 16:03:43 -0700555 RegisterAsLocked(self);
556 AssertExclusiveHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700557}
558
Ian Rogers81d425b2012-09-27 16:03:43 -0700559void ReaderWriterMutex::ExclusiveUnlock(Thread* self) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700560 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700561 AssertExclusiveHeld(self);
562 RegisterAsUnlocked(self);
Ian Rogersc5f17732014-06-05 20:48:42 -0700563 DCHECK_NE(exclusive_owner_, 0U);
Ian Rogers81d425b2012-09-27 16:03:43 -0700564#if ART_USE_FUTEXES
565 bool done = false;
566 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700567 int32_t cur_state = state_.LoadRelaxed();
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -0700568 if (LIKELY(cur_state == -1)) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700569 // We're no longer the owner.
570 exclusive_owner_ = 0;
Ian Rogersc7190692014-07-08 23:50:26 -0700571 // Change state from -1 to 0 and impose load/store ordering appropriate for lock release.
572 // Note, the relaxed loads below musn't reorder before the CompareExchange.
573 // TODO: the ordering here is non-trivial as state is split across 3 fields, fix by placing
574 // a status bit into the state on contention.
575 done = state_.CompareExchangeWeakSequentiallyConsistent(-1 /* cur_state*/, 0 /* new state */);
576 if (LIKELY(done)) { // Weak CAS may fail spuriously.
Ian Rogers81d425b2012-09-27 16:03:43 -0700577 // Wake any waiters.
Ian Rogersc7190692014-07-08 23:50:26 -0700578 if (UNLIKELY(num_pending_readers_.LoadRelaxed() > 0 ||
579 num_pending_writers_.LoadRelaxed() > 0)) {
580 futex(state_.Address(), FUTEX_WAKE, -1, NULL, NULL, 0);
Ian Rogers81d425b2012-09-27 16:03:43 -0700581 }
582 }
583 } else {
584 LOG(FATAL) << "Unexpected state_:" << cur_state << " for " << name_;
585 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700586 } while (!done);
Ian Rogers81d425b2012-09-27 16:03:43 -0700587#else
Ian Rogersc5f17732014-06-05 20:48:42 -0700588 exclusive_owner_ = 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700589 CHECK_MUTEX_CALL(pthread_rwlock_unlock, (&rwlock_));
Ian Rogers81d425b2012-09-27 16:03:43 -0700590#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700591}
592
Ian Rogers66aee5c2012-08-15 17:17:47 -0700593#if HAVE_TIMED_RWLOCK
Ian Rogersc604d732012-10-14 16:09:54 -0700594bool ReaderWriterMutex::ExclusiveLockWithTimeout(Thread* self, int64_t ms, int32_t ns) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700595 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700596#if ART_USE_FUTEXES
597 bool done = false;
Ian Rogersc604d732012-10-14 16:09:54 -0700598 timespec end_abs_ts;
Ian Rogers5bd97c42012-11-27 02:38:26 -0800599 InitTimeSpec(true, CLOCK_REALTIME, ms, ns, &end_abs_ts);
Ian Rogers81d425b2012-09-27 16:03:43 -0700600 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700601 int32_t cur_state = state_.LoadRelaxed();
Ian Rogers81d425b2012-09-27 16:03:43 -0700602 if (cur_state == 0) {
Ian Rogersc7190692014-07-08 23:50:26 -0700603 // Change state from 0 to -1 and impose load/store ordering appropriate for lock acquisition.
604 done = state_.CompareExchangeWeakAcquire(0 /* cur_state */, -1 /* new state */);
Ian Rogers81d425b2012-09-27 16:03:43 -0700605 } else {
606 // Failed to acquire, hang up.
Ian Rogersc604d732012-10-14 16:09:54 -0700607 timespec now_abs_ts;
Ian Rogers5bd97c42012-11-27 02:38:26 -0800608 InitTimeSpec(true, CLOCK_REALTIME, 0, 0, &now_abs_ts);
Ian Rogersc604d732012-10-14 16:09:54 -0700609 timespec rel_ts;
610 if (ComputeRelativeTimeSpec(&rel_ts, end_abs_ts, now_abs_ts)) {
611 return false; // Timed out.
612 }
Hiroshi Yamauchib3733082013-08-12 17:28:49 -0700613 ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
Ian Rogersc7190692014-07-08 23:50:26 -0700614 ++num_pending_writers_;
615 if (futex(state_.Address(), FUTEX_WAIT, cur_state, &rel_ts, NULL, 0) != 0) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700616 if (errno == ETIMEDOUT) {
Ian Rogersc7190692014-07-08 23:50:26 -0700617 --num_pending_writers_;
Ian Rogersc604d732012-10-14 16:09:54 -0700618 return false; // Timed out.
Brian Carlstrom0de79852013-07-25 22:29:58 -0700619 } else if ((errno != EAGAIN) && (errno != EINTR)) {
620 // EAGAIN and EINTR both indicate a spurious failure,
621 // recompute the relative time out from now and try again.
622 // We don't use TEMP_FAILURE_RETRY so we can recompute rel_ts;
Ian Rogers81d425b2012-09-27 16:03:43 -0700623 PLOG(FATAL) << "timed futex wait failed for " << name_;
624 }
625 }
Ian Rogersc7190692014-07-08 23:50:26 -0700626 --num_pending_writers_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700627 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700628 } while (!done);
Ian Rogers81d425b2012-09-27 16:03:43 -0700629#else
Ian Rogersc604d732012-10-14 16:09:54 -0700630 timespec ts;
Brian Carlstrombcc29262012-11-02 11:36:03 -0700631 InitTimeSpec(true, CLOCK_REALTIME, ms, ns, &ts);
Ian Rogersc604d732012-10-14 16:09:54 -0700632 int result = pthread_rwlock_timedwrlock(&rwlock_, &ts);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700633 if (result == ETIMEDOUT) {
634 return false;
635 }
636 if (result != 0) {
637 errno = result;
Ian Rogersa5acfd32012-08-15 11:50:10 -0700638 PLOG(FATAL) << "pthread_rwlock_timedwrlock failed for " << name_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700639 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700640#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700641 exclusive_owner_ = SafeGetTid(self);
Ian Rogers81d425b2012-09-27 16:03:43 -0700642 RegisterAsLocked(self);
643 AssertSharedHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700644 return true;
645}
Ian Rogers66aee5c2012-08-15 17:17:47 -0700646#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700647
Ian Rogers51d212e2014-10-23 17:48:20 -0700648#if ART_USE_FUTEXES
Ian Rogerscf7f1912014-10-22 22:06:39 -0700649void ReaderWriterMutex::HandleSharedLockContention(Thread* self, int32_t cur_state) {
650 // Owner holds it exclusively, hang up.
651 ScopedContentionRecorder scr(this, GetExclusiveOwnerTid(), SafeGetTid(self));
652 ++num_pending_readers_;
653 if (futex(state_.Address(), FUTEX_WAIT, cur_state, NULL, NULL, 0) != 0) {
654 if (errno != EAGAIN) {
655 PLOG(FATAL) << "futex wait failed for " << name_;
656 }
657 }
658 --num_pending_readers_;
659}
Ian Rogers51d212e2014-10-23 17:48:20 -0700660#endif
Ian Rogerscf7f1912014-10-22 22:06:39 -0700661
Ian Rogers81d425b2012-09-27 16:03:43 -0700662bool ReaderWriterMutex::SharedTryLock(Thread* self) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700663 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers81d425b2012-09-27 16:03:43 -0700664#if ART_USE_FUTEXES
665 bool done = false;
666 do {
Ian Rogersc7190692014-07-08 23:50:26 -0700667 int32_t cur_state = state_.LoadRelaxed();
Ian Rogers81d425b2012-09-27 16:03:43 -0700668 if (cur_state >= 0) {
Ian Rogersc7190692014-07-08 23:50:26 -0700669 // Add as an extra reader and impose load/store ordering appropriate for lock acquisition.
670 done = state_.CompareExchangeWeakAcquire(cur_state, cur_state + 1);
Ian Rogers81d425b2012-09-27 16:03:43 -0700671 } else {
672 // Owner holds it exclusively.
673 return false;
674 }
Brian Carlstromdf629502013-07-17 22:39:56 -0700675 } while (!done);
Ian Rogers81d425b2012-09-27 16:03:43 -0700676#else
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700677 int result = pthread_rwlock_tryrdlock(&rwlock_);
678 if (result == EBUSY) {
679 return false;
680 }
681 if (result != 0) {
682 errno = result;
683 PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
684 }
Ian Rogers81d425b2012-09-27 16:03:43 -0700685#endif
686 RegisterAsLocked(self);
687 AssertSharedHeld(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700688 return true;
689}
690
Ian Rogers81d425b2012-09-27 16:03:43 -0700691bool ReaderWriterMutex::IsSharedHeld(const Thread* self) const {
Ian Rogers01ae5802012-09-28 16:14:01 -0700692 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700693 bool result;
694 if (UNLIKELY(self == NULL)) { // Handle unattached threads.
Ian Rogers01ae5802012-09-28 16:14:01 -0700695 result = IsExclusiveHeld(self); // TODO: a better best effort here.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700696 } else {
697 result = (self->GetHeldMutex(level_) == this);
698 }
699 return result;
700}
701
Ian Rogers56edc432013-01-18 16:51:51 -0800702void ReaderWriterMutex::Dump(std::ostream& os) const {
703 os << name_
704 << " level=" << static_cast<int>(level_)
Mathieu Chartier5869a2c2014-10-08 14:26:23 -0700705 << " owner=" << GetExclusiveOwnerTid()
706#if ART_USE_FUTEXES
707 << " state=" << state_.LoadSequentiallyConsistent()
708 << " num_pending_writers=" << num_pending_writers_.LoadSequentiallyConsistent()
709 << " num_pending_readers=" << num_pending_readers_.LoadSequentiallyConsistent()
710#endif
711 << " ";
Ian Rogers56edc432013-01-18 16:51:51 -0800712 DumpContention(os);
Ian Rogers01ae5802012-09-28 16:14:01 -0700713}
714
715std::ostream& operator<<(std::ostream& os, const ReaderWriterMutex& mu) {
Ian Rogers56edc432013-01-18 16:51:51 -0800716 mu.Dump(os);
717 return os;
Ian Rogers01ae5802012-09-28 16:14:01 -0700718}
719
Ian Rogers23055dc2013-04-18 16:29:16 -0700720ConditionVariable::ConditionVariable(const char* name, Mutex& guard)
Ian Rogersc604d732012-10-14 16:09:54 -0700721 : name_(name), guard_(guard) {
722#if ART_USE_FUTEXES
Ian Rogers3e5cf302014-05-20 16:40:37 -0700723 DCHECK_EQ(0, sequence_.LoadRelaxed());
Ian Rogersc604d732012-10-14 16:09:54 -0700724 num_waiters_ = 0;
Ian Rogersc604d732012-10-14 16:09:54 -0700725#else
Narayan Kamath51b71022014-03-04 11:57:09 +0000726 pthread_condattr_t cond_attrs;
Ian Rogersc5f17732014-06-05 20:48:42 -0700727 CHECK_MUTEX_CALL(pthread_condattr_init, (&cond_attrs));
Narayan Kamath51b71022014-03-04 11:57:09 +0000728#if !defined(__APPLE__)
729 // Apple doesn't have CLOCK_MONOTONIC or pthread_condattr_setclock.
Ian Rogers51d212e2014-10-23 17:48:20 -0700730 CHECK_MUTEX_CALL(pthread_condattr_setclock, (&cond_attrs, CLOCK_MONOTONIC));
Narayan Kamath51b71022014-03-04 11:57:09 +0000731#endif
732 CHECK_MUTEX_CALL(pthread_cond_init, (&cond_, &cond_attrs));
Ian Rogersc604d732012-10-14 16:09:54 -0700733#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700734}
735
736ConditionVariable::~ConditionVariable() {
Ian Rogers5bd97c42012-11-27 02:38:26 -0800737#if ART_USE_FUTEXES
738 if (num_waiters_!= 0) {
Ian Rogers5bd97c42012-11-27 02:38:26 -0800739 Runtime* runtime = Runtime::Current();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700740 bool shutting_down = runtime == nullptr || runtime->IsShuttingDown(Thread::Current());
Ian Rogersd45f2012012-11-28 11:46:23 -0800741 LOG(shutting_down ? WARNING : FATAL) << "ConditionVariable::~ConditionVariable for " << name_
742 << " called with " << num_waiters_ << " waiters.";
Ian Rogers5bd97c42012-11-27 02:38:26 -0800743 }
744#else
Elliott Hughese62934d2012-04-09 11:24:29 -0700745 // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
746 // may still be using condition variables.
747 int rc = pthread_cond_destroy(&cond_);
748 if (rc != 0) {
749 errno = rc;
Ian Rogers50b35e22012-10-04 10:09:15 -0700750 MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
Ian Rogers120f1c72012-09-28 17:17:10 -0700751 Runtime* runtime = Runtime::Current();
Mathieu Chartier34e82932013-11-12 18:22:47 -0800752 bool shutting_down = (runtime == NULL) || runtime->IsShuttingDownLocked();
Elliott Hughese62934d2012-04-09 11:24:29 -0700753 PLOG(shutting_down ? WARNING : FATAL) << "pthread_cond_destroy failed for " << name_;
754 }
Ian Rogersc604d732012-10-14 16:09:54 -0700755#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700756}
757
Ian Rogersc604d732012-10-14 16:09:54 -0700758void ConditionVariable::Broadcast(Thread* self) {
759 DCHECK(self == NULL || self == Thread::Current());
760 // TODO: enable below, there's a race in thread creation that causes false failures currently.
761 // guard_.AssertExclusiveHeld(self);
Mathieu Chartiere46cd752012-10-31 16:56:18 -0700762 DCHECK_EQ(guard_.GetExclusiveOwnerTid(), SafeGetTid(self));
Ian Rogersc604d732012-10-14 16:09:54 -0700763#if ART_USE_FUTEXES
Ian Rogersd45f2012012-11-28 11:46:23 -0800764 if (num_waiters_ > 0) {
Ian Rogersb122a4b2013-11-19 18:00:50 -0800765 sequence_++; // Indicate the broadcast occurred.
Ian Rogersc604d732012-10-14 16:09:54 -0700766 bool done = false;
767 do {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700768 int32_t cur_sequence = sequence_.LoadRelaxed();
Ian Rogersd45f2012012-11-28 11:46:23 -0800769 // Requeue waiters onto mutex. The waiter holds the contender count on the mutex high ensuring
770 // mutex unlocks will awaken the requeued waiter thread.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800771 done = futex(sequence_.Address(), FUTEX_CMP_REQUEUE, 0,
Ian Rogers5bd97c42012-11-27 02:38:26 -0800772 reinterpret_cast<const timespec*>(std::numeric_limits<int32_t>::max()),
Ian Rogersc7190692014-07-08 23:50:26 -0700773 guard_.state_.Address(), cur_sequence) != -1;
Ian Rogers5bd97c42012-11-27 02:38:26 -0800774 if (!done) {
775 if (errno != EAGAIN) {
776 PLOG(FATAL) << "futex cmp requeue failed for " << name_;
777 }
Ian Rogers5bd97c42012-11-27 02:38:26 -0800778 }
Ian Rogersc604d732012-10-14 16:09:54 -0700779 } while (!done);
780 }
781#else
Elliott Hughes5f791332011-09-15 17:45:30 -0700782 CHECK_MUTEX_CALL(pthread_cond_broadcast, (&cond_));
Ian Rogersc604d732012-10-14 16:09:54 -0700783#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700784}
785
Ian Rogersc604d732012-10-14 16:09:54 -0700786void ConditionVariable::Signal(Thread* self) {
787 DCHECK(self == NULL || self == Thread::Current());
788 guard_.AssertExclusiveHeld(self);
789#if ART_USE_FUTEXES
Ian Rogersd45f2012012-11-28 11:46:23 -0800790 if (num_waiters_ > 0) {
Ian Rogersb122a4b2013-11-19 18:00:50 -0800791 sequence_++; // Indicate a signal occurred.
Ian Rogersc604d732012-10-14 16:09:54 -0700792 // Futex wake 1 waiter who will then come and in contend on mutex. It'd be nice to requeue them
793 // to avoid this, however, requeueing can only move all waiters.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800794 int num_woken = futex(sequence_.Address(), FUTEX_WAKE, 1, NULL, NULL, 0);
Ian Rogersd45f2012012-11-28 11:46:23 -0800795 // Check something was woken or else we changed sequence_ before they had chance to wait.
Ian Rogers5bd97c42012-11-27 02:38:26 -0800796 CHECK((num_woken == 0) || (num_woken == 1));
Ian Rogersc604d732012-10-14 16:09:54 -0700797 }
798#else
Elliott Hughes5f791332011-09-15 17:45:30 -0700799 CHECK_MUTEX_CALL(pthread_cond_signal, (&cond_));
Ian Rogersc604d732012-10-14 16:09:54 -0700800#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700801}
802
Ian Rogersc604d732012-10-14 16:09:54 -0700803void ConditionVariable::Wait(Thread* self) {
Ian Rogers1d54e732013-05-02 21:10:01 -0700804 guard_.CheckSafeToWait(self);
805 WaitHoldingLocks(self);
806}
807
808void ConditionVariable::WaitHoldingLocks(Thread* self) {
Ian Rogersc604d732012-10-14 16:09:54 -0700809 DCHECK(self == NULL || self == Thread::Current());
810 guard_.AssertExclusiveHeld(self);
Ian Rogersc604d732012-10-14 16:09:54 -0700811 unsigned int old_recursion_count = guard_.recursion_count_;
812#if ART_USE_FUTEXES
Ian Rogersc604d732012-10-14 16:09:54 -0700813 num_waiters_++;
Ian Rogersd45f2012012-11-28 11:46:23 -0800814 // Ensure the Mutex is contended so that requeued threads are awoken.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800815 guard_.num_contenders_++;
Ian Rogersc604d732012-10-14 16:09:54 -0700816 guard_.recursion_count_ = 1;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700817 int32_t cur_sequence = sequence_.LoadRelaxed();
Ian Rogersc604d732012-10-14 16:09:54 -0700818 guard_.ExclusiveUnlock(self);
Ian Rogersb122a4b2013-11-19 18:00:50 -0800819 if (futex(sequence_.Address(), FUTEX_WAIT, cur_sequence, NULL, NULL, 0) != 0) {
Ian Rogersd45f2012012-11-28 11:46:23 -0800820 // Futex failed, check it is an expected error.
821 // EAGAIN == EWOULDBLK, so we let the caller try again.
822 // EINTR implies a signal was sent to this thread.
823 if ((errno != EINTR) && (errno != EAGAIN)) {
Ian Rogersc604d732012-10-14 16:09:54 -0700824 PLOG(FATAL) << "futex wait failed for " << name_;
825 }
826 }
827 guard_.ExclusiveLock(self);
Ian Rogersd45f2012012-11-28 11:46:23 -0800828 CHECK_GE(num_waiters_, 0);
Ian Rogersc604d732012-10-14 16:09:54 -0700829 num_waiters_--;
Ian Rogersd45f2012012-11-28 11:46:23 -0800830 // We awoke and so no longer require awakes from the guard_'s unlock.
Ian Rogers3e5cf302014-05-20 16:40:37 -0700831 CHECK_GE(guard_.num_contenders_.LoadRelaxed(), 0);
Ian Rogersb122a4b2013-11-19 18:00:50 -0800832 guard_.num_contenders_--;
Ian Rogersc604d732012-10-14 16:09:54 -0700833#else
Ian Rogersc5f17732014-06-05 20:48:42 -0700834 uint64_t old_owner = guard_.exclusive_owner_;
835 guard_.exclusive_owner_ = 0;
Ian Rogersc604d732012-10-14 16:09:54 -0700836 guard_.recursion_count_ = 0;
837 CHECK_MUTEX_CALL(pthread_cond_wait, (&cond_, &guard_.mutex_));
Ian Rogersc5f17732014-06-05 20:48:42 -0700838 guard_.exclusive_owner_ = old_owner;
Ian Rogersc604d732012-10-14 16:09:54 -0700839#endif
840 guard_.recursion_count_ = old_recursion_count;
Elliott Hughes5f791332011-09-15 17:45:30 -0700841}
842
Ian Rogers7b078e82014-09-10 14:44:24 -0700843bool ConditionVariable::TimedWait(Thread* self, int64_t ms, int32_t ns) {
Ian Rogersc604d732012-10-14 16:09:54 -0700844 DCHECK(self == NULL || self == Thread::Current());
Ian Rogers7b078e82014-09-10 14:44:24 -0700845 bool timed_out = false;
Ian Rogersc604d732012-10-14 16:09:54 -0700846 guard_.AssertExclusiveHeld(self);
Ian Rogers1d54e732013-05-02 21:10:01 -0700847 guard_.CheckSafeToWait(self);
Ian Rogersc604d732012-10-14 16:09:54 -0700848 unsigned int old_recursion_count = guard_.recursion_count_;
849#if ART_USE_FUTEXES
Ian Rogersc604d732012-10-14 16:09:54 -0700850 timespec rel_ts;
Ian Rogers5bd97c42012-11-27 02:38:26 -0800851 InitTimeSpec(false, CLOCK_REALTIME, ms, ns, &rel_ts);
Ian Rogersc604d732012-10-14 16:09:54 -0700852 num_waiters_++;
Ian Rogersd45f2012012-11-28 11:46:23 -0800853 // Ensure the Mutex is contended so that requeued threads are awoken.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800854 guard_.num_contenders_++;
Ian Rogersc604d732012-10-14 16:09:54 -0700855 guard_.recursion_count_ = 1;
Ian Rogers3e5cf302014-05-20 16:40:37 -0700856 int32_t cur_sequence = sequence_.LoadRelaxed();
Ian Rogersc604d732012-10-14 16:09:54 -0700857 guard_.ExclusiveUnlock(self);
Ian Rogersb122a4b2013-11-19 18:00:50 -0800858 if (futex(sequence_.Address(), FUTEX_WAIT, cur_sequence, &rel_ts, NULL, 0) != 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700859 if (errno == ETIMEDOUT) {
Ian Rogersd45f2012012-11-28 11:46:23 -0800860 // Timed out we're done.
Ian Rogers7b078e82014-09-10 14:44:24 -0700861 timed_out = true;
Brian Carlstrom0de79852013-07-25 22:29:58 -0700862 } else if ((errno == EAGAIN) || (errno == EINTR)) {
Ian Rogersd45f2012012-11-28 11:46:23 -0800863 // A signal or ConditionVariable::Signal/Broadcast has come in.
Ian Rogersc604d732012-10-14 16:09:54 -0700864 } else {
865 PLOG(FATAL) << "timed futex wait failed for " << name_;
866 }
867 }
868 guard_.ExclusiveLock(self);
Ian Rogersd45f2012012-11-28 11:46:23 -0800869 CHECK_GE(num_waiters_, 0);
Ian Rogersc604d732012-10-14 16:09:54 -0700870 num_waiters_--;
Ian Rogersd45f2012012-11-28 11:46:23 -0800871 // We awoke and so no longer require awakes from the guard_'s unlock.
Ian Rogers3e5cf302014-05-20 16:40:37 -0700872 CHECK_GE(guard_.num_contenders_.LoadRelaxed(), 0);
Ian Rogersb122a4b2013-11-19 18:00:50 -0800873 guard_.num_contenders_--;
Ian Rogersc604d732012-10-14 16:09:54 -0700874#else
Narayan Kamath51b71022014-03-04 11:57:09 +0000875#if !defined(__APPLE__)
Ian Rogersc604d732012-10-14 16:09:54 -0700876 int clock = CLOCK_MONOTONIC;
Elliott Hughes5f791332011-09-15 17:45:30 -0700877#else
Ian Rogersc604d732012-10-14 16:09:54 -0700878 int clock = CLOCK_REALTIME;
Elliott Hughes5f791332011-09-15 17:45:30 -0700879#endif
Ian Rogersc5f17732014-06-05 20:48:42 -0700880 uint64_t old_owner = guard_.exclusive_owner_;
881 guard_.exclusive_owner_ = 0;
Ian Rogersc604d732012-10-14 16:09:54 -0700882 guard_.recursion_count_ = 0;
883 timespec ts;
Brian Carlstrombcc29262012-11-02 11:36:03 -0700884 InitTimeSpec(true, clock, ms, ns, &ts);
Narayan Kamath51b71022014-03-04 11:57:09 +0000885 int rc = TEMP_FAILURE_RETRY(pthread_cond_timedwait(&cond_, &guard_.mutex_, &ts));
Ian Rogers7b078e82014-09-10 14:44:24 -0700886 if (rc == ETIMEDOUT) {
887 timed_out = true;
888 } else if (rc != 0) {
Elliott Hughes5f791332011-09-15 17:45:30 -0700889 errno = rc;
890 PLOG(FATAL) << "TimedWait failed for " << name_;
891 }
Ian Rogersc5f17732014-06-05 20:48:42 -0700892 guard_.exclusive_owner_ = old_owner;
Ian Rogersc604d732012-10-14 16:09:54 -0700893#endif
894 guard_.recursion_count_ = old_recursion_count;
Ian Rogers7b078e82014-09-10 14:44:24 -0700895 return timed_out;
Elliott Hughes5f791332011-09-15 17:45:30 -0700896}
897
Ian Rogers719d1a32014-03-06 12:13:39 -0800898void Locks::Init() {
899 if (logging_lock_ != nullptr) {
900 // Already initialized.
Nicolas Geoffray7f0a6d62014-05-26 14:01:46 +0100901 if (kRuntimeISA == kX86 || kRuntimeISA == kX86_64) {
Chao-ying Fu9e369312014-05-21 11:20:52 -0700902 DCHECK(modify_ldt_lock_ != nullptr);
903 } else {
904 DCHECK(modify_ldt_lock_ == nullptr);
905 }
Ian Rogers719d1a32014-03-06 12:13:39 -0800906 DCHECK(abort_lock_ != nullptr);
Brian Carlstrom306db812014-09-05 13:01:41 -0700907 DCHECK(alloc_tracker_lock_ != nullptr);
Andreas Gampe74240812014-04-17 10:35:09 -0700908 DCHECK(allocated_monitor_ids_lock_ != nullptr);
Chao-ying Fu9e369312014-05-21 11:20:52 -0700909 DCHECK(allocated_thread_ids_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800910 DCHECK(breakpoint_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800911 DCHECK(classlinker_classes_lock_ != nullptr);
Brian Carlstrom306db812014-09-05 13:01:41 -0700912 DCHECK(deoptimization_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800913 DCHECK(heap_bitmap_lock_ != nullptr);
Brian Carlstrom306db812014-09-05 13:01:41 -0700914 DCHECK(intern_table_lock_ != nullptr);
Ian Rogers68d8b422014-07-17 11:09:10 -0700915 DCHECK(jni_libraries_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800916 DCHECK(logging_lock_ != nullptr);
917 DCHECK(mutator_lock_ != nullptr);
Brian Carlstrom306db812014-09-05 13:01:41 -0700918 DCHECK(profiler_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800919 DCHECK(thread_list_lock_ != nullptr);
920 DCHECK(thread_suspend_count_lock_ != nullptr);
921 DCHECK(trace_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800922 DCHECK(unexpected_signal_lock_ != nullptr);
Ian Rogers719d1a32014-03-06 12:13:39 -0800923 } else {
Chao-ying Fu9e369312014-05-21 11:20:52 -0700924 // Create global locks in level order from highest lock level to lowest.
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800925 LockLevel current_lock_level = kInstrumentEntrypointsLock;
926 DCHECK(instrument_entrypoints_lock_ == nullptr);
927 instrument_entrypoints_lock_ = new Mutex("instrument entrypoint lock", current_lock_level);
Ian Rogers719d1a32014-03-06 12:13:39 -0800928
Chao-ying Fu9e369312014-05-21 11:20:52 -0700929 #define UPDATE_CURRENT_LOCK_LEVEL(new_level) \
Brian Carlstrom306db812014-09-05 13:01:41 -0700930 if (new_level >= current_lock_level) { \
931 /* Do not use CHECKs or FATAL here, abort_lock_ is not setup yet. */ \
932 fprintf(stderr, "New local level %d is not less than current level %d\n", \
933 new_level, current_lock_level); \
934 exit(1); \
935 } \
Ian Rogersf3d874c2014-07-17 18:52:42 -0700936 current_lock_level = new_level;
937
938 UPDATE_CURRENT_LOCK_LEVEL(kMutatorLock);
939 DCHECK(mutator_lock_ == nullptr);
940 mutator_lock_ = new ReaderWriterMutex("mutator lock", current_lock_level);
Chao-ying Fu9e369312014-05-21 11:20:52 -0700941
942 UPDATE_CURRENT_LOCK_LEVEL(kHeapBitmapLock);
943 DCHECK(heap_bitmap_lock_ == nullptr);
944 heap_bitmap_lock_ = new ReaderWriterMutex("heap bitmap lock", current_lock_level);
945
Jeff Hao69dbec62014-09-15 18:03:41 -0700946 UPDATE_CURRENT_LOCK_LEVEL(kTraceLock);
947 DCHECK(trace_lock_ == nullptr);
948 trace_lock_ = new Mutex("trace lock", current_lock_level);
949
Chao-ying Fu9e369312014-05-21 11:20:52 -0700950 UPDATE_CURRENT_LOCK_LEVEL(kRuntimeShutdownLock);
951 DCHECK(runtime_shutdown_lock_ == nullptr);
952 runtime_shutdown_lock_ = new Mutex("runtime shutdown lock", current_lock_level);
953
954 UPDATE_CURRENT_LOCK_LEVEL(kProfilerLock);
955 DCHECK(profiler_lock_ == nullptr);
956 profiler_lock_ = new Mutex("profiler lock", current_lock_level);
957
Brian Carlstrom306db812014-09-05 13:01:41 -0700958 UPDATE_CURRENT_LOCK_LEVEL(kDeoptimizationLock);
959 DCHECK(deoptimization_lock_ == nullptr);
960 deoptimization_lock_ = new Mutex("Deoptimization lock", current_lock_level);
961
962 UPDATE_CURRENT_LOCK_LEVEL(kAllocTrackerLock);
963 DCHECK(alloc_tracker_lock_ == nullptr);
964 alloc_tracker_lock_ = new Mutex("AllocTracker lock", current_lock_level);
965
Chao-ying Fu9e369312014-05-21 11:20:52 -0700966 UPDATE_CURRENT_LOCK_LEVEL(kThreadListLock);
967 DCHECK(thread_list_lock_ == nullptr);
968 thread_list_lock_ = new Mutex("thread list lock", current_lock_level);
969
Ian Rogers68d8b422014-07-17 11:09:10 -0700970 UPDATE_CURRENT_LOCK_LEVEL(kJniLoadLibraryLock);
971 DCHECK(jni_libraries_lock_ == nullptr);
972 jni_libraries_lock_ = new Mutex("JNI shared libraries map lock", current_lock_level);
973
Chao-ying Fu9e369312014-05-21 11:20:52 -0700974 UPDATE_CURRENT_LOCK_LEVEL(kBreakpointLock);
Ian Rogers719d1a32014-03-06 12:13:39 -0800975 DCHECK(breakpoint_lock_ == nullptr);
Sebastien Hertzed2be172014-08-19 15:33:43 +0200976 breakpoint_lock_ = new ReaderWriterMutex("breakpoint lock", current_lock_level);
Chao-ying Fu9e369312014-05-21 11:20:52 -0700977
978 UPDATE_CURRENT_LOCK_LEVEL(kClassLinkerClassesLock);
Ian Rogers719d1a32014-03-06 12:13:39 -0800979 DCHECK(classlinker_classes_lock_ == nullptr);
980 classlinker_classes_lock_ = new ReaderWriterMutex("ClassLinker classes lock",
Chao-ying Fu9e369312014-05-21 11:20:52 -0700981 current_lock_level);
982
Andreas Gampe74240812014-04-17 10:35:09 -0700983 UPDATE_CURRENT_LOCK_LEVEL(kMonitorPoolLock);
984 DCHECK(allocated_monitor_ids_lock_ == nullptr);
985 allocated_monitor_ids_lock_ = new Mutex("allocated monitor ids lock", current_lock_level);
986
Chao-ying Fu9e369312014-05-21 11:20:52 -0700987 UPDATE_CURRENT_LOCK_LEVEL(kAllocatedThreadIdsLock);
988 DCHECK(allocated_thread_ids_lock_ == nullptr);
989 allocated_thread_ids_lock_ = new Mutex("allocated thread ids lock", current_lock_level);
990
Nicolas Geoffray7f0a6d62014-05-26 14:01:46 +0100991 if (kRuntimeISA == kX86 || kRuntimeISA == kX86_64) {
Chao-ying Fu9e369312014-05-21 11:20:52 -0700992 UPDATE_CURRENT_LOCK_LEVEL(kModifyLdtLock);
993 DCHECK(modify_ldt_lock_ == nullptr);
994 modify_ldt_lock_ = new Mutex("modify_ldt lock", current_lock_level);
995 }
996
997 UPDATE_CURRENT_LOCK_LEVEL(kInternTableLock);
Ian Rogers719d1a32014-03-06 12:13:39 -0800998 DCHECK(intern_table_lock_ == nullptr);
Chao-ying Fu9e369312014-05-21 11:20:52 -0700999 intern_table_lock_ = new Mutex("InternTable lock", current_lock_level);
1000
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -07001001 UPDATE_CURRENT_LOCK_LEVEL(kReferenceProcessorLock);
1002 DCHECK(reference_processor_lock_ == nullptr);
1003 reference_processor_lock_ = new Mutex("ReferenceProcessor lock", current_lock_level);
1004
1005 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueClearedReferencesLock);
1006 DCHECK(reference_queue_cleared_references_lock_ == nullptr);
1007 reference_queue_cleared_references_lock_ = new Mutex("ReferenceQueue cleared references lock", current_lock_level);
1008
1009 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueWeakReferencesLock);
1010 DCHECK(reference_queue_weak_references_lock_ == nullptr);
1011 reference_queue_weak_references_lock_ = new Mutex("ReferenceQueue cleared references lock", current_lock_level);
1012
1013 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueFinalizerReferencesLock);
1014 DCHECK(reference_queue_finalizer_references_lock_ == nullptr);
1015 reference_queue_finalizer_references_lock_ = new Mutex("ReferenceQueue finalizer references lock", current_lock_level);
1016
1017 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueuePhantomReferencesLock);
1018 DCHECK(reference_queue_phantom_references_lock_ == nullptr);
1019 reference_queue_phantom_references_lock_ = new Mutex("ReferenceQueue phantom references lock", current_lock_level);
1020
1021 UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueSoftReferencesLock);
1022 DCHECK(reference_queue_soft_references_lock_ == nullptr);
1023 reference_queue_soft_references_lock_ = new Mutex("ReferenceQueue soft references lock", current_lock_level);
1024
Chao-ying Fu9e369312014-05-21 11:20:52 -07001025 UPDATE_CURRENT_LOCK_LEVEL(kAbortLock);
1026 DCHECK(abort_lock_ == nullptr);
1027 abort_lock_ = new Mutex("abort lock", current_lock_level, true);
1028
1029 UPDATE_CURRENT_LOCK_LEVEL(kThreadSuspendCountLock);
1030 DCHECK(thread_suspend_count_lock_ == nullptr);
1031 thread_suspend_count_lock_ = new Mutex("thread suspend count lock", current_lock_level);
1032
1033 UPDATE_CURRENT_LOCK_LEVEL(kUnexpectedSignalLock);
1034 DCHECK(unexpected_signal_lock_ == nullptr);
1035 unexpected_signal_lock_ = new Mutex("unexpected signal lock", current_lock_level, true);
1036
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -07001037 UPDATE_CURRENT_LOCK_LEVEL(kMemMapsLock);
1038 DCHECK(mem_maps_lock_ == nullptr);
1039 mem_maps_lock_ = new Mutex("mem maps lock", current_lock_level);
1040
Chao-ying Fu9e369312014-05-21 11:20:52 -07001041 UPDATE_CURRENT_LOCK_LEVEL(kLoggingLock);
1042 DCHECK(logging_lock_ == nullptr);
1043 logging_lock_ = new Mutex("logging lock", current_lock_level, true);
1044
1045 #undef UPDATE_CURRENT_LOCK_LEVEL
Ian Rogers719d1a32014-03-06 12:13:39 -08001046 }
1047}
1048
1049
Elliott Hughese62934d2012-04-09 11:24:29 -07001050} // namespace art