Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/objectMonitor.cpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | da91efe96a93 |
| children | f34d701e952e |
| rev | line source |
|---|---|
| 1878 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. |
| 1878 | 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 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/vmSymbols.hpp" | |
| 27 #include "memory/resourceArea.hpp" | |
| 28 #include "oops/markOop.hpp" | |
| 29 #include "oops/oop.inline.hpp" | |
| 30 #include "runtime/handles.inline.hpp" | |
| 31 #include "runtime/interfaceSupport.hpp" | |
| 32 #include "runtime/mutexLocker.hpp" | |
| 33 #include "runtime/objectMonitor.hpp" | |
| 34 #include "runtime/objectMonitor.inline.hpp" | |
| 35 #include "runtime/osThread.hpp" | |
| 36 #include "runtime/stubRoutines.hpp" | |
| 37 #include "runtime/thread.hpp" | |
| 38 #include "services/threadService.hpp" | |
| 39 #include "utilities/dtrace.hpp" | |
| 40 #include "utilities/preserveException.hpp" | |
| 41 #ifdef TARGET_OS_FAMILY_linux | |
| 42 # include "os_linux.inline.hpp" | |
| 43 # include "thread_linux.inline.hpp" | |
| 44 #endif | |
| 45 #ifdef TARGET_OS_FAMILY_solaris | |
| 46 # include "os_solaris.inline.hpp" | |
| 47 # include "thread_solaris.inline.hpp" | |
| 48 #endif | |
| 49 #ifdef TARGET_OS_FAMILY_windows | |
| 50 # include "os_windows.inline.hpp" | |
| 51 # include "thread_windows.inline.hpp" | |
| 52 #endif | |
| 3960 | 53 #ifdef TARGET_OS_FAMILY_bsd |
| 54 # include "os_bsd.inline.hpp" | |
| 55 # include "thread_bsd.inline.hpp" | |
| 56 #endif | |
| 1878 | 57 |
| 58 #if defined(__GNUC__) && !defined(IA64) | |
| 59 // Need to inhibit inlining for older versions of GCC to avoid build-time failures | |
| 60 #define ATTR __attribute__((noinline)) | |
| 61 #else | |
| 62 #define ATTR | |
| 63 #endif | |
| 64 | |
| 65 | |
| 66 #ifdef DTRACE_ENABLED | |
| 67 | |
| 68 // Only bother with this argument setup if dtrace is available | |
| 69 // TODO-FIXME: probes should not fire when caller is _blocked. assert() accordingly. | |
| 70 | |
| 4006 | 71 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
72 #define DTRACE_MONITOR_PROBE_COMMON(obj, thread) \ |
| 4006 | 73 char* bytes = NULL; \ |
| 74 int len = 0; \ | |
| 75 jlong jtid = SharedRuntime::get_java_tid(thread); \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
76 Symbol* klassname = ((oop)obj)->klass()->name(); \ |
| 4006 | 77 if (klassname != NULL) { \ |
| 78 bytes = (char*)klassname->bytes(); \ | |
| 79 len = klassname->utf8_length(); \ | |
| 80 } | |
| 81 | |
| 82 #ifndef USDT2 | |
| 83 | |
| 1878 | 84 HS_DTRACE_PROBE_DECL4(hotspot, monitor__notify, |
| 85 jlong, uintptr_t, char*, int); | |
| 86 HS_DTRACE_PROBE_DECL4(hotspot, monitor__notifyAll, | |
| 87 jlong, uintptr_t, char*, int); | |
| 88 HS_DTRACE_PROBE_DECL4(hotspot, monitor__contended__enter, | |
| 89 jlong, uintptr_t, char*, int); | |
| 90 HS_DTRACE_PROBE_DECL4(hotspot, monitor__contended__entered, | |
| 91 jlong, uintptr_t, char*, int); | |
| 92 HS_DTRACE_PROBE_DECL4(hotspot, monitor__contended__exit, | |
| 93 jlong, uintptr_t, char*, int); | |
| 94 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
95 #define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ |
| 1878 | 96 { \ |
| 97 if (DTraceMonitorProbes) { \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
98 DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ |
| 1878 | 99 HS_DTRACE_PROBE5(hotspot, monitor__wait, jtid, \ |
| 100 (monitor), bytes, len, (millis)); \ | |
| 101 } \ | |
| 102 } | |
| 103 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
104 #define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \ |
| 1878 | 105 { \ |
| 106 if (DTraceMonitorProbes) { \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
107 DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ |
| 1878 | 108 HS_DTRACE_PROBE4(hotspot, monitor__##probe, jtid, \ |
| 109 (uintptr_t)(monitor), bytes, len); \ | |
| 110 } \ | |
| 111 } | |
| 112 | |
| 4006 | 113 #else /* USDT2 */ |
| 114 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
115 #define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ |
| 4006 | 116 { \ |
| 117 if (DTraceMonitorProbes) { \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
118 DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ |
| 4006 | 119 HOTSPOT_MONITOR_WAIT(jtid, \ |
| 120 (monitor), bytes, len, (millis)); \ | |
| 121 } \ | |
| 122 } | |
| 123 | |
| 124 #define HOTSPOT_MONITOR_contended__enter HOTSPOT_MONITOR_CONTENDED_ENTER | |
| 125 #define HOTSPOT_MONITOR_contended__entered HOTSPOT_MONITOR_CONTENDED_ENTERED | |
| 126 #define HOTSPOT_MONITOR_contended__exit HOTSPOT_MONITOR_CONTENDED_EXIT | |
| 127 #define HOTSPOT_MONITOR_notify HOTSPOT_MONITOR_NOTIFY | |
| 128 #define HOTSPOT_MONITOR_notifyAll HOTSPOT_MONITOR_NOTIFYALL | |
| 129 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
130 #define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \ |
| 4006 | 131 { \ |
| 132 if (DTraceMonitorProbes) { \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
133 DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ |
| 4006 | 134 HOTSPOT_MONITOR_##probe(jtid, \ |
| 135 (uintptr_t)(monitor), bytes, len); \ | |
| 136 } \ | |
| 137 } | |
| 138 | |
| 139 #endif /* USDT2 */ | |
| 1878 | 140 #else // ndef DTRACE_ENABLED |
| 141 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
142 #define DTRACE_MONITOR_WAIT_PROBE(obj, thread, millis, mon) {;} |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
143 #define DTRACE_MONITOR_PROBE(probe, obj, thread, mon) {;} |
| 1878 | 144 |
| 145 #endif // ndef DTRACE_ENABLED | |
| 146 | |
| 147 // Tunables ... | |
| 148 // The knob* variables are effectively final. Once set they should | |
| 149 // never be modified hence. Consider using __read_mostly with GCC. | |
| 150 | |
| 151 int ObjectMonitor::Knob_Verbose = 0 ; | |
| 152 int ObjectMonitor::Knob_SpinLimit = 5000 ; // derived by an external tool - | |
| 153 static int Knob_LogSpins = 0 ; // enable jvmstat tally for spins | |
| 154 static int Knob_HandOff = 0 ; | |
| 155 static int Knob_ReportSettings = 0 ; | |
| 156 | |
| 157 static int Knob_SpinBase = 0 ; // Floor AKA SpinMin | |
| 158 static int Knob_SpinBackOff = 0 ; // spin-loop backoff | |
| 159 static int Knob_CASPenalty = -1 ; // Penalty for failed CAS | |
| 160 static int Knob_OXPenalty = -1 ; // Penalty for observed _owner change | |
| 161 static int Knob_SpinSetSucc = 1 ; // spinners set the _succ field | |
| 162 static int Knob_SpinEarly = 1 ; | |
| 163 static int Knob_SuccEnabled = 1 ; // futile wake throttling | |
| 164 static int Knob_SuccRestrict = 0 ; // Limit successors + spinners to at-most-one | |
| 165 static int Knob_MaxSpinners = -1 ; // Should be a function of # CPUs | |
| 166 static int Knob_Bonus = 100 ; // spin success bonus | |
| 167 static int Knob_BonusB = 100 ; // spin success bonus | |
| 168 static int Knob_Penalty = 200 ; // spin failure penalty | |
| 169 static int Knob_Poverty = 1000 ; | |
| 170 static int Knob_SpinAfterFutile = 1 ; // Spin after returning from park() | |
| 171 static int Knob_FixedSpin = 0 ; | |
| 172 static int Knob_OState = 3 ; // Spinner checks thread state of _owner | |
| 173 static int Knob_UsePause = 1 ; | |
| 174 static int Knob_ExitPolicy = 0 ; | |
| 175 static int Knob_PreSpin = 10 ; // 20-100 likely better | |
| 176 static int Knob_ResetEvent = 0 ; | |
| 177 static int BackOffMask = 0 ; | |
| 178 | |
| 179 static int Knob_FastHSSEC = 0 ; | |
| 180 static int Knob_MoveNotifyee = 2 ; // notify() - disposition of notifyee | |
| 181 static int Knob_QMode = 0 ; // EntryList-cxq policy - queue discipline | |
| 182 static volatile int InitDone = 0 ; | |
| 183 | |
| 184 #define TrySpin TrySpin_VaryDuration | |
| 185 | |
| 186 // ----------------------------------------------------------------------------- | |
| 187 // Theory of operations -- Monitors lists, thread residency, etc: | |
| 188 // | |
| 189 // * A thread acquires ownership of a monitor by successfully | |
| 190 // CAS()ing the _owner field from null to non-null. | |
| 191 // | |
| 192 // * Invariant: A thread appears on at most one monitor list -- | |
| 193 // cxq, EntryList or WaitSet -- at any one time. | |
| 194 // | |
| 195 // * Contending threads "push" themselves onto the cxq with CAS | |
| 196 // and then spin/park. | |
| 197 // | |
| 198 // * After a contending thread eventually acquires the lock it must | |
| 199 // dequeue itself from either the EntryList or the cxq. | |
| 200 // | |
| 201 // * The exiting thread identifies and unparks an "heir presumptive" | |
| 202 // tentative successor thread on the EntryList. Critically, the | |
| 203 // exiting thread doesn't unlink the successor thread from the EntryList. | |
| 204 // After having been unparked, the wakee will recontend for ownership of | |
| 205 // the monitor. The successor (wakee) will either acquire the lock or | |
| 206 // re-park itself. | |
| 207 // | |
| 208 // Succession is provided for by a policy of competitive handoff. | |
| 209 // The exiting thread does _not_ grant or pass ownership to the | |
| 210 // successor thread. (This is also referred to as "handoff" succession"). | |
| 211 // Instead the exiting thread releases ownership and possibly wakes | |
| 212 // a successor, so the successor can (re)compete for ownership of the lock. | |
| 213 // If the EntryList is empty but the cxq is populated the exiting | |
| 214 // thread will drain the cxq into the EntryList. It does so by | |
| 215 // by detaching the cxq (installing null with CAS) and folding | |
| 216 // the threads from the cxq into the EntryList. The EntryList is | |
| 217 // doubly linked, while the cxq is singly linked because of the | |
| 218 // CAS-based "push" used to enqueue recently arrived threads (RATs). | |
| 219 // | |
| 220 // * Concurrency invariants: | |
| 221 // | |
| 222 // -- only the monitor owner may access or mutate the EntryList. | |
| 223 // The mutex property of the monitor itself protects the EntryList | |
| 224 // from concurrent interference. | |
| 225 // -- Only the monitor owner may detach the cxq. | |
| 226 // | |
| 227 // * The monitor entry list operations avoid locks, but strictly speaking | |
| 228 // they're not lock-free. Enter is lock-free, exit is not. | |
| 229 // See http://j2se.east/~dice/PERSIST/040825-LockFreeQueues.html | |
| 230 // | |
| 231 // * The cxq can have multiple concurrent "pushers" but only one concurrent | |
| 232 // detaching thread. This mechanism is immune from the ABA corruption. | |
| 233 // More precisely, the CAS-based "push" onto cxq is ABA-oblivious. | |
| 234 // | |
| 235 // * Taken together, the cxq and the EntryList constitute or form a | |
| 236 // single logical queue of threads stalled trying to acquire the lock. | |
| 237 // We use two distinct lists to improve the odds of a constant-time | |
| 238 // dequeue operation after acquisition (in the ::enter() epilog) and | |
| 239 // to reduce heat on the list ends. (c.f. Michael Scott's "2Q" algorithm). | |
| 240 // A key desideratum is to minimize queue & monitor metadata manipulation | |
| 241 // that occurs while holding the monitor lock -- that is, we want to | |
| 242 // minimize monitor lock holds times. Note that even a small amount of | |
| 243 // fixed spinning will greatly reduce the # of enqueue-dequeue operations | |
| 244 // on EntryList|cxq. That is, spinning relieves contention on the "inner" | |
| 245 // locks and monitor metadata. | |
| 246 // | |
| 247 // Cxq points to the the set of Recently Arrived Threads attempting entry. | |
| 248 // Because we push threads onto _cxq with CAS, the RATs must take the form of | |
| 249 // a singly-linked LIFO. We drain _cxq into EntryList at unlock-time when | |
| 250 // the unlocking thread notices that EntryList is null but _cxq is != null. | |
| 251 // | |
| 252 // The EntryList is ordered by the prevailing queue discipline and | |
| 253 // can be organized in any convenient fashion, such as a doubly-linked list or | |
| 254 // a circular doubly-linked list. Critically, we want insert and delete operations | |
| 255 // to operate in constant-time. If we need a priority queue then something akin | |
| 256 // to Solaris' sleepq would work nicely. Viz., | |
| 257 // http://agg.eng/ws/on10_nightly/source/usr/src/uts/common/os/sleepq.c. | |
| 258 // Queue discipline is enforced at ::exit() time, when the unlocking thread | |
| 259 // drains the cxq into the EntryList, and orders or reorders the threads on the | |
| 260 // EntryList accordingly. | |
| 261 // | |
| 262 // Barring "lock barging", this mechanism provides fair cyclic ordering, | |
| 263 // somewhat similar to an elevator-scan. | |
| 264 // | |
| 265 // * The monitor synchronization subsystem avoids the use of native | |
| 266 // synchronization primitives except for the narrow platform-specific | |
| 267 // park-unpark abstraction. See the comments in os_solaris.cpp regarding | |
| 268 // the semantics of park-unpark. Put another way, this monitor implementation | |
| 269 // depends only on atomic operations and park-unpark. The monitor subsystem | |
| 270 // manages all RUNNING->BLOCKED and BLOCKED->READY transitions while the | |
| 271 // underlying OS manages the READY<->RUN transitions. | |
| 272 // | |
| 273 // * Waiting threads reside on the WaitSet list -- wait() puts | |
| 274 // the caller onto the WaitSet. | |
| 275 // | |
| 276 // * notify() or notifyAll() simply transfers threads from the WaitSet to | |
| 277 // either the EntryList or cxq. Subsequent exit() operations will | |
| 278 // unpark the notifyee. Unparking a notifee in notify() is inefficient - | |
| 279 // it's likely the notifyee would simply impale itself on the lock held | |
| 280 // by the notifier. | |
| 281 // | |
| 282 // * An interesting alternative is to encode cxq as (List,LockByte) where | |
| 283 // the LockByte is 0 iff the monitor is owned. _owner is simply an auxiliary | |
| 284 // variable, like _recursions, in the scheme. The threads or Events that form | |
| 285 // the list would have to be aligned in 256-byte addresses. A thread would | |
| 286 // try to acquire the lock or enqueue itself with CAS, but exiting threads | |
| 287 // could use a 1-0 protocol and simply STB to set the LockByte to 0. | |
| 288 // Note that is is *not* word-tearing, but it does presume that full-word | |
| 289 // CAS operations are coherent with intermix with STB operations. That's true | |
| 290 // on most common processors. | |
| 291 // | |
| 292 // * See also http://blogs.sun.com/dave | |
| 293 | |
| 294 | |
| 295 // ----------------------------------------------------------------------------- | |
| 296 // Enter support | |
| 297 | |
| 298 bool ObjectMonitor::try_enter(Thread* THREAD) { | |
| 299 if (THREAD != _owner) { | |
| 300 if (THREAD->is_lock_owned ((address)_owner)) { | |
| 301 assert(_recursions == 0, "internal state error"); | |
| 302 _owner = THREAD ; | |
| 303 _recursions = 1 ; | |
| 304 OwnerIsThread = 1 ; | |
| 305 return true; | |
| 306 } | |
| 307 if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) { | |
| 308 return false; | |
| 309 } | |
| 310 return true; | |
| 311 } else { | |
| 312 _recursions++; | |
| 313 return true; | |
| 314 } | |
| 315 } | |
| 316 | |
| 317 void ATTR ObjectMonitor::enter(TRAPS) { | |
| 318 // The following code is ordered to check the most common cases first | |
| 319 // and to reduce RTS->RTO cache line upgrades on SPARC and IA32 processors. | |
| 320 Thread * const Self = THREAD ; | |
| 321 void * cur ; | |
| 322 | |
| 323 cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ; | |
| 324 if (cur == NULL) { | |
| 325 // Either ASSERT _recursions == 0 or explicitly set _recursions = 0. | |
| 326 assert (_recursions == 0 , "invariant") ; | |
| 327 assert (_owner == Self, "invariant") ; | |
| 328 // CONSIDER: set or assert OwnerIsThread == 1 | |
| 329 return ; | |
| 330 } | |
| 331 | |
| 332 if (cur == Self) { | |
| 333 // TODO-FIXME: check for integer overflow! BUGID 6557169. | |
| 334 _recursions ++ ; | |
| 335 return ; | |
| 336 } | |
| 337 | |
| 338 if (Self->is_lock_owned ((address)cur)) { | |
| 339 assert (_recursions == 0, "internal state error"); | |
| 340 _recursions = 1 ; | |
| 341 // Commute owner from a thread-specific on-stack BasicLockObject address to | |
| 342 // a full-fledged "Thread *". | |
| 343 _owner = Self ; | |
| 344 OwnerIsThread = 1 ; | |
| 345 return ; | |
| 346 } | |
| 347 | |
| 348 // We've encountered genuine contention. | |
| 349 assert (Self->_Stalled == 0, "invariant") ; | |
| 350 Self->_Stalled = intptr_t(this) ; | |
| 351 | |
| 352 // Try one round of spinning *before* enqueueing Self | |
| 353 // and before going through the awkward and expensive state | |
| 354 // transitions. The following spin is strictly optional ... | |
| 355 // Note that if we acquire the monitor from an initial spin | |
| 356 // we forgo posting JVMTI events and firing DTRACE probes. | |
| 357 if (Knob_SpinEarly && TrySpin (Self) > 0) { | |
| 358 assert (_owner == Self , "invariant") ; | |
| 359 assert (_recursions == 0 , "invariant") ; | |
| 360 assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ; | |
| 361 Self->_Stalled = 0 ; | |
| 362 return ; | |
| 363 } | |
| 364 | |
| 365 assert (_owner != Self , "invariant") ; | |
| 366 assert (_succ != Self , "invariant") ; | |
| 367 assert (Self->is_Java_thread() , "invariant") ; | |
| 368 JavaThread * jt = (JavaThread *) Self ; | |
| 369 assert (!SafepointSynchronize::is_at_safepoint(), "invariant") ; | |
| 370 assert (jt->thread_state() != _thread_blocked , "invariant") ; | |
| 371 assert (this->object() != NULL , "invariant") ; | |
| 372 assert (_count >= 0, "invariant") ; | |
| 373 | |
| 374 // Prevent deflation at STW-time. See deflate_idle_monitors() and is_busy(). | |
| 375 // Ensure the object-monitor relationship remains stable while there's contention. | |
| 376 Atomic::inc_ptr(&_count); | |
| 377 | |
| 378 { // Change java thread status to indicate blocked on monitor enter. | |
| 379 JavaThreadBlockedOnMonitorEnterState jtbmes(jt, this); | |
| 380 | |
| 381 DTRACE_MONITOR_PROBE(contended__enter, this, object(), jt); | |
| 382 if (JvmtiExport::should_post_monitor_contended_enter()) { | |
| 383 JvmtiExport::post_monitor_contended_enter(jt, this); | |
| 384 } | |
| 385 | |
| 386 OSThreadContendState osts(Self->osthread()); | |
| 387 ThreadBlockInVM tbivm(jt); | |
| 388 | |
| 389 Self->set_current_pending_monitor(this); | |
| 390 | |
| 391 // TODO-FIXME: change the following for(;;) loop to straight-line code. | |
| 392 for (;;) { | |
| 393 jt->set_suspend_equivalent(); | |
| 394 // cleared by handle_special_suspend_equivalent_condition() | |
| 395 // or java_suspend_self() | |
| 396 | |
| 397 EnterI (THREAD) ; | |
| 398 | |
| 399 if (!ExitSuspendEquivalent(jt)) break ; | |
| 400 | |
| 401 // | |
| 402 // We have acquired the contended monitor, but while we were | |
| 403 // waiting another thread suspended us. We don't want to enter | |
| 404 // the monitor while suspended because that would surprise the | |
| 405 // thread that suspended us. | |
| 406 // | |
| 407 _recursions = 0 ; | |
| 408 _succ = NULL ; | |
| 409 exit (Self) ; | |
| 410 | |
| 411 jt->java_suspend_self(); | |
| 412 } | |
| 413 Self->set_current_pending_monitor(NULL); | |
| 414 } | |
| 415 | |
| 416 Atomic::dec_ptr(&_count); | |
| 417 assert (_count >= 0, "invariant") ; | |
| 418 Self->_Stalled = 0 ; | |
| 419 | |
| 420 // Must either set _recursions = 0 or ASSERT _recursions == 0. | |
| 421 assert (_recursions == 0 , "invariant") ; | |
| 422 assert (_owner == Self , "invariant") ; | |
| 423 assert (_succ != Self , "invariant") ; | |
| 424 assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ; | |
| 425 | |
| 426 // The thread -- now the owner -- is back in vm mode. | |
| 427 // Report the glorious news via TI,DTrace and jvmstat. | |
| 428 // The probe effect is non-trivial. All the reportage occurs | |
| 429 // while we hold the monitor, increasing the length of the critical | |
| 430 // section. Amdahl's parallel speedup law comes vividly into play. | |
| 431 // | |
| 432 // Another option might be to aggregate the events (thread local or | |
| 433 // per-monitor aggregation) and defer reporting until a more opportune | |
| 434 // time -- such as next time some thread encounters contention but has | |
| 435 // yet to acquire the lock. While spinning that thread could | |
| 436 // spinning we could increment JVMStat counters, etc. | |
| 437 | |
| 438 DTRACE_MONITOR_PROBE(contended__entered, this, object(), jt); | |
| 439 if (JvmtiExport::should_post_monitor_contended_entered()) { | |
| 440 JvmtiExport::post_monitor_contended_entered(jt, this); | |
| 441 } | |
| 442 if (ObjectMonitor::_sync_ContendedLockAttempts != NULL) { | |
| 443 ObjectMonitor::_sync_ContendedLockAttempts->inc() ; | |
| 444 } | |
| 445 } | |
| 446 | |
| 447 | |
| 448 // Caveat: TryLock() is not necessarily serializing if it returns failure. | |
| 449 // Callers must compensate as needed. | |
| 450 | |
| 451 int ObjectMonitor::TryLock (Thread * Self) { | |
| 452 for (;;) { | |
| 453 void * own = _owner ; | |
| 454 if (own != NULL) return 0 ; | |
| 455 if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) { | |
| 456 // Either guarantee _recursions == 0 or set _recursions = 0. | |
| 457 assert (_recursions == 0, "invariant") ; | |
| 458 assert (_owner == Self, "invariant") ; | |
| 459 // CONSIDER: set or assert that OwnerIsThread == 1 | |
| 460 return 1 ; | |
| 461 } | |
| 462 // The lock had been free momentarily, but we lost the race to the lock. | |
| 463 // Interference -- the CAS failed. | |
| 464 // We can either return -1 or retry. | |
| 465 // Retry doesn't make as much sense because the lock was just acquired. | |
| 466 if (true) return -1 ; | |
| 467 } | |
| 468 } | |
| 469 | |
| 470 void ATTR ObjectMonitor::EnterI (TRAPS) { | |
| 471 Thread * Self = THREAD ; | |
| 472 assert (Self->is_Java_thread(), "invariant") ; | |
| 473 assert (((JavaThread *) Self)->thread_state() == _thread_blocked , "invariant") ; | |
| 474 | |
| 475 // Try the lock - TATAS | |
| 476 if (TryLock (Self) > 0) { | |
| 477 assert (_succ != Self , "invariant") ; | |
| 478 assert (_owner == Self , "invariant") ; | |
| 479 assert (_Responsible != Self , "invariant") ; | |
| 480 return ; | |
| 481 } | |
| 482 | |
| 483 DeferredInitialize () ; | |
| 484 | |
| 485 // We try one round of spinning *before* enqueueing Self. | |
| 486 // | |
| 487 // If the _owner is ready but OFFPROC we could use a YieldTo() | |
| 488 // operation to donate the remainder of this thread's quantum | |
| 489 // to the owner. This has subtle but beneficial affinity | |
| 490 // effects. | |
| 491 | |
| 492 if (TrySpin (Self) > 0) { | |
| 493 assert (_owner == Self , "invariant") ; | |
| 494 assert (_succ != Self , "invariant") ; | |
| 495 assert (_Responsible != Self , "invariant") ; | |
| 496 return ; | |
| 497 } | |
| 498 | |
| 499 // The Spin failed -- Enqueue and park the thread ... | |
| 500 assert (_succ != Self , "invariant") ; | |
| 501 assert (_owner != Self , "invariant") ; | |
| 502 assert (_Responsible != Self , "invariant") ; | |
| 503 | |
| 504 // Enqueue "Self" on ObjectMonitor's _cxq. | |
| 505 // | |
| 506 // Node acts as a proxy for Self. | |
| 507 // As an aside, if were to ever rewrite the synchronization code mostly | |
| 508 // in Java, WaitNodes, ObjectMonitors, and Events would become 1st-class | |
| 509 // Java objects. This would avoid awkward lifecycle and liveness issues, | |
| 510 // as well as eliminate a subset of ABA issues. | |
| 511 // TODO: eliminate ObjectWaiter and enqueue either Threads or Events. | |
| 512 // | |
| 513 | |
| 514 ObjectWaiter node(Self) ; | |
| 515 Self->_ParkEvent->reset() ; | |
| 516 node._prev = (ObjectWaiter *) 0xBAD ; | |
| 517 node.TState = ObjectWaiter::TS_CXQ ; | |
| 518 | |
| 519 // Push "Self" onto the front of the _cxq. | |
| 520 // Once on cxq/EntryList, Self stays on-queue until it acquires the lock. | |
| 521 // Note that spinning tends to reduce the rate at which threads | |
| 522 // enqueue and dequeue on EntryList|cxq. | |
| 523 ObjectWaiter * nxt ; | |
| 524 for (;;) { | |
| 525 node._next = nxt = _cxq ; | |
| 526 if (Atomic::cmpxchg_ptr (&node, &_cxq, nxt) == nxt) break ; | |
| 527 | |
| 528 // Interference - the CAS failed because _cxq changed. Just retry. | |
| 529 // As an optional optimization we retry the lock. | |
| 530 if (TryLock (Self) > 0) { | |
| 531 assert (_succ != Self , "invariant") ; | |
| 532 assert (_owner == Self , "invariant") ; | |
| 533 assert (_Responsible != Self , "invariant") ; | |
| 534 return ; | |
| 535 } | |
| 536 } | |
| 537 | |
| 538 // Check for cxq|EntryList edge transition to non-null. This indicates | |
| 539 // the onset of contention. While contention persists exiting threads | |
| 540 // will use a ST:MEMBAR:LD 1-1 exit protocol. When contention abates exit | |
| 541 // operations revert to the faster 1-0 mode. This enter operation may interleave | |
| 542 // (race) a concurrent 1-0 exit operation, resulting in stranding, so we | |
| 543 // arrange for one of the contending thread to use a timed park() operations | |
| 544 // to detect and recover from the race. (Stranding is form of progress failure | |
| 545 // where the monitor is unlocked but all the contending threads remain parked). | |
| 546 // That is, at least one of the contended threads will periodically poll _owner. | |
| 547 // One of the contending threads will become the designated "Responsible" thread. | |
| 548 // The Responsible thread uses a timed park instead of a normal indefinite park | |
| 549 // operation -- it periodically wakes and checks for and recovers from potential | |
| 550 // strandings admitted by 1-0 exit operations. We need at most one Responsible | |
| 551 // thread per-monitor at any given moment. Only threads on cxq|EntryList may | |
| 552 // be responsible for a monitor. | |
| 553 // | |
| 554 // Currently, one of the contended threads takes on the added role of "Responsible". | |
| 555 // A viable alternative would be to use a dedicated "stranding checker" thread | |
| 556 // that periodically iterated over all the threads (or active monitors) and unparked | |
| 557 // successors where there was risk of stranding. This would help eliminate the | |
| 558 // timer scalability issues we see on some platforms as we'd only have one thread | |
| 559 // -- the checker -- parked on a timer. | |
| 560 | |
| 561 if ((SyncFlags & 16) == 0 && nxt == NULL && _EntryList == NULL) { | |
| 562 // Try to assume the role of responsible thread for the monitor. | |
| 563 // CONSIDER: ST vs CAS vs { if (Responsible==null) Responsible=Self } | |
| 564 Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ; | |
| 565 } | |
| 566 | |
| 567 // The lock have been released while this thread was occupied queueing | |
| 568 // itself onto _cxq. To close the race and avoid "stranding" and | |
| 569 // progress-liveness failure we must resample-retry _owner before parking. | |
| 570 // Note the Dekker/Lamport duality: ST cxq; MEMBAR; LD Owner. | |
| 571 // In this case the ST-MEMBAR is accomplished with CAS(). | |
| 572 // | |
| 573 // TODO: Defer all thread state transitions until park-time. | |
| 574 // Since state transitions are heavy and inefficient we'd like | |
| 575 // to defer the state transitions until absolutely necessary, | |
| 576 // and in doing so avoid some transitions ... | |
| 577 | |
| 578 TEVENT (Inflated enter - Contention) ; | |
| 579 int nWakeups = 0 ; | |
| 580 int RecheckInterval = 1 ; | |
| 581 | |
| 582 for (;;) { | |
| 583 | |
| 584 if (TryLock (Self) > 0) break ; | |
| 585 assert (_owner != Self, "invariant") ; | |
| 586 | |
| 587 if ((SyncFlags & 2) && _Responsible == NULL) { | |
| 588 Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ; | |
| 589 } | |
| 590 | |
| 591 // park self | |
| 592 if (_Responsible == Self || (SyncFlags & 1)) { | |
| 593 TEVENT (Inflated enter - park TIMED) ; | |
| 594 Self->_ParkEvent->park ((jlong) RecheckInterval) ; | |
| 595 // Increase the RecheckInterval, but clamp the value. | |
| 596 RecheckInterval *= 8 ; | |
| 597 if (RecheckInterval > 1000) RecheckInterval = 1000 ; | |
| 598 } else { | |
| 599 TEVENT (Inflated enter - park UNTIMED) ; | |
| 600 Self->_ParkEvent->park() ; | |
| 601 } | |
| 602 | |
| 603 if (TryLock(Self) > 0) break ; | |
| 604 | |
| 605 // The lock is still contested. | |
| 606 // Keep a tally of the # of futile wakeups. | |
| 607 // Note that the counter is not protected by a lock or updated by atomics. | |
| 608 // That is by design - we trade "lossy" counters which are exposed to | |
| 609 // races during updates for a lower probe effect. | |
| 610 TEVENT (Inflated enter - Futile wakeup) ; | |
| 611 if (ObjectMonitor::_sync_FutileWakeups != NULL) { | |
| 612 ObjectMonitor::_sync_FutileWakeups->inc() ; | |
| 613 } | |
| 614 ++ nWakeups ; | |
| 615 | |
| 616 // Assuming this is not a spurious wakeup we'll normally find _succ == Self. | |
| 617 // We can defer clearing _succ until after the spin completes | |
| 618 // TrySpin() must tolerate being called with _succ == Self. | |
| 619 // Try yet another round of adaptive spinning. | |
| 620 if ((Knob_SpinAfterFutile & 1) && TrySpin (Self) > 0) break ; | |
| 621 | |
| 622 // We can find that we were unpark()ed and redesignated _succ while | |
| 623 // we were spinning. That's harmless. If we iterate and call park(), | |
| 624 // park() will consume the event and return immediately and we'll | |
| 625 // just spin again. This pattern can repeat, leaving _succ to simply | |
| 626 // spin on a CPU. Enable Knob_ResetEvent to clear pending unparks(). | |
| 627 // Alternately, we can sample fired() here, and if set, forgo spinning | |
| 628 // in the next iteration. | |
| 629 | |
| 630 if ((Knob_ResetEvent & 1) && Self->_ParkEvent->fired()) { | |
| 631 Self->_ParkEvent->reset() ; | |
| 632 OrderAccess::fence() ; | |
| 633 } | |
| 634 if (_succ == Self) _succ = NULL ; | |
| 635 | |
| 636 // Invariant: after clearing _succ a thread *must* retry _owner before parking. | |
| 637 OrderAccess::fence() ; | |
| 638 } | |
| 639 | |
| 640 // Egress : | |
| 641 // Self has acquired the lock -- Unlink Self from the cxq or EntryList. | |
| 642 // Normally we'll find Self on the EntryList . | |
| 643 // From the perspective of the lock owner (this thread), the | |
| 644 // EntryList is stable and cxq is prepend-only. | |
| 645 // The head of cxq is volatile but the interior is stable. | |
| 646 // In addition, Self.TState is stable. | |
| 647 | |
| 648 assert (_owner == Self , "invariant") ; | |
| 649 assert (object() != NULL , "invariant") ; | |
| 650 // I'd like to write: | |
| 651 // guarantee (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ; | |
| 652 // but as we're at a safepoint that's not safe. | |
| 653 | |
| 654 UnlinkAfterAcquire (Self, &node) ; | |
| 655 if (_succ == Self) _succ = NULL ; | |
| 656 | |
| 657 assert (_succ != Self, "invariant") ; | |
| 658 if (_Responsible == Self) { | |
| 659 _Responsible = NULL ; | |
| 660 // Dekker pivot-point. | |
| 661 // Consider OrderAccess::storeload() here | |
| 662 | |
| 663 // We may leave threads on cxq|EntryList without a designated | |
| 664 // "Responsible" thread. This is benign. When this thread subsequently | |
| 665 // exits the monitor it can "see" such preexisting "old" threads -- | |
| 666 // threads that arrived on the cxq|EntryList before the fence, above -- | |
| 667 // by LDing cxq|EntryList. Newly arrived threads -- that is, threads | |
| 668 // that arrive on cxq after the ST:MEMBAR, above -- will set Responsible | |
| 669 // non-null and elect a new "Responsible" timer thread. | |
| 670 // | |
| 671 // This thread executes: | |
| 672 // ST Responsible=null; MEMBAR (in enter epilog - here) | |
| 673 // LD cxq|EntryList (in subsequent exit) | |
| 674 // | |
| 675 // Entering threads in the slow/contended path execute: | |
| 676 // ST cxq=nonnull; MEMBAR; LD Responsible (in enter prolog) | |
| 677 // The (ST cxq; MEMBAR) is accomplished with CAS(). | |
| 678 // | |
| 679 // The MEMBAR, above, prevents the LD of cxq|EntryList in the subsequent | |
| 680 // exit operation from floating above the ST Responsible=null. | |
| 681 // | |
| 682 // In *practice* however, EnterI() is always followed by some atomic | |
| 683 // operation such as the decrement of _count in ::enter(). Those atomics | |
| 684 // obviate the need for the explicit MEMBAR, above. | |
| 685 } | |
| 686 | |
| 687 // We've acquired ownership with CAS(). | |
| 688 // CAS is serializing -- it has MEMBAR/FENCE-equivalent semantics. | |
| 689 // But since the CAS() this thread may have also stored into _succ, | |
| 690 // EntryList, cxq or Responsible. These meta-data updates must be | |
| 691 // visible __before this thread subsequently drops the lock. | |
| 692 // Consider what could occur if we didn't enforce this constraint -- | |
| 693 // STs to monitor meta-data and user-data could reorder with (become | |
| 694 // visible after) the ST in exit that drops ownership of the lock. | |
| 695 // Some other thread could then acquire the lock, but observe inconsistent | |
| 696 // or old monitor meta-data and heap data. That violates the JMM. | |
| 697 // To that end, the 1-0 exit() operation must have at least STST|LDST | |
| 698 // "release" barrier semantics. Specifically, there must be at least a | |
| 699 // STST|LDST barrier in exit() before the ST of null into _owner that drops | |
| 700 // the lock. The barrier ensures that changes to monitor meta-data and data | |
| 701 // protected by the lock will be visible before we release the lock, and | |
| 702 // therefore before some other thread (CPU) has a chance to acquire the lock. | |
| 703 // See also: http://gee.cs.oswego.edu/dl/jmm/cookbook.html. | |
| 704 // | |
| 705 // Critically, any prior STs to _succ or EntryList must be visible before | |
| 706 // the ST of null into _owner in the *subsequent* (following) corresponding | |
| 707 // monitorexit. Recall too, that in 1-0 mode monitorexit does not necessarily | |
| 708 // execute a serializing instruction. | |
| 709 | |
| 710 if (SyncFlags & 8) { | |
| 711 OrderAccess::fence() ; | |
| 712 } | |
| 713 return ; | |
| 714 } | |
| 715 | |
| 716 // ReenterI() is a specialized inline form of the latter half of the | |
| 717 // contended slow-path from EnterI(). We use ReenterI() only for | |
| 718 // monitor reentry in wait(). | |
| 719 // | |
| 720 // In the future we should reconcile EnterI() and ReenterI(), adding | |
| 721 // Knob_Reset and Knob_SpinAfterFutile support and restructuring the | |
| 722 // loop accordingly. | |
| 723 | |
| 724 void ATTR ObjectMonitor::ReenterI (Thread * Self, ObjectWaiter * SelfNode) { | |
| 725 assert (Self != NULL , "invariant") ; | |
| 726 assert (SelfNode != NULL , "invariant") ; | |
| 727 assert (SelfNode->_thread == Self , "invariant") ; | |
| 728 assert (_waiters > 0 , "invariant") ; | |
| 729 assert (((oop)(object()))->mark() == markOopDesc::encode(this) , "invariant") ; | |
| 730 assert (((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant") ; | |
| 731 JavaThread * jt = (JavaThread *) Self ; | |
| 732 | |
| 733 int nWakeups = 0 ; | |
| 734 for (;;) { | |
| 735 ObjectWaiter::TStates v = SelfNode->TState ; | |
| 736 guarantee (v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant") ; | |
| 737 assert (_owner != Self, "invariant") ; | |
| 738 | |
| 739 if (TryLock (Self) > 0) break ; | |
| 740 if (TrySpin (Self) > 0) break ; | |
| 741 | |
| 742 TEVENT (Wait Reentry - parking) ; | |
| 743 | |
| 744 // State transition wrappers around park() ... | |
| 745 // ReenterI() wisely defers state transitions until | |
| 746 // it's clear we must park the thread. | |
| 747 { | |
| 748 OSThreadContendState osts(Self->osthread()); | |
| 749 ThreadBlockInVM tbivm(jt); | |
| 750 | |
| 751 // cleared by handle_special_suspend_equivalent_condition() | |
| 752 // or java_suspend_self() | |
| 753 jt->set_suspend_equivalent(); | |
| 754 if (SyncFlags & 1) { | |
| 755 Self->_ParkEvent->park ((jlong)1000) ; | |
| 756 } else { | |
| 757 Self->_ParkEvent->park () ; | |
| 758 } | |
| 759 | |
| 760 // were we externally suspended while we were waiting? | |
| 761 for (;;) { | |
| 762 if (!ExitSuspendEquivalent (jt)) break ; | |
| 763 if (_succ == Self) { _succ = NULL; OrderAccess::fence(); } | |
| 764 jt->java_suspend_self(); | |
| 765 jt->set_suspend_equivalent(); | |
| 766 } | |
| 767 } | |
| 768 | |
| 769 // Try again, but just so we distinguish between futile wakeups and | |
| 770 // successful wakeups. The following test isn't algorithmically | |
| 771 // necessary, but it helps us maintain sensible statistics. | |
| 772 if (TryLock(Self) > 0) break ; | |
| 773 | |
| 774 // The lock is still contested. | |
| 775 // Keep a tally of the # of futile wakeups. | |
| 776 // Note that the counter is not protected by a lock or updated by atomics. | |
| 777 // That is by design - we trade "lossy" counters which are exposed to | |
| 778 // races during updates for a lower probe effect. | |
| 779 TEVENT (Wait Reentry - futile wakeup) ; | |
| 780 ++ nWakeups ; | |
| 781 | |
| 782 // Assuming this is not a spurious wakeup we'll normally | |
| 783 // find that _succ == Self. | |
| 784 if (_succ == Self) _succ = NULL ; | |
| 785 | |
| 786 // Invariant: after clearing _succ a contending thread | |
| 787 // *must* retry _owner before parking. | |
| 788 OrderAccess::fence() ; | |
| 789 | |
| 790 if (ObjectMonitor::_sync_FutileWakeups != NULL) { | |
| 791 ObjectMonitor::_sync_FutileWakeups->inc() ; | |
| 792 } | |
| 793 } | |
| 794 | |
| 795 // Self has acquired the lock -- Unlink Self from the cxq or EntryList . | |
| 796 // Normally we'll find Self on the EntryList. | |
| 797 // Unlinking from the EntryList is constant-time and atomic-free. | |
| 798 // From the perspective of the lock owner (this thread), the | |
| 799 // EntryList is stable and cxq is prepend-only. | |
| 800 // The head of cxq is volatile but the interior is stable. | |
| 801 // In addition, Self.TState is stable. | |
| 802 | |
| 803 assert (_owner == Self, "invariant") ; | |
| 804 assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ; | |
| 805 UnlinkAfterAcquire (Self, SelfNode) ; | |
| 806 if (_succ == Self) _succ = NULL ; | |
| 807 assert (_succ != Self, "invariant") ; | |
| 808 SelfNode->TState = ObjectWaiter::TS_RUN ; | |
| 809 OrderAccess::fence() ; // see comments at the end of EnterI() | |
| 810 } | |
| 811 | |
| 812 // after the thread acquires the lock in ::enter(). Equally, we could defer | |
| 813 // unlinking the thread until ::exit()-time. | |
| 814 | |
| 815 void ObjectMonitor::UnlinkAfterAcquire (Thread * Self, ObjectWaiter * SelfNode) | |
| 816 { | |
| 817 assert (_owner == Self, "invariant") ; | |
| 818 assert (SelfNode->_thread == Self, "invariant") ; | |
| 819 | |
| 820 if (SelfNode->TState == ObjectWaiter::TS_ENTER) { | |
| 821 // Normal case: remove Self from the DLL EntryList . | |
| 822 // This is a constant-time operation. | |
| 823 ObjectWaiter * nxt = SelfNode->_next ; | |
| 824 ObjectWaiter * prv = SelfNode->_prev ; | |
| 825 if (nxt != NULL) nxt->_prev = prv ; | |
| 826 if (prv != NULL) prv->_next = nxt ; | |
| 827 if (SelfNode == _EntryList ) _EntryList = nxt ; | |
| 828 assert (nxt == NULL || nxt->TState == ObjectWaiter::TS_ENTER, "invariant") ; | |
| 829 assert (prv == NULL || prv->TState == ObjectWaiter::TS_ENTER, "invariant") ; | |
| 830 TEVENT (Unlink from EntryList) ; | |
| 831 } else { | |
| 832 guarantee (SelfNode->TState == ObjectWaiter::TS_CXQ, "invariant") ; | |
| 833 // Inopportune interleaving -- Self is still on the cxq. | |
| 834 // This usually means the enqueue of self raced an exiting thread. | |
| 835 // Normally we'll find Self near the front of the cxq, so | |
| 836 // dequeueing is typically fast. If needbe we can accelerate | |
| 837 // this with some MCS/CHL-like bidirectional list hints and advisory | |
| 838 // back-links so dequeueing from the interior will normally operate | |
| 839 // in constant-time. | |
| 840 // Dequeue Self from either the head (with CAS) or from the interior | |
| 841 // with a linear-time scan and normal non-atomic memory operations. | |
| 842 // CONSIDER: if Self is on the cxq then simply drain cxq into EntryList | |
| 843 // and then unlink Self from EntryList. We have to drain eventually, | |
| 844 // so it might as well be now. | |
| 845 | |
| 846 ObjectWaiter * v = _cxq ; | |
| 847 assert (v != NULL, "invariant") ; | |
| 848 if (v != SelfNode || Atomic::cmpxchg_ptr (SelfNode->_next, &_cxq, v) != v) { | |
| 849 // The CAS above can fail from interference IFF a "RAT" arrived. | |
| 850 // In that case Self must be in the interior and can no longer be | |
| 851 // at the head of cxq. | |
| 852 if (v == SelfNode) { | |
| 853 assert (_cxq != v, "invariant") ; | |
| 854 v = _cxq ; // CAS above failed - start scan at head of list | |
| 855 } | |
| 856 ObjectWaiter * p ; | |
| 857 ObjectWaiter * q = NULL ; | |
| 858 for (p = v ; p != NULL && p != SelfNode; p = p->_next) { | |
| 859 q = p ; | |
| 860 assert (p->TState == ObjectWaiter::TS_CXQ, "invariant") ; | |
| 861 } | |
| 862 assert (v != SelfNode, "invariant") ; | |
| 863 assert (p == SelfNode, "Node not found on cxq") ; | |
| 864 assert (p != _cxq, "invariant") ; | |
| 865 assert (q != NULL, "invariant") ; | |
| 866 assert (q->_next == p, "invariant") ; | |
| 867 q->_next = p->_next ; | |
| 868 } | |
| 869 TEVENT (Unlink from cxq) ; | |
| 870 } | |
| 871 | |
| 872 // Diagnostic hygiene ... | |
| 873 SelfNode->_prev = (ObjectWaiter *) 0xBAD ; | |
| 874 SelfNode->_next = (ObjectWaiter *) 0xBAD ; | |
| 875 SelfNode->TState = ObjectWaiter::TS_RUN ; | |
| 876 } | |
| 877 | |
| 878 // ----------------------------------------------------------------------------- | |
| 879 // Exit support | |
| 880 // | |
| 881 // exit() | |
| 882 // ~~~~~~ | |
| 883 // Note that the collector can't reclaim the objectMonitor or deflate | |
| 884 // the object out from underneath the thread calling ::exit() as the | |
| 885 // thread calling ::exit() never transitions to a stable state. | |
| 886 // This inhibits GC, which in turn inhibits asynchronous (and | |
| 887 // inopportune) reclamation of "this". | |
| 888 // | |
| 889 // We'd like to assert that: (THREAD->thread_state() != _thread_blocked) ; | |
| 890 // There's one exception to the claim above, however. EnterI() can call | |
| 891 // exit() to drop a lock if the acquirer has been externally suspended. | |
| 892 // In that case exit() is called with _thread_state as _thread_blocked, | |
| 893 // but the monitor's _count field is > 0, which inhibits reclamation. | |
| 894 // | |
| 895 // 1-0 exit | |
| 896 // ~~~~~~~~ | |
| 897 // ::exit() uses a canonical 1-1 idiom with a MEMBAR although some of | |
| 898 // the fast-path operators have been optimized so the common ::exit() | |
| 899 // operation is 1-0. See i486.ad fast_unlock(), for instance. | |
| 900 // The code emitted by fast_unlock() elides the usual MEMBAR. This | |
| 901 // greatly improves latency -- MEMBAR and CAS having considerable local | |
| 902 // latency on modern processors -- but at the cost of "stranding". Absent the | |
| 903 // MEMBAR, a thread in fast_unlock() can race a thread in the slow | |
| 904 // ::enter() path, resulting in the entering thread being stranding | |
| 905 // and a progress-liveness failure. Stranding is extremely rare. | |
| 906 // We use timers (timed park operations) & periodic polling to detect | |
| 907 // and recover from stranding. Potentially stranded threads periodically | |
| 908 // wake up and poll the lock. See the usage of the _Responsible variable. | |
| 909 // | |
| 910 // The CAS() in enter provides for safety and exclusion, while the CAS or | |
| 911 // MEMBAR in exit provides for progress and avoids stranding. 1-0 locking | |
| 912 // eliminates the CAS/MEMBAR from the exist path, but it admits stranding. | |
| 913 // We detect and recover from stranding with timers. | |
| 914 // | |
| 915 // If a thread transiently strands it'll park until (a) another | |
| 916 // thread acquires the lock and then drops the lock, at which time the | |
| 917 // exiting thread will notice and unpark the stranded thread, or, (b) | |
| 918 // the timer expires. If the lock is high traffic then the stranding latency | |
| 919 // will be low due to (a). If the lock is low traffic then the odds of | |
| 920 // stranding are lower, although the worst-case stranding latency | |
| 921 // is longer. Critically, we don't want to put excessive load in the | |
| 922 // platform's timer subsystem. We want to minimize both the timer injection | |
| 923 // rate (timers created/sec) as well as the number of timers active at | |
| 924 // any one time. (more precisely, we want to minimize timer-seconds, which is | |
| 925 // the integral of the # of active timers at any instant over time). | |
| 926 // Both impinge on OS scalability. Given that, at most one thread parked on | |
| 927 // a monitor will use a timer. | |
| 928 | |
| 929 void ATTR ObjectMonitor::exit(TRAPS) { | |
| 930 Thread * Self = THREAD ; | |
| 931 if (THREAD != _owner) { | |
| 932 if (THREAD->is_lock_owned((address) _owner)) { | |
| 933 // Transmute _owner from a BasicLock pointer to a Thread address. | |
| 934 // We don't need to hold _mutex for this transition. | |
| 935 // Non-null to Non-null is safe as long as all readers can | |
| 936 // tolerate either flavor. | |
| 937 assert (_recursions == 0, "invariant") ; | |
| 938 _owner = THREAD ; | |
| 939 _recursions = 0 ; | |
| 940 OwnerIsThread = 1 ; | |
| 941 } else { | |
| 942 // NOTE: we need to handle unbalanced monitor enter/exit | |
| 943 // in native code by throwing an exception. | |
| 944 // TODO: Throw an IllegalMonitorStateException ? | |
| 945 TEVENT (Exit - Throw IMSX) ; | |
| 946 assert(false, "Non-balanced monitor enter/exit!"); | |
| 947 if (false) { | |
| 948 THROW(vmSymbols::java_lang_IllegalMonitorStateException()); | |
| 949 } | |
| 950 return; | |
| 951 } | |
| 952 } | |
| 953 | |
| 954 if (_recursions != 0) { | |
| 955 _recursions--; // this is simple recursive enter | |
| 956 TEVENT (Inflated exit - recursive) ; | |
| 957 return ; | |
| 958 } | |
| 959 | |
| 960 // Invariant: after setting Responsible=null an thread must execute | |
| 961 // a MEMBAR or other serializing instruction before fetching EntryList|cxq. | |
| 962 if ((SyncFlags & 4) == 0) { | |
| 963 _Responsible = NULL ; | |
| 964 } | |
| 965 | |
| 966 for (;;) { | |
| 967 assert (THREAD == _owner, "invariant") ; | |
| 968 | |
| 969 | |
| 970 if (Knob_ExitPolicy == 0) { | |
| 971 // release semantics: prior loads and stores from within the critical section | |
| 972 // must not float (reorder) past the following store that drops the lock. | |
| 973 // On SPARC that requires MEMBAR #loadstore|#storestore. | |
| 974 // But of course in TSO #loadstore|#storestore is not required. | |
| 975 // I'd like to write one of the following: | |
| 976 // A. OrderAccess::release() ; _owner = NULL | |
| 977 // B. OrderAccess::loadstore(); OrderAccess::storestore(); _owner = NULL; | |
| 978 // Unfortunately OrderAccess::release() and OrderAccess::loadstore() both | |
| 979 // store into a _dummy variable. That store is not needed, but can result | |
| 980 // in massive wasteful coherency traffic on classic SMP systems. | |
| 981 // Instead, I use release_store(), which is implemented as just a simple | |
| 982 // ST on x64, x86 and SPARC. | |
| 983 OrderAccess::release_store_ptr (&_owner, NULL) ; // drop the lock | |
| 984 OrderAccess::storeload() ; // See if we need to wake a successor | |
| 985 if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) { | |
| 986 TEVENT (Inflated exit - simple egress) ; | |
| 987 return ; | |
| 988 } | |
| 989 TEVENT (Inflated exit - complex egress) ; | |
| 990 | |
| 991 // Normally the exiting thread is responsible for ensuring succession, | |
| 992 // but if other successors are ready or other entering threads are spinning | |
| 993 // then this thread can simply store NULL into _owner and exit without | |
| 994 // waking a successor. The existence of spinners or ready successors | |
| 995 // guarantees proper succession (liveness). Responsibility passes to the | |
| 996 // ready or running successors. The exiting thread delegates the duty. | |
| 997 // More precisely, if a successor already exists this thread is absolved | |
| 998 // of the responsibility of waking (unparking) one. | |
| 999 // | |
| 1000 // The _succ variable is critical to reducing futile wakeup frequency. | |
| 1001 // _succ identifies the "heir presumptive" thread that has been made | |
| 1002 // ready (unparked) but that has not yet run. We need only one such | |
| 1003 // successor thread to guarantee progress. | |
| 1004 // See http://www.usenix.org/events/jvm01/full_papers/dice/dice.pdf | |
| 1005 // section 3.3 "Futile Wakeup Throttling" for details. | |
| 1006 // | |
| 1007 // Note that spinners in Enter() also set _succ non-null. | |
| 1008 // In the current implementation spinners opportunistically set | |
| 1009 // _succ so that exiting threads might avoid waking a successor. | |
| 1010 // Another less appealing alternative would be for the exiting thread | |
| 1011 // to drop the lock and then spin briefly to see if a spinner managed | |
| 1012 // to acquire the lock. If so, the exiting thread could exit | |
| 1013 // immediately without waking a successor, otherwise the exiting | |
| 1014 // thread would need to dequeue and wake a successor. | |
| 1015 // (Note that we'd need to make the post-drop spin short, but no | |
| 1016 // shorter than the worst-case round-trip cache-line migration time. | |
| 1017 // The dropped lock needs to become visible to the spinner, and then | |
| 1018 // the acquisition of the lock by the spinner must become visible to | |
| 1019 // the exiting thread). | |
| 1020 // | |
| 1021 | |
| 1022 // It appears that an heir-presumptive (successor) must be made ready. | |
| 1023 // Only the current lock owner can manipulate the EntryList or | |
| 1024 // drain _cxq, so we need to reacquire the lock. If we fail | |
| 1025 // to reacquire the lock the responsibility for ensuring succession | |
| 1026 // falls to the new owner. | |
| 1027 // | |
| 1028 if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) { | |
| 1029 return ; | |
| 1030 } | |
| 1031 TEVENT (Exit - Reacquired) ; | |
| 1032 } else { | |
| 1033 if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) { | |
| 1034 OrderAccess::release_store_ptr (&_owner, NULL) ; // drop the lock | |
| 1035 OrderAccess::storeload() ; | |
| 1036 // Ratify the previously observed values. | |
| 1037 if (_cxq == NULL || _succ != NULL) { | |
| 1038 TEVENT (Inflated exit - simple egress) ; | |
| 1039 return ; | |
| 1040 } | |
| 1041 | |
| 1042 // inopportune interleaving -- the exiting thread (this thread) | |
| 1043 // in the fast-exit path raced an entering thread in the slow-enter | |
| 1044 // path. | |
| 1045 // We have two choices: | |
| 1046 // A. Try to reacquire the lock. | |
| 1047 // If the CAS() fails return immediately, otherwise | |
| 1048 // we either restart/rerun the exit operation, or simply | |
| 1049 // fall-through into the code below which wakes a successor. | |
| 1050 // B. If the elements forming the EntryList|cxq are TSM | |
| 1051 // we could simply unpark() the lead thread and return | |
| 1052 // without having set _succ. | |
| 1053 if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) { | |
| 1054 TEVENT (Inflated exit - reacquired succeeded) ; | |
| 1055 return ; | |
| 1056 } | |
| 1057 TEVENT (Inflated exit - reacquired failed) ; | |
| 1058 } else { | |
| 1059 TEVENT (Inflated exit - complex egress) ; | |
| 1060 } | |
| 1061 } | |
| 1062 | |
| 1063 guarantee (_owner == THREAD, "invariant") ; | |
| 1064 | |
| 1065 ObjectWaiter * w = NULL ; | |
| 1066 int QMode = Knob_QMode ; | |
| 1067 | |
| 1068 if (QMode == 2 && _cxq != NULL) { | |
| 1069 // QMode == 2 : cxq has precedence over EntryList. | |
| 1070 // Try to directly wake a successor from the cxq. | |
| 1071 // If successful, the successor will need to unlink itself from cxq. | |
| 1072 w = _cxq ; | |
| 1073 assert (w != NULL, "invariant") ; | |
| 1074 assert (w->TState == ObjectWaiter::TS_CXQ, "Invariant") ; | |
| 1075 ExitEpilog (Self, w) ; | |
| 1076 return ; | |
| 1077 } | |
| 1078 | |
| 1079 if (QMode == 3 && _cxq != NULL) { | |
| 1080 // Aggressively drain cxq into EntryList at the first opportunity. | |
| 1081 // This policy ensure that recently-run threads live at the head of EntryList. | |
| 1082 // Drain _cxq into EntryList - bulk transfer. | |
| 1083 // First, detach _cxq. | |
| 1084 // The following loop is tantamount to: w = swap (&cxq, NULL) | |
| 1085 w = _cxq ; | |
| 1086 for (;;) { | |
| 1087 assert (w != NULL, "Invariant") ; | |
| 1088 ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ; | |
| 1089 if (u == w) break ; | |
| 1090 w = u ; | |
| 1091 } | |
| 1092 assert (w != NULL , "invariant") ; | |
| 1093 | |
| 1094 ObjectWaiter * q = NULL ; | |
| 1095 ObjectWaiter * p ; | |
| 1096 for (p = w ; p != NULL ; p = p->_next) { | |
| 1097 guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ; | |
| 1098 p->TState = ObjectWaiter::TS_ENTER ; | |
| 1099 p->_prev = q ; | |
| 1100 q = p ; | |
| 1101 } | |
| 1102 | |
| 1103 // Append the RATs to the EntryList | |
| 1104 // TODO: organize EntryList as a CDLL so we can locate the tail in constant-time. | |
| 1105 ObjectWaiter * Tail ; | |
| 1106 for (Tail = _EntryList ; Tail != NULL && Tail->_next != NULL ; Tail = Tail->_next) ; | |
| 1107 if (Tail == NULL) { | |
| 1108 _EntryList = w ; | |
| 1109 } else { | |
| 1110 Tail->_next = w ; | |
| 1111 w->_prev = Tail ; | |
| 1112 } | |
| 1113 | |
| 1114 // Fall thru into code that tries to wake a successor from EntryList | |
| 1115 } | |
| 1116 | |
| 1117 if (QMode == 4 && _cxq != NULL) { | |
| 1118 // Aggressively drain cxq into EntryList at the first opportunity. | |
| 1119 // This policy ensure that recently-run threads live at the head of EntryList. | |
| 1120 | |
| 1121 // Drain _cxq into EntryList - bulk transfer. | |
| 1122 // First, detach _cxq. | |
| 1123 // The following loop is tantamount to: w = swap (&cxq, NULL) | |
| 1124 w = _cxq ; | |
| 1125 for (;;) { | |
| 1126 assert (w != NULL, "Invariant") ; | |
| 1127 ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ; | |
| 1128 if (u == w) break ; | |
| 1129 w = u ; | |
| 1130 } | |
| 1131 assert (w != NULL , "invariant") ; | |
| 1132 | |
| 1133 ObjectWaiter * q = NULL ; | |
| 1134 ObjectWaiter * p ; | |
| 1135 for (p = w ; p != NULL ; p = p->_next) { | |
| 1136 guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ; | |
| 1137 p->TState = ObjectWaiter::TS_ENTER ; | |
| 1138 p->_prev = q ; | |
| 1139 q = p ; | |
| 1140 } | |
| 1141 | |
| 1142 // Prepend the RATs to the EntryList | |
| 1143 if (_EntryList != NULL) { | |
| 1144 q->_next = _EntryList ; | |
| 1145 _EntryList->_prev = q ; | |
| 1146 } | |
| 1147 _EntryList = w ; | |
| 1148 | |
| 1149 // Fall thru into code that tries to wake a successor from EntryList | |
| 1150 } | |
| 1151 | |
| 1152 w = _EntryList ; | |
| 1153 if (w != NULL) { | |
| 1154 // I'd like to write: guarantee (w->_thread != Self). | |
| 1155 // But in practice an exiting thread may find itself on the EntryList. | |
| 1156 // Lets say thread T1 calls O.wait(). Wait() enqueues T1 on O's waitset and | |
| 1157 // then calls exit(). Exit release the lock by setting O._owner to NULL. | |
| 1158 // Lets say T1 then stalls. T2 acquires O and calls O.notify(). The | |
| 1159 // notify() operation moves T1 from O's waitset to O's EntryList. T2 then | |
| 1160 // release the lock "O". T2 resumes immediately after the ST of null into | |
| 1161 // _owner, above. T2 notices that the EntryList is populated, so it | |
| 1162 // reacquires the lock and then finds itself on the EntryList. | |
| 1163 // Given all that, we have to tolerate the circumstance where "w" is | |
| 1164 // associated with Self. | |
| 1165 assert (w->TState == ObjectWaiter::TS_ENTER, "invariant") ; | |
| 1166 ExitEpilog (Self, w) ; | |
| 1167 return ; | |
| 1168 } | |
| 1169 | |
| 1170 // If we find that both _cxq and EntryList are null then just | |
| 1171 // re-run the exit protocol from the top. | |
| 1172 w = _cxq ; | |
| 1173 if (w == NULL) continue ; | |
| 1174 | |
| 1175 // Drain _cxq into EntryList - bulk transfer. | |
| 1176 // First, detach _cxq. | |
| 1177 // The following loop is tantamount to: w = swap (&cxq, NULL) | |
| 1178 for (;;) { | |
| 1179 assert (w != NULL, "Invariant") ; | |
| 1180 ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ; | |
| 1181 if (u == w) break ; | |
| 1182 w = u ; | |
| 1183 } | |
| 1184 TEVENT (Inflated exit - drain cxq into EntryList) ; | |
| 1185 | |
| 1186 assert (w != NULL , "invariant") ; | |
| 1187 assert (_EntryList == NULL , "invariant") ; | |
| 1188 | |
| 1189 // Convert the LIFO SLL anchored by _cxq into a DLL. | |
| 1190 // The list reorganization step operates in O(LENGTH(w)) time. | |
| 1191 // It's critical that this step operate quickly as | |
| 1192 // "Self" still holds the outer-lock, restricting parallelism | |
| 1193 // and effectively lengthening the critical section. | |
| 1194 // Invariant: s chases t chases u. | |
| 1195 // TODO-FIXME: consider changing EntryList from a DLL to a CDLL so | |
| 1196 // we have faster access to the tail. | |
| 1197 | |
| 1198 if (QMode == 1) { | |
| 1199 // QMode == 1 : drain cxq to EntryList, reversing order | |
| 1200 // We also reverse the order of the list. | |
| 1201 ObjectWaiter * s = NULL ; | |
| 1202 ObjectWaiter * t = w ; | |
| 1203 ObjectWaiter * u = NULL ; | |
| 1204 while (t != NULL) { | |
| 1205 guarantee (t->TState == ObjectWaiter::TS_CXQ, "invariant") ; | |
| 1206 t->TState = ObjectWaiter::TS_ENTER ; | |
| 1207 u = t->_next ; | |
| 1208 t->_prev = u ; | |
| 1209 t->_next = s ; | |
| 1210 s = t; | |
| 1211 t = u ; | |
| 1212 } | |
| 1213 _EntryList = s ; | |
| 1214 assert (s != NULL, "invariant") ; | |
| 1215 } else { | |
| 1216 // QMode == 0 or QMode == 2 | |
| 1217 _EntryList = w ; | |
| 1218 ObjectWaiter * q = NULL ; | |
| 1219 ObjectWaiter * p ; | |
| 1220 for (p = w ; p != NULL ; p = p->_next) { | |
| 1221 guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ; | |
| 1222 p->TState = ObjectWaiter::TS_ENTER ; | |
| 1223 p->_prev = q ; | |
| 1224 q = p ; | |
| 1225 } | |
| 1226 } | |
| 1227 | |
| 1228 // In 1-0 mode we need: ST EntryList; MEMBAR #storestore; ST _owner = NULL | |
| 1229 // The MEMBAR is satisfied by the release_store() operation in ExitEpilog(). | |
| 1230 | |
| 1231 // See if we can abdicate to a spinner instead of waking a thread. | |
| 1232 // A primary goal of the implementation is to reduce the | |
| 1233 // context-switch rate. | |
| 1234 if (_succ != NULL) continue; | |
| 1235 | |
| 1236 w = _EntryList ; | |
| 1237 if (w != NULL) { | |
| 1238 guarantee (w->TState == ObjectWaiter::TS_ENTER, "invariant") ; | |
| 1239 ExitEpilog (Self, w) ; | |
| 1240 return ; | |
| 1241 } | |
| 1242 } | |
| 1243 } | |
| 1244 | |
| 1245 // ExitSuspendEquivalent: | |
| 1246 // A faster alternate to handle_special_suspend_equivalent_condition() | |
| 1247 // | |
| 1248 // handle_special_suspend_equivalent_condition() unconditionally | |
| 1249 // acquires the SR_lock. On some platforms uncontended MutexLocker() | |
| 1250 // operations have high latency. Note that in ::enter() we call HSSEC | |
| 1251 // while holding the monitor, so we effectively lengthen the critical sections. | |
| 1252 // | |
| 1253 // There are a number of possible solutions: | |
| 1254 // | |
| 1255 // A. To ameliorate the problem we might also defer state transitions | |
| 1256 // to as late as possible -- just prior to parking. | |
| 1257 // Given that, we'd call HSSEC after having returned from park(), | |
| 1258 // but before attempting to acquire the monitor. This is only a | |
| 1259 // partial solution. It avoids calling HSSEC while holding the | |
| 1260 // monitor (good), but it still increases successor reacquisition latency -- | |
| 1261 // the interval between unparking a successor and the time the successor | |
| 1262 // resumes and retries the lock. See ReenterI(), which defers state transitions. | |
| 1263 // If we use this technique we can also avoid EnterI()-exit() loop | |
| 1264 // in ::enter() where we iteratively drop the lock and then attempt | |
| 1265 // to reacquire it after suspending. | |
| 1266 // | |
| 1267 // B. In the future we might fold all the suspend bits into a | |
| 1268 // composite per-thread suspend flag and then update it with CAS(). | |
| 1269 // Alternately, a Dekker-like mechanism with multiple variables | |
| 1270 // would suffice: | |
| 1271 // ST Self->_suspend_equivalent = false | |
| 1272 // MEMBAR | |
| 1273 // LD Self_>_suspend_flags | |
| 1274 // | |
| 1275 | |
| 1276 | |
| 1277 bool ObjectMonitor::ExitSuspendEquivalent (JavaThread * jSelf) { | |
| 1278 int Mode = Knob_FastHSSEC ; | |
| 1279 if (Mode && !jSelf->is_external_suspend()) { | |
| 1280 assert (jSelf->is_suspend_equivalent(), "invariant") ; | |
| 1281 jSelf->clear_suspend_equivalent() ; | |
| 1282 if (2 == Mode) OrderAccess::storeload() ; | |
| 1283 if (!jSelf->is_external_suspend()) return false ; | |
| 1284 // We raced a suspension -- fall thru into the slow path | |
| 1285 TEVENT (ExitSuspendEquivalent - raced) ; | |
| 1286 jSelf->set_suspend_equivalent() ; | |
| 1287 } | |
| 1288 return jSelf->handle_special_suspend_equivalent_condition() ; | |
| 1289 } | |
| 1290 | |
| 1291 | |
| 1292 void ObjectMonitor::ExitEpilog (Thread * Self, ObjectWaiter * Wakee) { | |
| 1293 assert (_owner == Self, "invariant") ; | |
| 1294 | |
| 1295 // Exit protocol: | |
| 1296 // 1. ST _succ = wakee | |
| 1297 // 2. membar #loadstore|#storestore; | |
| 1298 // 2. ST _owner = NULL | |
| 1299 // 3. unpark(wakee) | |
| 1300 | |
| 1301 _succ = Knob_SuccEnabled ? Wakee->_thread : NULL ; | |
| 1302 ParkEvent * Trigger = Wakee->_event ; | |
| 1303 | |
| 1304 // Hygiene -- once we've set _owner = NULL we can't safely dereference Wakee again. | |
| 1305 // The thread associated with Wakee may have grabbed the lock and "Wakee" may be | |
| 1306 // out-of-scope (non-extant). | |
| 1307 Wakee = NULL ; | |
| 1308 | |
| 1309 // Drop the lock | |
| 1310 OrderAccess::release_store_ptr (&_owner, NULL) ; | |
| 1311 OrderAccess::fence() ; // ST _owner vs LD in unpark() | |
| 1312 | |
| 1313 if (SafepointSynchronize::do_call_back()) { | |
| 1314 TEVENT (unpark before SAFEPOINT) ; | |
| 1315 } | |
| 1316 | |
| 1317 DTRACE_MONITOR_PROBE(contended__exit, this, object(), Self); | |
| 1318 Trigger->unpark() ; | |
| 1319 | |
| 1320 // Maintain stats and report events to JVMTI | |
| 1321 if (ObjectMonitor::_sync_Parks != NULL) { | |
| 1322 ObjectMonitor::_sync_Parks->inc() ; | |
| 1323 } | |
| 1324 } | |
| 1325 | |
| 1326 | |
| 1327 // ----------------------------------------------------------------------------- | |
| 1328 // Class Loader deadlock handling. | |
| 1329 // | |
| 1330 // complete_exit exits a lock returning recursion count | |
| 1331 // complete_exit/reenter operate as a wait without waiting | |
| 1332 // complete_exit requires an inflated monitor | |
| 1333 // The _owner field is not always the Thread addr even with an | |
| 1334 // inflated monitor, e.g. the monitor can be inflated by a non-owning | |
| 1335 // thread due to contention. | |
| 1336 intptr_t ObjectMonitor::complete_exit(TRAPS) { | |
| 1337 Thread * const Self = THREAD; | |
| 1338 assert(Self->is_Java_thread(), "Must be Java thread!"); | |
| 1339 JavaThread *jt = (JavaThread *)THREAD; | |
| 1340 | |
| 1341 DeferredInitialize(); | |
| 1342 | |
| 1343 if (THREAD != _owner) { | |
| 1344 if (THREAD->is_lock_owned ((address)_owner)) { | |
| 1345 assert(_recursions == 0, "internal state error"); | |
| 1346 _owner = THREAD ; /* Convert from basiclock addr to Thread addr */ | |
| 1347 _recursions = 0 ; | |
| 1348 OwnerIsThread = 1 ; | |
| 1349 } | |
| 1350 } | |
| 1351 | |
| 1352 guarantee(Self == _owner, "complete_exit not owner"); | |
| 1353 intptr_t save = _recursions; // record the old recursion count | |
| 1354 _recursions = 0; // set the recursion level to be 0 | |
| 1355 exit (Self) ; // exit the monitor | |
| 1356 guarantee (_owner != Self, "invariant"); | |
| 1357 return save; | |
| 1358 } | |
| 1359 | |
| 1360 // reenter() enters a lock and sets recursion count | |
| 1361 // complete_exit/reenter operate as a wait without waiting | |
| 1362 void ObjectMonitor::reenter(intptr_t recursions, TRAPS) { | |
| 1363 Thread * const Self = THREAD; | |
| 1364 assert(Self->is_Java_thread(), "Must be Java thread!"); | |
| 1365 JavaThread *jt = (JavaThread *)THREAD; | |
| 1366 | |
| 1367 guarantee(_owner != Self, "reenter already owner"); | |
| 1368 enter (THREAD); // enter the monitor | |
| 1369 guarantee (_recursions == 0, "reenter recursion"); | |
| 1370 _recursions = recursions; | |
| 1371 return; | |
| 1372 } | |
| 1373 | |
| 1374 | |
| 1375 // ----------------------------------------------------------------------------- | |
| 1376 // A macro is used below because there may already be a pending | |
| 1377 // exception which should not abort the execution of the routines | |
| 1378 // which use this (which is why we don't put this into check_slow and | |
| 1379 // call it with a CHECK argument). | |
| 1380 | |
| 1381 #define CHECK_OWNER() \ | |
| 1382 do { \ | |
| 1383 if (THREAD != _owner) { \ | |
| 1384 if (THREAD->is_lock_owned((address) _owner)) { \ | |
| 1385 _owner = THREAD ; /* Convert from basiclock addr to Thread addr */ \ | |
| 1386 _recursions = 0; \ | |
| 1387 OwnerIsThread = 1 ; \ | |
| 1388 } else { \ | |
| 1389 TEVENT (Throw IMSX) ; \ | |
| 1390 THROW(vmSymbols::java_lang_IllegalMonitorStateException()); \ | |
| 1391 } \ | |
| 1392 } \ | |
| 1393 } while (false) | |
| 1394 | |
| 1395 // check_slow() is a misnomer. It's called to simply to throw an IMSX exception. | |
| 1396 // TODO-FIXME: remove check_slow() -- it's likely dead. | |
| 1397 | |
| 1398 void ObjectMonitor::check_slow(TRAPS) { | |
| 1399 TEVENT (check_slow - throw IMSX) ; | |
| 1400 assert(THREAD != _owner && !THREAD->is_lock_owned((address) _owner), "must not be owner"); | |
| 1401 THROW_MSG(vmSymbols::java_lang_IllegalMonitorStateException(), "current thread not owner"); | |
| 1402 } | |
| 1403 | |
| 1404 static int Adjust (volatile int * adr, int dx) { | |
| 1405 int v ; | |
| 1406 for (v = *adr ; Atomic::cmpxchg (v + dx, adr, v) != v; v = *adr) ; | |
| 1407 return v ; | |
| 1408 } | |
| 1409 // ----------------------------------------------------------------------------- | |
| 1410 // Wait/Notify/NotifyAll | |
| 1411 // | |
| 1412 // Note: a subset of changes to ObjectMonitor::wait() | |
| 1413 // will need to be replicated in complete_exit above | |
| 1414 void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) { | |
| 1415 Thread * const Self = THREAD ; | |
| 1416 assert(Self->is_Java_thread(), "Must be Java thread!"); | |
| 1417 JavaThread *jt = (JavaThread *)THREAD; | |
| 1418 | |
| 1419 DeferredInitialize () ; | |
| 1420 | |
| 1421 // Throw IMSX or IEX. | |
| 1422 CHECK_OWNER(); | |
| 1423 | |
| 1424 // check for a pending interrupt | |
| 1425 if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) { | |
| 1426 // post monitor waited event. Note that this is past-tense, we are done waiting. | |
| 1427 if (JvmtiExport::should_post_monitor_waited()) { | |
| 1428 // Note: 'false' parameter is passed here because the | |
| 1429 // wait was not timed out due to thread interrupt. | |
| 1430 JvmtiExport::post_monitor_waited(jt, this, false); | |
| 1431 } | |
| 1432 TEVENT (Wait - Throw IEX) ; | |
| 1433 THROW(vmSymbols::java_lang_InterruptedException()); | |
| 1434 return ; | |
| 1435 } | |
| 1436 TEVENT (Wait) ; | |
| 1437 | |
| 1438 assert (Self->_Stalled == 0, "invariant") ; | |
| 1439 Self->_Stalled = intptr_t(this) ; | |
| 1440 jt->set_current_waiting_monitor(this); | |
| 1441 | |
| 1442 // create a node to be put into the queue | |
| 1443 // Critically, after we reset() the event but prior to park(), we must check | |
| 1444 // for a pending interrupt. | |
| 1445 ObjectWaiter node(Self); | |
| 1446 node.TState = ObjectWaiter::TS_WAIT ; | |
| 1447 Self->_ParkEvent->reset() ; | |
| 1448 OrderAccess::fence(); // ST into Event; membar ; LD interrupted-flag | |
| 1449 | |
| 1450 // Enter the waiting queue, which is a circular doubly linked list in this case | |
| 1451 // but it could be a priority queue or any data structure. | |
| 1452 // _WaitSetLock protects the wait queue. Normally the wait queue is accessed only | |
| 1453 // by the the owner of the monitor *except* in the case where park() | |
| 1454 // returns because of a timeout of interrupt. Contention is exceptionally rare | |
| 1455 // so we use a simple spin-lock instead of a heavier-weight blocking lock. | |
| 1456 | |
| 1457 Thread::SpinAcquire (&_WaitSetLock, "WaitSet - add") ; | |
| 1458 AddWaiter (&node) ; | |
| 1459 Thread::SpinRelease (&_WaitSetLock) ; | |
| 1460 | |
| 1461 if ((SyncFlags & 4) == 0) { | |
| 1462 _Responsible = NULL ; | |
| 1463 } | |
| 1464 intptr_t save = _recursions; // record the old recursion count | |
| 1465 _waiters++; // increment the number of waiters | |
| 1466 _recursions = 0; // set the recursion level to be 1 | |
| 1467 exit (Self) ; // exit the monitor | |
| 1468 guarantee (_owner != Self, "invariant") ; | |
| 1469 | |
| 1470 // As soon as the ObjectMonitor's ownership is dropped in the exit() | |
| 1471 // call above, another thread can enter() the ObjectMonitor, do the | |
| 1472 // notify(), and exit() the ObjectMonitor. If the other thread's | |
| 1473 // exit() call chooses this thread as the successor and the unpark() | |
| 1474 // call happens to occur while this thread is posting a | |
| 1475 // MONITOR_CONTENDED_EXIT event, then we run the risk of the event | |
| 1476 // handler using RawMonitors and consuming the unpark(). | |
| 1477 // | |
| 1478 // To avoid the problem, we re-post the event. This does no harm | |
| 1479 // even if the original unpark() was not consumed because we are the | |
| 1480 // chosen successor for this monitor. | |
| 1481 if (node._notified != 0 && _succ == Self) { | |
| 1482 node._event->unpark(); | |
| 1483 } | |
| 1484 | |
| 1485 // The thread is on the WaitSet list - now park() it. | |
| 1486 // On MP systems it's conceivable that a brief spin before we park | |
| 1487 // could be profitable. | |
| 1488 // | |
| 1489 // TODO-FIXME: change the following logic to a loop of the form | |
| 1490 // while (!timeout && !interrupted && _notified == 0) park() | |
| 1491 | |
| 1492 int ret = OS_OK ; | |
| 1493 int WasNotified = 0 ; | |
| 1494 { // State transition wrappers | |
| 1495 OSThread* osthread = Self->osthread(); | |
| 1496 OSThreadWaitState osts(osthread, true); | |
| 1497 { | |
| 1498 ThreadBlockInVM tbivm(jt); | |
| 1499 // Thread is in thread_blocked state and oop access is unsafe. | |
| 1500 jt->set_suspend_equivalent(); | |
| 1501 | |
| 1502 if (interruptible && (Thread::is_interrupted(THREAD, false) || HAS_PENDING_EXCEPTION)) { | |
| 1503 // Intentionally empty | |
| 1504 } else | |
| 1505 if (node._notified == 0) { | |
| 1506 if (millis <= 0) { | |
| 1507 Self->_ParkEvent->park () ; | |
| 1508 } else { | |
| 1509 ret = Self->_ParkEvent->park (millis) ; | |
| 1510 } | |
| 1511 } | |
| 1512 | |
| 1513 // were we externally suspended while we were waiting? | |
| 1514 if (ExitSuspendEquivalent (jt)) { | |
| 1515 // TODO-FIXME: add -- if succ == Self then succ = null. | |
| 1516 jt->java_suspend_self(); | |
| 1517 } | |
| 1518 | |
| 1519 } // Exit thread safepoint: transition _thread_blocked -> _thread_in_vm | |
| 1520 | |
| 1521 | |
| 1522 // Node may be on the WaitSet, the EntryList (or cxq), or in transition | |
| 1523 // from the WaitSet to the EntryList. | |
| 1524 // See if we need to remove Node from the WaitSet. | |
| 1525 // We use double-checked locking to avoid grabbing _WaitSetLock | |
| 1526 // if the thread is not on the wait queue. | |
| 1527 // | |
| 1528 // Note that we don't need a fence before the fetch of TState. | |
| 1529 // In the worst case we'll fetch a old-stale value of TS_WAIT previously | |
| 1530 // written by the is thread. (perhaps the fetch might even be satisfied | |
| 1531 // by a look-aside into the processor's own store buffer, although given | |
| 1532 // the length of the code path between the prior ST and this load that's | |
| 1533 // highly unlikely). If the following LD fetches a stale TS_WAIT value | |
| 1534 // then we'll acquire the lock and then re-fetch a fresh TState value. | |
| 1535 // That is, we fail toward safety. | |
| 1536 | |
| 1537 if (node.TState == ObjectWaiter::TS_WAIT) { | |
| 1538 Thread::SpinAcquire (&_WaitSetLock, "WaitSet - unlink") ; | |
| 1539 if (node.TState == ObjectWaiter::TS_WAIT) { | |
| 1540 DequeueSpecificWaiter (&node) ; // unlink from WaitSet | |
| 1541 assert(node._notified == 0, "invariant"); | |
| 1542 node.TState = ObjectWaiter::TS_RUN ; | |
| 1543 } | |
| 1544 Thread::SpinRelease (&_WaitSetLock) ; | |
| 1545 } | |
| 1546 | |
| 1547 // The thread is now either on off-list (TS_RUN), | |
| 1548 // on the EntryList (TS_ENTER), or on the cxq (TS_CXQ). | |
| 1549 // The Node's TState variable is stable from the perspective of this thread. | |
| 1550 // No other threads will asynchronously modify TState. | |
| 1551 guarantee (node.TState != ObjectWaiter::TS_WAIT, "invariant") ; | |
| 1552 OrderAccess::loadload() ; | |
| 1553 if (_succ == Self) _succ = NULL ; | |
| 1554 WasNotified = node._notified ; | |
| 1555 | |
| 1556 // Reentry phase -- reacquire the monitor. | |
| 1557 // re-enter contended monitor after object.wait(). | |
| 1558 // retain OBJECT_WAIT state until re-enter successfully completes | |
| 1559 // Thread state is thread_in_vm and oop access is again safe, | |
| 1560 // although the raw address of the object may have changed. | |
| 1561 // (Don't cache naked oops over safepoints, of course). | |
| 1562 | |
| 1563 // post monitor waited event. Note that this is past-tense, we are done waiting. | |
| 1564 if (JvmtiExport::should_post_monitor_waited()) { | |
| 1565 JvmtiExport::post_monitor_waited(jt, this, ret == OS_TIMEOUT); | |
| 1566 } | |
| 1567 OrderAccess::fence() ; | |
| 1568 | |
| 1569 assert (Self->_Stalled != 0, "invariant") ; | |
| 1570 Self->_Stalled = 0 ; | |
| 1571 | |
| 1572 assert (_owner != Self, "invariant") ; | |
| 1573 ObjectWaiter::TStates v = node.TState ; | |
| 1574 if (v == ObjectWaiter::TS_RUN) { | |
| 1575 enter (Self) ; | |
| 1576 } else { | |
| 1577 guarantee (v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant") ; | |
| 1578 ReenterI (Self, &node) ; | |
| 1579 node.wait_reenter_end(this); | |
| 1580 } | |
| 1581 | |
| 1582 // Self has reacquired the lock. | |
| 1583 // Lifecycle - the node representing Self must not appear on any queues. | |
| 1584 // Node is about to go out-of-scope, but even if it were immortal we wouldn't | |
| 1585 // want residual elements associated with this thread left on any lists. | |
| 1586 guarantee (node.TState == ObjectWaiter::TS_RUN, "invariant") ; | |
| 1587 assert (_owner == Self, "invariant") ; | |
| 1588 assert (_succ != Self , "invariant") ; | |
| 1589 } // OSThreadWaitState() | |
| 1590 | |
| 1591 jt->set_current_waiting_monitor(NULL); | |
| 1592 | |
| 1593 guarantee (_recursions == 0, "invariant") ; | |
| 1594 _recursions = save; // restore the old recursion count | |
| 1595 _waiters--; // decrement the number of waiters | |
| 1596 | |
| 1597 // Verify a few postconditions | |
| 1598 assert (_owner == Self , "invariant") ; | |
| 1599 assert (_succ != Self , "invariant") ; | |
| 1600 assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ; | |
| 1601 | |
| 1602 if (SyncFlags & 32) { | |
| 1603 OrderAccess::fence() ; | |
| 1604 } | |
| 1605 | |
| 1606 // check if the notification happened | |
| 1607 if (!WasNotified) { | |
| 1608 // no, it could be timeout or Thread.interrupt() or both | |
| 1609 // check for interrupt event, otherwise it is timeout | |
| 1610 if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) { | |
| 1611 TEVENT (Wait - throw IEX from epilog) ; | |
| 1612 THROW(vmSymbols::java_lang_InterruptedException()); | |
| 1613 } | |
| 1614 } | |
| 1615 | |
| 1616 // NOTE: Spurious wake up will be consider as timeout. | |
| 1617 // Monitor notify has precedence over thread interrupt. | |
| 1618 } | |
| 1619 | |
| 1620 | |
| 1621 // Consider: | |
| 1622 // If the lock is cool (cxq == null && succ == null) and we're on an MP system | |
| 1623 // then instead of transferring a thread from the WaitSet to the EntryList | |
| 1624 // we might just dequeue a thread from the WaitSet and directly unpark() it. | |
| 1625 | |
| 1626 void ObjectMonitor::notify(TRAPS) { | |
| 1627 CHECK_OWNER(); | |
| 1628 if (_WaitSet == NULL) { | |
| 1629 TEVENT (Empty-Notify) ; | |
| 1630 return ; | |
| 1631 } | |
| 1632 DTRACE_MONITOR_PROBE(notify, this, object(), THREAD); | |
| 1633 | |
| 1634 int Policy = Knob_MoveNotifyee ; | |
| 1635 | |
| 1636 Thread::SpinAcquire (&_WaitSetLock, "WaitSet - notify") ; | |
| 1637 ObjectWaiter * iterator = DequeueWaiter() ; | |
| 1638 if (iterator != NULL) { | |
| 1639 TEVENT (Notify1 - Transfer) ; | |
| 1640 guarantee (iterator->TState == ObjectWaiter::TS_WAIT, "invariant") ; | |
| 1641 guarantee (iterator->_notified == 0, "invariant") ; | |
| 1642 if (Policy != 4) { | |
| 1643 iterator->TState = ObjectWaiter::TS_ENTER ; | |
| 1644 } | |
| 1645 iterator->_notified = 1 ; | |
| 1646 | |
| 1647 ObjectWaiter * List = _EntryList ; | |
| 1648 if (List != NULL) { | |
| 1649 assert (List->_prev == NULL, "invariant") ; | |
| 1650 assert (List->TState == ObjectWaiter::TS_ENTER, "invariant") ; | |
| 1651 assert (List != iterator, "invariant") ; | |
| 1652 } | |
| 1653 | |
| 1654 if (Policy == 0) { // prepend to EntryList | |
| 1655 if (List == NULL) { | |
| 1656 iterator->_next = iterator->_prev = NULL ; | |
| 1657 _EntryList = iterator ; | |
| 1658 } else { | |
| 1659 List->_prev = iterator ; | |
| 1660 iterator->_next = List ; | |
| 1661 iterator->_prev = NULL ; | |
| 1662 _EntryList = iterator ; | |
| 1663 } | |
| 1664 } else | |
| 1665 if (Policy == 1) { // append to EntryList | |
| 1666 if (List == NULL) { | |
| 1667 iterator->_next = iterator->_prev = NULL ; | |
| 1668 _EntryList = iterator ; | |
| 1669 } else { | |
| 1670 // CONSIDER: finding the tail currently requires a linear-time walk of | |
| 1671 // the EntryList. We can make tail access constant-time by converting to | |
| 1672 // a CDLL instead of using our current DLL. | |
| 1673 ObjectWaiter * Tail ; | |
| 1674 for (Tail = List ; Tail->_next != NULL ; Tail = Tail->_next) ; | |
| 1675 assert (Tail != NULL && Tail->_next == NULL, "invariant") ; | |
| 1676 Tail->_next = iterator ; | |
| 1677 iterator->_prev = Tail ; | |
| 1678 iterator->_next = NULL ; | |
| 1679 } | |
| 1680 } else | |
| 1681 if (Policy == 2) { // prepend to cxq | |
| 1682 // prepend to cxq | |
| 1683 if (List == NULL) { | |
| 1684 iterator->_next = iterator->_prev = NULL ; | |
| 1685 _EntryList = iterator ; | |
| 1686 } else { | |
| 1687 iterator->TState = ObjectWaiter::TS_CXQ ; | |
| 1688 for (;;) { | |
| 1689 ObjectWaiter * Front = _cxq ; | |
| 1690 iterator->_next = Front ; | |
| 1691 if (Atomic::cmpxchg_ptr (iterator, &_cxq, Front) == Front) { | |
| 1692 break ; | |
| 1693 } | |
| 1694 } | |
| 1695 } | |
| 1696 } else | |
| 1697 if (Policy == 3) { // append to cxq | |
| 1698 iterator->TState = ObjectWaiter::TS_CXQ ; | |
| 1699 for (;;) { | |
| 1700 ObjectWaiter * Tail ; | |
| 1701 Tail = _cxq ; | |
| 1702 if (Tail == NULL) { | |
| 1703 iterator->_next = NULL ; | |
| 1704 if (Atomic::cmpxchg_ptr (iterator, &_cxq, NULL) == NULL) { | |
| 1705 break ; | |
| 1706 } | |
| 1707 } else { | |
| 1708 while (Tail->_next != NULL) Tail = Tail->_next ; | |
| 1709 Tail->_next = iterator ; | |
| 1710 iterator->_prev = Tail ; | |
| 1711 iterator->_next = NULL ; | |
| 1712 break ; | |
| 1713 } | |
| 1714 } | |
| 1715 } else { | |
| 1716 ParkEvent * ev = iterator->_event ; | |
| 1717 iterator->TState = ObjectWaiter::TS_RUN ; | |
| 1718 OrderAccess::fence() ; | |
| 1719 ev->unpark() ; | |
| 1720 } | |
| 1721 | |
| 1722 if (Policy < 4) { | |
| 1723 iterator->wait_reenter_begin(this); | |
| 1724 } | |
| 1725 | |
| 1726 // _WaitSetLock protects the wait queue, not the EntryList. We could | |
| 1727 // move the add-to-EntryList operation, above, outside the critical section | |
| 1728 // protected by _WaitSetLock. In practice that's not useful. With the | |
| 1729 // exception of wait() timeouts and interrupts the monitor owner | |
| 1730 // is the only thread that grabs _WaitSetLock. There's almost no contention | |
| 1731 // on _WaitSetLock so it's not profitable to reduce the length of the | |
| 1732 // critical section. | |
| 1733 } | |
| 1734 | |
| 1735 Thread::SpinRelease (&_WaitSetLock) ; | |
| 1736 | |
| 1737 if (iterator != NULL && ObjectMonitor::_sync_Notifications != NULL) { | |
| 1738 ObjectMonitor::_sync_Notifications->inc() ; | |
| 1739 } | |
| 1740 } | |
| 1741 | |
| 1742 | |
| 1743 void ObjectMonitor::notifyAll(TRAPS) { | |
| 1744 CHECK_OWNER(); | |
| 1745 ObjectWaiter* iterator; | |
| 1746 if (_WaitSet == NULL) { | |
| 1747 TEVENT (Empty-NotifyAll) ; | |
| 1748 return ; | |
| 1749 } | |
| 1750 DTRACE_MONITOR_PROBE(notifyAll, this, object(), THREAD); | |
| 1751 | |
| 1752 int Policy = Knob_MoveNotifyee ; | |
| 1753 int Tally = 0 ; | |
| 1754 Thread::SpinAcquire (&_WaitSetLock, "WaitSet - notifyall") ; | |
| 1755 | |
| 1756 for (;;) { | |
| 1757 iterator = DequeueWaiter () ; | |
| 1758 if (iterator == NULL) break ; | |
| 1759 TEVENT (NotifyAll - Transfer1) ; | |
| 1760 ++Tally ; | |
| 1761 | |
| 1762 // Disposition - what might we do with iterator ? | |
| 1763 // a. add it directly to the EntryList - either tail or head. | |
| 1764 // b. push it onto the front of the _cxq. | |
| 1765 // For now we use (a). | |
| 1766 | |
| 1767 guarantee (iterator->TState == ObjectWaiter::TS_WAIT, "invariant") ; | |
| 1768 guarantee (iterator->_notified == 0, "invariant") ; | |
| 1769 iterator->_notified = 1 ; | |
| 1770 if (Policy != 4) { | |
| 1771 iterator->TState = ObjectWaiter::TS_ENTER ; | |
| 1772 } | |
| 1773 | |
| 1774 ObjectWaiter * List = _EntryList ; | |
| 1775 if (List != NULL) { | |
| 1776 assert (List->_prev == NULL, "invariant") ; | |
| 1777 assert (List->TState == ObjectWaiter::TS_ENTER, "invariant") ; | |
| 1778 assert (List != iterator, "invariant") ; | |
| 1779 } | |
| 1780 | |
| 1781 if (Policy == 0) { // prepend to EntryList | |
| 1782 if (List == NULL) { | |
| 1783 iterator->_next = iterator->_prev = NULL ; | |
| 1784 _EntryList = iterator ; | |
| 1785 } else { | |
| 1786 List->_prev = iterator ; | |
| 1787 iterator->_next = List ; | |
| 1788 iterator->_prev = NULL ; | |
| 1789 _EntryList = iterator ; | |
| 1790 } | |
| 1791 } else | |
| 1792 if (Policy == 1) { // append to EntryList | |
| 1793 if (List == NULL) { | |
| 1794 iterator->_next = iterator->_prev = NULL ; | |
| 1795 _EntryList = iterator ; | |
| 1796 } else { | |
| 1797 // CONSIDER: finding the tail currently requires a linear-time walk of | |
| 1798 // the EntryList. We can make tail access constant-time by converting to | |
| 1799 // a CDLL instead of using our current DLL. | |
| 1800 ObjectWaiter * Tail ; | |
| 1801 for (Tail = List ; Tail->_next != NULL ; Tail = Tail->_next) ; | |
| 1802 assert (Tail != NULL && Tail->_next == NULL, "invariant") ; | |
| 1803 Tail->_next = iterator ; | |
| 1804 iterator->_prev = Tail ; | |
| 1805 iterator->_next = NULL ; | |
| 1806 } | |
| 1807 } else | |
| 1808 if (Policy == 2) { // prepend to cxq | |
| 1809 // prepend to cxq | |
| 1810 iterator->TState = ObjectWaiter::TS_CXQ ; | |
| 1811 for (;;) { | |
| 1812 ObjectWaiter * Front = _cxq ; | |
| 1813 iterator->_next = Front ; | |
| 1814 if (Atomic::cmpxchg_ptr (iterator, &_cxq, Front) == Front) { | |
| 1815 break ; | |
| 1816 } | |
| 1817 } | |
| 1818 } else | |
| 1819 if (Policy == 3) { // append to cxq | |
| 1820 iterator->TState = ObjectWaiter::TS_CXQ ; | |
| 1821 for (;;) { | |
| 1822 ObjectWaiter * Tail ; | |
| 1823 Tail = _cxq ; | |
| 1824 if (Tail == NULL) { | |
| 1825 iterator->_next = NULL ; | |
| 1826 if (Atomic::cmpxchg_ptr (iterator, &_cxq, NULL) == NULL) { | |
| 1827 break ; | |
| 1828 } | |
| 1829 } else { | |
| 1830 while (Tail->_next != NULL) Tail = Tail->_next ; | |
| 1831 Tail->_next = iterator ; | |
| 1832 iterator->_prev = Tail ; | |
| 1833 iterator->_next = NULL ; | |
| 1834 break ; | |
| 1835 } | |
| 1836 } | |
| 1837 } else { | |
| 1838 ParkEvent * ev = iterator->_event ; | |
| 1839 iterator->TState = ObjectWaiter::TS_RUN ; | |
| 1840 OrderAccess::fence() ; | |
| 1841 ev->unpark() ; | |
| 1842 } | |
| 1843 | |
| 1844 if (Policy < 4) { | |
| 1845 iterator->wait_reenter_begin(this); | |
| 1846 } | |
| 1847 | |
| 1848 // _WaitSetLock protects the wait queue, not the EntryList. We could | |
| 1849 // move the add-to-EntryList operation, above, outside the critical section | |
| 1850 // protected by _WaitSetLock. In practice that's not useful. With the | |
| 1851 // exception of wait() timeouts and interrupts the monitor owner | |
| 1852 // is the only thread that grabs _WaitSetLock. There's almost no contention | |
| 1853 // on _WaitSetLock so it's not profitable to reduce the length of the | |
| 1854 // critical section. | |
| 1855 } | |
| 1856 | |
| 1857 Thread::SpinRelease (&_WaitSetLock) ; | |
| 1858 | |
| 1859 if (Tally != 0 && ObjectMonitor::_sync_Notifications != NULL) { | |
| 1860 ObjectMonitor::_sync_Notifications->inc(Tally) ; | |
| 1861 } | |
| 1862 } | |
| 1863 | |
| 1864 // ----------------------------------------------------------------------------- | |
| 1865 // Adaptive Spinning Support | |
| 1866 // | |
| 1867 // Adaptive spin-then-block - rational spinning | |
| 1868 // | |
| 1869 // Note that we spin "globally" on _owner with a classic SMP-polite TATAS | |
| 1870 // algorithm. On high order SMP systems it would be better to start with | |
| 1871 // a brief global spin and then revert to spinning locally. In the spirit of MCS/CLH, | |
| 1872 // a contending thread could enqueue itself on the cxq and then spin locally | |
| 1873 // on a thread-specific variable such as its ParkEvent._Event flag. | |
| 1874 // That's left as an exercise for the reader. Note that global spinning is | |
| 1875 // not problematic on Niagara, as the L2$ serves the interconnect and has both | |
| 1876 // low latency and massive bandwidth. | |
| 1877 // | |
| 1878 // Broadly, we can fix the spin frequency -- that is, the % of contended lock | |
| 1879 // acquisition attempts where we opt to spin -- at 100% and vary the spin count | |
| 1880 // (duration) or we can fix the count at approximately the duration of | |
| 1881 // a context switch and vary the frequency. Of course we could also | |
| 1882 // vary both satisfying K == Frequency * Duration, where K is adaptive by monitor. | |
| 1883 // See http://j2se.east/~dice/PERSIST/040824-AdaptiveSpinning.html. | |
| 1884 // | |
| 1885 // This implementation varies the duration "D", where D varies with | |
| 1886 // the success rate of recent spin attempts. (D is capped at approximately | |
| 1887 // length of a round-trip context switch). The success rate for recent | |
| 1888 // spin attempts is a good predictor of the success rate of future spin | |
| 1889 // attempts. The mechanism adapts automatically to varying critical | |
| 1890 // section length (lock modality), system load and degree of parallelism. | |
| 1891 // D is maintained per-monitor in _SpinDuration and is initialized | |
| 1892 // optimistically. Spin frequency is fixed at 100%. | |
| 1893 // | |
| 1894 // Note that _SpinDuration is volatile, but we update it without locks | |
| 1895 // or atomics. The code is designed so that _SpinDuration stays within | |
| 1896 // a reasonable range even in the presence of races. The arithmetic | |
| 1897 // operations on _SpinDuration are closed over the domain of legal values, | |
| 1898 // so at worst a race will install and older but still legal value. | |
| 1899 // At the very worst this introduces some apparent non-determinism. | |
| 1900 // We might spin when we shouldn't or vice-versa, but since the spin | |
| 1901 // count are relatively short, even in the worst case, the effect is harmless. | |
| 1902 // | |
| 1903 // Care must be taken that a low "D" value does not become an | |
| 1904 // an absorbing state. Transient spinning failures -- when spinning | |
| 1905 // is overall profitable -- should not cause the system to converge | |
| 1906 // on low "D" values. We want spinning to be stable and predictable | |
| 1907 // and fairly responsive to change and at the same time we don't want | |
| 1908 // it to oscillate, become metastable, be "too" non-deterministic, | |
| 1909 // or converge on or enter undesirable stable absorbing states. | |
| 1910 // | |
| 1911 // We implement a feedback-based control system -- using past behavior | |
| 1912 // to predict future behavior. We face two issues: (a) if the | |
| 1913 // input signal is random then the spin predictor won't provide optimal | |
| 1914 // results, and (b) if the signal frequency is too high then the control | |
| 1915 // system, which has some natural response lag, will "chase" the signal. | |
| 1916 // (b) can arise from multimodal lock hold times. Transient preemption | |
| 1917 // can also result in apparent bimodal lock hold times. | |
| 1918 // Although sub-optimal, neither condition is particularly harmful, as | |
| 1919 // in the worst-case we'll spin when we shouldn't or vice-versa. | |
| 1920 // The maximum spin duration is rather short so the failure modes aren't bad. | |
| 1921 // To be conservative, I've tuned the gain in system to bias toward | |
| 1922 // _not spinning. Relatedly, the system can sometimes enter a mode where it | |
| 1923 // "rings" or oscillates between spinning and not spinning. This happens | |
| 1924 // when spinning is just on the cusp of profitability, however, so the | |
| 1925 // situation is not dire. The state is benign -- there's no need to add | |
| 1926 // hysteresis control to damp the transition rate between spinning and | |
| 1927 // not spinning. | |
| 1928 // | |
| 1929 | |
| 1930 intptr_t ObjectMonitor::SpinCallbackArgument = 0 ; | |
| 1931 int (*ObjectMonitor::SpinCallbackFunction)(intptr_t, int) = NULL ; | |
| 1932 | |
| 1933 // Spinning: Fixed frequency (100%), vary duration | |
| 1934 | |
| 1935 | |
| 1936 int ObjectMonitor::TrySpin_VaryDuration (Thread * Self) { | |
| 1937 | |
| 1938 // Dumb, brutal spin. Good for comparative measurements against adaptive spinning. | |
| 1939 int ctr = Knob_FixedSpin ; | |
| 1940 if (ctr != 0) { | |
| 1941 while (--ctr >= 0) { | |
| 1942 if (TryLock (Self) > 0) return 1 ; | |
| 1943 SpinPause () ; | |
| 1944 } | |
| 1945 return 0 ; | |
| 1946 } | |
| 1947 | |
| 1948 for (ctr = Knob_PreSpin + 1; --ctr >= 0 ; ) { | |
| 1949 if (TryLock(Self) > 0) { | |
| 1950 // Increase _SpinDuration ... | |
| 1951 // Note that we don't clamp SpinDuration precisely at SpinLimit. | |
| 1952 // Raising _SpurDuration to the poverty line is key. | |
| 1953 int x = _SpinDuration ; | |
| 1954 if (x < Knob_SpinLimit) { | |
| 1955 if (x < Knob_Poverty) x = Knob_Poverty ; | |
| 1956 _SpinDuration = x + Knob_BonusB ; | |
| 1957 } | |
| 1958 return 1 ; | |
| 1959 } | |
| 1960 SpinPause () ; | |
| 1961 } | |
| 1962 | |
| 1963 // Admission control - verify preconditions for spinning | |
| 1964 // | |
| 1965 // We always spin a little bit, just to prevent _SpinDuration == 0 from | |
| 1966 // becoming an absorbing state. Put another way, we spin briefly to | |
| 1967 // sample, just in case the system load, parallelism, contention, or lock | |
| 1968 // modality changed. | |
| 1969 // | |
| 1970 // Consider the following alternative: | |
| 1971 // Periodically set _SpinDuration = _SpinLimit and try a long/full | |
| 1972 // spin attempt. "Periodically" might mean after a tally of | |
| 1973 // the # of failed spin attempts (or iterations) reaches some threshold. | |
| 1974 // This takes us into the realm of 1-out-of-N spinning, where we | |
| 1975 // hold the duration constant but vary the frequency. | |
| 1976 | |
| 1977 ctr = _SpinDuration ; | |
| 1978 if (ctr < Knob_SpinBase) ctr = Knob_SpinBase ; | |
| 1979 if (ctr <= 0) return 0 ; | |
| 1980 | |
| 1981 if (Knob_SuccRestrict && _succ != NULL) return 0 ; | |
| 1982 if (Knob_OState && NotRunnable (Self, (Thread *) _owner)) { | |
| 1983 TEVENT (Spin abort - notrunnable [TOP]); | |
| 1984 return 0 ; | |
| 1985 } | |
| 1986 | |
| 1987 int MaxSpin = Knob_MaxSpinners ; | |
| 1988 if (MaxSpin >= 0) { | |
| 1989 if (_Spinner > MaxSpin) { | |
| 1990 TEVENT (Spin abort -- too many spinners) ; | |
| 1991 return 0 ; | |
| 1992 } | |
| 1993 // Slighty racy, but benign ... | |
| 1994 Adjust (&_Spinner, 1) ; | |
| 1995 } | |
| 1996 | |
| 1997 // We're good to spin ... spin ingress. | |
| 1998 // CONSIDER: use Prefetch::write() to avoid RTS->RTO upgrades | |
| 1999 // when preparing to LD...CAS _owner, etc and the CAS is likely | |
| 2000 // to succeed. | |
| 2001 int hits = 0 ; | |
| 2002 int msk = 0 ; | |
| 2003 int caspty = Knob_CASPenalty ; | |
| 2004 int oxpty = Knob_OXPenalty ; | |
| 2005 int sss = Knob_SpinSetSucc ; | |
| 2006 if (sss && _succ == NULL ) _succ = Self ; | |
| 2007 Thread * prv = NULL ; | |
| 2008 | |
| 2009 // There are three ways to exit the following loop: | |
| 2010 // 1. A successful spin where this thread has acquired the lock. | |
| 2011 // 2. Spin failure with prejudice | |
| 2012 // 3. Spin failure without prejudice | |
| 2013 | |
| 2014 while (--ctr >= 0) { | |
| 2015 | |
| 2016 // Periodic polling -- Check for pending GC | |
| 2017 // Threads may spin while they're unsafe. | |
| 2018 // We don't want spinning threads to delay the JVM from reaching | |
| 2019 // a stop-the-world safepoint or to steal cycles from GC. | |
| 2020 // If we detect a pending safepoint we abort in order that | |
| 2021 // (a) this thread, if unsafe, doesn't delay the safepoint, and (b) | |
| 2022 // this thread, if safe, doesn't steal cycles from GC. | |
| 2023 // This is in keeping with the "no loitering in runtime" rule. | |
| 2024 // We periodically check to see if there's a safepoint pending. | |
| 2025 if ((ctr & 0xFF) == 0) { | |
| 2026 if (SafepointSynchronize::do_call_back()) { | |
| 2027 TEVENT (Spin: safepoint) ; | |
| 2028 goto Abort ; // abrupt spin egress | |
| 2029 } | |
| 2030 if (Knob_UsePause & 1) SpinPause () ; | |
| 2031 | |
| 2032 int (*scb)(intptr_t,int) = SpinCallbackFunction ; | |
| 2033 if (hits > 50 && scb != NULL) { | |
| 2034 int abend = (*scb)(SpinCallbackArgument, 0) ; | |
| 2035 } | |
| 2036 } | |
| 2037 | |
| 2038 if (Knob_UsePause & 2) SpinPause() ; | |
| 2039 | |
| 2040 // Exponential back-off ... Stay off the bus to reduce coherency traffic. | |
| 2041 // This is useful on classic SMP systems, but is of less utility on | |
| 2042 // N1-style CMT platforms. | |
| 2043 // | |
| 2044 // Trade-off: lock acquisition latency vs coherency bandwidth. | |
| 2045 // Lock hold times are typically short. A histogram | |
| 2046 // of successful spin attempts shows that we usually acquire | |
| 2047 // the lock early in the spin. That suggests we want to | |
| 2048 // sample _owner frequently in the early phase of the spin, | |
| 2049 // but then back-off and sample less frequently as the spin | |
| 2050 // progresses. The back-off makes a good citizen on SMP big | |
| 2051 // SMP systems. Oversampling _owner can consume excessive | |
| 2052 // coherency bandwidth. Relatedly, if we _oversample _owner we | |
| 2053 // can inadvertently interfere with the the ST m->owner=null. | |
| 2054 // executed by the lock owner. | |
| 2055 if (ctr & msk) continue ; | |
| 2056 ++hits ; | |
| 2057 if ((hits & 0xF) == 0) { | |
| 2058 // The 0xF, above, corresponds to the exponent. | |
| 2059 // Consider: (msk+1)|msk | |
| 2060 msk = ((msk << 2)|3) & BackOffMask ; | |
| 2061 } | |
| 2062 | |
| 2063 // Probe _owner with TATAS | |
| 2064 // If this thread observes the monitor transition or flicker | |
| 2065 // from locked to unlocked to locked, then the odds that this | |
| 2066 // thread will acquire the lock in this spin attempt go down | |
| 2067 // considerably. The same argument applies if the CAS fails | |
| 2068 // or if we observe _owner change from one non-null value to | |
| 2069 // another non-null value. In such cases we might abort | |
| 2070 // the spin without prejudice or apply a "penalty" to the | |
| 2071 // spin count-down variable "ctr", reducing it by 100, say. | |
| 2072 | |
| 2073 Thread * ox = (Thread *) _owner ; | |
| 2074 if (ox == NULL) { | |
| 2075 ox = (Thread *) Atomic::cmpxchg_ptr (Self, &_owner, NULL) ; | |
| 2076 if (ox == NULL) { | |
| 2077 // The CAS succeeded -- this thread acquired ownership | |
| 2078 // Take care of some bookkeeping to exit spin state. | |
| 2079 if (sss && _succ == Self) { | |
| 2080 _succ = NULL ; | |
| 2081 } | |
| 2082 if (MaxSpin > 0) Adjust (&_Spinner, -1) ; | |
| 2083 | |
| 2084 // Increase _SpinDuration : | |
| 2085 // The spin was successful (profitable) so we tend toward | |
| 2086 // longer spin attempts in the future. | |
| 2087 // CONSIDER: factor "ctr" into the _SpinDuration adjustment. | |
| 2088 // If we acquired the lock early in the spin cycle it | |
| 2089 // makes sense to increase _SpinDuration proportionally. | |
| 2090 // Note that we don't clamp SpinDuration precisely at SpinLimit. | |
| 2091 int x = _SpinDuration ; | |
| 2092 if (x < Knob_SpinLimit) { | |
| 2093 if (x < Knob_Poverty) x = Knob_Poverty ; | |
| 2094 _SpinDuration = x + Knob_Bonus ; | |
| 2095 } | |
| 2096 return 1 ; | |
| 2097 } | |
| 2098 | |
| 2099 // The CAS failed ... we can take any of the following actions: | |
| 2100 // * penalize: ctr -= Knob_CASPenalty | |
| 2101 // * exit spin with prejudice -- goto Abort; | |
| 2102 // * exit spin without prejudice. | |
| 2103 // * Since CAS is high-latency, retry again immediately. | |
| 2104 prv = ox ; | |
| 2105 TEVENT (Spin: cas failed) ; | |
| 2106 if (caspty == -2) break ; | |
| 2107 if (caspty == -1) goto Abort ; | |
| 2108 ctr -= caspty ; | |
| 2109 continue ; | |
| 2110 } | |
| 2111 | |
| 2112 // Did lock ownership change hands ? | |
| 2113 if (ox != prv && prv != NULL ) { | |
| 2114 TEVENT (spin: Owner changed) | |
| 2115 if (oxpty == -2) break ; | |
| 2116 if (oxpty == -1) goto Abort ; | |
| 2117 ctr -= oxpty ; | |
| 2118 } | |
| 2119 prv = ox ; | |
| 2120 | |
| 2121 // Abort the spin if the owner is not executing. | |
| 2122 // The owner must be executing in order to drop the lock. | |
| 2123 // Spinning while the owner is OFFPROC is idiocy. | |
| 2124 // Consider: ctr -= RunnablePenalty ; | |
| 2125 if (Knob_OState && NotRunnable (Self, ox)) { | |
| 2126 TEVENT (Spin abort - notrunnable); | |
| 2127 goto Abort ; | |
| 2128 } | |
| 2129 if (sss && _succ == NULL ) _succ = Self ; | |
| 2130 } | |
| 2131 | |
| 2132 // Spin failed with prejudice -- reduce _SpinDuration. | |
| 2133 // TODO: Use an AIMD-like policy to adjust _SpinDuration. | |
| 2134 // AIMD is globally stable. | |
| 2135 TEVENT (Spin failure) ; | |
| 2136 { | |
| 2137 int x = _SpinDuration ; | |
| 2138 if (x > 0) { | |
| 2139 // Consider an AIMD scheme like: x -= (x >> 3) + 100 | |
| 2140 // This is globally sample and tends to damp the response. | |
| 2141 x -= Knob_Penalty ; | |
| 2142 if (x < 0) x = 0 ; | |
| 2143 _SpinDuration = x ; | |
| 2144 } | |
| 2145 } | |
| 2146 | |
| 2147 Abort: | |
| 2148 if (MaxSpin >= 0) Adjust (&_Spinner, -1) ; | |
| 2149 if (sss && _succ == Self) { | |
| 2150 _succ = NULL ; | |
| 2151 // Invariant: after setting succ=null a contending thread | |
| 2152 // must recheck-retry _owner before parking. This usually happens | |
| 2153 // in the normal usage of TrySpin(), but it's safest | |
| 2154 // to make TrySpin() as foolproof as possible. | |
| 2155 OrderAccess::fence() ; | |
| 2156 if (TryLock(Self) > 0) return 1 ; | |
| 2157 } | |
| 2158 return 0 ; | |
| 2159 } | |
| 2160 | |
| 2161 // NotRunnable() -- informed spinning | |
| 2162 // | |
| 2163 // Don't bother spinning if the owner is not eligible to drop the lock. | |
| 2164 // Peek at the owner's schedctl.sc_state and Thread._thread_values and | |
| 2165 // spin only if the owner thread is _thread_in_Java or _thread_in_vm. | |
| 2166 // The thread must be runnable in order to drop the lock in timely fashion. | |
| 2167 // If the _owner is not runnable then spinning will not likely be | |
| 2168 // successful (profitable). | |
| 2169 // | |
| 2170 // Beware -- the thread referenced by _owner could have died | |
| 2171 // so a simply fetch from _owner->_thread_state might trap. | |
| 2172 // Instead, we use SafeFetchXX() to safely LD _owner->_thread_state. | |
| 2173 // Because of the lifecycle issues the schedctl and _thread_state values | |
| 2174 // observed by NotRunnable() might be garbage. NotRunnable must | |
| 2175 // tolerate this and consider the observed _thread_state value | |
| 2176 // as advisory. | |
| 2177 // | |
| 2178 // Beware too, that _owner is sometimes a BasicLock address and sometimes | |
| 2179 // a thread pointer. We differentiate the two cases with OwnerIsThread. | |
| 2180 // Alternately, we might tag the type (thread pointer vs basiclock pointer) | |
| 2181 // with the LSB of _owner. Another option would be to probablistically probe | |
| 2182 // the putative _owner->TypeTag value. | |
| 2183 // | |
| 2184 // Checking _thread_state isn't perfect. Even if the thread is | |
| 2185 // in_java it might be blocked on a page-fault or have been preempted | |
| 2186 // and sitting on a ready/dispatch queue. _thread state in conjunction | |
| 2187 // with schedctl.sc_state gives us a good picture of what the | |
| 2188 // thread is doing, however. | |
| 2189 // | |
| 2190 // TODO: check schedctl.sc_state. | |
| 2191 // We'll need to use SafeFetch32() to read from the schedctl block. | |
| 2192 // See RFE #5004247 and http://sac.sfbay.sun.com/Archives/CaseLog/arc/PSARC/2005/351/ | |
| 2193 // | |
| 2194 // The return value from NotRunnable() is *advisory* -- the | |
| 2195 // result is based on sampling and is not necessarily coherent. | |
| 2196 // The caller must tolerate false-negative and false-positive errors. | |
| 2197 // Spinning, in general, is probabilistic anyway. | |
| 2198 | |
| 2199 | |
| 2200 int ObjectMonitor::NotRunnable (Thread * Self, Thread * ox) { | |
| 2201 // Check either OwnerIsThread or ox->TypeTag == 2BAD. | |
| 2202 if (!OwnerIsThread) return 0 ; | |
| 2203 | |
| 2204 if (ox == NULL) return 0 ; | |
| 2205 | |
| 2206 // Avoid transitive spinning ... | |
| 2207 // Say T1 spins or blocks trying to acquire L. T1._Stalled is set to L. | |
| 2208 // Immediately after T1 acquires L it's possible that T2, also | |
| 2209 // spinning on L, will see L.Owner=T1 and T1._Stalled=L. | |
| 2210 // This occurs transiently after T1 acquired L but before | |
| 2211 // T1 managed to clear T1.Stalled. T2 does not need to abort | |
| 2212 // its spin in this circumstance. | |
| 2213 intptr_t BlockedOn = SafeFetchN ((intptr_t *) &ox->_Stalled, intptr_t(1)) ; | |
| 2214 | |
| 2215 if (BlockedOn == 1) return 1 ; | |
| 2216 if (BlockedOn != 0) { | |
| 2217 return BlockedOn != intptr_t(this) && _owner == ox ; | |
| 2218 } | |
| 2219 | |
| 2220 assert (sizeof(((JavaThread *)ox)->_thread_state == sizeof(int)), "invariant") ; | |
| 2221 int jst = SafeFetch32 ((int *) &((JavaThread *) ox)->_thread_state, -1) ; ; | |
| 2222 // consider also: jst != _thread_in_Java -- but that's overspecific. | |
| 2223 return jst == _thread_blocked || jst == _thread_in_native ; | |
| 2224 } | |
| 2225 | |
| 2226 | |
| 2227 // ----------------------------------------------------------------------------- | |
| 2228 // WaitSet management ... | |
| 2229 | |
| 2230 ObjectWaiter::ObjectWaiter(Thread* thread) { | |
| 2231 _next = NULL; | |
| 2232 _prev = NULL; | |
| 2233 _notified = 0; | |
| 2234 TState = TS_RUN ; | |
| 2235 _thread = thread; | |
| 2236 _event = thread->_ParkEvent ; | |
| 2237 _active = false; | |
| 2238 assert (_event != NULL, "invariant") ; | |
| 2239 } | |
| 2240 | |
| 2241 void ObjectWaiter::wait_reenter_begin(ObjectMonitor *mon) { | |
| 2242 JavaThread *jt = (JavaThread *)this->_thread; | |
| 2243 _active = JavaThreadBlockedOnMonitorEnterState::wait_reenter_begin(jt, mon); | |
| 2244 } | |
| 2245 | |
| 2246 void ObjectWaiter::wait_reenter_end(ObjectMonitor *mon) { | |
| 2247 JavaThread *jt = (JavaThread *)this->_thread; | |
| 2248 JavaThreadBlockedOnMonitorEnterState::wait_reenter_end(jt, _active); | |
| 2249 } | |
| 2250 | |
| 2251 inline void ObjectMonitor::AddWaiter(ObjectWaiter* node) { | |
| 2252 assert(node != NULL, "should not dequeue NULL node"); | |
| 2253 assert(node->_prev == NULL, "node already in list"); | |
| 2254 assert(node->_next == NULL, "node already in list"); | |
| 2255 // put node at end of queue (circular doubly linked list) | |
| 2256 if (_WaitSet == NULL) { | |
| 2257 _WaitSet = node; | |
| 2258 node->_prev = node; | |
| 2259 node->_next = node; | |
| 2260 } else { | |
| 2261 ObjectWaiter* head = _WaitSet ; | |
| 2262 ObjectWaiter* tail = head->_prev; | |
| 2263 assert(tail->_next == head, "invariant check"); | |
| 2264 tail->_next = node; | |
| 2265 head->_prev = node; | |
| 2266 node->_next = head; | |
| 2267 node->_prev = tail; | |
| 2268 } | |
| 2269 } | |
| 2270 | |
| 2271 inline ObjectWaiter* ObjectMonitor::DequeueWaiter() { | |
| 2272 // dequeue the very first waiter | |
| 2273 ObjectWaiter* waiter = _WaitSet; | |
| 2274 if (waiter) { | |
| 2275 DequeueSpecificWaiter(waiter); | |
| 2276 } | |
| 2277 return waiter; | |
| 2278 } | |
| 2279 | |
| 2280 inline void ObjectMonitor::DequeueSpecificWaiter(ObjectWaiter* node) { | |
| 2281 assert(node != NULL, "should not dequeue NULL node"); | |
| 2282 assert(node->_prev != NULL, "node already removed from list"); | |
| 2283 assert(node->_next != NULL, "node already removed from list"); | |
| 2284 // when the waiter has woken up because of interrupt, | |
| 2285 // timeout or other spurious wake-up, dequeue the | |
| 2286 // waiter from waiting list | |
| 2287 ObjectWaiter* next = node->_next; | |
| 2288 if (next == node) { | |
| 2289 assert(node->_prev == node, "invariant check"); | |
| 2290 _WaitSet = NULL; | |
| 2291 } else { | |
| 2292 ObjectWaiter* prev = node->_prev; | |
| 2293 assert(prev->_next == node, "invariant check"); | |
| 2294 assert(next->_prev == node, "invariant check"); | |
| 2295 next->_prev = prev; | |
| 2296 prev->_next = next; | |
| 2297 if (_WaitSet == node) { | |
| 2298 _WaitSet = next; | |
| 2299 } | |
| 2300 } | |
| 2301 node->_next = NULL; | |
| 2302 node->_prev = NULL; | |
| 2303 } | |
| 2304 | |
| 2305 // ----------------------------------------------------------------------------- | |
| 2306 // PerfData support | |
| 2307 PerfCounter * ObjectMonitor::_sync_ContendedLockAttempts = NULL ; | |
| 2308 PerfCounter * ObjectMonitor::_sync_FutileWakeups = NULL ; | |
| 2309 PerfCounter * ObjectMonitor::_sync_Parks = NULL ; | |
| 2310 PerfCounter * ObjectMonitor::_sync_EmptyNotifications = NULL ; | |
| 2311 PerfCounter * ObjectMonitor::_sync_Notifications = NULL ; | |
| 2312 PerfCounter * ObjectMonitor::_sync_PrivateA = NULL ; | |
| 2313 PerfCounter * ObjectMonitor::_sync_PrivateB = NULL ; | |
| 2314 PerfCounter * ObjectMonitor::_sync_SlowExit = NULL ; | |
| 2315 PerfCounter * ObjectMonitor::_sync_SlowEnter = NULL ; | |
| 2316 PerfCounter * ObjectMonitor::_sync_SlowNotify = NULL ; | |
| 2317 PerfCounter * ObjectMonitor::_sync_SlowNotifyAll = NULL ; | |
| 2318 PerfCounter * ObjectMonitor::_sync_FailedSpins = NULL ; | |
| 2319 PerfCounter * ObjectMonitor::_sync_SuccessfulSpins = NULL ; | |
| 2320 PerfCounter * ObjectMonitor::_sync_MonInCirculation = NULL ; | |
| 2321 PerfCounter * ObjectMonitor::_sync_MonScavenged = NULL ; | |
| 2322 PerfCounter * ObjectMonitor::_sync_Inflations = NULL ; | |
| 2323 PerfCounter * ObjectMonitor::_sync_Deflations = NULL ; | |
| 2324 PerfLongVariable * ObjectMonitor::_sync_MonExtant = NULL ; | |
| 2325 | |
| 2326 // One-shot global initialization for the sync subsystem. | |
| 2327 // We could also defer initialization and initialize on-demand | |
| 2328 // the first time we call inflate(). Initialization would | |
| 2329 // be protected - like so many things - by the MonitorCache_lock. | |
| 2330 | |
| 2331 void ObjectMonitor::Initialize () { | |
| 2332 static int InitializationCompleted = 0 ; | |
| 2333 assert (InitializationCompleted == 0, "invariant") ; | |
| 2334 InitializationCompleted = 1 ; | |
| 2335 if (UsePerfData) { | |
| 2336 EXCEPTION_MARK ; | |
| 2337 #define NEWPERFCOUNTER(n) {n = PerfDataManager::create_counter(SUN_RT, #n, PerfData::U_Events,CHECK); } | |
| 2338 #define NEWPERFVARIABLE(n) {n = PerfDataManager::create_variable(SUN_RT, #n, PerfData::U_Events,CHECK); } | |
| 2339 NEWPERFCOUNTER(_sync_Inflations) ; | |
| 2340 NEWPERFCOUNTER(_sync_Deflations) ; | |
| 2341 NEWPERFCOUNTER(_sync_ContendedLockAttempts) ; | |
| 2342 NEWPERFCOUNTER(_sync_FutileWakeups) ; | |
| 2343 NEWPERFCOUNTER(_sync_Parks) ; | |
| 2344 NEWPERFCOUNTER(_sync_EmptyNotifications) ; | |
| 2345 NEWPERFCOUNTER(_sync_Notifications) ; | |
| 2346 NEWPERFCOUNTER(_sync_SlowEnter) ; | |
| 2347 NEWPERFCOUNTER(_sync_SlowExit) ; | |
| 2348 NEWPERFCOUNTER(_sync_SlowNotify) ; | |
| 2349 NEWPERFCOUNTER(_sync_SlowNotifyAll) ; | |
| 2350 NEWPERFCOUNTER(_sync_FailedSpins) ; | |
| 2351 NEWPERFCOUNTER(_sync_SuccessfulSpins) ; | |
| 2352 NEWPERFCOUNTER(_sync_PrivateA) ; | |
| 2353 NEWPERFCOUNTER(_sync_PrivateB) ; | |
| 2354 NEWPERFCOUNTER(_sync_MonInCirculation) ; | |
| 2355 NEWPERFCOUNTER(_sync_MonScavenged) ; | |
| 2356 NEWPERFVARIABLE(_sync_MonExtant) ; | |
| 2357 #undef NEWPERFCOUNTER | |
| 2358 } | |
| 2359 } | |
| 2360 | |
| 2361 | |
| 2362 // Compile-time asserts | |
| 2363 // When possible, it's better to catch errors deterministically at | |
| 2364 // compile-time than at runtime. The down-side to using compile-time | |
| 2365 // asserts is that error message -- often something about negative array | |
| 2366 // indices -- is opaque. | |
| 2367 | |
| 2368 #define CTASSERT(x) { int tag[1-(2*!(x))]; printf ("Tag @" INTPTR_FORMAT "\n", (intptr_t)tag); } | |
| 2369 | |
| 2370 void ObjectMonitor::ctAsserts() { | |
| 2371 CTASSERT(offset_of (ObjectMonitor, _header) == 0); | |
| 2372 } | |
| 2373 | |
| 2374 | |
| 2375 static char * kvGet (char * kvList, const char * Key) { | |
| 2376 if (kvList == NULL) return NULL ; | |
| 2377 size_t n = strlen (Key) ; | |
| 2378 char * Search ; | |
| 2379 for (Search = kvList ; *Search ; Search += strlen(Search) + 1) { | |
| 2380 if (strncmp (Search, Key, n) == 0) { | |
| 2381 if (Search[n] == '=') return Search + n + 1 ; | |
| 2382 if (Search[n] == 0) return (char *) "1" ; | |
| 2383 } | |
| 2384 } | |
| 2385 return NULL ; | |
| 2386 } | |
| 2387 | |
| 2388 static int kvGetInt (char * kvList, const char * Key, int Default) { | |
| 2389 char * v = kvGet (kvList, Key) ; | |
| 2390 int rslt = v ? ::strtol (v, NULL, 0) : Default ; | |
| 2391 if (Knob_ReportSettings && v != NULL) { | |
| 2392 ::printf (" SyncKnob: %s %d(%d)\n", Key, rslt, Default) ; | |
| 2393 ::fflush (stdout) ; | |
| 2394 } | |
| 2395 return rslt ; | |
| 2396 } | |
| 2397 | |
| 2398 void ObjectMonitor::DeferredInitialize () { | |
| 2399 if (InitDone > 0) return ; | |
| 2400 if (Atomic::cmpxchg (-1, &InitDone, 0) != 0) { | |
| 2401 while (InitDone != 1) ; | |
| 2402 return ; | |
| 2403 } | |
| 2404 | |
| 2405 // One-shot global initialization ... | |
| 2406 // The initialization is idempotent, so we don't need locks. | |
| 2407 // In the future consider doing this via os::init_2(). | |
| 2408 // SyncKnobs consist of <Key>=<Value> pairs in the style | |
| 2409 // of environment variables. Start by converting ':' to NUL. | |
| 2410 | |
| 2411 if (SyncKnobs == NULL) SyncKnobs = "" ; | |
| 2412 | |
| 2413 size_t sz = strlen (SyncKnobs) ; | |
| 2414 char * knobs = (char *) malloc (sz + 2) ; | |
| 2415 if (knobs == NULL) { | |
| 2416 vm_exit_out_of_memory (sz + 2, "Parse SyncKnobs") ; | |
| 2417 guarantee (0, "invariant") ; | |
| 2418 } | |
| 2419 strcpy (knobs, SyncKnobs) ; | |
| 2420 knobs[sz+1] = 0 ; | |
| 2421 for (char * p = knobs ; *p ; p++) { | |
| 2422 if (*p == ':') *p = 0 ; | |
| 2423 } | |
| 2424 | |
| 2425 #define SETKNOB(x) { Knob_##x = kvGetInt (knobs, #x, Knob_##x); } | |
| 2426 SETKNOB(ReportSettings) ; | |
| 2427 SETKNOB(Verbose) ; | |
| 2428 SETKNOB(FixedSpin) ; | |
| 2429 SETKNOB(SpinLimit) ; | |
| 2430 SETKNOB(SpinBase) ; | |
| 2431 SETKNOB(SpinBackOff); | |
| 2432 SETKNOB(CASPenalty) ; | |
| 2433 SETKNOB(OXPenalty) ; | |
| 2434 SETKNOB(LogSpins) ; | |
| 2435 SETKNOB(SpinSetSucc) ; | |
| 2436 SETKNOB(SuccEnabled) ; | |
| 2437 SETKNOB(SuccRestrict) ; | |
| 2438 SETKNOB(Penalty) ; | |
| 2439 SETKNOB(Bonus) ; | |
| 2440 SETKNOB(BonusB) ; | |
| 2441 SETKNOB(Poverty) ; | |
| 2442 SETKNOB(SpinAfterFutile) ; | |
| 2443 SETKNOB(UsePause) ; | |
| 2444 SETKNOB(SpinEarly) ; | |
| 2445 SETKNOB(OState) ; | |
| 2446 SETKNOB(MaxSpinners) ; | |
| 2447 SETKNOB(PreSpin) ; | |
| 2448 SETKNOB(ExitPolicy) ; | |
| 2449 SETKNOB(QMode); | |
| 2450 SETKNOB(ResetEvent) ; | |
| 2451 SETKNOB(MoveNotifyee) ; | |
| 2452 SETKNOB(FastHSSEC) ; | |
| 2453 #undef SETKNOB | |
| 2454 | |
| 2455 if (os::is_MP()) { | |
| 2456 BackOffMask = (1 << Knob_SpinBackOff) - 1 ; | |
| 2457 if (Knob_ReportSettings) ::printf ("BackOffMask=%X\n", BackOffMask) ; | |
| 2458 // CONSIDER: BackOffMask = ROUNDUP_NEXT_POWER2 (ncpus-1) | |
| 2459 } else { | |
| 2460 Knob_SpinLimit = 0 ; | |
| 2461 Knob_SpinBase = 0 ; | |
| 2462 Knob_PreSpin = 0 ; | |
| 2463 Knob_FixedSpin = -1 ; | |
| 2464 } | |
| 2465 | |
| 2466 if (Knob_LogSpins == 0) { | |
| 2467 ObjectMonitor::_sync_FailedSpins = NULL ; | |
| 2468 } | |
| 2469 | |
| 2470 free (knobs) ; | |
| 2471 OrderAccess::fence() ; | |
| 2472 InitDone = 1 ; | |
| 2473 } | |
| 2474 | |
| 2475 #ifndef PRODUCT | |
| 2476 void ObjectMonitor::verify() { | |
| 2477 } | |
| 2478 | |
| 2479 void ObjectMonitor::print() { | |
| 2480 } | |
| 2481 #endif |