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