1 /* 2 * Copyright (c) 1998, 2024, 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_RUNTIME_OBJECTMONITOR_HPP 26 #define SHARE_RUNTIME_OBJECTMONITOR_HPP 27 28 #include "memory/allocation.hpp" 29 #include "memory/padded.hpp" 30 #include "oops/markWord.hpp" 31 #include "oops/weakHandle.hpp" 32 #include "runtime/perfDataTypes.hpp" 33 #include "utilities/checkedCast.hpp" 34 35 class ObjectMonitor; 36 class ParkEvent; 37 38 // ObjectWaiter serves as a "proxy" or surrogate thread. 39 // TODO-FIXME: Eliminate ObjectWaiter and use the thread-specific 40 // ParkEvent instead. Beware, however, that the JVMTI code 41 // knows about ObjectWaiters, so we'll have to reconcile that code. 42 // See next_waiter(), first_waiter(), etc. 43 44 class ObjectWaiter : public StackObj { 45 public: 46 enum TStates { TS_UNDEF, TS_READY, TS_RUN, TS_WAIT, TS_ENTER, TS_CXQ }; 47 ObjectWaiter* volatile _next; 48 ObjectWaiter* volatile _prev; 49 JavaThread* _thread; 50 uint64_t _notifier_tid; 51 ParkEvent * _event; 52 volatile int _notified; 53 volatile TStates TState; 54 bool _active; // Contention monitoring is enabled 55 public: 56 ObjectWaiter(JavaThread* current); 57 58 void wait_reenter_begin(ObjectMonitor *mon); 59 void wait_reenter_end(ObjectMonitor *mon); 60 }; 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 // ObjectMonitor Layout Overview/Highlights/Restrictions: 71 // 72 // - The _header field must be at offset 0 because the displaced header 73 // from markWord is stored there. We do not want markWord.hpp to include 74 // ObjectMonitor.hpp to avoid exposing ObjectMonitor everywhere. This 75 // means that ObjectMonitor cannot inherit from any other class nor can 76 // it use any virtual member functions. This restriction is critical to 77 // the proper functioning of the VM. 78 // - The _header and _owner fields should be separated by enough space 79 // to avoid false sharing due to parallel access by different threads. 80 // This is an advisory recommendation. 81 // - The general layout of the fields in ObjectMonitor is: 82 // _header 83 // <lightly_used_fields> 84 // <optional padding> 85 // _owner 86 // <remaining_fields> 87 // - The VM assumes write ordering and machine word alignment with 88 // respect to the _owner field and the <remaining_fields> that can 89 // be read in parallel by other threads. 90 // - Generally fields that are accessed closely together in time should 91 // be placed proximally in space to promote data cache locality. That 92 // is, temporal locality should condition spatial locality. 93 // - We have to balance avoiding false sharing with excessive invalidation 94 // from coherence traffic. As such, we try to cluster fields that tend 95 // to be _written_ at approximately the same time onto the same data 96 // cache line. 97 // - We also have to balance the natural tension between minimizing 98 // single threaded capacity misses with excessive multi-threaded 99 // coherency misses. There is no single optimal layout for both 100 // single-threaded and multi-threaded environments. 101 // 102 // - See TEST_VM(ObjectMonitor, sanity) gtest for how critical restrictions are 103 // enforced. 104 // - Adjacent ObjectMonitors should be separated by enough space to avoid 105 // false sharing. This is handled by the ObjectMonitor allocation code 106 // in synchronizer.cpp. Also see TEST_VM(SynchronizerTest, sanity) gtest. 107 // 108 // Futures notes: 109 // - Separating _owner from the <remaining_fields> by enough space to 110 // avoid false sharing might be profitable. Given 111 // http://blogs.oracle.com/dave/entry/cas_and_cache_trivia_invalidate 112 // we know that the CAS in monitorenter will invalidate the line 113 // underlying _owner. We want to avoid an L1 data cache miss on that 114 // same line for monitorexit. Putting these <remaining_fields>: 115 // _recursions, _EntryList, _cxq, and _succ, all of which may be 116 // fetched in the inflated unlock path, on a different cache line 117 // would make them immune to CAS-based invalidation from the _owner 118 // field. 119 // 120 // - The _recursions field should be of type int, or int32_t but not 121 // intptr_t. There's no reason to use a 64-bit type for this field 122 // in a 64-bit JVM. 123 124 #define OM_CACHE_LINE_SIZE DEFAULT_CACHE_LINE_SIZE 125 126 class ObjectMonitor : public CHeapObj<mtObjectMonitor> { 127 friend class ObjectSynchronizer; 128 friend class ObjectWaiter; 129 friend class VMStructs; 130 JVMCI_ONLY(friend class JVMCIVMStructs;) 131 132 static OopStorage* _oop_storage; 133 134 // The sync code expects the header field to be at offset zero (0). 135 // Enforced by the assert() in header_addr(). 136 volatile markWord _header; // displaced object header word - mark 137 WeakHandle _object; // backward object pointer 138 // Separate _header and _owner on different cache lines since both can 139 // have busy multi-threaded access. _header and _object are set at initial 140 // inflation. The _object does not change, so it is a good choice to share 141 // its cache line with _header. 142 DEFINE_PAD_MINUS_SIZE(0, OM_CACHE_LINE_SIZE, sizeof(volatile markWord) + 143 sizeof(WeakHandle)); 144 // Used by async deflation as a marker in the _owner field. 145 // Note that the choice of the two markers is peculiar: 146 // - They need to represent values that cannot be pointers. In particular, 147 // we achieve this by using the lowest two bits. 148 // - ANONYMOUS_OWNER should be a small value, it is used in generated code 149 // and small values encode much better. 150 // - We test for anonymous owner by testing for the lowest bit, therefore 151 // DEFLATER_MARKER must *not* have that bit set. 152 static const uintptr_t DEFLATER_MARKER_VALUE = 2; 153 #define DEFLATER_MARKER reinterpret_cast<void*>(DEFLATER_MARKER_VALUE) 154 public: 155 // NOTE: Typed as uintptr_t so that we can pick it up in SA, via vmStructs. 156 static const uintptr_t ANONYMOUS_OWNER = 1; 157 static const uintptr_t ANONYMOUS_OWNER_OR_DEFLATER_MARKER = ANONYMOUS_OWNER | DEFLATER_MARKER_VALUE; 158 159 private: 160 static void* anon_owner_ptr() { return reinterpret_cast<void*>(ANONYMOUS_OWNER); } 161 162 void* volatile _owner; // pointer to owning thread OR BasicLock 163 volatile uint64_t _previous_owner_tid; // thread id of the previous owner of the monitor 164 // Separate _owner and _next_om on different cache lines since 165 // both can have busy multi-threaded access. _previous_owner_tid is only 166 // changed by ObjectMonitor::exit() so it is a good choice to share the 167 // cache line with _owner. 168 DEFINE_PAD_MINUS_SIZE(1, OM_CACHE_LINE_SIZE, sizeof(void* volatile) + 169 sizeof(volatile uint64_t)); 170 ObjectMonitor* _next_om; // Next ObjectMonitor* linkage 171 volatile intx _recursions; // recursion count, 0 for first entry 172 ObjectWaiter* volatile _EntryList; // Threads blocked on entry or reentry. 173 // The list is actually composed of WaitNodes, 174 // acting as proxies for Threads. 175 176 ObjectWaiter* volatile _cxq; // LL of recently-arrived threads blocked on entry. 177 JavaThread* volatile _succ; // Heir presumptive thread - used for futile wakeup throttling 178 JavaThread* volatile _Responsible; 179 180 volatile int _SpinDuration; 181 182 int _contentions; // Number of active contentions in enter(). It is used by is_busy() 183 // along with other fields to determine if an ObjectMonitor can be 184 // deflated. It is also used by the async deflation protocol. See 185 // ObjectMonitor::deflate_monitor(). 186 protected: 187 ObjectWaiter* volatile _WaitSet; // LL of threads wait()ing on the monitor 188 volatile int _waiters; // number of waiting threads 189 private: 190 volatile int _WaitSetLock; // protects Wait Queue - simple spinlock 191 192 public: 193 194 static void Initialize(); 195 196 // Only perform a PerfData operation if the PerfData object has been 197 // allocated and if the PerfDataManager has not freed the PerfData 198 // objects which can happen at normal VM shutdown. 199 // 200 #define OM_PERFDATA_OP(f, op_str) \ 201 do { \ 202 if (ObjectMonitor::_sync_ ## f != nullptr && \ 203 PerfDataManager::has_PerfData()) { \ 204 ObjectMonitor::_sync_ ## f->op_str; \ 205 } \ 206 } while (0) 207 208 static PerfCounter * _sync_ContendedLockAttempts; 209 static PerfCounter * _sync_FutileWakeups; 210 static PerfCounter * _sync_Parks; 211 static PerfCounter * _sync_Notifications; 212 static PerfCounter * _sync_Inflations; 213 static PerfCounter * _sync_Deflations; 214 static PerfLongVariable * _sync_MonExtant; 215 216 static int Knob_SpinLimit; 217 218 static ByteSize header_offset() { return byte_offset_of(ObjectMonitor, _header); } 219 static ByteSize owner_offset() { return byte_offset_of(ObjectMonitor, _owner); } 220 static ByteSize recursions_offset() { return byte_offset_of(ObjectMonitor, _recursions); } 221 static ByteSize cxq_offset() { return byte_offset_of(ObjectMonitor, _cxq); } 222 static ByteSize succ_offset() { return byte_offset_of(ObjectMonitor, _succ); } 223 static ByteSize EntryList_offset() { return byte_offset_of(ObjectMonitor, _EntryList); } 224 225 // ObjectMonitor references can be ORed with markWord::monitor_value 226 // as part of the ObjectMonitor tagging mechanism. When we combine an 227 // ObjectMonitor reference with an offset, we need to remove the tag 228 // value in order to generate the proper address. 229 // 230 // We can either adjust the ObjectMonitor reference and then add the 231 // offset or we can adjust the offset that is added to the ObjectMonitor 232 // reference. The latter avoids an AGI (Address Generation Interlock) 233 // stall so the helper macro adjusts the offset value that is returned 234 // to the ObjectMonitor reference manipulation code: 235 // 236 // Lightweight locking fetches ObjectMonitor references from a cache 237 // instead of the markWord and doesn't work with tagged values. 238 // 239 #define OM_OFFSET_NO_MONITOR_VALUE_TAG(f) \ 240 ((in_bytes(ObjectMonitor::f ## _offset())) - (LockingMode == LM_LIGHTWEIGHT ? 0 : checked_cast<int>(markWord::monitor_value))) 241 242 markWord header() const; 243 uintptr_t header_value() const; 244 volatile markWord* header_addr(); 245 void set_header(markWord hdr); 246 247 // TODO[OMWorld]: Cleanup these names, the storage `_header` usage depends on the locking mode. 248 intptr_t hash_lightweight_locking() const; 249 void set_hash_lightweight_locking(intptr_t hash); 250 251 bool is_busy() const { 252 // TODO-FIXME: assert _owner == null implies _recursions = 0 253 intptr_t ret_code = intptr_t(_waiters) | intptr_t(_cxq) | intptr_t(_EntryList); 254 int cnts = contentions(); // read once 255 if (cnts > 0) { 256 ret_code |= intptr_t(cnts); 257 } 258 if (!owner_is_DEFLATER_MARKER()) { 259 ret_code |= intptr_t(owner_raw()); 260 } 261 return ret_code != 0; 262 } 263 bool is_contended() const { 264 intptr_t ret_code = intptr_t(_waiters) | intptr_t(_cxq) | intptr_t(_EntryList); 265 int cnts = contentions(); 266 if (cnts > 0) { 267 ret_code |= intptr_t(cnts); 268 } 269 return ret_code != 0; 270 } 271 const char* is_busy_to_string(stringStream* ss); 272 273 bool is_entered(JavaThread* current) const; 274 275 // Returns true if this OM has an owner, false otherwise. 276 bool has_owner() const; 277 void* owner() const; // Returns null if DEFLATER_MARKER is observed. 278 void* owner_raw() const; 279 // Returns true if owner field == DEFLATER_MARKER and false otherwise. 280 bool owner_is_DEFLATER_MARKER() const; 281 // Returns true if 'this' is being async deflated and false otherwise. 282 bool is_being_async_deflated(); 283 // Clear _owner field; current value must match old_value. 284 void release_clear_owner(void* old_value); 285 // Simply set _owner field to new_value; current value must match old_value. 286 void set_owner_from(void* old_value, void* new_value); 287 // Simply set _owner field to current; current value must match basic_lock_p. 288 void set_owner_from_BasicLock(void* basic_lock_p, JavaThread* current); 289 // Try to set _owner field to new_value if the current value matches 290 // old_value, using Atomic::cmpxchg(). Otherwise, does not change the 291 // _owner field. Returns the prior value of the _owner field. 292 void* try_set_owner_from(void* old_value, void* new_value); 293 294 void set_owner_anonymous() { 295 set_owner_from(nullptr, anon_owner_ptr()); 296 } 297 298 bool is_owner_anonymous() const { 299 return owner_raw() == anon_owner_ptr(); 300 } 301 302 void set_owner_from_anonymous(Thread* owner) { 303 set_owner_from(anon_owner_ptr(), owner); 304 } 305 306 // Simply get _next_om field. 307 ObjectMonitor* next_om() const; 308 // Simply set _next_om field to new_value. 309 void set_next_om(ObjectMonitor* new_value); 310 311 int waiters() const; 312 313 int contentions() const; 314 void add_to_contentions(int value); 315 intx recursions() const { return _recursions; } 316 void set_recursions(size_t recursions); 317 318 // JVM/TI GetObjectMonitorUsage() needs this: 319 ObjectWaiter* first_waiter() { return _WaitSet; } 320 ObjectWaiter* next_waiter(ObjectWaiter* o) { return o->_next; } 321 JavaThread* thread_of_waiter(ObjectWaiter* o) { return o->_thread; } 322 323 ObjectMonitor(oop object); 324 ~ObjectMonitor(); 325 326 oop object() const; 327 oop object_peek() const; 328 bool object_is_cleared() const; 329 bool object_is_dead() const; 330 bool object_refers_to(oop obj) const; 331 332 // Returns true if the specified thread owns the ObjectMonitor. Otherwise 333 // returns false and throws IllegalMonitorStateException (IMSE). 334 bool check_owner(TRAPS); 335 336 private: 337 class ExitOnSuspend { 338 protected: 339 ObjectMonitor* _om; 340 bool _om_exited; 341 public: 342 ExitOnSuspend(ObjectMonitor* om) : _om(om), _om_exited(false) {} 343 void operator()(JavaThread* current); 344 bool exited() { return _om_exited; } 345 }; 346 class ClearSuccOnSuspend { 347 protected: 348 ObjectMonitor* _om; 349 public: 350 ClearSuccOnSuspend(ObjectMonitor* om) : _om(om) {} 351 void operator()(JavaThread* current); 352 }; 353 public: 354 bool try_enter(JavaThread* current); 355 bool enter_for(JavaThread* locking_thread); 356 bool enter(JavaThread* current); 357 void exit(JavaThread* current, bool not_suspended = true); 358 void wait(jlong millis, bool interruptible, TRAPS); 359 void notify(TRAPS); 360 void notifyAll(TRAPS); 361 362 void print() const; 363 #ifdef ASSERT 364 void print_debug_style_on(outputStream* st) const; 365 #endif 366 void print_on(outputStream* st) const; 367 368 // Use the following at your own risk 369 intx complete_exit(JavaThread* current); 370 371 private: 372 void AddWaiter(ObjectWaiter* waiter); 373 void INotify(JavaThread* current); 374 ObjectWaiter* DequeueWaiter(); 375 void DequeueSpecificWaiter(ObjectWaiter* waiter); 376 void EnterI(JavaThread* current); 377 void ReenterI(JavaThread* current, ObjectWaiter* current_node); 378 void UnlinkAfterAcquire(JavaThread* current, ObjectWaiter* current_node); 379 int TryLock(JavaThread* current); 380 int TrySpin(JavaThread* current); 381 void ExitEpilog(JavaThread* current, ObjectWaiter* Wakee); 382 383 // Deflation support 384 bool deflate_monitor(Thread* current); 385 public: 386 bool deflate_anon_monitor(JavaThread* current); 387 private: 388 void install_displaced_markword_in_object(const oop obj); 389 }; 390 391 // RAII object to ensure that ObjectMonitor::is_being_async_deflated() is 392 // stable within the context of this mark. 393 class ObjectMonitorContentionMark { 394 ObjectMonitor* _monitor; 395 396 public: 397 ObjectMonitorContentionMark(ObjectMonitor* monitor); 398 ~ObjectMonitorContentionMark(); 399 }; 400 401 #endif // SHARE_RUNTIME_OBJECTMONITOR_HPP