blob: 1b5ab763e240d83e8f4b7cb0c599a42584d3a52e [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
Elliott Hughes54e7df12011-09-16 11:47:04 -070017#ifndef ART_SRC_MONITOR_H_
18#define ART_SRC_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"
Elliott Hughesc33a32b2011-10-11 18:18:07 -070028#include "heap.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070029#include "thread.h"
Elliott Hughes5f791332011-09-15 17:45:30 -070030
31namespace art {
32
33/*
34 * Monitor shape field. Used to distinguish thin locks from fat locks.
35 */
36#define LW_SHAPE_THIN 0
37#define LW_SHAPE_FAT 1
Elliott Hughes5f791332011-09-15 17:45:30 -070038
39/*
40 * Hash state field. Used to signify that an object has had its
41 * identity hash code exposed or relocated.
42 */
43#define LW_HASH_STATE_UNHASHED 0
44#define LW_HASH_STATE_HASHED 1
45#define LW_HASH_STATE_HASHED_AND_MOVED 3
46#define LW_HASH_STATE_MASK 0x3
47#define LW_HASH_STATE_SHIFT 1
48#define LW_HASH_STATE(x) (((x) >> LW_HASH_STATE_SHIFT) & LW_HASH_STATE_MASK)
49
50/*
Elliott Hughes5f791332011-09-15 17:45:30 -070051 * Lock owner field. Contains the thread id of the thread currently
52 * holding the lock.
53 */
54#define LW_LOCK_OWNER_MASK 0xffff
55#define LW_LOCK_OWNER_SHIFT 3
56#define LW_LOCK_OWNER(x) (((x) >> LW_LOCK_OWNER_SHIFT) & LW_LOCK_OWNER_MASK)
57
Mathieu Chartier66f19252012-09-18 08:57:04 -070058class AbstractMethod;
Elliott Hughes54e7df12011-09-16 11:47:04 -070059class Object;
60class Thread;
Elliott Hughes08fc03a2012-06-26 17:34:00 -070061class StackVisitor;
Elliott Hughes5f791332011-09-15 17:45:30 -070062
63class Monitor {
64 public:
65 ~Monitor();
66
Elliott Hughesfc861622011-10-17 17:57:47 -070067 static bool IsSensitiveThread();
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -080068 static void Init(uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)());
Elliott Hughes32d6e1e2011-10-11 14:47:44 -070069
Ian Rogers00f7d0e2012-07-19 15:28:27 -070070 static uint32_t GetThinLockId(uint32_t raw_lock_word)
71 NO_THREAD_SAFETY_ANALYSIS; // Reading lock owner without holding lock is racy.
Elliott Hughes5f791332011-09-15 17:45:30 -070072
Ian Rogers00f7d0e2012-07-19 15:28:27 -070073 static void MonitorEnter(Thread* thread, Object* obj)
74 EXCLUSIVE_LOCK_FUNCTION(monitor_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -070075 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -070076 static bool MonitorExit(Thread* thread, Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -070077 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Ian Rogers00f7d0e2012-07-19 15:28:27 -070078 UNLOCK_FUNCTION(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -070079
Ian Rogers00f7d0e2012-07-19 15:28:27 -070080 static void Notify(Thread* self, Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -070081 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -070082 static void NotifyAll(Thread* self, Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -070083 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes4cd121e2013-01-07 17:35:41 -080084 static void Wait(Thread* self, Object* obj, int64_t ms, int32_t ns, bool interruptShouldThrow, ThreadState why)
Ian Rogersb726dcb2012-09-05 08:57:23 -070085 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -070086
Ian Rogers00f7d0e2012-07-19 15:28:27 -070087 static void DescribeWait(std::ostream& os, const Thread* thread)
Ian Rogersb726dcb2012-09-05 08:57:23 -070088 LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
89 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes4993bbc2013-01-10 15:41:25 -080090
Elliott Hughesf9501702013-01-11 11:22:27 -080091 // Used to implement JDWP's ThreadReference.CurrentContendedMonitor.
92 static Object* GetContendedMonitor(Thread* thread);
93
Elliott Hughes4993bbc2013-01-10 15:41:25 -080094 // Calls 'callback' once for each lock held in the single stack frame represented by
95 // the current state of 'stack_visitor'.
96 static void VisitLocks(StackVisitor* stack_visitor, void (*callback)(Object*, void*), void* callback_context)
Ian Rogersb726dcb2012-09-05 08:57:23 -070097 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes8e4aac52011-09-26 17:03:36 -070098
Elliott Hughesc33a32b2011-10-11 18:18:07 -070099 Object* GetObject();
100
Elliott Hughes5f791332011-09-15 17:45:30 -0700101 private:
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700102 explicit Monitor(Thread* owner, Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700103 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700104
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700105 void AppendToWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
106 void RemoveFromWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700107
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700108 static void Inflate(Thread* self, Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700109 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700110
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700111 void LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent,
112 const char* owner_filename, uint32_t owner_line_number)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700113 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughesfc861622011-10-17 17:57:47 -0700114
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700115 static void FailedUnlock(Object* obj, Thread* expected_owner, Thread* found_owner, Monitor* mon)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700116 LOCKS_EXCLUDED(Locks::thread_list_lock_)
117 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800118
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700119 void Lock(Thread* self) EXCLUSIVE_LOCK_FUNCTION(monitor_lock_);
120 bool Unlock(Thread* thread, bool for_wait) UNLOCK_FUNCTION(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700121
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700122 void Notify(Thread* self) NO_THREAD_SAFETY_ANALYSIS;
Ian Rogers50b35e22012-10-04 10:09:15 -0700123 void NotifyWithLock(Thread* self)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700124 EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700125 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700126
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700127 void NotifyAll(Thread* self) NO_THREAD_SAFETY_ANALYSIS;
128 void NotifyAllWithLock()
129 EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700130 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700131
132
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800133 void Wait(Thread* self, int64_t msec, int32_t nsec, bool interruptShouldThrow, ThreadState why)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700134 NO_THREAD_SAFETY_ANALYSIS;
Elliott Hughes4cd121e2013-01-07 17:35:41 -0800135 void WaitWithLock(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow, ThreadState why)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700136 EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700137 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700138
jeffhao33dc7712011-11-09 17:54:24 -0800139 // Translates the provided method and pc into its declaring class' source file and line number.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700140 void TranslateLocation(const AbstractMethod* method, uint32_t pc,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700141 const char*& source_file, uint32_t& line_number) const
Ian Rogersb726dcb2012-09-05 08:57:23 -0700142 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
jeffhao33dc7712011-11-09 17:54:24 -0800143
Elliott Hughesfc861622011-10-17 17:57:47 -0700144 static bool (*is_sensitive_thread_hook_)();
Elliott Hughesfc861622011-10-17 17:57:47 -0700145 static uint32_t lock_profiling_threshold_;
Elliott Hughes32d6e1e2011-10-11 14:47:44 -0700146
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700147 Mutex monitor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
148
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700149 // Which thread currently owns the lock?
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800150 Thread* volatile owner_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700151
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700152 // Owner's recursive lock depth.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700153 int lock_count_ GUARDED_BY(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700154
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700155 // What object are we part of (for debugging).
Ian Rogers6d0b13e2012-02-07 09:25:29 -0800156 Object* const obj_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700157
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700158 // Threads currently waiting on this monitor.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700159 Thread* wait_set_ GUARDED_BY(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700160
Ian Rogers0399dde2012-06-06 17:09:28 -0700161 // Method and dex pc where the lock owner acquired the lock, used when lock
jeffhao33dc7712011-11-09 17:54:24 -0800162 // sampling is enabled. locking_method_ may be null if the lock is currently
163 // unlocked, or if the lock is acquired by the system when the stack is empty.
Mathieu Chartier66f19252012-09-18 08:57:04 -0700164 const AbstractMethod* locking_method_ GUARDED_BY(monitor_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700165 uint32_t locking_dex_pc_ GUARDED_BY(monitor_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700166
Elliott Hughesf327e072013-01-09 16:01:26 -0800167 friend class MonitorInfo;
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700168 friend class MonitorList;
Elliott Hughes5f791332011-09-15 17:45:30 -0700169 friend class Object;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700170 DISALLOW_COPY_AND_ASSIGN(Monitor);
171};
172
173class MonitorList {
174 public:
175 MonitorList();
176 ~MonitorList();
177
178 void Add(Monitor* m);
179
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700180 void SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700181 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700182
183 private:
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700184 Mutex monitor_list_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
185 std::list<Monitor*> list_ GUARDED_BY(monitor_list_lock_);
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700186
187 DISALLOW_COPY_AND_ASSIGN(MonitorList);
Elliott Hughes5f791332011-09-15 17:45:30 -0700188};
189
Elliott Hughesf327e072013-01-09 16:01:26 -0800190// Collects information about the current state of an object's monitor.
191// This is very unsafe, and must only be called when all threads are suspended.
192// For use only by the JDWP implementation.
193class MonitorInfo {
194 public:
195 MonitorInfo(Object* o) EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
196
197 Thread* owner;
198 size_t entry_count;
199 std::vector<Thread*> waiters;
200
201 private:
202 DISALLOW_COPY_AND_ASSIGN(MonitorInfo);
203};
204
Elliott Hughes5f791332011-09-15 17:45:30 -0700205} // namespace art
206
Elliott Hughes54e7df12011-09-16 11:47:04 -0700207#endif // ART_SRC_MONITOR_H_