blob: 3dca12a3651888721cf7f5210edb494517536c5d [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
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_BASE_MUTEX_H_
18#define ART_RUNTIME_BASE_MUTEX_H_
Elliott Hughes8daa0922011-09-11 13:46:25 -070019
20#include <pthread.h>
Brian Carlstromcd74c4b2012-01-23 13:21:00 -080021#include <stdint.h>
Elliott Hughesffb465f2012-03-01 18:46:05 -080022
23#include <iosfwd>
Elliott Hughes8daa0922011-09-11 13:46:25 -070024#include <string>
25
Ian Rogersef7d42f2014-01-06 12:55:46 -080026#include "atomic.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080027#include "base/logging.h"
Elliott Hughes76160052012-12-12 16:31:20 -080028#include "base/macros.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070029#include "globals.h"
Ian Rogers81d425b2012-09-27 16:03:43 -070030
Ian Rogersab470162012-09-29 23:06:53 -070031#if defined(__APPLE__)
Ian Rogers81d425b2012-09-27 16:03:43 -070032#define ART_USE_FUTEXES 0
Ian Rogersab470162012-09-29 23:06:53 -070033#else
Chris Dearmanc0141782013-11-14 17:29:21 -080034#define ART_USE_FUTEXES 1
Ian Rogersab470162012-09-29 23:06:53 -070035#endif
Elliott Hughes8daa0922011-09-11 13:46:25 -070036
Ian Rogers66aee5c2012-08-15 17:17:47 -070037// Currently Darwin doesn't support locks with timeouts.
38#if !defined(__APPLE__)
39#define HAVE_TIMED_RWLOCK 1
40#else
41#define HAVE_TIMED_RWLOCK 0
42#endif
43
Elliott Hughes8daa0922011-09-11 13:46:25 -070044namespace art {
45
Mathieu Chartier90443472015-07-16 20:32:27 -070046class SHARED_LOCKABLE ReaderWriterMutex;
47class SHARED_LOCKABLE MutatorMutex;
Ian Rogers56edc432013-01-18 16:51:51 -080048class ScopedContentionRecorder;
Ian Rogers50b35e22012-10-04 10:09:15 -070049class Thread;
50
Ian Rogers719d1a32014-03-06 12:13:39 -080051// LockLevel is used to impose a lock hierarchy [1] where acquisition of a Mutex at a higher or
52// equal level to a lock a thread holds is invalid. The lock hierarchy achieves a cycle free
53// partial ordering and thereby cause deadlock situations to fail checks.
54//
55// [1] http://www.drdobbs.com/parallel/use-lock-hierarchies-to-avoid-deadlock/204801163
56enum LockLevel {
57 kLoggingLock = 0,
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -070058 kMemMapsLock,
Raghu Gandham7de77dd2014-06-13 15:16:31 -070059 kSwapMutexesLock,
Ian Rogers719d1a32014-03-06 12:13:39 -080060 kUnexpectedSignalLock,
61 kThreadSuspendCountLock,
62 kAbortLock,
Igor Murashkine2facc52015-07-10 13:49:08 -070063 kLambdaTableLock,
Ian Rogers719d1a32014-03-06 12:13:39 -080064 kJdwpSocketLock,
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -080065 kRegionSpaceRegionLock,
Mathieu Chartier29946052015-12-21 13:02:14 -080066 kRosAllocGlobalLock,
67 kRosAllocBracketLock,
68 kRosAllocBulkFreeLock,
Mathieu Chartier673ed3d2015-08-28 14:56:43 -070069 kMarkSweepMarkStackLock,
Andreas Gampebc4d2182016-02-22 10:03:12 -080070 kTransactionLogLock,
Mathieu Chartier673ed3d2015-08-28 14:56:43 -070071 kJniWeakGlobalsLock,
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -070072 kReferenceQueueSoftReferencesLock,
73 kReferenceQueuePhantomReferencesLock,
74 kReferenceQueueFinalizerReferencesLock,
75 kReferenceQueueWeakReferencesLock,
76 kReferenceQueueClearedReferencesLock,
77 kReferenceProcessorLock,
David Srbecky5cc349f2015-12-18 15:04:48 +000078 kJitDebugInterfaceLock,
Ian Rogers719d1a32014-03-06 12:13:39 -080079 kAllocSpaceLock,
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -080080 kBumpPointerSpaceBlockLock,
Mathieu Chartierc7853442015-03-27 14:35:38 -070081 kArenaPoolLock,
Ian Rogers719d1a32014-03-06 12:13:39 -080082 kDexFileMethodInlinerLock,
83 kDexFileToMethodInlinerMapLock,
Ian Rogers719d1a32014-03-06 12:13:39 -080084 kInternTableLock,
Vladimir Marko3f5838d2014-08-07 18:07:18 +010085 kOatFileSecondaryLookupLock,
Mathieu Chartiere58991b2015-10-13 07:59:34 -070086 kOatFileCountLock,
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -070087 kOatFileManagerLock,
Andreas Gampe7526d782015-06-22 22:53:45 -070088 kTracingUniqueMethodsLock,
89 kTracingStreamingLock,
Mathieu Chartierb8aa1e42016-04-05 14:36:57 -070090 kDeoptimizedMethodsLock,
Nicolas Geoffray480d5102016-04-18 12:09:30 +010091 kJitCodeCacheLock,
Mathieu Chartierb8aa1e42016-04-05 14:36:57 -070092 kClassLoaderClassesLock,
Ian Rogers719d1a32014-03-06 12:13:39 -080093 kDefaultMutexLevel,
94 kMarkSweepLargeObjectLock,
95 kPinTableLock,
Ian Rogers719d1a32014-03-06 12:13:39 -080096 kJdwpObjectRegistryLock,
Chao-ying Fu9e369312014-05-21 11:20:52 -070097 kModifyLdtLock,
98 kAllocatedThreadIdsLock,
Andreas Gampe74240812014-04-17 10:35:09 -070099 kMonitorPoolLock,
bowen_lai2435a432015-03-13 14:34:40 +0800100 kMethodVerifiersLock,
Mathieu Chartierb8aa1e42016-04-05 14:36:57 -0700101 kClassLinkerClassesLock, // TODO rename.
Ian Rogers719d1a32014-03-06 12:13:39 -0800102 kBreakpointLock,
103 kMonitorLock,
Mathieu Chartier440e4ce2014-03-31 16:36:35 -0700104 kMonitorListLock,
Ian Rogers68d8b422014-07-17 11:09:10 -0700105 kJniLoadLibraryLock,
Ian Rogers719d1a32014-03-06 12:13:39 -0800106 kThreadListLock,
Brian Carlstrom306db812014-09-05 13:01:41 -0700107 kAllocTrackerLock,
Ian Rogers719d1a32014-03-06 12:13:39 -0800108 kDeoptimizationLock,
Ian Rogers719d1a32014-03-06 12:13:39 -0800109 kProfilerLock,
Sebastien Hertz4e5b2082015-03-24 19:03:40 +0100110 kJdwpShutdownLock,
Ian Rogers719d1a32014-03-06 12:13:39 -0800111 kJdwpEventListLock,
112 kJdwpAttachLock,
113 kJdwpStartLock,
114 kRuntimeShutdownLock,
Jeff Hao69dbec62014-09-15 18:03:41 -0700115 kTraceLock,
Ian Rogers719d1a32014-03-06 12:13:39 -0800116 kHeapBitmapLock,
117 kMutatorLock,
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700118 kInstrumentEntrypointsLock,
Ian Rogers719d1a32014-03-06 12:13:39 -0800119 kZygoteCreationLock,
120
121 kLockLevelCount // Must come last.
122};
123std::ostream& operator<<(std::ostream& os, const LockLevel& rhs);
124
Brian Carlstrom2e250c82013-08-14 18:08:52 -0700125const bool kDebugLocking = kIsDebugBuild;
Ian Rogers25fd14b2012-09-05 10:56:38 -0700126
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700127// Record Log contention information, dumpable via SIGQUIT.
128#ifdef ART_USE_FUTEXES
Jeff Hao08f2e7b2013-09-09 16:44:02 -0700129// To enable lock contention logging, set this to true.
130const bool kLogLockContentions = false;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700131#else
132// Keep this false as lock contention logging is supported only with
133// futex.
134const bool kLogLockContentions = false;
135#endif
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700136const size_t kContentionLogSize = 4;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700137const size_t kContentionLogDataSize = kLogLockContentions ? 1 : 0;
138const size_t kAllMutexDataSize = kLogLockContentions ? 1 : 0;
139
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700140// Base class for all Mutex implementations
141class BaseMutex {
142 public:
Ian Rogersbab74962013-04-19 10:04:10 -0700143 const char* GetName() const {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700144 return name_;
145 }
146
147 virtual bool IsMutex() const { return false; }
148 virtual bool IsReaderWriterMutex() const { return false; }
Yu Lieac44242015-06-29 10:50:03 +0800149 virtual bool IsMutatorMutex() const { return false; }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700150
Ian Rogers56edc432013-01-18 16:51:51 -0800151 virtual void Dump(std::ostream& os) const = 0;
152
153 static void DumpAll(std::ostream& os);
154
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700155 protected:
156 friend class ConditionVariable;
157
Ian Rogers81d425b2012-09-27 16:03:43 -0700158 BaseMutex(const char* name, LockLevel level);
Ian Rogers56edc432013-01-18 16:51:51 -0800159 virtual ~BaseMutex();
Ian Rogers81d425b2012-09-27 16:03:43 -0700160 void RegisterAsLocked(Thread* self);
161 void RegisterAsUnlocked(Thread* self);
162 void CheckSafeToWait(Thread* self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700163
Ian Rogers56edc432013-01-18 16:51:51 -0800164 friend class ScopedContentionRecorder;
165
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700166 void RecordContention(uint64_t blocked_tid, uint64_t owner_tid, uint64_t nano_time_blocked);
Ian Rogers56edc432013-01-18 16:51:51 -0800167 void DumpContention(std::ostream& os) const;
168
Ian Rogers81d425b2012-09-27 16:03:43 -0700169 const LockLevel level_; // Support for lock hierarchy.
Ian Rogersbab74962013-04-19 10:04:10 -0700170 const char* const name_;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700171
Ian Rogers56edc432013-01-18 16:51:51 -0800172 // A log entry that records contention but makes no guarantee that either tid will be held live.
173 struct ContentionLogEntry {
174 ContentionLogEntry() : blocked_tid(0), owner_tid(0) {}
175 uint64_t blocked_tid;
176 uint64_t owner_tid;
177 AtomicInteger count;
178 };
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700179 struct ContentionLogData {
180 ContentionLogEntry contention_log[kContentionLogSize];
181 // The next entry in the contention log to be updated. Value ranges from 0 to
182 // kContentionLogSize - 1.
183 AtomicInteger cur_content_log_entry;
184 // Number of times the Mutex has been contended.
185 AtomicInteger contention_count;
186 // Sum of time waited by all contenders in ns.
Ian Rogers37f3c962014-07-17 11:25:30 -0700187 Atomic<uint64_t> wait_time;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700188 void AddToWaitTime(uint64_t value);
189 ContentionLogData() : wait_time(0) {}
190 };
Ian Rogers3e5cf302014-05-20 16:40:37 -0700191 ContentionLogData contention_log_data_[kContentionLogDataSize];
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700192
193 public:
194 bool HasEverContended() const {
195 if (kLogLockContentions) {
Ian Rogers3e5cf302014-05-20 16:40:37 -0700196 return contention_log_data_->contention_count.LoadSequentiallyConsistent() > 0;
Hiroshi Yamauchi1afde132013-08-06 17:09:30 -0700197 }
198 return false;
199 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700200};
201
202// A Mutex is used to achieve mutual exclusion between threads. A Mutex can be used to gain
203// exclusive access to what it guards. A Mutex can be in one of two states:
204// - Free - not owned by any thread,
205// - Exclusive - owned by a single thread.
206//
207// The effect of locking and unlocking operations on the state is:
208// State | ExclusiveLock | ExclusiveUnlock
209// -------------------------------------------
210// Free | Exclusive | error
211// Exclusive | Block* | Free
212// * Mutex is not reentrant and so an attempt to ExclusiveLock on the same thread will result in
213// an error. Being non-reentrant simplifies Waiting on ConditionVariables.
Ian Rogers01ae5802012-09-28 16:14:01 -0700214std::ostream& operator<<(std::ostream& os, const Mutex& mu);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700215class LOCKABLE Mutex : public BaseMutex {
216 public:
Ian Rogers81d425b2012-09-27 16:03:43 -0700217 explicit Mutex(const char* name, LockLevel level = kDefaultMutexLevel, bool recursive = false);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700218 ~Mutex();
219
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700220 virtual bool IsMutex() const { return true; }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700221
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700222 // Block until mutex is free then acquire exclusive access.
Mathieu Chartier90443472015-07-16 20:32:27 -0700223 void ExclusiveLock(Thread* self) ACQUIRE();
224 void Lock(Thread* self) ACQUIRE() { ExclusiveLock(self); }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700225
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700226 // Returns true if acquires exclusive access, false otherwise.
Mathieu Chartier90443472015-07-16 20:32:27 -0700227 bool ExclusiveTryLock(Thread* self) TRY_ACQUIRE(true);
228 bool TryLock(Thread* self) TRY_ACQUIRE(true) { return ExclusiveTryLock(self); }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700229
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700230 // Release exclusive access.
Mathieu Chartier90443472015-07-16 20:32:27 -0700231 void ExclusiveUnlock(Thread* self) RELEASE();
232 void Unlock(Thread* self) RELEASE() { ExclusiveUnlock(self); }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700233
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700234 // Is the current thread the exclusive holder of the Mutex.
Ian Rogers81d425b2012-09-27 16:03:43 -0700235 bool IsExclusiveHeld(const Thread* self) const;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700236
237 // Assert that the Mutex is exclusively held by the current thread.
Mathieu Chartier90443472015-07-16 20:32:27 -0700238 void AssertExclusiveHeld(const Thread* self) ASSERT_CAPABILITY(this) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000239 if (kDebugLocking && (gAborting == 0)) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700240 CHECK(IsExclusiveHeld(self)) << *this;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700241 }
242 }
Mathieu Chartier90443472015-07-16 20:32:27 -0700243 void AssertHeld(const Thread* self) ASSERT_CAPABILITY(this) { AssertExclusiveHeld(self); }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700244
245 // Assert that the Mutex is not held by the current thread.
Mathieu Chartier90443472015-07-16 20:32:27 -0700246 void AssertNotHeldExclusive(const Thread* self) ASSERT_CAPABILITY(!*this) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000247 if (kDebugLocking && (gAborting == 0)) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700248 CHECK(!IsExclusiveHeld(self)) << *this;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700249 }
250 }
Mathieu Chartier90443472015-07-16 20:32:27 -0700251 void AssertNotHeld(const Thread* self) ASSERT_CAPABILITY(!*this) {
252 AssertNotHeldExclusive(self);
253 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700254
Ian Rogersc7190692014-07-08 23:50:26 -0700255 // Id associated with exclusive owner. No memory ordering semantics if called from a thread other
256 // than the owner.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700257 uint64_t GetExclusiveOwnerTid() const;
258
259 // Returns how many times this Mutex has been locked, it is better to use AssertHeld/NotHeld.
260 unsigned int GetDepth() const {
261 return recursion_count_;
262 }
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700263
Ian Rogers56edc432013-01-18 16:51:51 -0800264 virtual void Dump(std::ostream& os) const;
Ian Rogers01ae5802012-09-28 16:14:01 -0700265
Mathieu Chartier90443472015-07-16 20:32:27 -0700266 // For negative capabilities in clang annotations.
267 const Mutex& operator!() const { return *this; }
268
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700269 private:
Ian Rogersc604d732012-10-14 16:09:54 -0700270#if ART_USE_FUTEXES
271 // 0 is unheld, 1 is held.
Ian Rogersc7190692014-07-08 23:50:26 -0700272 AtomicInteger state_;
Ian Rogersc604d732012-10-14 16:09:54 -0700273 // Exclusive owner.
274 volatile uint64_t exclusive_owner_;
275 // Number of waiting contenders.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800276 AtomicInteger num_contenders_;
Ian Rogersc604d732012-10-14 16:09:54 -0700277#else
Elliott Hughes8daa0922011-09-11 13:46:25 -0700278 pthread_mutex_t mutex_;
Ian Rogersc5f17732014-06-05 20:48:42 -0700279 volatile uint64_t exclusive_owner_; // Guarded by mutex_.
Ian Rogersc604d732012-10-14 16:09:54 -0700280#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700281 const bool recursive_; // Can the lock be recursively held?
282 unsigned int recursion_count_;
Elliott Hughesf1498432012-03-28 19:34:27 -0700283 friend class ConditionVariable;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700284 DISALLOW_COPY_AND_ASSIGN(Mutex);
285};
286
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700287// A ReaderWriterMutex is used to achieve mutual exclusion between threads, similar to a Mutex.
288// Unlike a Mutex a ReaderWriterMutex can be used to gain exclusive (writer) or shared (reader)
289// access to what it guards. A flaw in relation to a Mutex is that it cannot be used with a
290// condition variable. A ReaderWriterMutex can be in one of three states:
291// - Free - not owned by any thread,
292// - Exclusive - owned by a single thread,
293// - Shared(n) - shared amongst n threads.
294//
295// The effect of locking and unlocking operations on the state is:
296//
297// State | ExclusiveLock | ExclusiveUnlock | SharedLock | SharedUnlock
298// ----------------------------------------------------------------------------
299// Free | Exclusive | error | SharedLock(1) | error
300// Exclusive | Block | Free | Block | error
301// Shared(n) | Block | error | SharedLock(n+1)* | Shared(n-1) or Free
302// * for large values of n the SharedLock may block.
Ian Rogers01ae5802012-09-28 16:14:01 -0700303std::ostream& operator<<(std::ostream& os, const ReaderWriterMutex& mu);
Mathieu Chartier90443472015-07-16 20:32:27 -0700304class SHARED_LOCKABLE ReaderWriterMutex : public BaseMutex {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700305 public:
Ian Rogers81d425b2012-09-27 16:03:43 -0700306 explicit ReaderWriterMutex(const char* name, LockLevel level = kDefaultMutexLevel);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700307 ~ReaderWriterMutex();
308
309 virtual bool IsReaderWriterMutex() const { return true; }
310
311 // Block until ReaderWriterMutex is free then acquire exclusive access.
Mathieu Chartier90443472015-07-16 20:32:27 -0700312 void ExclusiveLock(Thread* self) ACQUIRE();
313 void WriterLock(Thread* self) ACQUIRE() { ExclusiveLock(self); }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700314
315 // Release exclusive access.
Mathieu Chartier90443472015-07-16 20:32:27 -0700316 void ExclusiveUnlock(Thread* self) RELEASE();
317 void WriterUnlock(Thread* self) RELEASE() { ExclusiveUnlock(self); }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700318
319 // Block until ReaderWriterMutex is free and acquire exclusive access. Returns true on success
320 // or false if timeout is reached.
Ian Rogers66aee5c2012-08-15 17:17:47 -0700321#if HAVE_TIMED_RWLOCK
Ian Rogersc604d732012-10-14 16:09:54 -0700322 bool ExclusiveLockWithTimeout(Thread* self, int64_t ms, int32_t ns)
Ian Rogers81d425b2012-09-27 16:03:43 -0700323 EXCLUSIVE_TRYLOCK_FUNCTION(true);
Ian Rogers66aee5c2012-08-15 17:17:47 -0700324#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700325
326 // Block until ReaderWriterMutex is shared or free then acquire a share on the access.
Mathieu Chartier90443472015-07-16 20:32:27 -0700327 void SharedLock(Thread* self) ACQUIRE_SHARED() ALWAYS_INLINE;
328 void ReaderLock(Thread* self) ACQUIRE_SHARED() { SharedLock(self); }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700329
330 // Try to acquire share of ReaderWriterMutex.
Mathieu Chartier90443472015-07-16 20:32:27 -0700331 bool SharedTryLock(Thread* self) SHARED_TRYLOCK_FUNCTION(true);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700332
333 // Release a share of the access.
Mathieu Chartier90443472015-07-16 20:32:27 -0700334 void SharedUnlock(Thread* self) RELEASE_SHARED() ALWAYS_INLINE;
335 void ReaderUnlock(Thread* self) RELEASE_SHARED() { SharedUnlock(self); }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700336
337 // Is the current thread the exclusive holder of the ReaderWriterMutex.
Ian Rogers81d425b2012-09-27 16:03:43 -0700338 bool IsExclusiveHeld(const Thread* self) const;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700339
340 // Assert the current thread has exclusive access to the ReaderWriterMutex.
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700341 void AssertExclusiveHeld(const Thread* self) ASSERT_CAPABILITY(this) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000342 if (kDebugLocking && (gAborting == 0)) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700343 CHECK(IsExclusiveHeld(self)) << *this;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700344 }
345 }
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700346 void AssertWriterHeld(const Thread* self) ASSERT_CAPABILITY(this) { AssertExclusiveHeld(self); }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700347
348 // Assert the current thread doesn't have exclusive access to the ReaderWriterMutex.
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700349 void AssertNotExclusiveHeld(const Thread* self) ASSERT_CAPABILITY(!this) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000350 if (kDebugLocking && (gAborting == 0)) {
Ian Rogerse3359f72013-06-11 15:14:11 -0700351 CHECK(!IsExclusiveHeld(self)) << *this;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700352 }
353 }
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700354 void AssertNotWriterHeld(const Thread* self) ASSERT_CAPABILITY(!this) {
355 AssertNotExclusiveHeld(self);
356 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700357
358 // Is the current thread a shared holder of the ReaderWriterMutex.
Ian Rogers81d425b2012-09-27 16:03:43 -0700359 bool IsSharedHeld(const Thread* self) const;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700360
361 // Assert the current thread has shared access to the ReaderWriterMutex.
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700362 void AssertSharedHeld(const Thread* self) ASSERT_SHARED_CAPABILITY(this) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000363 if (kDebugLocking && (gAborting == 0)) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700364 // TODO: we can only assert this well when self != null.
365 CHECK(IsSharedHeld(self) || self == nullptr) << *this;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700366 }
367 }
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700368 void AssertReaderHeld(const Thread* self) ASSERT_SHARED_CAPABILITY(this) {
369 AssertSharedHeld(self);
370 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700371
372 // Assert the current thread doesn't hold this ReaderWriterMutex either in shared or exclusive
373 // mode.
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700374 void AssertNotHeld(const Thread* self) ASSERT_SHARED_CAPABILITY(!this) {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000375 if (kDebugLocking && (gAborting == 0)) {
Ian Rogers01ae5802012-09-28 16:14:01 -0700376 CHECK(!IsSharedHeld(self)) << *this;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700377 }
Elliott Hughes8daa0922011-09-11 13:46:25 -0700378 }
379
Ian Rogersc7190692014-07-08 23:50:26 -0700380 // Id associated with exclusive owner. No memory ordering semantics if called from a thread other
381 // than the owner.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700382 uint64_t GetExclusiveOwnerTid() const;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700383
Ian Rogers56edc432013-01-18 16:51:51 -0800384 virtual void Dump(std::ostream& os) const;
Ian Rogers01ae5802012-09-28 16:14:01 -0700385
Mathieu Chartier90443472015-07-16 20:32:27 -0700386 // For negative capabilities in clang annotations.
387 const ReaderWriterMutex& operator!() const { return *this; }
388
Ian Rogers81d425b2012-09-27 16:03:43 -0700389 private:
Ian Rogers51d212e2014-10-23 17:48:20 -0700390#if ART_USE_FUTEXES
Ian Rogerscf7f1912014-10-22 22:06:39 -0700391 // Out-of-inline path for handling contention for a SharedLock.
392 void HandleSharedLockContention(Thread* self, int32_t cur_state);
393
Ian Rogers81d425b2012-09-27 16:03:43 -0700394 // -1 implies held exclusive, +ve shared held by state_ many owners.
Ian Rogersc7190692014-07-08 23:50:26 -0700395 AtomicInteger state_;
396 // Exclusive owner. Modification guarded by this mutex.
Ian Rogers81d425b2012-09-27 16:03:43 -0700397 volatile uint64_t exclusive_owner_;
Ian Rogersc7190692014-07-08 23:50:26 -0700398 // Number of contenders waiting for a reader share.
399 AtomicInteger num_pending_readers_;
400 // Number of contenders waiting to be the writer.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800401 AtomicInteger num_pending_writers_;
Ian Rogers81d425b2012-09-27 16:03:43 -0700402#else
403 pthread_rwlock_t rwlock_;
Ian Rogersc5f17732014-06-05 20:48:42 -0700404 volatile uint64_t exclusive_owner_; // Guarded by rwlock_.
Ian Rogers81d425b2012-09-27 16:03:43 -0700405#endif
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700406 DISALLOW_COPY_AND_ASSIGN(ReaderWriterMutex);
407};
408
Yu Lieac44242015-06-29 10:50:03 +0800409// MutatorMutex is a special kind of ReaderWriterMutex created specifically for the
410// Locks::mutator_lock_ mutex. The behaviour is identical to the ReaderWriterMutex except that
411// thread state changes also play a part in lock ownership. The mutator_lock_ will not be truly
412// held by any mutator threads. However, a thread in the kRunnable state is considered to have
413// shared ownership of the mutator lock and therefore transitions in and out of the kRunnable
414// state have associated implications on lock ownership. Extra methods to handle the state
415// transitions have been added to the interface but are only accessible to the methods dealing
416// with state transitions. The thread state and flags attributes are used to ensure thread state
417// transitions are consistent with the permitted behaviour of the mutex.
418//
419// *) The most important consequence of this behaviour is that all threads must be in one of the
420// suspended states before exclusive ownership of the mutator mutex is sought.
421//
422std::ostream& operator<<(std::ostream& os, const MutatorMutex& mu);
Mathieu Chartier90443472015-07-16 20:32:27 -0700423class SHARED_LOCKABLE MutatorMutex : public ReaderWriterMutex {
Yu Lieac44242015-06-29 10:50:03 +0800424 public:
425 explicit MutatorMutex(const char* name, LockLevel level = kDefaultMutexLevel)
426 : ReaderWriterMutex(name, level) {}
427 ~MutatorMutex() {}
428
429 virtual bool IsMutatorMutex() const { return true; }
430
Mathieu Chartier90443472015-07-16 20:32:27 -0700431 // For negative capabilities in clang annotations.
432 const MutatorMutex& operator!() const { return *this; }
433
Yu Lieac44242015-06-29 10:50:03 +0800434 private:
435 friend class Thread;
436 void TransitionFromRunnableToSuspended(Thread* self) UNLOCK_FUNCTION() ALWAYS_INLINE;
437 void TransitionFromSuspendedToRunnable(Thread* self) SHARED_LOCK_FUNCTION() ALWAYS_INLINE;
438
439 DISALLOW_COPY_AND_ASSIGN(MutatorMutex);
440};
441
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700442// ConditionVariables allow threads to queue and sleep. Threads may then be resumed individually
443// (Signal) or all at once (Broadcast).
Elliott Hughes5f791332011-09-15 17:45:30 -0700444class ConditionVariable {
445 public:
Roland Levillain3887c462015-08-12 18:15:42 +0100446 ConditionVariable(const char* name, Mutex& mutex);
Elliott Hughes5f791332011-09-15 17:45:30 -0700447 ~ConditionVariable();
448
Ian Rogersc604d732012-10-14 16:09:54 -0700449 void Broadcast(Thread* self);
450 void Signal(Thread* self);
451 // TODO: No thread safety analysis on Wait and TimedWait as they call mutex operations via their
452 // pointer copy, thereby defeating annotalysis.
453 void Wait(Thread* self) NO_THREAD_SAFETY_ANALYSIS;
Ian Rogers7b078e82014-09-10 14:44:24 -0700454 bool TimedWait(Thread* self, int64_t ms, int32_t ns) NO_THREAD_SAFETY_ANALYSIS;
Ian Rogers1d54e732013-05-02 21:10:01 -0700455 // Variant of Wait that should be used with caution. Doesn't validate that no mutexes are held
456 // when waiting.
457 // TODO: remove this.
458 void WaitHoldingLocks(Thread* self) NO_THREAD_SAFETY_ANALYSIS;
Elliott Hughes5f791332011-09-15 17:45:30 -0700459
460 private:
Ian Rogers23055dc2013-04-18 16:29:16 -0700461 const char* const name_;
Ian Rogersc604d732012-10-14 16:09:54 -0700462 // The Mutex being used by waiters. It is an error to mix condition variables between different
463 // Mutexes.
464 Mutex& guard_;
465#if ART_USE_FUTEXES
466 // A counter that is modified by signals and broadcasts. This ensures that when a waiter gives up
Ian Rogersd45f2012012-11-28 11:46:23 -0800467 // their Mutex and another thread takes it and signals, the waiting thread observes that sequence_
468 // changed and doesn't enter the wait. Modified while holding guard_, but is read by futex wait
469 // without guard_ held.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800470 AtomicInteger sequence_;
Ian Rogersc604d732012-10-14 16:09:54 -0700471 // Number of threads that have come into to wait, not the length of the waiters on the futex as
Ian Rogers5bd97c42012-11-27 02:38:26 -0800472 // waiters may have been requeued onto guard_. Guarded by guard_.
Ian Rogersc604d732012-10-14 16:09:54 -0700473 volatile int32_t num_waiters_;
Ian Rogersc604d732012-10-14 16:09:54 -0700474#else
475 pthread_cond_t cond_;
476#endif
Elliott Hughes5f791332011-09-15 17:45:30 -0700477 DISALLOW_COPY_AND_ASSIGN(ConditionVariable);
478};
479
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700480// Scoped locker/unlocker for a regular Mutex that acquires mu upon construction and releases it
481// upon destruction.
Mathieu Chartier90443472015-07-16 20:32:27 -0700482class SCOPED_CAPABILITY MutexLock {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700483 public:
Roland Levillain3887c462015-08-12 18:15:42 +0100484 MutexLock(Thread* self, Mutex& mu) ACQUIRE(mu) : self_(self), mu_(mu) {
Ian Rogers81d425b2012-09-27 16:03:43 -0700485 mu_.ExclusiveLock(self_);
486 }
487
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700488 ~MutexLock() RELEASE() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700489 mu_.ExclusiveUnlock(self_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700490 }
491
492 private:
Ian Rogers81d425b2012-09-27 16:03:43 -0700493 Thread* const self_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700494 Mutex& mu_;
495 DISALLOW_COPY_AND_ASSIGN(MutexLock);
496};
497// Catch bug where variable name is omitted. "MutexLock (lock);" instead of "MutexLock mu(lock)".
Andreas Gampe575e78c2014-11-03 23:41:03 -0800498#define MutexLock(x) static_assert(0, "MutexLock declaration missing variable name")
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700499
500// Scoped locker/unlocker for a ReaderWriterMutex that acquires read access to mu upon
501// construction and releases it upon destruction.
Mathieu Chartier90443472015-07-16 20:32:27 -0700502class SCOPED_CAPABILITY ReaderMutexLock {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700503 public:
Roland Levillain3887c462015-08-12 18:15:42 +0100504 ReaderMutexLock(Thread* self, ReaderWriterMutex& mu) ACQUIRE(mu) :
Ian Rogers81d425b2012-09-27 16:03:43 -0700505 self_(self), mu_(mu) {
506 mu_.SharedLock(self_);
507 }
508
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700509 ~ReaderMutexLock() RELEASE() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700510 mu_.SharedUnlock(self_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700511 }
512
513 private:
Ian Rogers81d425b2012-09-27 16:03:43 -0700514 Thread* const self_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700515 ReaderWriterMutex& mu_;
516 DISALLOW_COPY_AND_ASSIGN(ReaderMutexLock);
517};
518// Catch bug where variable name is omitted. "ReaderMutexLock (lock);" instead of
519// "ReaderMutexLock mu(lock)".
Andreas Gampe575e78c2014-11-03 23:41:03 -0800520#define ReaderMutexLock(x) static_assert(0, "ReaderMutexLock declaration missing variable name")
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700521
522// Scoped locker/unlocker for a ReaderWriterMutex that acquires write access to mu upon
523// construction and releases it upon destruction.
Mathieu Chartier90443472015-07-16 20:32:27 -0700524class SCOPED_CAPABILITY WriterMutexLock {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700525 public:
Roland Levillain3887c462015-08-12 18:15:42 +0100526 WriterMutexLock(Thread* self, ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) :
Ian Rogers81d425b2012-09-27 16:03:43 -0700527 self_(self), mu_(mu) {
528 mu_.ExclusiveLock(self_);
529 }
530
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700531 ~WriterMutexLock() UNLOCK_FUNCTION() {
Ian Rogers81d425b2012-09-27 16:03:43 -0700532 mu_.ExclusiveUnlock(self_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700533 }
534
535 private:
Ian Rogers50b35e22012-10-04 10:09:15 -0700536 Thread* const self_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700537 ReaderWriterMutex& mu_;
538 DISALLOW_COPY_AND_ASSIGN(WriterMutexLock);
539};
540// Catch bug where variable name is omitted. "WriterMutexLock (lock);" instead of
541// "WriterMutexLock mu(lock)".
Andreas Gampe575e78c2014-11-03 23:41:03 -0800542#define WriterMutexLock(x) static_assert(0, "WriterMutexLock declaration missing variable name")
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700543
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700544// For StartNoThreadSuspension and EndNoThreadSuspension.
545class CAPABILITY("role") Role {
546 public:
547 void Acquire() ACQUIRE() {}
548 void Release() RELEASE() {}
549 const Role& operator!() const { return *this; }
550};
551
552class Uninterruptible : public Role {
553};
554
Ian Rogers719d1a32014-03-06 12:13:39 -0800555// Global mutexes corresponding to the levels above.
556class Locks {
557 public:
558 static void Init();
Mathieu Chartier91e56692015-03-03 13:51:04 -0800559 static void InitConditions() NO_THREAD_SAFETY_ANALYSIS; // Condition variables.
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700560 // Guards allocation entrypoint instrumenting.
Ian Rogers4ad5cd32014-11-11 23:08:07 -0800561 static Mutex* instrument_entrypoints_lock_;
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700562
Yu Lieac44242015-06-29 10:50:03 +0800563 // A barrier is used to synchronize the GC/Debugger thread with mutator threads. When GC/Debugger
564 // thread wants to suspend all mutator threads, it needs to wait for all mutator threads to pass
565 // a barrier. Threads that are already suspended will get their barrier passed by the GC/Debugger
566 // thread; threads in the runnable state will pass the barrier when they transit to the suspended
567 // state. GC/Debugger thread will be woken up when all mutator threads are suspended.
Ian Rogers719d1a32014-03-06 12:13:39 -0800568 //
569 // Thread suspension:
Yu Lieac44242015-06-29 10:50:03 +0800570 // mutator thread | GC/Debugger
571 // .. running .. | .. running ..
Ian Rogers719d1a32014-03-06 12:13:39 -0800572 // .. running .. | Request thread suspension by:
573 // .. running .. | - acquiring thread_suspend_count_lock_
574 // .. running .. | - incrementing Thread::suspend_count_ on
575 // .. running .. | all mutator threads
576 // .. running .. | - releasing thread_suspend_count_lock_
Yu Lieac44242015-06-29 10:50:03 +0800577 // .. running .. | Block wait for all threads to pass a barrier
Ian Rogers719d1a32014-03-06 12:13:39 -0800578 // Poll Thread::suspend_count_ and enter full | .. blocked ..
579 // suspend code. | .. blocked ..
Yu Lieac44242015-06-29 10:50:03 +0800580 // Change state to kSuspended (pass the barrier) | Wake up when all threads pass the barrier
581 // x: Acquire thread_suspend_count_lock_ | .. running ..
582 // while Thread::suspend_count_ > 0 | .. running ..
583 // - wait on Thread::resume_cond_ | .. running ..
584 // (releases thread_suspend_count_lock_) | .. running ..
Ian Rogers719d1a32014-03-06 12:13:39 -0800585 // .. waiting .. | Request thread resumption by:
586 // .. waiting .. | - acquiring thread_suspend_count_lock_
587 // .. waiting .. | - decrementing Thread::suspend_count_ on
588 // .. waiting .. | all mutator threads
589 // .. waiting .. | - notifying on Thread::resume_cond_
590 // - re-acquire thread_suspend_count_lock_ | - releasing thread_suspend_count_lock_
591 // Release thread_suspend_count_lock_ | .. running ..
Yu Lieac44242015-06-29 10:50:03 +0800592 // Change to kRunnable | .. running ..
593 // - this uses a CAS operation to ensure the | .. running ..
594 // suspend request flag isn't raised as the | .. running ..
595 // state is changed | .. running ..
596 // - if the CAS operation fails then goto x | .. running ..
Ian Rogers719d1a32014-03-06 12:13:39 -0800597 // .. running .. | .. running ..
Yu Lieac44242015-06-29 10:50:03 +0800598 static MutatorMutex* mutator_lock_ ACQUIRED_AFTER(instrument_entrypoints_lock_);
Ian Rogers719d1a32014-03-06 12:13:39 -0800599
600 // Allow reader-writer mutual exclusion on the mark and live bitmaps of the heap.
601 static ReaderWriterMutex* heap_bitmap_lock_ ACQUIRED_AFTER(mutator_lock_);
602
603 // Guards shutdown of the runtime.
604 static Mutex* runtime_shutdown_lock_ ACQUIRED_AFTER(heap_bitmap_lock_);
605
Chao-ying Fu9e369312014-05-21 11:20:52 -0700606 // Guards background profiler global state.
607 static Mutex* profiler_lock_ ACQUIRED_AFTER(runtime_shutdown_lock_);
608
609 // Guards trace (ie traceview) requests.
610 static Mutex* trace_lock_ ACQUIRED_AFTER(profiler_lock_);
611
Brian Carlstrom306db812014-09-05 13:01:41 -0700612 // Guards debugger recent allocation records.
613 static Mutex* alloc_tracker_lock_ ACQUIRED_AFTER(trace_lock_);
614
615 // Guards updates to instrumentation to ensure mutual exclusion of
616 // events like deoptimization requests.
617 // TODO: improve name, perhaps instrumentation_update_lock_.
618 static Mutex* deoptimization_lock_ ACQUIRED_AFTER(alloc_tracker_lock_);
619
Jeff Haoa2c38642015-09-17 17:29:01 -0700620 // Guards String initializer register map in interpreter.
621 static Mutex* interpreter_string_init_map_lock_ ACQUIRED_AFTER(deoptimization_lock_);
622
Ian Rogers719d1a32014-03-06 12:13:39 -0800623 // The thread_list_lock_ guards ThreadList::list_. It is also commonly held to stop threads
624 // attaching and detaching.
Jeff Haoa2c38642015-09-17 17:29:01 -0700625 static Mutex* thread_list_lock_ ACQUIRED_AFTER(interpreter_string_init_map_lock_);
Ian Rogers719d1a32014-03-06 12:13:39 -0800626
Mathieu Chartier91e56692015-03-03 13:51:04 -0800627 // Signaled when threads terminate. Used to determine when all non-daemons have terminated.
628 static ConditionVariable* thread_exit_cond_ GUARDED_BY(Locks::thread_list_lock_);
629
Ian Rogers68d8b422014-07-17 11:09:10 -0700630 // Guards maintaining loading library data structures.
631 static Mutex* jni_libraries_lock_ ACQUIRED_AFTER(thread_list_lock_);
632
Ian Rogers719d1a32014-03-06 12:13:39 -0800633 // Guards breakpoints.
Sebastien Hertzed2be172014-08-19 15:33:43 +0200634 static ReaderWriterMutex* breakpoint_lock_ ACQUIRED_AFTER(jni_libraries_lock_);
Ian Rogers719d1a32014-03-06 12:13:39 -0800635
Ian Rogers719d1a32014-03-06 12:13:39 -0800636 // Guards lists of classes within the class linker.
Chao-ying Fu9e369312014-05-21 11:20:52 -0700637 static ReaderWriterMutex* classlinker_classes_lock_ ACQUIRED_AFTER(breakpoint_lock_);
Ian Rogers719d1a32014-03-06 12:13:39 -0800638
639 // When declaring any Mutex add DEFAULT_MUTEX_ACQUIRED_AFTER to use annotalysis to check the code
640 // doesn't try to hold a higher level Mutex.
Mathieu Chartier12d625f2015-03-13 11:33:37 -0700641 #define DEFAULT_MUTEX_ACQUIRED_AFTER ACQUIRED_AFTER(Locks::classlinker_classes_lock_)
Ian Rogers719d1a32014-03-06 12:13:39 -0800642
Andreas Gampe74240812014-04-17 10:35:09 -0700643 static Mutex* allocated_monitor_ids_lock_ ACQUIRED_AFTER(classlinker_classes_lock_);
644
Chao-ying Fu9e369312014-05-21 11:20:52 -0700645 // Guard the allocation/deallocation of thread ids.
Andreas Gampe74240812014-04-17 10:35:09 -0700646 static Mutex* allocated_thread_ids_lock_ ACQUIRED_AFTER(allocated_monitor_ids_lock_);
Chao-ying Fu9e369312014-05-21 11:20:52 -0700647
648 // Guards modification of the LDT on x86.
649 static Mutex* modify_ldt_lock_ ACQUIRED_AFTER(allocated_thread_ids_lock_);
650
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700651 // Guards opened oat files in OatFileManager.
652 static ReaderWriterMutex* oat_file_manager_lock_ ACQUIRED_AFTER(modify_ldt_lock_);
653
Mathieu Chartiere58991b2015-10-13 07:59:34 -0700654 // Guards opened oat files in OatFileManager.
655 static ReaderWriterMutex* oat_file_count_lock_ ACQUIRED_AFTER(oat_file_manager_lock_);
656
Ian Rogers719d1a32014-03-06 12:13:39 -0800657 // Guards intern table.
Mathieu Chartiere58991b2015-10-13 07:59:34 -0700658 static Mutex* intern_table_lock_ ACQUIRED_AFTER(oat_file_count_lock_);
Ian Rogers719d1a32014-03-06 12:13:39 -0800659
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -0700660 // Guards reference processor.
661 static Mutex* reference_processor_lock_ ACQUIRED_AFTER(intern_table_lock_);
662
663 // Guards cleared references queue.
664 static Mutex* reference_queue_cleared_references_lock_ ACQUIRED_AFTER(reference_processor_lock_);
665
666 // Guards weak references queue.
667 static Mutex* reference_queue_weak_references_lock_ ACQUIRED_AFTER(reference_queue_cleared_references_lock_);
668
669 // Guards finalizer references queue.
670 static Mutex* reference_queue_finalizer_references_lock_ ACQUIRED_AFTER(reference_queue_weak_references_lock_);
671
672 // Guards phantom references queue.
673 static Mutex* reference_queue_phantom_references_lock_ ACQUIRED_AFTER(reference_queue_finalizer_references_lock_);
674
675 // Guards soft references queue.
676 static Mutex* reference_queue_soft_references_lock_ ACQUIRED_AFTER(reference_queue_phantom_references_lock_);
677
Ian Rogers719d1a32014-03-06 12:13:39 -0800678 // Have an exclusive aborting thread.
Mathieu Chartiera5a53ef2014-09-12 12:58:05 -0700679 static Mutex* abort_lock_ ACQUIRED_AFTER(reference_queue_soft_references_lock_);
Ian Rogers719d1a32014-03-06 12:13:39 -0800680
681 // Allow mutual exclusion when manipulating Thread::suspend_count_.
682 // TODO: Does the trade-off of a per-thread lock make sense?
683 static Mutex* thread_suspend_count_lock_ ACQUIRED_AFTER(abort_lock_);
684
685 // One unexpected signal at a time lock.
686 static Mutex* unexpected_signal_lock_ ACQUIRED_AFTER(thread_suspend_count_lock_);
687
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700688 // Guards the maps in mem_map.
689 static Mutex* mem_maps_lock_ ACQUIRED_AFTER(unexpected_signal_lock_);
690
Ian Rogers719d1a32014-03-06 12:13:39 -0800691 // Have an exclusive logging thread.
692 static Mutex* logging_lock_ ACQUIRED_AFTER(unexpected_signal_lock_);
Igor Murashkine2facc52015-07-10 13:49:08 -0700693
694 // Allow reader-writer mutual exclusion on the boxed table of lambda objects.
695 // TODO: this should be a RW mutex lock, except that ConditionVariables don't work with it.
696 static Mutex* lambda_table_lock_ ACQUIRED_AFTER(mutator_lock_);
Ian Rogers719d1a32014-03-06 12:13:39 -0800697};
698
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700699class Roles {
700 public:
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700701 // Uninterruptible means that the thread may not become suspended.
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700702 static Uninterruptible uninterruptible_;
703};
704
Elliott Hughes8daa0922011-09-11 13:46:25 -0700705} // namespace art
706
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700707#endif // ART_RUNTIME_BASE_MUTEX_H_