1 /*
2 * Copyright (c) 1998, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_RUNTIME_OBJECTMONITOR_HPP
26 #define SHARE_VM_RUNTIME_OBJECTMONITOR_HPP
27
28 #include "memory/padded.hpp"
29 #include "runtime/os.hpp"
30 #include "runtime/park.hpp"
31 #include "runtime/perfData.hpp"
32
33 // ObjectWaiter serves as a "proxy" or surrogate thread.
34 // TODO-FIXME: Eliminate ObjectWaiter and use the thread-specific
35 // ParkEvent instead. Beware, however, that the JVMTI code
36 // knows about ObjectWaiters, so we'll have to reconcile that code.
37 // See next_waiter(), first_waiter(), etc.
38
39 class ObjectWaiter : public StackObj {
40 public:
41 enum TStates { TS_UNDEF, TS_READY, TS_RUN, TS_WAIT, TS_ENTER, TS_CXQ };
42 enum Sorted { PREPEND, APPEND, SORTED };
43 ObjectWaiter * volatile _next;
44 ObjectWaiter * volatile _prev;
45 Thread* _thread;
46 jlong _notifier_tid;
47 ParkEvent * _event;
48 volatile int _notified;
49 volatile TStates TState;
50 Sorted _Sorted; // List placement disposition
51 bool _active; // Contention monitoring is enabled
52 public:
53 ObjectWaiter(Thread* thread);
54
55 void wait_reenter_begin(ObjectMonitor *mon);
56 void wait_reenter_end(ObjectMonitor *mon);
57 };
58
59 // forward declaration to avoid include tracing.hpp
60 class EventJavaMonitorWait;
61
62 // The ObjectMonitor class implements the heavyweight version of a
63 // JavaMonitor. The lightweight BasicLock/stack lock version has been
64 // inflated into an ObjectMonitor. This inflation is typically due to
65 // contention or use of Object.wait().
66 //
67 // WARNING: This is a very sensitive and fragile class. DO NOT make any
68 // changes unless you are fully aware of the underlying semantics.
69 //
70 // Class JvmtiRawMonitor currently inherits from ObjectMonitor so
71 // changes in this class must be careful to not break JvmtiRawMonitor.
72 // These two subsystems should be separated.
73 //
74 // ObjectMonitor Layout Overview/Highlights/Restrictions:
75 //
76 // - The _header field must be at offset 0 because the displaced header
77 // from markOop is stored there. We do not want markOop.hpp to include
78 // ObjectMonitor.hpp to avoid exposing ObjectMonitor everywhere. This
79 // means that ObjectMonitor cannot inherit from any other class nor can
80 // it use any virtual member functions. This restriction is critical to
81 // the proper functioning of the VM.
82 // - The _header and _owner fields should be separated by enough space
83 // to avoid false sharing due to parallel access by different threads.
84 // This is an advisory recommendation.
85 // - The general layout of the fields in ObjectMonitor is:
86 // _header
87 // <lightly_used_fields>
88 // <optional padding>
89 // _owner
90 // <remaining_fields>
91 // - The VM assumes write ordering and machine word alignment with
92 // respect to the _owner field and the <remaining_fields> that can
93 // be read in parallel by other threads.
94 // - Generally fields that are accessed closely together in time should
95 // be placed proximally in space to promote data cache locality. That
96 // is, temporal locality should condition spatial locality.
97 // - We have to balance avoiding false sharing with excessive invalidation
98 // from coherence traffic. As such, we try to cluster fields that tend
99 // to be _written_ at approximately the same time onto the same data
100 // cache line.
101 // - We also have to balance the natural tension between minimizing
102 // single threaded capacity misses with excessive multi-threaded
103 // coherency misses. There is no single optimal layout for both
104 // single-threaded and multi-threaded environments.
105 //
106 // - See ObjectMonitor::sanity_checks() for how critical restrictions are
107 // enforced and advisory recommendations are reported.
108 // - Adjacent ObjectMonitors should be separated by enough space to avoid
109 // false sharing. This is handled by the ObjectMonitor allocation code
110 // in synchronizer.cpp. Also see ObjectSynchronizer::sanity_checks().
111 //
112 // Futures notes:
113 // - Separating _owner from the <remaining_fields> by enough space to
114 // avoid false sharing might be profitable. Given
115 // http://blogs.oracle.com/dave/entry/cas_and_cache_trivia_invalidate
116 // we know that the CAS in monitorenter will invalidate the line
117 // underlying _owner. We want to avoid an L1 data cache miss on that
118 // same line for monitorexit. Putting these <remaining_fields>:
119 // _recursions, _EntryList, _cxq, and _succ, all of which may be
120 // fetched in the inflated unlock path, on a different cache line
121 // would make them immune to CAS-based invalidation from the _owner
122 // field.
123 //
124 // - The _recursions field should be of type int, or int32_t but not
125 // intptr_t. There's no reason to use a 64-bit type for this field
126 // in a 64-bit JVM.
127
128 class ObjectMonitor {
129 public:
130 enum {
131 OM_OK, // no error
132 OM_SYSTEM_ERROR, // operating system error
133 OM_ILLEGAL_MONITOR_STATE, // IllegalMonitorStateException
134 OM_INTERRUPTED, // Thread.interrupt()
135 OM_TIMED_OUT // Object.wait() timed out
136 };
137
138 private:
139 friend class ObjectSynchronizer;
140 friend class ObjectWaiter;
141 friend class VMStructs;
142
143 volatile markOop _header; // displaced object header word - mark
144 void* volatile _object; // backward object pointer - strong root
145 public:
146 ObjectMonitor * FreeNext; // Free list linkage
147 private:
148 DEFINE_PAD_MINUS_SIZE(0, DEFAULT_CACHE_LINE_SIZE,
149 sizeof(volatile markOop) + sizeof(void * volatile) +
150 sizeof(ObjectMonitor *));
151 protected: // protected for JvmtiRawMonitor
152 void * volatile _owner; // pointer to owning thread OR BasicLock
153 volatile jlong _previous_owner_tid; // thread id of the previous owner of the monitor
154 volatile intptr_t _recursions; // recursion count, 0 for first entry
155 ObjectWaiter * volatile _EntryList; // Threads blocked on entry or reentry.
156 // The list is actually composed of WaitNodes,
157 // acting as proxies for Threads.
158 private:
159 ObjectWaiter * volatile _cxq; // LL of recently-arrived threads blocked on entry.
160 Thread * volatile _succ; // Heir presumptive thread - used for futile wakeup throttling
161 Thread * volatile _Responsible;
162
163 volatile int _Spinner; // for exit->spinner handoff optimization
164 volatile int _SpinDuration;
165
166 volatile jint _count; // reference count to prevent reclamation/deflation
167 // at stop-the-world time. See deflate_idle_monitors().
168 // _count is approximately |_WaitSet| + |_EntryList|
169 protected:
170 ObjectWaiter * volatile _WaitSet; // LL of threads wait()ing on the monitor
171 volatile jint _waiters; // number of waiting threads
172 private:
173 volatile int _WaitSetLock; // protects Wait Queue - simple spinlock
174 typedef enum { Free = 0, New, Old } AllocationState; // Free must be 0 for monitor to be free after memset(..,0,..).
175 AllocationState _allocation_state;
176
177 public:
178 static void Initialize();
179
180 // Only perform a PerfData operation if the PerfData object has been
181 // allocated and if the PerfDataManager has not freed the PerfData
182 // objects which can happen at normal VM shutdown.
183 //
184 #define OM_PERFDATA_OP(f, op_str) \
185 do { \
186 if (ObjectMonitor::_sync_ ## f != NULL && \
187 PerfDataManager::has_PerfData()) { \
188 ObjectMonitor::_sync_ ## f->op_str; \
189 } \
190 } while (0)
191
192 static PerfCounter * _sync_ContendedLockAttempts;
193 static PerfCounter * _sync_FutileWakeups;
194 static PerfCounter * _sync_Parks;
195 static PerfCounter * _sync_EmptyNotifications;
196 static PerfCounter * _sync_Notifications;
197 static PerfCounter * _sync_SlowEnter;
198 static PerfCounter * _sync_SlowExit;
199 static PerfCounter * _sync_SlowNotify;
200 static PerfCounter * _sync_SlowNotifyAll;
201 static PerfCounter * _sync_FailedSpins;
202 static PerfCounter * _sync_SuccessfulSpins;
203 static PerfCounter * _sync_PrivateA;
204 static PerfCounter * _sync_PrivateB;
205 static PerfCounter * _sync_MonInCirculation;
206 static PerfCounter * _sync_MonScavenged;
207 static PerfCounter * _sync_Inflations;
208 static PerfCounter * _sync_Deflations;
209 static PerfLongVariable * _sync_MonExtant;
210
211 static int Knob_ExitRelease;
212 static int Knob_Verbose;
213 static int Knob_VerifyInUse;
214 static int Knob_VerifyMatch;
215 static int Knob_SpinLimit;
216
217 void* operator new (size_t size) throw() {
218 return AllocateHeap(size, mtInternal);
219 }
220 void* operator new[] (size_t size) throw() {
221 return operator new (size);
222 }
223 void operator delete(void* p) {
224 FreeHeap(p);
225 }
226 void operator delete[] (void *p) {
227 operator delete(p);
228 }
229
230 // TODO-FIXME: the "offset" routines should return a type of off_t instead of int ...
231 // ByteSize would also be an appropriate type.
232 static int header_offset_in_bytes() { return offset_of(ObjectMonitor, _header); }
233 static int object_offset_in_bytes() { return offset_of(ObjectMonitor, _object); }
234 static int owner_offset_in_bytes() { return offset_of(ObjectMonitor, _owner); }
235 static int count_offset_in_bytes() { return offset_of(ObjectMonitor, _count); }
236 static int recursions_offset_in_bytes() { return offset_of(ObjectMonitor, _recursions); }
237 static int cxq_offset_in_bytes() { return offset_of(ObjectMonitor, _cxq); }
238 static int succ_offset_in_bytes() { return offset_of(ObjectMonitor, _succ); }
239 static int EntryList_offset_in_bytes() { return offset_of(ObjectMonitor, _EntryList); }
240
241 // ObjectMonitor references can be ORed with markOopDesc::monitor_value
242 // as part of the ObjectMonitor tagging mechanism. When we combine an
243 // ObjectMonitor reference with an offset, we need to remove the tag
244 // value in order to generate the proper address.
245 //
246 // We can either adjust the ObjectMonitor reference and then add the
247 // offset or we can adjust the offset that is added to the ObjectMonitor
248 // reference. The latter avoids an AGI (Address Generation Interlock)
249 // stall so the helper macro adjusts the offset value that is returned
250 // to the ObjectMonitor reference manipulation code:
251 //
252 #define OM_OFFSET_NO_MONITOR_VALUE_TAG(f) \
253 ((ObjectMonitor::f ## _offset_in_bytes()) - markOopDesc::monitor_value)
254
255 markOop header() const;
256 void set_header(markOop hdr);
257
258 intptr_t is_busy() const {
259 // TODO-FIXME: merge _count and _waiters.
260 // TODO-FIXME: assert _owner == null implies _recursions = 0
261 // TODO-FIXME: assert _WaitSet != null implies _count > 0
262 return _count|_waiters|intptr_t(_owner)|intptr_t(_cxq)|intptr_t(_EntryList);
263 }
264
265 intptr_t is_entered(Thread* current) const;
266
267 void* owner() const;
268 void set_owner(void* owner);
269
270 jint waiters() const;
271
272 jint count() const;
273 jint contentions() const;
274 intptr_t recursions() const { return _recursions; }
275
276 // JVM/TI GetObjectMonitorUsage() needs this:
277 ObjectWaiter* first_waiter() { return _WaitSet; }
278 ObjectWaiter* next_waiter(ObjectWaiter* o) { return o->_next; }
279 Thread* thread_of_waiter(ObjectWaiter* o) { return o->_thread; }
280
281 protected:
282 // We don't typically expect or want the ctors or dtors to run.
283 // normal ObjectMonitors are type-stable and immortal.
284 ObjectMonitor() { ::memset((void *)this, 0, sizeof(*this)); }
285
286 ~ObjectMonitor() {
287 // TODO: Add asserts ...
288 // _cxq == 0 _succ == NULL _owner == NULL _waiters == 0
289 // _count == 0 _EntryList == NULL etc
290 }
291
292 private:
293 void Recycle() {
294 // TODO: add stronger asserts ...
295 // _cxq == 0 _succ == NULL _owner == NULL _waiters == 0
296 // _count == 0 EntryList == NULL
297 // _recursions == 0 _WaitSet == NULL
298 assert(((is_busy()|_recursions) == 0), "freeing inuse monitor");
299 _succ = NULL;
300 _EntryList = NULL;
301 _cxq = NULL;
302 _WaitSet = NULL;
303 _recursions = 0;
304 }
305
306 public:
307
308 void* object() const;
309 void* object_addr();
310 void set_object(void* obj);
311 void set_allocation_state(AllocationState s) { _allocation_state = s; }
312 AllocationState allocation_state() const { return _allocation_state; }
313 bool is_free() const { return _allocation_state == Free; }
314 bool is_active() const { return !is_free(); }
315 bool is_old() const { return _allocation_state == Old; }
316 bool is_new() const { return _allocation_state == New; }
317
318 bool check(TRAPS); // true if the thread owns the monitor.
319 void check_slow(TRAPS);
320 void clear();
321 static void sanity_checks(); // public for -XX:+ExecuteInternalVMTests
322 // in PRODUCT for -XX:SyncKnobs=Verbose=1
323
324 bool enter(TRAPS); // returns false if monitor is being deflated and caller should retry locking the object.
325 void exit(bool not_suspended, TRAPS);
326 void wait(jlong millis, bool interruptable, TRAPS);
327 void notify(TRAPS);
328 void notifyAll(TRAPS);
329
330 // Use the following at your own risk
331 intptr_t complete_exit(TRAPS);
332 bool reenter(intptr_t recursions, TRAPS); // returns false if monitor is being deflated and caller should retry locking the object.
333
334 private:
335 void AddWaiter(ObjectWaiter * waiter);
336 static void DeferredInitialize();
337 void INotify(Thread * Self);
338 ObjectWaiter * DequeueWaiter();
339 void DequeueSpecificWaiter(ObjectWaiter * waiter);
340 void EnterI(TRAPS);
341 void ReenterI(Thread * Self, ObjectWaiter * SelfNode);
342 void UnlinkAfterAcquire(Thread * Self, ObjectWaiter * SelfNode);
343 int TryLock(Thread * Self);
344 int NotRunnable(Thread * Self, Thread * Owner);
345 int TrySpin(Thread * Self);
346 void ExitEpilog(Thread * Self, ObjectWaiter * Wakee);
347 bool ExitSuspendEquivalent(JavaThread * Self);
348 void post_monitor_wait_event(EventJavaMonitorWait * event,
349 jlong notifier_tid,
350 jlong timeout,
351 bool timedout);
352
353 bool try_disable_monitor(); // Must be run by java thread in VM mode.
354 void install_displaced_markword_in_object();
355 };
356
357 #undef TEVENT
358 #define TEVENT(nom) { if (SyncVerbose) FEVENT(nom); }
359
360 #define FEVENT(nom) \
361 { \
362 static volatile int ctr = 0; \
363 int v = ++ctr; \
364 if ((v & (v - 1)) == 0) { \
365 tty->print_cr("INFO: " #nom " : %d", v); \
366 tty->flush(); \
367 } \
368 }
369
370 #undef TEVENT
371 #define TEVENT(nom) {;}
372
373
374 #endif // SHARE_VM_RUNTIME_OBJECTMONITOR_HPP