mutex.h revision 4e2cb098017bf073335ebb02b1bc0a36828cd720
18daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes/* 28daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * Copyright (C) 2011 The Android Open Source Project 38daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * 48daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * Licensed under the Apache License, Version 2.0 (the "License"); 58daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * you may not use this file except in compliance with the License. 68daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * You may obtain a copy of the License at 78daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * 88daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * http://www.apache.org/licenses/LICENSE-2.0 98daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * 108daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * Unless required by applicable law or agreed to in writing, software 118daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * distributed under the License is distributed on an "AS IS" BASIS, 128daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 138daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * See the License for the specific language governing permissions and 148daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes * limitations under the License. 158daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes */ 168daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 17fc0e3219edc9a5bf81b166e82fd5db2796eb6a0dBrian Carlstrom#ifndef ART_RUNTIME_BASE_MUTEX_H_ 18fc0e3219edc9a5bf81b166e82fd5db2796eb6a0dBrian Carlstrom#define ART_RUNTIME_BASE_MUTEX_H_ 198daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 208daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes#include <pthread.h> 21cd74c4b3a6893c876c6e03fd99a1264249653d80Brian Carlstrom#include <stdint.h> 22ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes 23ffb465f23d9549dd591e6aa62e9250523cb00233Elliott Hughes#include <iosfwd> 248daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes#include <string> 258daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 26ef7d42fca18c16fbaf103822ad16f23246e2905dIan Rogers#include "atomic.h" 2707ed66b5ae659c452cbe1ab20c3dbf1d6f546461Elliott Hughes#include "base/logging.h" 28761600567d73b23324ae0251e871c15d6849ffd8Elliott Hughes#include "base/macros.h" 2900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers#include "globals.h" 3081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 31ab47016374d340011680e9cd970ee7d6225d6704Ian Rogers#if defined(__APPLE__) 3281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers#define ART_USE_FUTEXES 0 33ab47016374d340011680e9cd970ee7d6225d6704Ian Rogers#else 34c01417898a6e4f8a5663d6c0556982488c133cdfChris Dearman#define ART_USE_FUTEXES 1 35ab47016374d340011680e9cd970ee7d6225d6704Ian Rogers#endif 368daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 3766aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers// Currently Darwin doesn't support locks with timeouts. 3866aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#if !defined(__APPLE__) 3966aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#define HAVE_TIMED_RWLOCK 1 4066aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#else 4166aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#define HAVE_TIMED_RWLOCK 0 4266aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#endif 4366aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers 448daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughesnamespace art { 458daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 4690443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartierclass SHARED_LOCKABLE ReaderWriterMutex; 4790443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartierclass SHARED_LOCKABLE MutatorMutex; 4856edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogersclass ScopedContentionRecorder; 4950b35e2fd1a68cd1240e4a9d9f363e11764957d1Ian Rogersclass Thread; 5050b35e2fd1a68cd1240e4a9d9f363e11764957d1Ian Rogers 51719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// LockLevel is used to impose a lock hierarchy [1] where acquisition of a Mutex at a higher or 52719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// equal level to a lock a thread holds is invalid. The lock hierarchy achieves a cycle free 53719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// partial ordering and thereby cause deadlock situations to fail checks. 54719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// 55719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// [1] http://www.drdobbs.com/parallel/use-lock-hierarchies-to-avoid-deadlock/204801163 56719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersenum LockLevel { 57719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kLoggingLock = 0, 583eed93dd5be03e5539827bebf0f414251a12e15eHiroshi Yamauchi kMemMapsLock, 597de77dd4f2d3cbb0615ee001589eb99ae82c3dccRaghu Gandham kSwapMutexesLock, 60719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kUnexpectedSignalLock, 61719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kThreadSuspendCountLock, 62719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kAbortLock, 63e2facc5b18cd756a8b5500fb3d90da69c9ee0fb7Igor Murashkin kLambdaTableLock, 64719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpSocketLock, 652cd334ae2d4287216523882f0d298cf3901b7ab1Hiroshi Yamauchi kRegionSpaceRegionLock, 66310008008c90fea246efd00cb99ee7ded97c5209Mathieu Chartier kTransactionLogLock, 67a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueueSoftReferencesLock, 68a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueuePhantomReferencesLock, 69a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueueFinalizerReferencesLock, 70a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueueWeakReferencesLock, 71a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueueClearedReferencesLock, 72a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceProcessorLock, 73e5f13e57ff8fa36342beb33830b3ec5942a61ccaMathieu Chartier kJitCodeCacheLock, 74719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kRosAllocGlobalLock, 75719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kRosAllocBracketLock, 76719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kRosAllocBulkFreeLock, 77719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kAllocSpaceLock, 782cd334ae2d4287216523882f0d298cf3901b7ab1Hiroshi Yamauchi kBumpPointerSpaceBlockLock, 79c785344b87221f5e4e6473e5b762e4e61fe65dcfMathieu Chartier kArenaPoolLock, 80719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kDexFileMethodInlinerLock, 81719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kDexFileToMethodInlinerMapLock, 82719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kMarkSweepMarkStackLock, 83719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kInternTableLock, 843f5838d7d0b9fc63db0ccc35c2ea05ed29264986Vladimir Marko kOatFileSecondaryLookupLock, 857526d783ab68ed1dd53c763c75895cb432532b0fAndreas Gampe kTracingUniqueMethodsLock, 867526d783ab68ed1dd53c763c75895cb432532b0fAndreas Gampe kTracingStreamingLock, 87719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kDefaultMutexLevel, 88719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kMarkSweepLargeObjectLock, 89719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kPinTableLock, 90719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpObjectRegistryLock, 919e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu kModifyLdtLock, 929e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu kAllocatedThreadIdsLock, 9374240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe kMonitorPoolLock, 942435a43f6c851c23922d8508fb17c6079248201cbowen_lai kMethodVerifiersLock, 95719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kClassLinkerClassesLock, 96719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kBreakpointLock, 97719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kMonitorLock, 98440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier kMonitorListLock, 9968d8b42ddec39ec0174162d90d4abaa004d1983eIan Rogers kJniLoadLibraryLock, 100719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kThreadListLock, 101306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom kAllocTrackerLock, 102719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kDeoptimizationLock, 103719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kProfilerLock, 1044e5b20863898006ec6c9d120cda167d38dda6e60Sebastien Hertz kJdwpShutdownLock, 105719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpEventListLock, 106719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpAttachLock, 107719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpStartLock, 108719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kRuntimeShutdownLock, 10969dbec6d9d55eeb2867949c2791d01dc9aa916c8Jeff Hao kTraceLock, 110719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kHeapBitmapLock, 111719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kMutatorLock, 1129ef78b59da51080882e47505896b420977fd79aeMathieu Chartier kInstrumentEntrypointsLock, 113719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kZygoteCreationLock, 114719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 115719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kLockLevelCount // Must come last. 116719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers}; 117719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersstd::ostream& operator<<(std::ostream& os, const LockLevel& rhs); 118719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 1192e250c826b3c405d675017efe79e5db3651c9ee6Brian Carlstromconst bool kDebugLocking = kIsDebugBuild; 12025fd14b87cced64a179dee885573113be5e11944Ian Rogers 1211afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi// Record Log contention information, dumpable via SIGQUIT. 1221afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi#ifdef ART_USE_FUTEXES 12308f2e7b59fab9df108d3d91e6eeb4bbccbb325d1Jeff Hao// To enable lock contention logging, set this to true. 12408f2e7b59fab9df108d3d91e6eeb4bbccbb325d1Jeff Haoconst bool kLogLockContentions = false; 1251afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi#else 1261afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi// Keep this false as lock contention logging is supported only with 1271afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi// futex. 1281afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchiconst bool kLogLockContentions = false; 1291afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi#endif 130d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogersconst size_t kContentionLogSize = 4; 1311afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchiconst size_t kContentionLogDataSize = kLogLockContentions ? 1 : 0; 1321afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchiconst size_t kAllMutexDataSize = kLogLockContentions ? 1 : 0; 1331afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi 13400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Base class for all Mutex implementations 13500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersclass BaseMutex { 13600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 137bab74963db2484ea5f10a82ea26e8a99722bfefeIan Rogers const char* GetName() const { 13800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers return name_; 13900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 14000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 14100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers virtual bool IsMutex() const { return false; } 14200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers virtual bool IsReaderWriterMutex() const { return false; } 143eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li virtual bool IsMutatorMutex() const { return false; } 14400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 14556edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers virtual void Dump(std::ostream& os) const = 0; 14656edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers 14756edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers static void DumpAll(std::ostream& os); 14856edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers 14900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers protected: 15000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers friend class ConditionVariable; 15100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 15281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers BaseMutex(const char* name, LockLevel level); 15356edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers virtual ~BaseMutex(); 15481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void RegisterAsLocked(Thread* self); 15581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void RegisterAsUnlocked(Thread* self); 15681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void CheckSafeToWait(Thread* self); 15700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 15856edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers friend class ScopedContentionRecorder; 15956edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers 1601afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi void RecordContention(uint64_t blocked_tid, uint64_t owner_tid, uint64_t nano_time_blocked); 16156edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers void DumpContention(std::ostream& os) const; 16256edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers 16381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers const LockLevel level_; // Support for lock hierarchy. 164bab74963db2484ea5f10a82ea26e8a99722bfefeIan Rogers const char* const name_; 1651afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi 16656edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers // A log entry that records contention but makes no guarantee that either tid will be held live. 16756edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers struct ContentionLogEntry { 16856edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers ContentionLogEntry() : blocked_tid(0), owner_tid(0) {} 16956edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers uint64_t blocked_tid; 17056edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers uint64_t owner_tid; 17156edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers AtomicInteger count; 17256edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers }; 1731afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi struct ContentionLogData { 1741afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi ContentionLogEntry contention_log[kContentionLogSize]; 1751afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi // The next entry in the contention log to be updated. Value ranges from 0 to 1761afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi // kContentionLogSize - 1. 1771afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi AtomicInteger cur_content_log_entry; 1781afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi // Number of times the Mutex has been contended. 1791afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi AtomicInteger contention_count; 1801afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi // Sum of time waited by all contenders in ns. 18137f3c968ecd04e77802fe17bb82dabc07de21ca1Ian Rogers Atomic<uint64_t> wait_time; 1821afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi void AddToWaitTime(uint64_t value); 1831afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi ContentionLogData() : wait_time(0) {} 1841afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi }; 1853e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers ContentionLogData contention_log_data_[kContentionLogDataSize]; 1861afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi 1871afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi public: 1881afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi bool HasEverContended() const { 1891afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi if (kLogLockContentions) { 1903e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers return contention_log_data_->contention_count.LoadSequentiallyConsistent() > 0; 1911afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi } 1921afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi return false; 1931afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi } 19400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers}; 19500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 19600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// A Mutex is used to achieve mutual exclusion between threads. A Mutex can be used to gain 19700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// exclusive access to what it guards. A Mutex can be in one of two states: 19800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Free - not owned by any thread, 19900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Exclusive - owned by a single thread. 20000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// 20100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// The effect of locking and unlocking operations on the state is: 20200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// State | ExclusiveLock | ExclusiveUnlock 20300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// ------------------------------------------- 20400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Free | Exclusive | error 20500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Exclusive | Block* | Free 20600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// * Mutex is not reentrant and so an attempt to ExclusiveLock on the same thread will result in 20700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// an error. Being non-reentrant simplifies Waiting on ConditionVariables. 20801ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogersstd::ostream& operator<<(std::ostream& os, const Mutex& mu); 20900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersclass LOCKABLE Mutex : public BaseMutex { 21000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 21181d425b0b232962441616f8b14f73620bffef5e5Ian Rogers explicit Mutex(const char* name, LockLevel level = kDefaultMutexLevel, bool recursive = false); 21200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ~Mutex(); 21300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 21400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers virtual bool IsMutex() const { return true; } 21500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 21600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Block until mutex is free then acquire exclusive access. 21790443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void ExclusiveLock(Thread* self) ACQUIRE(); 21890443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void Lock(Thread* self) ACQUIRE() { ExclusiveLock(self); } 21900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 22000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Returns true if acquires exclusive access, false otherwise. 22190443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier bool ExclusiveTryLock(Thread* self) TRY_ACQUIRE(true); 22290443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier bool TryLock(Thread* self) TRY_ACQUIRE(true) { return ExclusiveTryLock(self); } 22300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 22400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Release exclusive access. 22590443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void ExclusiveUnlock(Thread* self) RELEASE(); 22690443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void Unlock(Thread* self) RELEASE() { ExclusiveUnlock(self); } 22700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 22800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Is the current thread the exclusive holder of the Mutex. 22981d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool IsExclusiveHeld(const Thread* self) const; 2308daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 23100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert that the Mutex is exclusively held by the current thread. 23290443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void AssertExclusiveHeld(const Thread* self) ASSERT_CAPABILITY(this) { 233db978719dbcb73fc6acfd193561445c4462786b8Nicolas Geoffray if (kDebugLocking && (gAborting == 0)) { 23401ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers CHECK(IsExclusiveHeld(self)) << *this; 23500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 23600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 23790443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void AssertHeld(const Thread* self) ASSERT_CAPABILITY(this) { AssertExclusiveHeld(self); } 23800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 23900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert that the Mutex is not held by the current thread. 24090443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void AssertNotHeldExclusive(const Thread* self) ASSERT_CAPABILITY(!*this) { 241db978719dbcb73fc6acfd193561445c4462786b8Nicolas Geoffray if (kDebugLocking && (gAborting == 0)) { 24201ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers CHECK(!IsExclusiveHeld(self)) << *this; 24300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 24400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 24590443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void AssertNotHeld(const Thread* self) ASSERT_CAPABILITY(!*this) { 24690443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier AssertNotHeldExclusive(self); 24790443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier } 24800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 249c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Id associated with exclusive owner. No memory ordering semantics if called from a thread other 250c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // than the owner. 25100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers uint64_t GetExclusiveOwnerTid() const; 25200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 25300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Returns how many times this Mutex has been locked, it is better to use AssertHeld/NotHeld. 25400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers unsigned int GetDepth() const { 25500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers return recursion_count_; 25600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 25700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 25856edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers virtual void Dump(std::ostream& os) const; 25901ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers 26090443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier // For negative capabilities in clang annotations. 26190443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier const Mutex& operator!() const { return *this; } 26290443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier 26300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers private: 264c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#if ART_USE_FUTEXES 265c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // 0 is unheld, 1 is held. 266c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers AtomicInteger state_; 267c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // Exclusive owner. 268c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers volatile uint64_t exclusive_owner_; 269c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // Number of waiting contenders. 270b122a4bbed34ab22b4c1541ee25e5cf22f12a926Ian Rogers AtomicInteger num_contenders_; 271c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#else 27200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers pthread_mutex_t mutex_; 273c5f17732d8144491c642776b6b48c85dfadf4b52Ian Rogers volatile uint64_t exclusive_owner_; // Guarded by mutex_. 274c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#endif 27500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers const bool recursive_; // Can the lock be recursively held? 27600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers unsigned int recursion_count_; 277f1498437b0d6beb9f4f91980b98cbeb0b5c773ceElliott Hughes friend class ConditionVariable; 2788daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes DISALLOW_COPY_AND_ASSIGN(Mutex); 2798daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes}; 2808daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 28100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// A ReaderWriterMutex is used to achieve mutual exclusion between threads, similar to a Mutex. 28200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Unlike a Mutex a ReaderWriterMutex can be used to gain exclusive (writer) or shared (reader) 28300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// access to what it guards. A flaw in relation to a Mutex is that it cannot be used with a 28400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// condition variable. A ReaderWriterMutex can be in one of three states: 28500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Free - not owned by any thread, 28600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Exclusive - owned by a single thread, 28700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Shared(n) - shared amongst n threads. 28800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// 28900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// The effect of locking and unlocking operations on the state is: 29000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// 29100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// State | ExclusiveLock | ExclusiveUnlock | SharedLock | SharedUnlock 29200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// ---------------------------------------------------------------------------- 29300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Free | Exclusive | error | SharedLock(1) | error 29400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Exclusive | Block | Free | Block | error 29500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Shared(n) | Block | error | SharedLock(n+1)* | Shared(n-1) or Free 29600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// * for large values of n the SharedLock may block. 29701ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogersstd::ostream& operator<<(std::ostream& os, const ReaderWriterMutex& mu); 29890443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartierclass SHARED_LOCKABLE ReaderWriterMutex : public BaseMutex { 2998daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes public: 30081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers explicit ReaderWriterMutex(const char* name, LockLevel level = kDefaultMutexLevel); 30100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ~ReaderWriterMutex(); 30200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 30300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers virtual bool IsReaderWriterMutex() const { return true; } 30400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 30500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Block until ReaderWriterMutex is free then acquire exclusive access. 30690443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void ExclusiveLock(Thread* self) ACQUIRE(); 30790443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void WriterLock(Thread* self) ACQUIRE() { ExclusiveLock(self); } 30800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 30900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Release exclusive access. 31090443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void ExclusiveUnlock(Thread* self) RELEASE(); 31190443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void WriterUnlock(Thread* self) RELEASE() { ExclusiveUnlock(self); } 31200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 31300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Block until ReaderWriterMutex is free and acquire exclusive access. Returns true on success 31400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // or false if timeout is reached. 31566aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#if HAVE_TIMED_RWLOCK 316c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers bool ExclusiveLockWithTimeout(Thread* self, int64_t ms, int32_t ns) 31781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers EXCLUSIVE_TRYLOCK_FUNCTION(true); 31866aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#endif 31900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 32000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Block until ReaderWriterMutex is shared or free then acquire a share on the access. 32190443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void SharedLock(Thread* self) ACQUIRE_SHARED() ALWAYS_INLINE; 32290443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void ReaderLock(Thread* self) ACQUIRE_SHARED() { SharedLock(self); } 32300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 32400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Try to acquire share of ReaderWriterMutex. 32590443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier bool SharedTryLock(Thread* self) SHARED_TRYLOCK_FUNCTION(true); 32600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 32700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Release a share of the access. 32890443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void SharedUnlock(Thread* self) RELEASE_SHARED() ALWAYS_INLINE; 32990443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier void ReaderUnlock(Thread* self) RELEASE_SHARED() { SharedUnlock(self); } 33000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 33100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Is the current thread the exclusive holder of the ReaderWriterMutex. 33281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool IsExclusiveHeld(const Thread* self) const; 33300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 33400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert the current thread has exclusive access to the ReaderWriterMutex. 33581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertExclusiveHeld(const Thread* self) { 336db978719dbcb73fc6acfd193561445c4462786b8Nicolas Geoffray if (kDebugLocking && (gAborting == 0)) { 33701ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers CHECK(IsExclusiveHeld(self)) << *this; 33800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 3398daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes } 34081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertWriterHeld(const Thread* self) { AssertExclusiveHeld(self); } 3418daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 34200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert the current thread doesn't have exclusive access to the ReaderWriterMutex. 34381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertNotExclusiveHeld(const Thread* self) { 344db978719dbcb73fc6acfd193561445c4462786b8Nicolas Geoffray if (kDebugLocking && (gAborting == 0)) { 345e3359f7ad7671c5816f17145ca3a01516512e8d6Ian Rogers CHECK(!IsExclusiveHeld(self)) << *this; 34600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 34700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 34881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertNotWriterHeld(const Thread* self) { AssertNotExclusiveHeld(self); } 34900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 35000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Is the current thread a shared holder of the ReaderWriterMutex. 35181d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool IsSharedHeld(const Thread* self) const; 35200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 35300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert the current thread has shared access to the ReaderWriterMutex. 35481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertSharedHeld(const Thread* self) { 355db978719dbcb73fc6acfd193561445c4462786b8Nicolas Geoffray if (kDebugLocking && (gAborting == 0)) { 3562cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier // TODO: we can only assert this well when self != null. 3572cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier CHECK(IsSharedHeld(self) || self == nullptr) << *this; 35800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 3598daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes } 36081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertReaderHeld(const Thread* self) { AssertSharedHeld(self); } 3618daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 36200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert the current thread doesn't hold this ReaderWriterMutex either in shared or exclusive 36300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // mode. 36481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertNotHeld(const Thread* self) { 365db978719dbcb73fc6acfd193561445c4462786b8Nicolas Geoffray if (kDebugLocking && (gAborting == 0)) { 36601ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers CHECK(!IsSharedHeld(self)) << *this; 36700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 36800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 36900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 370c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Id associated with exclusive owner. No memory ordering semantics if called from a thread other 371c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // than the owner. 37200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers uint64_t GetExclusiveOwnerTid() const; 37381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 37456edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers virtual void Dump(std::ostream& os) const; 37501ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers 37690443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier // For negative capabilities in clang annotations. 37790443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier const ReaderWriterMutex& operator!() const { return *this; } 37890443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier 3798daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes private: 38051d212ef31945743abe8a469707aaa25bab95357Ian Rogers#if ART_USE_FUTEXES 381cf7f19135f0e273f7b0136315633c2abfc715343Ian Rogers // Out-of-inline path for handling contention for a SharedLock. 382cf7f19135f0e273f7b0136315633c2abfc715343Ian Rogers void HandleSharedLockContention(Thread* self, int32_t cur_state); 383cf7f19135f0e273f7b0136315633c2abfc715343Ian Rogers 38481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers // -1 implies held exclusive, +ve shared held by state_ many owners. 385c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers AtomicInteger state_; 386c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Exclusive owner. Modification guarded by this mutex. 38781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers volatile uint64_t exclusive_owner_; 388c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Number of contenders waiting for a reader share. 389c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers AtomicInteger num_pending_readers_; 390c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Number of contenders waiting to be the writer. 391b122a4bbed34ab22b4c1541ee25e5cf22f12a926Ian Rogers AtomicInteger num_pending_writers_; 39281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers#else 39300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers pthread_rwlock_t rwlock_; 394c5f17732d8144491c642776b6b48c85dfadf4b52Ian Rogers volatile uint64_t exclusive_owner_; // Guarded by rwlock_. 39581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers#endif 39600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers DISALLOW_COPY_AND_ASSIGN(ReaderWriterMutex); 3978daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes}; 3988daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 399eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// MutatorMutex is a special kind of ReaderWriterMutex created specifically for the 400eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// Locks::mutator_lock_ mutex. The behaviour is identical to the ReaderWriterMutex except that 401eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// thread state changes also play a part in lock ownership. The mutator_lock_ will not be truly 402eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// held by any mutator threads. However, a thread in the kRunnable state is considered to have 403eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// shared ownership of the mutator lock and therefore transitions in and out of the kRunnable 404eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// state have associated implications on lock ownership. Extra methods to handle the state 405eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// transitions have been added to the interface but are only accessible to the methods dealing 406eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// with state transitions. The thread state and flags attributes are used to ensure thread state 407eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// transitions are consistent with the permitted behaviour of the mutex. 408eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// 409eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// *) The most important consequence of this behaviour is that all threads must be in one of the 410eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// suspended states before exclusive ownership of the mutator mutex is sought. 411eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li// 412eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Listd::ostream& operator<<(std::ostream& os, const MutatorMutex& mu); 41390443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartierclass SHARED_LOCKABLE MutatorMutex : public ReaderWriterMutex { 414eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li public: 415eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li explicit MutatorMutex(const char* name, LockLevel level = kDefaultMutexLevel) 416eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li : ReaderWriterMutex(name, level) {} 417eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li ~MutatorMutex() {} 418eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li 419eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li virtual bool IsMutatorMutex() const { return true; } 420eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li 42190443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier // For negative capabilities in clang annotations. 42290443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier const MutatorMutex& operator!() const { return *this; } 42390443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartier 424eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li private: 425eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li friend class Thread; 426eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li void TransitionFromRunnableToSuspended(Thread* self) UNLOCK_FUNCTION() ALWAYS_INLINE; 427eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li void TransitionFromSuspendedToRunnable(Thread* self) SHARED_LOCK_FUNCTION() ALWAYS_INLINE; 428eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li 429eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li DISALLOW_COPY_AND_ASSIGN(MutatorMutex); 430eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li}; 431eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li 43200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// ConditionVariables allow threads to queue and sleep. Threads may then be resumed individually 43300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// (Signal) or all at once (Broadcast). 4345f79133a435ebcb20000370d56046fe01201dd80Elliott Hughesclass ConditionVariable { 4355f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes public: 43623055dc5d7a90c4a12e259fd0ed7cd4d04d89182Ian Rogers explicit ConditionVariable(const char* name, Mutex& mutex); 4375f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes ~ConditionVariable(); 4385f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 439c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers void Broadcast(Thread* self); 440c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers void Signal(Thread* self); 441c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // TODO: No thread safety analysis on Wait and TimedWait as they call mutex operations via their 442c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // pointer copy, thereby defeating annotalysis. 443c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers void Wait(Thread* self) NO_THREAD_SAFETY_ANALYSIS; 4447b078e8c04f3e1451dbdd18543c8b9692b5b067eIan Rogers bool TimedWait(Thread* self, int64_t ms, int32_t ns) NO_THREAD_SAFETY_ANALYSIS; 4451d54e73444e017d3a65234e0f193846f3e27472bIan Rogers // Variant of Wait that should be used with caution. Doesn't validate that no mutexes are held 4461d54e73444e017d3a65234e0f193846f3e27472bIan Rogers // when waiting. 4471d54e73444e017d3a65234e0f193846f3e27472bIan Rogers // TODO: remove this. 4481d54e73444e017d3a65234e0f193846f3e27472bIan Rogers void WaitHoldingLocks(Thread* self) NO_THREAD_SAFETY_ANALYSIS; 4495f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 4505f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes private: 45123055dc5d7a90c4a12e259fd0ed7cd4d04d89182Ian Rogers const char* const name_; 452c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // The Mutex being used by waiters. It is an error to mix condition variables between different 453c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // Mutexes. 454c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers Mutex& guard_; 455c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#if ART_USE_FUTEXES 456c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // A counter that is modified by signals and broadcasts. This ensures that when a waiter gives up 457d45f201e9bd43490e30a35710865789b8d70e249Ian Rogers // their Mutex and another thread takes it and signals, the waiting thread observes that sequence_ 458d45f201e9bd43490e30a35710865789b8d70e249Ian Rogers // changed and doesn't enter the wait. Modified while holding guard_, but is read by futex wait 459d45f201e9bd43490e30a35710865789b8d70e249Ian Rogers // without guard_ held. 460b122a4bbed34ab22b4c1541ee25e5cf22f12a926Ian Rogers AtomicInteger sequence_; 461c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // Number of threads that have come into to wait, not the length of the waiters on the futex as 4625bd97c483c1de1eb97afe76123b1b9ab53095edfIan Rogers // waiters may have been requeued onto guard_. Guarded by guard_. 463c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers volatile int32_t num_waiters_; 464c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#else 465c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers pthread_cond_t cond_; 466c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#endif 4675f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes DISALLOW_COPY_AND_ASSIGN(ConditionVariable); 4685f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes}; 4695f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 47000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Scoped locker/unlocker for a regular Mutex that acquires mu upon construction and releases it 47100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// upon destruction. 47290443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartierclass SCOPED_CAPABILITY MutexLock { 47300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 4744e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier explicit MutexLock(Thread* self, Mutex& mu) ACQUIRE(mu) : self_(self), mu_(mu) { 47581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.ExclusiveLock(self_); 47681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers } 47781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 4784e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier ~MutexLock() RELEASE() { 47981d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.ExclusiveUnlock(self_); 48000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 48100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 48200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers private: 48381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers Thread* const self_; 48400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers Mutex& mu_; 48500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers DISALLOW_COPY_AND_ASSIGN(MutexLock); 48600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers}; 48700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Catch bug where variable name is omitted. "MutexLock (lock);" instead of "MutexLock mu(lock)". 488575e78c41ece0dec969d31f46be563d4eb7ae43bAndreas Gampe#define MutexLock(x) static_assert(0, "MutexLock declaration missing variable name") 48900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 49000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Scoped locker/unlocker for a ReaderWriterMutex that acquires read access to mu upon 49100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// construction and releases it upon destruction. 49290443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartierclass SCOPED_CAPABILITY ReaderMutexLock { 49300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 4944e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier explicit ReaderMutexLock(Thread* self, ReaderWriterMutex& mu) ACQUIRE(mu) : 49581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers self_(self), mu_(mu) { 49681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.SharedLock(self_); 49781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers } 49881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 4994e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier ~ReaderMutexLock() RELEASE() { 50081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.SharedUnlock(self_); 50100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 50200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 50300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers private: 50481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers Thread* const self_; 50500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ReaderWriterMutex& mu_; 50600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers DISALLOW_COPY_AND_ASSIGN(ReaderMutexLock); 50700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers}; 50800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Catch bug where variable name is omitted. "ReaderMutexLock (lock);" instead of 50900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// "ReaderMutexLock mu(lock)". 510575e78c41ece0dec969d31f46be563d4eb7ae43bAndreas Gampe#define ReaderMutexLock(x) static_assert(0, "ReaderMutexLock declaration missing variable name") 51100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 51200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Scoped locker/unlocker for a ReaderWriterMutex that acquires write access to mu upon 51300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// construction and releases it upon destruction. 51490443477f9a0061581c420775ce3b7eeae7468bcMathieu Chartierclass SCOPED_CAPABILITY WriterMutexLock { 51500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 51681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers explicit WriterMutexLock(Thread* self, ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : 51781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers self_(self), mu_(mu) { 51881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.ExclusiveLock(self_); 51981d425b0b232962441616f8b14f73620bffef5e5Ian Rogers } 52081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 52100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ~WriterMutexLock() UNLOCK_FUNCTION() { 52281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.ExclusiveUnlock(self_); 52300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 52400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 52500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers private: 52650b35e2fd1a68cd1240e4a9d9f363e11764957d1Ian Rogers Thread* const self_; 52700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ReaderWriterMutex& mu_; 52800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers DISALLOW_COPY_AND_ASSIGN(WriterMutexLock); 52900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers}; 53000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Catch bug where variable name is omitted. "WriterMutexLock (lock);" instead of 53100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// "WriterMutexLock mu(lock)". 532575e78c41ece0dec969d31f46be563d4eb7ae43bAndreas Gampe#define WriterMutexLock(x) static_assert(0, "WriterMutexLock declaration missing variable name") 53300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 5344e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier// For StartNoThreadSuspension and EndNoThreadSuspension. 5354e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartierclass CAPABILITY("role") Role { 5364e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier public: 5374e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier void Acquire() ACQUIRE() {} 5384e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier void Release() RELEASE() {} 5394e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier const Role& operator!() const { return *this; } 5404e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier}; 5414e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier 5424e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartierclass Uninterruptible : public Role { 5434e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier}; 5444e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier 545719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// Global mutexes corresponding to the levels above. 546719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersclass Locks { 547719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers public: 548719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static void Init(); 54991e56692c6bd9fa1d41951ee7dc311f19461f4beMathieu Chartier static void InitConditions() NO_THREAD_SAFETY_ANALYSIS; // Condition variables. 5509ef78b59da51080882e47505896b420977fd79aeMathieu Chartier // Guards allocation entrypoint instrumenting. 5514ad5cd3e7d519484559ef778d96fb3f0be8919faIan Rogers static Mutex* instrument_entrypoints_lock_; 5529ef78b59da51080882e47505896b420977fd79aeMathieu Chartier 553eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // A barrier is used to synchronize the GC/Debugger thread with mutator threads. When GC/Debugger 554eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // thread wants to suspend all mutator threads, it needs to wait for all mutator threads to pass 555eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // a barrier. Threads that are already suspended will get their barrier passed by the GC/Debugger 556eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // thread; threads in the runnable state will pass the barrier when they transit to the suspended 557eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // state. GC/Debugger thread will be woken up when all mutator threads are suspended. 558719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // 559719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Thread suspension: 560eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // mutator thread | GC/Debugger 561eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // .. running .. | .. running .. 562719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | Request thread suspension by: 563719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | - acquiring thread_suspend_count_lock_ 564719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | - incrementing Thread::suspend_count_ on 565719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | all mutator threads 566719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | - releasing thread_suspend_count_lock_ 567eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // .. running .. | Block wait for all threads to pass a barrier 568719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Poll Thread::suspend_count_ and enter full | .. blocked .. 569719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // suspend code. | .. blocked .. 570eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // Change state to kSuspended (pass the barrier) | Wake up when all threads pass the barrier 571eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // x: Acquire thread_suspend_count_lock_ | .. running .. 572eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // while Thread::suspend_count_ > 0 | .. running .. 573eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // - wait on Thread::resume_cond_ | .. running .. 574eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // (releases thread_suspend_count_lock_) | .. running .. 575719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | Request thread resumption by: 576719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | - acquiring thread_suspend_count_lock_ 577719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | - decrementing Thread::suspend_count_ on 578719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | all mutator threads 579719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | - notifying on Thread::resume_cond_ 580719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // - re-acquire thread_suspend_count_lock_ | - releasing thread_suspend_count_lock_ 581719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Release thread_suspend_count_lock_ | .. running .. 582eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // Change to kRunnable | .. running .. 583eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // - this uses a CAS operation to ensure the | .. running .. 584eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // suspend request flag isn't raised as the | .. running .. 585eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // state is changed | .. running .. 586eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li // - if the CAS operation fails then goto x | .. running .. 587719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | .. running .. 588eac4424b3420c280f97ff2f815b5dedd8dac9801Yu Li static MutatorMutex* mutator_lock_ ACQUIRED_AFTER(instrument_entrypoints_lock_); 589719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 590719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Allow reader-writer mutual exclusion on the mark and live bitmaps of the heap. 591719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static ReaderWriterMutex* heap_bitmap_lock_ ACQUIRED_AFTER(mutator_lock_); 592719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 593719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Guards shutdown of the runtime. 594719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static Mutex* runtime_shutdown_lock_ ACQUIRED_AFTER(heap_bitmap_lock_); 595719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 5969e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu // Guards background profiler global state. 5979e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static Mutex* profiler_lock_ ACQUIRED_AFTER(runtime_shutdown_lock_); 5989e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu 5999e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu // Guards trace (ie traceview) requests. 6009e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static Mutex* trace_lock_ ACQUIRED_AFTER(profiler_lock_); 6019e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu 602306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom // Guards debugger recent allocation records. 603306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom static Mutex* alloc_tracker_lock_ ACQUIRED_AFTER(trace_lock_); 604306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom 605306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom // Guards updates to instrumentation to ensure mutual exclusion of 606306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom // events like deoptimization requests. 607306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom // TODO: improve name, perhaps instrumentation_update_lock_. 608306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom static Mutex* deoptimization_lock_ ACQUIRED_AFTER(alloc_tracker_lock_); 609306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom 610719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // The thread_list_lock_ guards ThreadList::list_. It is also commonly held to stop threads 611719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // attaching and detaching. 612306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom static Mutex* thread_list_lock_ ACQUIRED_AFTER(deoptimization_lock_); 613719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 61491e56692c6bd9fa1d41951ee7dc311f19461f4beMathieu Chartier // Signaled when threads terminate. Used to determine when all non-daemons have terminated. 61591e56692c6bd9fa1d41951ee7dc311f19461f4beMathieu Chartier static ConditionVariable* thread_exit_cond_ GUARDED_BY(Locks::thread_list_lock_); 61691e56692c6bd9fa1d41951ee7dc311f19461f4beMathieu Chartier 61768d8b42ddec39ec0174162d90d4abaa004d1983eIan Rogers // Guards maintaining loading library data structures. 61868d8b42ddec39ec0174162d90d4abaa004d1983eIan Rogers static Mutex* jni_libraries_lock_ ACQUIRED_AFTER(thread_list_lock_); 61968d8b42ddec39ec0174162d90d4abaa004d1983eIan Rogers 620719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Guards breakpoints. 621ed2be1725fb79075892b1a9103487c9d9a95b350Sebastien Hertz static ReaderWriterMutex* breakpoint_lock_ ACQUIRED_AFTER(jni_libraries_lock_); 622719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 623719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Guards lists of classes within the class linker. 6249e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static ReaderWriterMutex* classlinker_classes_lock_ ACQUIRED_AFTER(breakpoint_lock_); 625719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 626719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // When declaring any Mutex add DEFAULT_MUTEX_ACQUIRED_AFTER to use annotalysis to check the code 627719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // doesn't try to hold a higher level Mutex. 62812d625f87bcd6c4059a205bb39007a255f57f382Mathieu Chartier #define DEFAULT_MUTEX_ACQUIRED_AFTER ACQUIRED_AFTER(Locks::classlinker_classes_lock_) 629719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 63074240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe static Mutex* allocated_monitor_ids_lock_ ACQUIRED_AFTER(classlinker_classes_lock_); 63174240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe 6329e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu // Guard the allocation/deallocation of thread ids. 63374240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe static Mutex* allocated_thread_ids_lock_ ACQUIRED_AFTER(allocated_monitor_ids_lock_); 6349e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu 6359e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu // Guards modification of the LDT on x86. 6369e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static Mutex* modify_ldt_lock_ ACQUIRED_AFTER(allocated_thread_ids_lock_); 6379e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu 638719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Guards intern table. 6399e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static Mutex* intern_table_lock_ ACQUIRED_AFTER(modify_ldt_lock_); 640719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 641a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards reference processor. 642a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_processor_lock_ ACQUIRED_AFTER(intern_table_lock_); 643a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 644a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards cleared references queue. 645a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_cleared_references_lock_ ACQUIRED_AFTER(reference_processor_lock_); 646a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 647a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards weak references queue. 648a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_weak_references_lock_ ACQUIRED_AFTER(reference_queue_cleared_references_lock_); 649a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 650a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards finalizer references queue. 651a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_finalizer_references_lock_ ACQUIRED_AFTER(reference_queue_weak_references_lock_); 652a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 653a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards phantom references queue. 654a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_phantom_references_lock_ ACQUIRED_AFTER(reference_queue_finalizer_references_lock_); 655a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 656a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards soft references queue. 657a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_soft_references_lock_ ACQUIRED_AFTER(reference_queue_phantom_references_lock_); 658a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 659719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Have an exclusive aborting thread. 660a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* abort_lock_ ACQUIRED_AFTER(reference_queue_soft_references_lock_); 661719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 662719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Allow mutual exclusion when manipulating Thread::suspend_count_. 663719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // TODO: Does the trade-off of a per-thread lock make sense? 664719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static Mutex* thread_suspend_count_lock_ ACQUIRED_AFTER(abort_lock_); 665719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 666719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // One unexpected signal at a time lock. 667719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static Mutex* unexpected_signal_lock_ ACQUIRED_AFTER(thread_suspend_count_lock_); 668719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 6693eed93dd5be03e5539827bebf0f414251a12e15eHiroshi Yamauchi // Guards the maps in mem_map. 6703eed93dd5be03e5539827bebf0f414251a12e15eHiroshi Yamauchi static Mutex* mem_maps_lock_ ACQUIRED_AFTER(unexpected_signal_lock_); 6713eed93dd5be03e5539827bebf0f414251a12e15eHiroshi Yamauchi 672719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Have an exclusive logging thread. 673719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static Mutex* logging_lock_ ACQUIRED_AFTER(unexpected_signal_lock_); 674e2facc5b18cd756a8b5500fb3d90da69c9ee0fb7Igor Murashkin 675e2facc5b18cd756a8b5500fb3d90da69c9ee0fb7Igor Murashkin // Allow reader-writer mutual exclusion on the boxed table of lambda objects. 676e2facc5b18cd756a8b5500fb3d90da69c9ee0fb7Igor Murashkin // TODO: this should be a RW mutex lock, except that ConditionVariables don't work with it. 677e2facc5b18cd756a8b5500fb3d90da69c9ee0fb7Igor Murashkin static Mutex* lambda_table_lock_ ACQUIRED_AFTER(mutator_lock_); 678719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers}; 679719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 6804e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartierclass Roles { 6814e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier public: 6824e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier static Uninterruptible uninterruptible_; 6834e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier}; 6844e2cb098017bf073335ebb02b1bc0a36828cd720Mathieu Chartier 6858daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes} // namespace art 6868daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 687fc0e3219edc9a5bf81b166e82fd5db2796eb6a0dBrian Carlstrom#endif // ART_RUNTIME_BASE_MUTEX_H_ 688