mutex.h revision 575e78c41ece0dec969d31f46be563d4eb7ae43b
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 46719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersclass LOCKABLE ReaderWriterMutex; 4756edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogersclass ScopedContentionRecorder; 4850b35e2fd1a68cd1240e4a9d9f363e11764957d1Ian Rogersclass Thread; 4950b35e2fd1a68cd1240e4a9d9f363e11764957d1Ian Rogers 50719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// LockLevel is used to impose a lock hierarchy [1] where acquisition of a Mutex at a higher or 51719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// equal level to a lock a thread holds is invalid. The lock hierarchy achieves a cycle free 52719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// partial ordering and thereby cause deadlock situations to fail checks. 53719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// 54719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// [1] http://www.drdobbs.com/parallel/use-lock-hierarchies-to-avoid-deadlock/204801163 55719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersenum LockLevel { 56719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kLoggingLock = 0, 573eed93dd5be03e5539827bebf0f414251a12e15eHiroshi Yamauchi kMemMapsLock, 587de77dd4f2d3cbb0615ee001589eb99ae82c3dccRaghu Gandham kSwapMutexesLock, 59719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kUnexpectedSignalLock, 60719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kThreadSuspendCountLock, 61719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kAbortLock, 62719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpSocketLock, 63a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueueSoftReferencesLock, 64a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueuePhantomReferencesLock, 65a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueueFinalizerReferencesLock, 66a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueueWeakReferencesLock, 67a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceQueueClearedReferencesLock, 68a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier kReferenceProcessorLock, 69719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kRosAllocGlobalLock, 70719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kRosAllocBracketLock, 71719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kRosAllocBulkFreeLock, 72719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kAllocSpaceLock, 73719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kDexFileMethodInlinerLock, 74719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kDexFileToMethodInlinerMapLock, 75719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kMarkSweepMarkStackLock, 76719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kTransactionLogLock, 77719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kInternTableLock, 783f5838d7d0b9fc63db0ccc35c2ea05ed29264986Vladimir Marko kOatFileSecondaryLookupLock, 79719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kDefaultMutexLevel, 80719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kMarkSweepLargeObjectLock, 81719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kPinTableLock, 82719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpObjectRegistryLock, 839e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu kModifyLdtLock, 849e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu kAllocatedThreadIdsLock, 8574240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe kMonitorPoolLock, 86719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kClassLinkerClassesLock, 87719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kBreakpointLock, 88719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kMonitorLock, 89440e4ceb310349ee8eb569495bc04d3d7fbe71cbMathieu Chartier kMonitorListLock, 9068d8b42ddec39ec0174162d90d4abaa004d1983eIan Rogers kJniLoadLibraryLock, 91719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kThreadListLock, 92719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kBreakpointInvokeLock, 93306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom kAllocTrackerLock, 94719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kDeoptimizationLock, 95719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kProfilerLock, 96719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpEventListLock, 97719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpAttachLock, 98719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kJdwpStartLock, 99719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kRuntimeShutdownLock, 10069dbec6d9d55eeb2867949c2791d01dc9aa916c8Jeff Hao kTraceLock, 101719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kHeapBitmapLock, 102719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kMutatorLock, 1039ef78b59da51080882e47505896b420977fd79aeMathieu Chartier kInstrumentEntrypointsLock, 104f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers kThreadListSuspendThreadLock, 105719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kZygoteCreationLock, 106719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 107719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers kLockLevelCount // Must come last. 108719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers}; 109719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersstd::ostream& operator<<(std::ostream& os, const LockLevel& rhs); 110719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 1112e250c826b3c405d675017efe79e5db3651c9ee6Brian Carlstromconst bool kDebugLocking = kIsDebugBuild; 11225fd14b87cced64a179dee885573113be5e11944Ian Rogers 1131afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi// Record Log contention information, dumpable via SIGQUIT. 1141afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi#ifdef ART_USE_FUTEXES 11508f2e7b59fab9df108d3d91e6eeb4bbccbb325d1Jeff Hao// To enable lock contention logging, set this to true. 11608f2e7b59fab9df108d3d91e6eeb4bbccbb325d1Jeff Haoconst bool kLogLockContentions = false; 1171afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi#else 1181afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi// Keep this false as lock contention logging is supported only with 1191afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi// futex. 1201afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchiconst bool kLogLockContentions = false; 1211afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi#endif 122d9c4fc94fa618617f94e1de9af5f034549100753Ian Rogersconst size_t kContentionLogSize = 4; 1231afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchiconst size_t kContentionLogDataSize = kLogLockContentions ? 1 : 0; 1241afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchiconst size_t kAllMutexDataSize = kLogLockContentions ? 1 : 0; 1251afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi 12600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Base class for all Mutex implementations 12700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersclass BaseMutex { 12800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 129bab74963db2484ea5f10a82ea26e8a99722bfefeIan Rogers const char* GetName() const { 13000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers return name_; 13100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 13200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 13300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers virtual bool IsMutex() const { return false; } 13400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers virtual bool IsReaderWriterMutex() const { return false; } 13500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 13656edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers virtual void Dump(std::ostream& os) const = 0; 13756edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers 13856edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers static void DumpAll(std::ostream& os); 13956edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers 14000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers protected: 14100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers friend class ConditionVariable; 14200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 14381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers BaseMutex(const char* name, LockLevel level); 14456edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers virtual ~BaseMutex(); 14581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void RegisterAsLocked(Thread* self); 14681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void RegisterAsUnlocked(Thread* self); 14781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void CheckSafeToWait(Thread* self); 14800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 14956edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers friend class ScopedContentionRecorder; 15056edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers 1511afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi void RecordContention(uint64_t blocked_tid, uint64_t owner_tid, uint64_t nano_time_blocked); 15256edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers void DumpContention(std::ostream& os) const; 15356edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers 15481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers const LockLevel level_; // Support for lock hierarchy. 155bab74963db2484ea5f10a82ea26e8a99722bfefeIan Rogers const char* const name_; 1561afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi 15756edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers // A log entry that records contention but makes no guarantee that either tid will be held live. 15856edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers struct ContentionLogEntry { 15956edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers ContentionLogEntry() : blocked_tid(0), owner_tid(0) {} 16056edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers uint64_t blocked_tid; 16156edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers uint64_t owner_tid; 16256edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers AtomicInteger count; 16356edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers }; 1641afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi struct ContentionLogData { 1651afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi ContentionLogEntry contention_log[kContentionLogSize]; 1661afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi // The next entry in the contention log to be updated. Value ranges from 0 to 1671afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi // kContentionLogSize - 1. 1681afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi AtomicInteger cur_content_log_entry; 1691afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi // Number of times the Mutex has been contended. 1701afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi AtomicInteger contention_count; 1711afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi // Sum of time waited by all contenders in ns. 17237f3c968ecd04e77802fe17bb82dabc07de21ca1Ian Rogers Atomic<uint64_t> wait_time; 1731afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi void AddToWaitTime(uint64_t value); 1741afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi ContentionLogData() : wait_time(0) {} 1751afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi }; 1763e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers ContentionLogData contention_log_data_[kContentionLogDataSize]; 1771afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi 1781afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi public: 1791afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi bool HasEverContended() const { 1801afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi if (kLogLockContentions) { 1813e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers return contention_log_data_->contention_count.LoadSequentiallyConsistent() > 0; 1821afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi } 1831afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi return false; 1841afde13b36cc1d67528104c2b1395495f669cd3fHiroshi Yamauchi } 18500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers}; 18600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 18700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// A Mutex is used to achieve mutual exclusion between threads. A Mutex can be used to gain 18800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// exclusive access to what it guards. A Mutex can be in one of two states: 18900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Free - not owned by any thread, 19000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Exclusive - owned by a single thread. 19100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// 19200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// The effect of locking and unlocking operations on the state is: 19300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// State | ExclusiveLock | ExclusiveUnlock 19400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// ------------------------------------------- 19500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Free | Exclusive | error 19600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Exclusive | Block* | Free 19700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// * Mutex is not reentrant and so an attempt to ExclusiveLock on the same thread will result in 19800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// an error. Being non-reentrant simplifies Waiting on ConditionVariables. 19901ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogersstd::ostream& operator<<(std::ostream& os, const Mutex& mu); 20000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersclass LOCKABLE Mutex : public BaseMutex { 20100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 20281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers explicit Mutex(const char* name, LockLevel level = kDefaultMutexLevel, bool recursive = false); 20300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ~Mutex(); 20400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 20500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers virtual bool IsMutex() const { return true; } 20600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 20700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Block until mutex is free then acquire exclusive access. 20881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void ExclusiveLock(Thread* self) EXCLUSIVE_LOCK_FUNCTION(); 20981d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void Lock(Thread* self) EXCLUSIVE_LOCK_FUNCTION() { ExclusiveLock(self); } 21000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 21100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Returns true if acquires exclusive access, false otherwise. 21281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool ExclusiveTryLock(Thread* self) EXCLUSIVE_TRYLOCK_FUNCTION(true); 21381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool TryLock(Thread* self) EXCLUSIVE_TRYLOCK_FUNCTION(true) { return ExclusiveTryLock(self); } 21400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 21500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Release exclusive access. 21681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void ExclusiveUnlock(Thread* self) UNLOCK_FUNCTION(); 21781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void Unlock(Thread* self) UNLOCK_FUNCTION() { ExclusiveUnlock(self); } 21800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 21900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Is the current thread the exclusive holder of the Mutex. 22081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool IsExclusiveHeld(const Thread* self) const; 2218daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 22200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert that the Mutex is exclusively held by the current thread. 22381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertExclusiveHeld(const Thread* self) { 2243c539ffccabada93c404c0dfba8b52926ae06d0cAnwar Ghuloum if (kDebugLocking && (gAborting == 0)) { 22501ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers CHECK(IsExclusiveHeld(self)) << *this; 22600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 22700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 22881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertHeld(const Thread* self) { AssertExclusiveHeld(self); } 22900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 23000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert that the Mutex is not held by the current thread. 23181d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertNotHeldExclusive(const Thread* self) { 2323c539ffccabada93c404c0dfba8b52926ae06d0cAnwar Ghuloum if (kDebugLocking && (gAborting == 0)) { 23301ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers CHECK(!IsExclusiveHeld(self)) << *this; 23400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 23500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 23681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertNotHeld(const Thread* self) { AssertNotHeldExclusive(self); } 23700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 238c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Id associated with exclusive owner. No memory ordering semantics if called from a thread other 239c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // than the owner. 24000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers uint64_t GetExclusiveOwnerTid() const; 24100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 24200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Returns how many times this Mutex has been locked, it is better to use AssertHeld/NotHeld. 24300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers unsigned int GetDepth() const { 24400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers return recursion_count_; 24500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 24600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 24756edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers virtual void Dump(std::ostream& os) const; 24801ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers 24900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers private: 250c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#if ART_USE_FUTEXES 251c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // 0 is unheld, 1 is held. 252c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers AtomicInteger state_; 253c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // Exclusive owner. 254c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers volatile uint64_t exclusive_owner_; 255c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // Number of waiting contenders. 256b122a4bbed34ab22b4c1541ee25e5cf22f12a926Ian Rogers AtomicInteger num_contenders_; 257c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#else 25800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers pthread_mutex_t mutex_; 259c5f17732d8144491c642776b6b48c85dfadf4b52Ian Rogers volatile uint64_t exclusive_owner_; // Guarded by mutex_. 260c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#endif 26100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers const bool recursive_; // Can the lock be recursively held? 26200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers unsigned int recursion_count_; 263f1498437b0d6beb9f4f91980b98cbeb0b5c773ceElliott Hughes friend class ConditionVariable; 2648daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes DISALLOW_COPY_AND_ASSIGN(Mutex); 2658daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes}; 2668daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 26700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// A ReaderWriterMutex is used to achieve mutual exclusion between threads, similar to a Mutex. 26800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Unlike a Mutex a ReaderWriterMutex can be used to gain exclusive (writer) or shared (reader) 26900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// access to what it guards. A flaw in relation to a Mutex is that it cannot be used with a 27000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// condition variable. A ReaderWriterMutex can be in one of three states: 27100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Free - not owned by any thread, 27200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Exclusive - owned by a single thread, 27300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// - Shared(n) - shared amongst n threads. 27400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// 27500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// The effect of locking and unlocking operations on the state is: 27600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// 27700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// State | ExclusiveLock | ExclusiveUnlock | SharedLock | SharedUnlock 27800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// ---------------------------------------------------------------------------- 27900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Free | Exclusive | error | SharedLock(1) | error 28000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Exclusive | Block | Free | Block | error 28100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Shared(n) | Block | error | SharedLock(n+1)* | Shared(n-1) or Free 28200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// * for large values of n the SharedLock may block. 28301ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogersstd::ostream& operator<<(std::ostream& os, const ReaderWriterMutex& mu); 28400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersclass LOCKABLE ReaderWriterMutex : public BaseMutex { 2858daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes public: 28681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers explicit ReaderWriterMutex(const char* name, LockLevel level = kDefaultMutexLevel); 28700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ~ReaderWriterMutex(); 28800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 28900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers virtual bool IsReaderWriterMutex() const { return true; } 29000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 29100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Block until ReaderWriterMutex is free then acquire exclusive access. 29281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void ExclusiveLock(Thread* self) EXCLUSIVE_LOCK_FUNCTION(); 29381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void WriterLock(Thread* self) EXCLUSIVE_LOCK_FUNCTION() { ExclusiveLock(self); } 29400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 29500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Release exclusive access. 29681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void ExclusiveUnlock(Thread* self) UNLOCK_FUNCTION(); 29781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void WriterUnlock(Thread* self) UNLOCK_FUNCTION() { ExclusiveUnlock(self); } 29800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 29900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Block until ReaderWriterMutex is free and acquire exclusive access. Returns true on success 30000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // or false if timeout is reached. 30166aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#if HAVE_TIMED_RWLOCK 302c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers bool ExclusiveLockWithTimeout(Thread* self, int64_t ms, int32_t ns) 30381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers EXCLUSIVE_TRYLOCK_FUNCTION(true); 30466aee5cd571cf4739d2735769304202ea5051fb8Ian Rogers#endif 30500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 30600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Block until ReaderWriterMutex is shared or free then acquire a share on the access. 3071ffa32f0be7becec4907b26ead353e4b17e1219cIan Rogers void SharedLock(Thread* self) SHARED_LOCK_FUNCTION() ALWAYS_INLINE; 30881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void ReaderLock(Thread* self) SHARED_LOCK_FUNCTION() { SharedLock(self); } 30900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 31000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Try to acquire share of ReaderWriterMutex. 31181d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool SharedTryLock(Thread* self) EXCLUSIVE_TRYLOCK_FUNCTION(true); 31200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 31300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Release a share of the access. 3141ffa32f0be7becec4907b26ead353e4b17e1219cIan Rogers void SharedUnlock(Thread* self) UNLOCK_FUNCTION() ALWAYS_INLINE; 31581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void ReaderUnlock(Thread* self) UNLOCK_FUNCTION() { SharedUnlock(self); } 31600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 31700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Is the current thread the exclusive holder of the ReaderWriterMutex. 31881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool IsExclusiveHeld(const Thread* self) const; 31900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 32000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert the current thread has exclusive access to the ReaderWriterMutex. 32181d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertExclusiveHeld(const Thread* self) { 322702a85b33c57da99e83698129a289687cdb0be1fSebastien Hertz if (kDebugLocking && (gAborting == 0)) { 32301ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers CHECK(IsExclusiveHeld(self)) << *this; 32400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 3258daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes } 32681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertWriterHeld(const Thread* self) { AssertExclusiveHeld(self); } 3278daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 32800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert the current thread doesn't have exclusive access to the ReaderWriterMutex. 32981d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertNotExclusiveHeld(const Thread* self) { 330702a85b33c57da99e83698129a289687cdb0be1fSebastien Hertz if (kDebugLocking && (gAborting == 0)) { 331e3359f7ad7671c5816f17145ca3a01516512e8d6Ian Rogers CHECK(!IsExclusiveHeld(self)) << *this; 33200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 33300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 33481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertNotWriterHeld(const Thread* self) { AssertNotExclusiveHeld(self); } 33500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 33600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Is the current thread a shared holder of the ReaderWriterMutex. 33781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers bool IsSharedHeld(const Thread* self) const; 33800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 33900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert the current thread has shared access to the ReaderWriterMutex. 34081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertSharedHeld(const Thread* self) { 341702a85b33c57da99e83698129a289687cdb0be1fSebastien Hertz if (kDebugLocking && (gAborting == 0)) { 34223055dc5d7a90c4a12e259fd0ed7cd4d04d89182Ian Rogers // TODO: we can only assert this well when self != NULL. 34323055dc5d7a90c4a12e259fd0ed7cd4d04d89182Ian Rogers CHECK(IsSharedHeld(self) || self == NULL) << *this; 34400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 3458daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes } 34681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertReaderHeld(const Thread* self) { AssertSharedHeld(self); } 3478daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 34800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // Assert the current thread doesn't hold this ReaderWriterMutex either in shared or exclusive 34900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers // mode. 35081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers void AssertNotHeld(const Thread* self) { 3513c539ffccabada93c404c0dfba8b52926ae06d0cAnwar Ghuloum if (kDebugLocking && (gAborting == 0)) { 35201ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers CHECK(!IsSharedHeld(self)) << *this; 35300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 35400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 35500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 356c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Id associated with exclusive owner. No memory ordering semantics if called from a thread other 357c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // than the owner. 35800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers uint64_t GetExclusiveOwnerTid() const; 35981d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 36056edc432fa914f7ccfa87ce443e64f5ef475666dIan Rogers virtual void Dump(std::ostream& os) const; 36101ae5808367e641a983e3f8bb82b3e0d364cd03eIan Rogers 3628daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes private: 36351d212ef31945743abe8a469707aaa25bab95357Ian Rogers#if ART_USE_FUTEXES 364cf7f19135f0e273f7b0136315633c2abfc715343Ian Rogers // Out-of-inline path for handling contention for a SharedLock. 365cf7f19135f0e273f7b0136315633c2abfc715343Ian Rogers void HandleSharedLockContention(Thread* self, int32_t cur_state); 366cf7f19135f0e273f7b0136315633c2abfc715343Ian Rogers 36781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers // -1 implies held exclusive, +ve shared held by state_ many owners. 368c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers AtomicInteger state_; 369c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Exclusive owner. Modification guarded by this mutex. 37081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers volatile uint64_t exclusive_owner_; 371c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Number of contenders waiting for a reader share. 372c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers AtomicInteger num_pending_readers_; 373c7190697f8665e706f6ebb4ae36fa63c46a32cd5Ian Rogers // Number of contenders waiting to be the writer. 374b122a4bbed34ab22b4c1541ee25e5cf22f12a926Ian Rogers AtomicInteger num_pending_writers_; 37581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers#else 37600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers pthread_rwlock_t rwlock_; 377c5f17732d8144491c642776b6b48c85dfadf4b52Ian Rogers volatile uint64_t exclusive_owner_; // Guarded by rwlock_. 37881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers#endif 37900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers DISALLOW_COPY_AND_ASSIGN(ReaderWriterMutex); 3808daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes}; 3818daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 38200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// ConditionVariables allow threads to queue and sleep. Threads may then be resumed individually 38300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// (Signal) or all at once (Broadcast). 3845f79133a435ebcb20000370d56046fe01201dd80Elliott Hughesclass ConditionVariable { 3855f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes public: 38623055dc5d7a90c4a12e259fd0ed7cd4d04d89182Ian Rogers explicit ConditionVariable(const char* name, Mutex& mutex); 3875f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes ~ConditionVariable(); 3885f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 389c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers void Broadcast(Thread* self); 390c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers void Signal(Thread* self); 391c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // TODO: No thread safety analysis on Wait and TimedWait as they call mutex operations via their 392c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // pointer copy, thereby defeating annotalysis. 393c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers void Wait(Thread* self) NO_THREAD_SAFETY_ANALYSIS; 3947b078e8c04f3e1451dbdd18543c8b9692b5b067eIan Rogers bool TimedWait(Thread* self, int64_t ms, int32_t ns) NO_THREAD_SAFETY_ANALYSIS; 3951d54e73444e017d3a65234e0f193846f3e27472bIan Rogers // Variant of Wait that should be used with caution. Doesn't validate that no mutexes are held 3961d54e73444e017d3a65234e0f193846f3e27472bIan Rogers // when waiting. 3971d54e73444e017d3a65234e0f193846f3e27472bIan Rogers // TODO: remove this. 3981d54e73444e017d3a65234e0f193846f3e27472bIan Rogers void WaitHoldingLocks(Thread* self) NO_THREAD_SAFETY_ANALYSIS; 3995f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 4005f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes private: 40123055dc5d7a90c4a12e259fd0ed7cd4d04d89182Ian Rogers const char* const name_; 402c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // The Mutex being used by waiters. It is an error to mix condition variables between different 403c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // Mutexes. 404c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers Mutex& guard_; 405c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#if ART_USE_FUTEXES 406c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // A counter that is modified by signals and broadcasts. This ensures that when a waiter gives up 407d45f201e9bd43490e30a35710865789b8d70e249Ian Rogers // their Mutex and another thread takes it and signals, the waiting thread observes that sequence_ 408d45f201e9bd43490e30a35710865789b8d70e249Ian Rogers // changed and doesn't enter the wait. Modified while holding guard_, but is read by futex wait 409d45f201e9bd43490e30a35710865789b8d70e249Ian Rogers // without guard_ held. 410b122a4bbed34ab22b4c1541ee25e5cf22f12a926Ian Rogers AtomicInteger sequence_; 411c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers // Number of threads that have come into to wait, not the length of the waiters on the futex as 4125bd97c483c1de1eb97afe76123b1b9ab53095edfIan Rogers // waiters may have been requeued onto guard_. Guarded by guard_. 413c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers volatile int32_t num_waiters_; 414c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#else 415c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers pthread_cond_t cond_; 416c604d731730b43231f63040c8db1d58304da0cf3Ian Rogers#endif 4175f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes DISALLOW_COPY_AND_ASSIGN(ConditionVariable); 4185f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes}; 4195f79133a435ebcb20000370d56046fe01201dd80Elliott Hughes 42000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Scoped locker/unlocker for a regular Mutex that acquires mu upon construction and releases it 42100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// upon destruction. 42200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersclass SCOPED_LOCKABLE MutexLock { 42300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 42481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers explicit MutexLock(Thread* self, Mutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : self_(self), mu_(mu) { 42581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.ExclusiveLock(self_); 42681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers } 42781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 42800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ~MutexLock() UNLOCK_FUNCTION() { 42981d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.ExclusiveUnlock(self_); 43000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 43100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 43200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers private: 43381d425b0b232962441616f8b14f73620bffef5e5Ian Rogers Thread* const self_; 43400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers Mutex& mu_; 43500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers DISALLOW_COPY_AND_ASSIGN(MutexLock); 43600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers}; 43700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Catch bug where variable name is omitted. "MutexLock (lock);" instead of "MutexLock mu(lock)". 438575e78c41ece0dec969d31f46be563d4eb7ae43bAndreas Gampe#define MutexLock(x) static_assert(0, "MutexLock declaration missing variable name") 43900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 44000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Scoped locker/unlocker for a ReaderWriterMutex that acquires read access to mu upon 44100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// construction and releases it upon destruction. 44200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersclass SCOPED_LOCKABLE ReaderMutexLock { 44300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 44481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers explicit ReaderMutexLock(Thread* self, ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : 44581d425b0b232962441616f8b14f73620bffef5e5Ian Rogers self_(self), mu_(mu) { 44681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.SharedLock(self_); 44781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers } 44881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 44900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ~ReaderMutexLock() UNLOCK_FUNCTION() { 45081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.SharedUnlock(self_); 45100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 45200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 45300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers private: 45481d425b0b232962441616f8b14f73620bffef5e5Ian Rogers Thread* const self_; 45500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ReaderWriterMutex& mu_; 45600f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers DISALLOW_COPY_AND_ASSIGN(ReaderMutexLock); 45700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers}; 45800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Catch bug where variable name is omitted. "ReaderMutexLock (lock);" instead of 45900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// "ReaderMutexLock mu(lock)". 460575e78c41ece0dec969d31f46be563d4eb7ae43bAndreas Gampe#define ReaderMutexLock(x) static_assert(0, "ReaderMutexLock declaration missing variable name") 46100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 46200f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Scoped locker/unlocker for a ReaderWriterMutex that acquires write access to mu upon 46300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// construction and releases it upon destruction. 46400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogersclass SCOPED_LOCKABLE WriterMutexLock { 46500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers public: 46681d425b0b232962441616f8b14f73620bffef5e5Ian Rogers explicit WriterMutexLock(Thread* self, ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : 46781d425b0b232962441616f8b14f73620bffef5e5Ian Rogers self_(self), mu_(mu) { 46881d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.ExclusiveLock(self_); 46981d425b0b232962441616f8b14f73620bffef5e5Ian Rogers } 47081d425b0b232962441616f8b14f73620bffef5e5Ian Rogers 47100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ~WriterMutexLock() UNLOCK_FUNCTION() { 47281d425b0b232962441616f8b14f73620bffef5e5Ian Rogers mu_.ExclusiveUnlock(self_); 47300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers } 47400f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 47500f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers private: 47650b35e2fd1a68cd1240e4a9d9f363e11764957d1Ian Rogers Thread* const self_; 47700f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers ReaderWriterMutex& mu_; 47800f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers DISALLOW_COPY_AND_ASSIGN(WriterMutexLock); 47900f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers}; 48000f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// Catch bug where variable name is omitted. "WriterMutexLock (lock);" instead of 48100f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers// "WriterMutexLock mu(lock)". 482575e78c41ece0dec969d31f46be563d4eb7ae43bAndreas Gampe#define WriterMutexLock(x) static_assert(0, "WriterMutexLock declaration missing variable name") 48300f7d0eaa6bd93d33bf0c1429bf4ba0b3f28abacIan Rogers 484719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers// Global mutexes corresponding to the levels above. 485719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogersclass Locks { 486719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers public: 487719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static void Init(); 488719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 489f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers // There's a potential race for two threads to try to suspend each other and for both of them 490f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers // to succeed and get blocked becoming runnable. This lock ensures that only one thread is 491f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers // requesting suspension of another at any time. As the the thread list suspend thread logic 492f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers // transitions to runnable, if the current thread were tried to be suspended then this thread 493f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers // would block holding this lock until it could safely request thread suspension of the other 494f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers // thread without that thread having a suspension request against this thread. This avoids a 495f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers // potential deadlock cycle. 496f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers static Mutex* thread_list_suspend_thread_lock_; 497f3d874c60ee3ada19ce26a5c4e532312b6f3a9e9Ian Rogers 4989ef78b59da51080882e47505896b420977fd79aeMathieu Chartier // Guards allocation entrypoint instrumenting. 4999ef78b59da51080882e47505896b420977fd79aeMathieu Chartier static Mutex* instrument_entrypoints_lock_ ACQUIRED_AFTER(thread_list_suspend_thread_lock_); 5009ef78b59da51080882e47505896b420977fd79aeMathieu Chartier 501719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // The mutator_lock_ is used to allow mutators to execute in a shared (reader) mode or to block 502719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // mutators by having an exclusive (writer) owner. In normal execution each mutator thread holds 503719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // a share on the mutator_lock_. The garbage collector may also execute with shared access but 504719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // at times requires exclusive access to the heap (not to be confused with the heap meta-data 505719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // guarded by the heap_lock_ below). When the garbage collector requires exclusive access it asks 506719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // the mutators to suspend themselves which also involves usage of the thread_suspend_count_lock_ 507719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // to cover weaknesses in using ReaderWriterMutexes with ConditionVariables. We use a condition 508719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // variable to wait upon in the suspension logic as releasing and then re-acquiring a share on 509719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // the mutator lock doesn't necessarily allow the exclusive user (e.g the garbage collector) 510719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // chance to acquire the lock. 511719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // 512719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Thread suspension: 513719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Shared users | Exclusive user 514719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // (holding mutator lock and in kRunnable state) | .. running .. 515719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | Request thread suspension by: 516719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | - acquiring thread_suspend_count_lock_ 517719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | - incrementing Thread::suspend_count_ on 518719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | all mutator threads 519719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | - releasing thread_suspend_count_lock_ 520719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | Block trying to acquire exclusive mutator lock 521719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Poll Thread::suspend_count_ and enter full | .. blocked .. 522719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // suspend code. | .. blocked .. 523719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Change state to kSuspended | .. blocked .. 524719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // x: Release share on mutator_lock_ | Carry out exclusive access 525719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Acquire thread_suspend_count_lock_ | .. exclusive .. 526719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // while Thread::suspend_count_ > 0 | .. exclusive .. 527719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // - wait on Thread::resume_cond_ | .. exclusive .. 528719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // (releases thread_suspend_count_lock_) | .. exclusive .. 529719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | Release mutator_lock_ 530719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | Request thread resumption by: 531719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | - acquiring thread_suspend_count_lock_ 532719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | - decrementing Thread::suspend_count_ on 533719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | all mutator threads 534719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. waiting .. | - notifying on Thread::resume_cond_ 535719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // - re-acquire thread_suspend_count_lock_ | - releasing thread_suspend_count_lock_ 536719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Release thread_suspend_count_lock_ | .. running .. 537719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Acquire share on mutator_lock_ | .. running .. 538719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // - This could block but the thread still | .. running .. 539719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // has a state of kSuspended and so this | .. running .. 540719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // isn't an issue. | .. running .. 541719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Acquire thread_suspend_count_lock_ | .. running .. 542719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // - we poll here as we're transitioning into | .. running .. 543719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // kRunnable and an individual thread suspend | .. running .. 544719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // request (e.g for debugging) won't try | .. running .. 545719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // to acquire the mutator lock (which would | .. running .. 546719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // block as we hold the mutator lock). This | .. running .. 547719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // poll ensures that if the suspender thought | .. running .. 548719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // we were suspended by incrementing our | .. running .. 549719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Thread::suspend_count_ and then reading | .. running .. 550719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // our state we go back to waiting on | .. running .. 551719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Thread::resume_cond_. | .. running .. 552719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // can_go_runnable = Thread::suspend_count_ == 0 | .. running .. 553719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Release thread_suspend_count_lock_ | .. running .. 554719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // if can_go_runnable | .. running .. 555719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Change state to kRunnable | .. running .. 556719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // else | .. running .. 557719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Goto x | .. running .. 558719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // .. running .. | .. running .. 5599ef78b59da51080882e47505896b420977fd79aeMathieu Chartier static ReaderWriterMutex* mutator_lock_ ACQUIRED_AFTER(instrument_entrypoints_lock_); 560719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 561719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Allow reader-writer mutual exclusion on the mark and live bitmaps of the heap. 562719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static ReaderWriterMutex* heap_bitmap_lock_ ACQUIRED_AFTER(mutator_lock_); 563719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 564719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Guards shutdown of the runtime. 565719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static Mutex* runtime_shutdown_lock_ ACQUIRED_AFTER(heap_bitmap_lock_); 566719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 5679e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu // Guards background profiler global state. 5689e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static Mutex* profiler_lock_ ACQUIRED_AFTER(runtime_shutdown_lock_); 5699e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu 5709e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu // Guards trace (ie traceview) requests. 5719e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static Mutex* trace_lock_ ACQUIRED_AFTER(profiler_lock_); 5729e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu 573306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom // Guards debugger recent allocation records. 574306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom static Mutex* alloc_tracker_lock_ ACQUIRED_AFTER(trace_lock_); 575306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom 576306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom // Guards updates to instrumentation to ensure mutual exclusion of 577306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom // events like deoptimization requests. 578306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom // TODO: improve name, perhaps instrumentation_update_lock_. 579306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom static Mutex* deoptimization_lock_ ACQUIRED_AFTER(alloc_tracker_lock_); 580306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom 581719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // The thread_list_lock_ guards ThreadList::list_. It is also commonly held to stop threads 582719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // attaching and detaching. 583306db81aba41eb244a4e8299cf58ac18ae9999c7Brian Carlstrom static Mutex* thread_list_lock_ ACQUIRED_AFTER(deoptimization_lock_); 584719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 58568d8b42ddec39ec0174162d90d4abaa004d1983eIan Rogers // Guards maintaining loading library data structures. 58668d8b42ddec39ec0174162d90d4abaa004d1983eIan Rogers static Mutex* jni_libraries_lock_ ACQUIRED_AFTER(thread_list_lock_); 58768d8b42ddec39ec0174162d90d4abaa004d1983eIan Rogers 588719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Guards breakpoints. 589ed2be1725fb79075892b1a9103487c9d9a95b350Sebastien Hertz static ReaderWriterMutex* breakpoint_lock_ ACQUIRED_AFTER(jni_libraries_lock_); 590719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 591719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Guards lists of classes within the class linker. 5929e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static ReaderWriterMutex* classlinker_classes_lock_ ACQUIRED_AFTER(breakpoint_lock_); 593719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 594719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // When declaring any Mutex add DEFAULT_MUTEX_ACQUIRED_AFTER to use annotalysis to check the code 595719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // doesn't try to hold a higher level Mutex. 596719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers #define DEFAULT_MUTEX_ACQUIRED_AFTER ACQUIRED_AFTER(Locks::classlinker_classes_lock_) 597719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 59874240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe static Mutex* allocated_monitor_ids_lock_ ACQUIRED_AFTER(classlinker_classes_lock_); 59974240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe 6009e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu // Guard the allocation/deallocation of thread ids. 60174240819ae09e29b2753ef38f4eb4be1c2762e2eAndreas Gampe static Mutex* allocated_thread_ids_lock_ ACQUIRED_AFTER(allocated_monitor_ids_lock_); 6029e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu 6039e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu // Guards modification of the LDT on x86. 6049e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static Mutex* modify_ldt_lock_ ACQUIRED_AFTER(allocated_thread_ids_lock_); 6059e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu 606719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Guards intern table. 6079e36931cc79ca665908db9575126881d1cfdea5aChao-ying Fu static Mutex* intern_table_lock_ ACQUIRED_AFTER(modify_ldt_lock_); 608719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 609a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards reference processor. 610a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_processor_lock_ ACQUIRED_AFTER(intern_table_lock_); 611a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 612a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards cleared references queue. 613a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_cleared_references_lock_ ACQUIRED_AFTER(reference_processor_lock_); 614a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 615a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards weak references queue. 616a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_weak_references_lock_ ACQUIRED_AFTER(reference_queue_cleared_references_lock_); 617a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 618a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards finalizer references queue. 619a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_finalizer_references_lock_ ACQUIRED_AFTER(reference_queue_weak_references_lock_); 620a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 621a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards phantom references queue. 622a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_phantom_references_lock_ ACQUIRED_AFTER(reference_queue_finalizer_references_lock_); 623a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 624a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier // Guards soft references queue. 625a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* reference_queue_soft_references_lock_ ACQUIRED_AFTER(reference_queue_phantom_references_lock_); 626a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier 627719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Have an exclusive aborting thread. 628a5a53efea976af505f4f849b5925d5e14c4f8e5cMathieu Chartier static Mutex* abort_lock_ ACQUIRED_AFTER(reference_queue_soft_references_lock_); 629719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 630719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Allow mutual exclusion when manipulating Thread::suspend_count_. 631719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // TODO: Does the trade-off of a per-thread lock make sense? 632719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static Mutex* thread_suspend_count_lock_ ACQUIRED_AFTER(abort_lock_); 633719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 634719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // One unexpected signal at a time lock. 635719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static Mutex* unexpected_signal_lock_ ACQUIRED_AFTER(thread_suspend_count_lock_); 636719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 6373eed93dd5be03e5539827bebf0f414251a12e15eHiroshi Yamauchi // Guards the maps in mem_map. 6383eed93dd5be03e5539827bebf0f414251a12e15eHiroshi Yamauchi static Mutex* mem_maps_lock_ ACQUIRED_AFTER(unexpected_signal_lock_); 6393eed93dd5be03e5539827bebf0f414251a12e15eHiroshi Yamauchi 640719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers // Have an exclusive logging thread. 641719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers static Mutex* logging_lock_ ACQUIRED_AFTER(unexpected_signal_lock_); 642719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers}; 643719d1a33f6569864f529e5a3fff59e7bca97aad0Ian Rogers 6448daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes} // namespace art 6458daa0929f08a3080ea64dbd4e997e72f411e6fc9Elliott Hughes 646fc0e3219edc9a5bf81b166e82fd5db2796eb6a0dBrian Carlstrom#endif // ART_RUNTIME_BASE_MUTEX_H_ 647