blob: c464400f467aaf310736efa8eda5e4905102113c [file] [log] [blame]
Elliott Hughes5f791332011-09-15 17:45:30 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_MONITOR_H_
18#define ART_RUNTIME_MONITOR_H_
Elliott Hughes5f791332011-09-15 17:45:30 -070019
20#include <pthread.h>
21#include <stdint.h>
22
Elliott Hughes8e4aac52011-09-26 17:03:36 -070023#include <iosfwd>
Elliott Hughesc33a32b2011-10-11 18:18:07 -070024#include <list>
Elliott Hughesf327e072013-01-09 16:01:26 -080025#include <vector>
Elliott Hughes8e4aac52011-09-26 17:03:36 -070026
Elliott Hughes76b61672012-12-12 17:47:30 -080027#include "base/mutex.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080028#include "root_visitor.h"
29#include "thread_state.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070030
31namespace art {
32
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080033namespace mirror {
Brian Carlstromea46f952013-07-30 01:26:50 -070034 class ArtMethod;
35 class Object;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080036} // namespace mirror
Ian Rogersd9c4fc92013-10-01 19:45:43 -070037class LockWord;
Elliott Hughes54e7df12011-09-16 11:47:04 -070038class Thread;
Elliott Hughes08fc03a2012-06-26 17:34:00 -070039class StackVisitor;
Elliott Hughes5f791332011-09-15 17:45:30 -070040
41class Monitor {
42 public:
Ian Rogersd9c4fc92013-10-01 19:45:43 -070043 // The default number of spins that are done before thread suspension is used to forcibly inflate
44 // a lock word. See Runtime::max_spins_before_thin_lock_inflation_.
45 constexpr static size_t kDefaultMaxSpinsBeforeThinLockInflation = 50;
46
Elliott Hughes5f791332011-09-15 17:45:30 -070047 ~Monitor();
48
Elliott Hughesfc861622011-10-17 17:57:47 -070049 static bool IsSensitiveThread();
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080050 static void Init(uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)());
Elliott Hughes32d6e1e2011-10-11 14:47:44 -070051
Ian Rogersd9c4fc92013-10-01 19:45:43 -070052 // Return the thread id of the lock owner or 0 when there is no owner.
53 static uint32_t GetLockOwnerThreadId(mirror::Object* obj)
54 NO_THREAD_SAFETY_ANALYSIS; // TODO: Reading lock owner without holding lock is racy.
Elliott Hughes5f791332011-09-15 17:45:30 -070055
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080056 static void MonitorEnter(Thread* thread, mirror::Object* obj)
Ian Rogers00f7d0e2012-07-19 15:28:27 -070057 EXCLUSIVE_LOCK_FUNCTION(monitor_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -070058 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080059 static bool MonitorExit(Thread* thread, mirror::Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -070060 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Ian Rogers00f7d0e2012-07-19 15:28:27 -070061 UNLOCK_FUNCTION(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -070062
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080063 static void Notify(Thread* self, mirror::Object* obj)
Ian Rogersd9c4fc92013-10-01 19:45:43 -070064 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers13c479e2013-10-11 07:59:01 -070065 DoNotify(self, obj, false);
Ian Rogersd9c4fc92013-10-01 19:45:43 -070066 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080067 static void NotifyAll(Thread* self, mirror::Object* obj)
Ian Rogersd9c4fc92013-10-01 19:45:43 -070068 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers13c479e2013-10-11 07:59:01 -070069 DoNotify(self, obj, true);
Ian Rogersd9c4fc92013-10-01 19:45:43 -070070 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080071 static void Wait(Thread* self, mirror::Object* obj, int64_t ms, int32_t ns,
72 bool interruptShouldThrow, ThreadState why)
Ian Rogersb726dcb2012-09-05 08:57:23 -070073 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -070074
Ian Rogers00f7d0e2012-07-19 15:28:27 -070075 static void DescribeWait(std::ostream& os, const Thread* thread)
Ian Rogersb726dcb2012-09-05 08:57:23 -070076 LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
77 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes4993bbc2013-01-10 15:41:25 -080078
Elliott Hughesf9501702013-01-11 11:22:27 -080079 // Used to implement JDWP's ThreadReference.CurrentContendedMonitor.
Ian Rogersd9c4fc92013-10-01 19:45:43 -070080 static mirror::Object* GetContendedMonitor(Thread* thread)
81 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughesf9501702013-01-11 11:22:27 -080082
Elliott Hughes4993bbc2013-01-10 15:41:25 -080083 // Calls 'callback' once for each lock held in the single stack frame represented by
84 // the current state of 'stack_visitor'.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080085 static void VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*),
86 void* callback_context)
Ian Rogersb726dcb2012-09-05 08:57:23 -070087 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes8e4aac52011-09-26 17:03:36 -070088
Ian Rogersd9c4fc92013-10-01 19:45:43 -070089 static bool IsValidLockWord(LockWord lock_word);
Ian Rogers7dfb28c2013-08-22 08:18:36 -070090
Mathieu Chartierad2541a2013-10-25 10:05:23 -070091 mirror::Object* GetObject() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -070092 return obj_;
93 }
94
Mathieu Chartier6aa3df92013-09-17 15:17:28 -070095 void SetObject(mirror::Object* object);
Elliott Hughesc33a32b2011-10-11 18:18:07 -070096
Ian Rogersd9c4fc92013-10-01 19:45:43 -070097 Thread* GetOwner() const NO_THREAD_SAFETY_ANALYSIS {
98 return owner_;
99 }
100
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700101 int32_t GetHashCode() const {
102 return hash_code_;
103 }
104
105 bool IsLocked() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
106
107 static void InflateThinLocked(Thread* self, mirror::Object* obj, LockWord lock_word,
108 uint32_t hash_code) NO_THREAD_SAFETY_ANALYSIS;
109
Elliott Hughes5f791332011-09-15 17:45:30 -0700110 private:
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700111 explicit Monitor(Thread* owner, mirror::Object* obj, uint32_t hash_code)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700112 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700113
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700114 // Install the monitor into its object, may fail if another thread installs a different monitor
115 // first.
116 bool Install(Thread* self)
117 LOCKS_EXCLUDED(monitor_lock_)
118 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
119
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700120 void AppendToWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
121 void RemoveFromWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700122
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700123 static void Inflate(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700124 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700125
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700126 void LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent,
127 const char* owner_filename, uint32_t owner_line_number)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700128 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughesfc861622011-10-17 17:57:47 -0700129
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800130 static void FailedUnlock(mirror::Object* obj, Thread* expected_owner, Thread* found_owner, Monitor* mon)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700131 LOCKS_EXCLUDED(Locks::thread_list_lock_)
132 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800133
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700134 void Lock(Thread* self)
135 LOCKS_EXCLUDED(monitor_lock_)
136 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
137 bool Unlock(Thread* thread)
138 LOCKS_EXCLUDED(monitor_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700139 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700140
Ian Rogers13c479e2013-10-11 07:59:01 -0700141 static void DoNotify(Thread* self, mirror::Object* obj, bool notify_all)
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700142 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
143
144 void Notify(Thread* self)
145 LOCKS_EXCLUDED(monitor_lock_)
146 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
147
148 void NotifyAll(Thread* self)
149 LOCKS_EXCLUDED(monitor_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700150 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700151
152
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800153 void Wait(Thread* self, int64_t msec, int32_t nsec, bool interruptShouldThrow, ThreadState why)
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700154 LOCKS_EXCLUDED(monitor_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700155 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700156
jeffhao33dc7712011-11-09 17:54:24 -0800157 // Translates the provided method and pc into its declaring class' source file and line number.
Brian Carlstromea46f952013-07-30 01:26:50 -0700158 void TranslateLocation(const mirror::ArtMethod* method, uint32_t pc,
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700159 const char** source_file, uint32_t* line_number) const
Ian Rogersb726dcb2012-09-05 08:57:23 -0700160 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
jeffhao33dc7712011-11-09 17:54:24 -0800161
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700162 uint32_t GetOwnerThreadId();
163
Elliott Hughesfc861622011-10-17 17:57:47 -0700164 static bool (*is_sensitive_thread_hook_)();
Elliott Hughesfc861622011-10-17 17:57:47 -0700165 static uint32_t lock_profiling_threshold_;
Elliott Hughes32d6e1e2011-10-11 14:47:44 -0700166
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700167 Mutex monitor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700168 ConditionVariable monitor_contenders_ GUARDED_BY(monitor_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700169
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700170 // Which thread currently owns the lock?
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700171 Thread* volatile owner_ GUARDED_BY(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700172
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700173 // Owner's recursive lock depth.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700174 int lock_count_ GUARDED_BY(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700175
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700176 // What object are we part of.
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700177 mirror::Object* obj_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700178
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700179 // Threads currently waiting on this monitor.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700180 Thread* wait_set_ GUARDED_BY(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700181
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700182 // Stored object hash code, always generated.
183 const uint32_t hash_code_;
184
Ian Rogers0399dde2012-06-06 17:09:28 -0700185 // Method and dex pc where the lock owner acquired the lock, used when lock
jeffhao33dc7712011-11-09 17:54:24 -0800186 // sampling is enabled. locking_method_ may be null if the lock is currently
187 // unlocked, or if the lock is acquired by the system when the stack is empty.
Brian Carlstromea46f952013-07-30 01:26:50 -0700188 const mirror::ArtMethod* locking_method_ GUARDED_BY(monitor_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700189 uint32_t locking_dex_pc_ GUARDED_BY(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700190
Elliott Hughesf327e072013-01-09 16:01:26 -0800191 friend class MonitorInfo;
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700192 friend class MonitorList;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800193 friend class mirror::Object;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700194 DISALLOW_COPY_AND_ASSIGN(Monitor);
195};
196
197class MonitorList {
198 public:
199 MonitorList();
200 ~MonitorList();
201
202 void Add(Monitor* m);
203
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700204 void SweepMonitorList(RootVisitor visitor, void* arg) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -0700205 void DisallowNewMonitors();
206 void AllowNewMonitors();
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700207
208 private:
Mathieu Chartierc11d9b82013-09-19 10:01:59 -0700209 bool allow_new_monitors_ GUARDED_BY(monitor_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700210 Mutex monitor_list_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Mathieu Chartierc11d9b82013-09-19 10:01:59 -0700211 ConditionVariable monitor_add_condition_ GUARDED_BY(monitor_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700212 std::list<Monitor*> list_ GUARDED_BY(monitor_list_lock_);
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700213
Ian Rogers7dfb28c2013-08-22 08:18:36 -0700214 friend class Monitor;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700215 DISALLOW_COPY_AND_ASSIGN(MonitorList);
Elliott Hughes5f791332011-09-15 17:45:30 -0700216};
217
Elliott Hughesf327e072013-01-09 16:01:26 -0800218// Collects information about the current state of an object's monitor.
219// This is very unsafe, and must only be called when all threads are suspended.
220// For use only by the JDWP implementation.
221class MonitorInfo {
222 public:
Brian Carlstrom93ba8932013-07-17 21:31:49 -0700223 explicit MonitorInfo(mirror::Object* o) EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughesf327e072013-01-09 16:01:26 -0800224
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700225 Thread* owner_;
226 size_t entry_count_;
227 std::vector<Thread*> waiters_;
Elliott Hughesf327e072013-01-09 16:01:26 -0800228
229 private:
230 DISALLOW_COPY_AND_ASSIGN(MonitorInfo);
231};
232
Elliott Hughes5f791332011-09-15 17:45:30 -0700233} // namespace art
234
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700235#endif // ART_RUNTIME_MONITOR_H_