Mercurial > hg > truffle
annotate src/share/vm/runtime/synchronizer.cpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | da91efe96a93 |
| children | e522a00b91aa 070d523b96a7 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
702
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
702
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
702
diff
changeset
|
21 * questions. |
| 0 | 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/biasedLocking.hpp" | |
| 31 #include "runtime/handles.inline.hpp" | |
| 32 #include "runtime/interfaceSupport.hpp" | |
| 33 #include "runtime/mutexLocker.hpp" | |
| 34 #include "runtime/objectMonitor.hpp" | |
| 35 #include "runtime/objectMonitor.inline.hpp" | |
| 36 #include "runtime/osThread.hpp" | |
| 37 #include "runtime/stubRoutines.hpp" | |
| 38 #include "runtime/synchronizer.hpp" | |
| 39 #include "utilities/dtrace.hpp" | |
| 40 #include "utilities/events.hpp" | |
| 41 #include "utilities/preserveException.hpp" | |
| 42 #ifdef TARGET_OS_FAMILY_linux | |
| 43 # include "os_linux.inline.hpp" | |
| 44 # include "thread_linux.inline.hpp" | |
| 45 #endif | |
| 46 #ifdef TARGET_OS_FAMILY_solaris | |
| 47 # include "os_solaris.inline.hpp" | |
| 48 # include "thread_solaris.inline.hpp" | |
| 49 #endif | |
| 50 #ifdef TARGET_OS_FAMILY_windows | |
| 51 # include "os_windows.inline.hpp" | |
| 52 # include "thread_windows.inline.hpp" | |
| 53 #endif | |
| 3960 | 54 #ifdef TARGET_OS_FAMILY_bsd |
| 55 # include "os_bsd.inline.hpp" | |
| 56 # include "thread_bsd.inline.hpp" | |
| 57 #endif | |
| 0 | 58 |
| 59 #if defined(__GNUC__) && !defined(IA64) | |
| 60 // Need to inhibit inlining for older versions of GCC to avoid build-time failures | |
| 61 #define ATTR __attribute__((noinline)) | |
| 62 #else | |
| 63 #define ATTR | |
| 64 #endif | |
| 65 | |
| 66 // The "core" versions of monitor enter and exit reside in this file. | |
| 67 // The interpreter and compilers contain specialized transliterated | |
| 68 // variants of the enter-exit fast-path operations. See i486.ad fast_lock(), | |
| 69 // for instance. If you make changes here, make sure to modify the | |
| 70 // interpreter, and both C1 and C2 fast-path inline locking code emission. | |
| 71 // | |
| 72 // | |
| 73 // ----------------------------------------------------------------------------- | |
| 74 | |
| 75 #ifdef DTRACE_ENABLED | |
| 76 | |
| 77 // Only bother with this argument setup if dtrace is available | |
| 78 // TODO-FIXME: probes should not fire when caller is _blocked. assert() accordingly. | |
| 79 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
80 #define DTRACE_MONITOR_PROBE_COMMON(obj, thread) \ |
| 0 | 81 char* bytes = NULL; \ |
| 82 int len = 0; \ | |
| 83 jlong jtid = SharedRuntime::get_java_tid(thread); \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
84 Symbol* klassname = ((oop)(obj))->klass()->name(); \ |
| 0 | 85 if (klassname != NULL) { \ |
| 86 bytes = (char*)klassname->bytes(); \ | |
| 87 len = klassname->utf8_length(); \ | |
| 88 } | |
| 89 | |
| 4006 | 90 #ifndef USDT2 |
| 91 HS_DTRACE_PROBE_DECL5(hotspot, monitor__wait, | |
| 92 jlong, uintptr_t, char*, int, long); | |
| 93 HS_DTRACE_PROBE_DECL4(hotspot, monitor__waited, | |
| 94 jlong, uintptr_t, char*, int); | |
| 95 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
96 #define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ |
| 0 | 97 { \ |
| 98 if (DTraceMonitorProbes) { \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
99 DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ |
| 0 | 100 HS_DTRACE_PROBE5(hotspot, monitor__wait, jtid, \ |
| 101 (monitor), bytes, len, (millis)); \ | |
| 102 } \ | |
| 103 } | |
| 104 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
105 #define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \ |
| 0 | 106 { \ |
| 107 if (DTraceMonitorProbes) { \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
108 DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ |
| 0 | 109 HS_DTRACE_PROBE4(hotspot, monitor__##probe, jtid, \ |
| 110 (uintptr_t)(monitor), bytes, len); \ | |
| 111 } \ | |
| 112 } | |
| 113 | |
| 4006 | 114 #else /* USDT2 */ |
| 115 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
116 #define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ |
| 4006 | 117 { \ |
| 118 if (DTraceMonitorProbes) { \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
119 DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ |
| 4006 | 120 HOTSPOT_MONITOR_WAIT(jtid, \ |
| 121 (uintptr_t)(monitor), bytes, len, (millis)); \ | |
| 122 } \ | |
| 123 } | |
| 124 | |
| 125 #define HOTSPOT_MONITOR_PROBE_waited HOTSPOT_MONITOR_PROBE_WAITED | |
| 126 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
127 #define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \ |
| 4006 | 128 { \ |
| 129 if (DTraceMonitorProbes) { \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
130 DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ |
| 4006 | 131 HOTSPOT_MONITOR_PROBE_##probe(jtid, /* probe = waited */ \ |
| 132 (uintptr_t)(monitor), bytes, len); \ | |
| 133 } \ | |
| 134 } | |
| 135 | |
| 136 #endif /* USDT2 */ | |
| 0 | 137 #else // ndef DTRACE_ENABLED |
| 138 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4006
diff
changeset
|
139 #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
|
140 #define DTRACE_MONITOR_PROBE(probe, obj, thread, mon) {;} |
| 0 | 141 |
| 142 #endif // ndef DTRACE_ENABLED | |
| 143 | |
| 1878 | 144 // This exists only as a workaround of dtrace bug 6254741 |
| 145 int dtrace_waited_probe(ObjectMonitor* monitor, Handle obj, Thread* thr) { | |
| 146 DTRACE_MONITOR_PROBE(waited, monitor, obj(), thr); | |
| 147 return 0; | |
| 148 } | |
| 149 | |
| 150 #define NINFLATIONLOCKS 256 | |
| 151 static volatile intptr_t InflationLocks [NINFLATIONLOCKS] ; | |
| 152 | |
| 153 ObjectMonitor * ObjectSynchronizer::gBlockList = NULL ; | |
| 154 ObjectMonitor * volatile ObjectSynchronizer::gFreeList = NULL ; | |
| 155 ObjectMonitor * volatile ObjectSynchronizer::gOmInUseList = NULL ; | |
| 156 int ObjectSynchronizer::gOmInUseCount = 0; | |
| 157 static volatile intptr_t ListLock = 0 ; // protects global monitor free-list cache | |
| 158 static volatile int MonitorFreeCount = 0 ; // # on gFreeList | |
| 159 static volatile int MonitorPopulation = 0 ; // # Extant -- in circulation | |
| 160 #define CHAINMARKER ((oop)-1) | |
| 161 | |
| 162 // ----------------------------------------------------------------------------- | |
| 163 // Fast Monitor Enter/Exit | |
| 164 // This the fast monitor enter. The interpreter and compiler use | |
| 165 // some assembly copies of this code. Make sure update those code | |
| 166 // if the following function is changed. The implementation is | |
| 167 // extremely sensitive to race condition. Be careful. | |
| 168 | |
| 169 void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS) { | |
| 170 if (UseBiasedLocking) { | |
| 171 if (!SafepointSynchronize::is_at_safepoint()) { | |
| 172 BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD); | |
| 173 if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) { | |
| 174 return; | |
| 175 } | |
| 176 } else { | |
| 177 assert(!attempt_rebias, "can not rebias toward VM thread"); | |
| 178 BiasedLocking::revoke_at_safepoint(obj); | |
| 179 } | |
| 180 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 181 } | |
| 182 | |
| 183 slow_enter (obj, lock, THREAD) ; | |
| 184 } | |
| 185 | |
| 186 void ObjectSynchronizer::fast_exit(oop object, BasicLock* lock, TRAPS) { | |
| 187 assert(!object->mark()->has_bias_pattern(), "should not see bias pattern here"); | |
| 188 // if displaced header is null, the previous enter is recursive enter, no-op | |
| 189 markOop dhw = lock->displaced_header(); | |
| 190 markOop mark ; | |
| 191 if (dhw == NULL) { | |
| 192 // Recursive stack-lock. | |
| 193 // Diagnostics -- Could be: stack-locked, inflating, inflated. | |
| 194 mark = object->mark() ; | |
| 195 assert (!mark->is_neutral(), "invariant") ; | |
| 196 if (mark->has_locker() && mark != markOopDesc::INFLATING()) { | |
| 197 assert(THREAD->is_lock_owned((address)mark->locker()), "invariant") ; | |
| 198 } | |
| 199 if (mark->has_monitor()) { | |
| 200 ObjectMonitor * m = mark->monitor() ; | |
| 201 assert(((oop)(m->object()))->mark() == mark, "invariant") ; | |
| 202 assert(m->is_entered(THREAD), "invariant") ; | |
| 203 } | |
| 204 return ; | |
| 205 } | |
| 206 | |
| 207 mark = object->mark() ; | |
| 0 | 208 |
| 1878 | 209 // If the object is stack-locked by the current thread, try to |
| 210 // swing the displaced header from the box back to the mark. | |
| 211 if (mark == (markOop) lock) { | |
| 212 assert (dhw->is_neutral(), "invariant") ; | |
| 213 if ((markOop) Atomic::cmpxchg_ptr (dhw, object->mark_addr(), mark) == mark) { | |
| 214 TEVENT (fast_exit: release stacklock) ; | |
| 215 return; | |
| 216 } | |
| 217 } | |
| 218 | |
| 219 ObjectSynchronizer::inflate(THREAD, object)->exit (THREAD) ; | |
| 220 } | |
| 221 | |
| 222 // ----------------------------------------------------------------------------- | |
| 223 // Interpreter/Compiler Slow Case | |
| 224 // This routine is used to handle interpreter/compiler slow case | |
| 225 // We don't need to use fast path here, because it must have been | |
| 226 // failed in the interpreter/compiler code. | |
| 227 void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) { | |
| 228 markOop mark = obj->mark(); | |
| 229 assert(!mark->has_bias_pattern(), "should not see bias pattern here"); | |
| 230 | |
| 231 if (mark->is_neutral()) { | |
| 232 // Anticipate successful CAS -- the ST of the displaced mark must | |
| 233 // be visible <= the ST performed by the CAS. | |
| 234 lock->set_displaced_header(mark); | |
| 235 if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) { | |
| 236 TEVENT (slow_enter: release stacklock) ; | |
| 237 return ; | |
| 238 } | |
| 239 // Fall through to inflate() ... | |
| 240 } else | |
| 241 if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) { | |
| 242 assert(lock != mark->locker(), "must not re-lock the same lock"); | |
| 243 assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock"); | |
| 244 lock->set_displaced_header(NULL); | |
| 245 return; | |
| 246 } | |
| 247 | |
| 248 #if 0 | |
| 249 // The following optimization isn't particularly useful. | |
| 250 if (mark->has_monitor() && mark->monitor()->is_entered(THREAD)) { | |
| 251 lock->set_displaced_header (NULL) ; | |
| 252 return ; | |
| 253 } | |
| 254 #endif | |
| 255 | |
| 256 // The object header will never be displaced to this lock, | |
| 257 // so it does not matter what the value is, except that it | |
| 258 // must be non-zero to avoid looking like a re-entrant lock, | |
| 259 // and must not look locked either. | |
| 260 lock->set_displaced_header(markOopDesc::unused_mark()); | |
| 261 ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD); | |
| 262 } | |
| 263 | |
| 264 // This routine is used to handle interpreter/compiler slow case | |
| 265 // We don't need to use fast path here, because it must have | |
| 266 // failed in the interpreter/compiler code. Simply use the heavy | |
| 267 // weight monitor should be ok, unless someone find otherwise. | |
| 268 void ObjectSynchronizer::slow_exit(oop object, BasicLock* lock, TRAPS) { | |
| 269 fast_exit (object, lock, THREAD) ; | |
| 270 } | |
| 271 | |
| 272 // ----------------------------------------------------------------------------- | |
| 273 // Class Loader support to workaround deadlocks on the class loader lock objects | |
| 274 // Also used by GC | |
| 275 // complete_exit()/reenter() are used to wait on a nested lock | |
| 276 // i.e. to give up an outer lock completely and then re-enter | |
| 277 // Used when holding nested locks - lock acquisition order: lock1 then lock2 | |
| 278 // 1) complete_exit lock1 - saving recursion count | |
| 279 // 2) wait on lock2 | |
| 280 // 3) when notified on lock2, unlock lock2 | |
| 281 // 4) reenter lock1 with original recursion count | |
| 282 // 5) lock lock2 | |
| 283 // NOTE: must use heavy weight monitor to handle complete_exit/reenter() | |
| 284 intptr_t ObjectSynchronizer::complete_exit(Handle obj, TRAPS) { | |
| 285 TEVENT (complete_exit) ; | |
| 286 if (UseBiasedLocking) { | |
| 287 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 288 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 0 | 289 } |
| 290 | |
| 1878 | 291 ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj()); |
| 292 | |
| 293 return monitor->complete_exit(THREAD); | |
| 294 } | |
| 295 | |
| 296 // NOTE: must use heavy weight monitor to handle complete_exit/reenter() | |
| 297 void ObjectSynchronizer::reenter(Handle obj, intptr_t recursion, TRAPS) { | |
| 298 TEVENT (reenter) ; | |
| 299 if (UseBiasedLocking) { | |
| 300 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 301 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 302 } | |
| 303 | |
| 304 ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj()); | |
| 305 | |
| 306 monitor->reenter(recursion, THREAD); | |
| 307 } | |
| 308 // ----------------------------------------------------------------------------- | |
| 309 // JNI locks on java objects | |
| 310 // NOTE: must use heavy weight monitor to handle jni monitor enter | |
| 311 void ObjectSynchronizer::jni_enter(Handle obj, TRAPS) { // possible entry from jni enter | |
| 312 // the current locking is from JNI instead of Java code | |
| 313 TEVENT (jni_enter) ; | |
| 314 if (UseBiasedLocking) { | |
| 315 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 316 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 317 } | |
| 318 THREAD->set_current_pending_monitor_is_from_java(false); | |
| 319 ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD); | |
| 320 THREAD->set_current_pending_monitor_is_from_java(true); | |
| 321 } | |
| 322 | |
| 323 // NOTE: must use heavy weight monitor to handle jni monitor enter | |
| 324 bool ObjectSynchronizer::jni_try_enter(Handle obj, Thread* THREAD) { | |
| 325 if (UseBiasedLocking) { | |
| 326 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 327 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 0 | 328 } |
| 329 | |
| 1878 | 330 ObjectMonitor* monitor = ObjectSynchronizer::inflate_helper(obj()); |
| 331 return monitor->try_enter(THREAD); | |
| 332 } | |
| 333 | |
| 334 | |
| 335 // NOTE: must use heavy weight monitor to handle jni monitor exit | |
| 336 void ObjectSynchronizer::jni_exit(oop obj, Thread* THREAD) { | |
| 337 TEVENT (jni_exit) ; | |
| 338 if (UseBiasedLocking) { | |
| 339 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 340 } | |
| 341 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 342 | |
| 343 ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj); | |
| 344 // If this thread has locked the object, exit the monitor. Note: can't use | |
| 345 // monitor->check(CHECK); must exit even if an exception is pending. | |
| 346 if (monitor->check(THREAD)) { | |
| 347 monitor->exit(THREAD); | |
| 0 | 348 } |
| 1878 | 349 } |
| 350 | |
| 351 // ----------------------------------------------------------------------------- | |
| 352 // Internal VM locks on java objects | |
| 353 // standard constructor, allows locking failures | |
| 354 ObjectLocker::ObjectLocker(Handle obj, Thread* thread, bool doLock) { | |
| 355 _dolock = doLock; | |
| 356 _thread = thread; | |
| 357 debug_only(if (StrictSafepointChecks) _thread->check_for_valid_safepoint_state(false);) | |
| 358 _obj = obj; | |
| 0 | 359 |
| 1878 | 360 if (_dolock) { |
| 361 TEVENT (ObjectLocker) ; | |
| 362 | |
| 363 ObjectSynchronizer::fast_enter(_obj, &_lock, false, _thread); | |
| 364 } | |
| 365 } | |
| 366 | |
| 367 ObjectLocker::~ObjectLocker() { | |
| 368 if (_dolock) { | |
| 369 ObjectSynchronizer::fast_exit(_obj(), &_lock, _thread); | |
| 370 } | |
| 371 } | |
| 0 | 372 |
| 373 | |
| 1878 | 374 // ----------------------------------------------------------------------------- |
| 375 // Wait/Notify/NotifyAll | |
| 376 // NOTE: must use heavy weight monitor to handle wait() | |
| 377 void ObjectSynchronizer::wait(Handle obj, jlong millis, TRAPS) { | |
| 378 if (UseBiasedLocking) { | |
| 379 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 380 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 381 } | |
| 382 if (millis < 0) { | |
| 383 TEVENT (wait - throw IAX) ; | |
| 384 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative"); | |
| 385 } | |
| 386 ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj()); | |
| 387 DTRACE_MONITOR_WAIT_PROBE(monitor, obj(), THREAD, millis); | |
| 388 monitor->wait(millis, true, THREAD); | |
| 389 | |
| 390 /* This dummy call is in place to get around dtrace bug 6254741. Once | |
| 391 that's fixed we can uncomment the following line and remove the call */ | |
| 392 // DTRACE_MONITOR_PROBE(waited, monitor, obj(), THREAD); | |
| 393 dtrace_waited_probe(monitor, obj, THREAD); | |
| 394 } | |
| 0 | 395 |
| 1878 | 396 void ObjectSynchronizer::waitUninterruptibly (Handle obj, jlong millis, TRAPS) { |
| 397 if (UseBiasedLocking) { | |
| 398 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 399 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 400 } | |
| 401 if (millis < 0) { | |
| 402 TEVENT (wait - throw IAX) ; | |
| 403 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative"); | |
| 404 } | |
| 405 ObjectSynchronizer::inflate(THREAD, obj()) -> wait(millis, false, THREAD) ; | |
| 406 } | |
| 407 | |
| 408 void ObjectSynchronizer::notify(Handle obj, TRAPS) { | |
| 409 if (UseBiasedLocking) { | |
| 410 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 411 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 412 } | |
| 0 | 413 |
| 1878 | 414 markOop mark = obj->mark(); |
| 415 if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) { | |
| 416 return; | |
| 417 } | |
| 418 ObjectSynchronizer::inflate(THREAD, obj())->notify(THREAD); | |
| 419 } | |
| 0 | 420 |
| 1878 | 421 // NOTE: see comment of notify() |
| 422 void ObjectSynchronizer::notifyall(Handle obj, TRAPS) { | |
| 423 if (UseBiasedLocking) { | |
| 424 BiasedLocking::revoke_and_rebias(obj, false, THREAD); | |
| 425 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 426 } | |
| 427 | |
| 428 markOop mark = obj->mark(); | |
| 429 if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) { | |
| 430 return; | |
| 431 } | |
| 432 ObjectSynchronizer::inflate(THREAD, obj())->notifyAll(THREAD); | |
| 433 } | |
| 434 | |
| 435 // ----------------------------------------------------------------------------- | |
| 436 // Hash Code handling | |
| 437 // | |
| 0 | 438 // Performance concern: |
| 439 // OrderAccess::storestore() calls release() which STs 0 into the global volatile | |
| 440 // OrderAccess::Dummy variable. This store is unnecessary for correctness. | |
| 441 // Many threads STing into a common location causes considerable cache migration | |
| 442 // or "sloshing" on large SMP system. As such, I avoid using OrderAccess::storestore() | |
| 443 // until it's repaired. In some cases OrderAccess::fence() -- which incurs local | |
| 444 // latency on the executing processor -- is a better choice as it scales on SMP | |
| 445 // systems. See http://blogs.sun.com/dave/entry/biased_locking_in_hotspot for a | |
| 446 // discussion of coherency costs. Note that all our current reference platforms | |
| 447 // provide strong ST-ST order, so the issue is moot on IA32, x64, and SPARC. | |
| 448 // | |
| 449 // As a general policy we use "volatile" to control compiler-based reordering | |
| 450 // and explicit fences (barriers) to control for architectural reordering performed | |
| 451 // by the CPU(s) or platform. | |
| 452 | |
| 453 static int MBFence (int x) { OrderAccess::fence(); return x; } | |
| 454 | |
| 455 struct SharedGlobals { | |
| 456 // These are highly shared mostly-read variables. | |
| 457 // To avoid false-sharing they need to be the sole occupants of a $ line. | |
| 458 double padPrefix [8]; | |
| 459 volatile int stwRandom ; | |
| 460 volatile int stwCycle ; | |
| 461 | |
| 462 // Hot RW variables -- Sequester to avoid false-sharing | |
| 463 double padSuffix [16]; | |
| 464 volatile int hcSequence ; | |
| 465 double padFinal [8] ; | |
| 466 } ; | |
| 467 | |
| 468 static SharedGlobals GVars ; | |
| 1587 | 469 static int MonitorScavengeThreshold = 1000000 ; |
| 470 static volatile int ForceMonitorScavenge = 0 ; // Scavenge required and pending | |
| 0 | 471 |
| 1878 | 472 static markOop ReadStableMark (oop obj) { |
| 473 markOop mark = obj->mark() ; | |
| 474 if (!mark->is_being_inflated()) { | |
| 475 return mark ; // normal fast-path return | |
| 476 } | |
| 0 | 477 |
| 1878 | 478 int its = 0 ; |
| 479 for (;;) { | |
| 480 markOop mark = obj->mark() ; | |
| 481 if (!mark->is_being_inflated()) { | |
| 482 return mark ; // normal fast-path return | |
| 483 } | |
| 484 | |
| 485 // The object is being inflated by some other thread. | |
| 486 // The caller of ReadStableMark() must wait for inflation to complete. | |
| 487 // Avoid live-lock | |
| 488 // TODO: consider calling SafepointSynchronize::do_call_back() while | |
| 489 // spinning to see if there's a safepoint pending. If so, immediately | |
| 490 // yielding or blocking would be appropriate. Avoid spinning while | |
| 491 // there is a safepoint pending. | |
| 492 // TODO: add inflation contention performance counters. | |
| 493 // TODO: restrict the aggregate number of spinners. | |
| 0 | 494 |
| 1878 | 495 ++its ; |
| 496 if (its > 10000 || !os::is_MP()) { | |
| 497 if (its & 1) { | |
| 498 os::NakedYield() ; | |
| 499 TEVENT (Inflate: INFLATING - yield) ; | |
| 500 } else { | |
| 501 // Note that the following code attenuates the livelock problem but is not | |
| 502 // a complete remedy. A more complete solution would require that the inflating | |
| 503 // thread hold the associated inflation lock. The following code simply restricts | |
| 504 // the number of spinners to at most one. We'll have N-2 threads blocked | |
| 505 // on the inflationlock, 1 thread holding the inflation lock and using | |
| 506 // a yield/park strategy, and 1 thread in the midst of inflation. | |
| 507 // A more refined approach would be to change the encoding of INFLATING | |
| 508 // to allow encapsulation of a native thread pointer. Threads waiting for | |
| 509 // inflation to complete would use CAS to push themselves onto a singly linked | |
| 510 // list rooted at the markword. Once enqueued, they'd loop, checking a per-thread flag | |
| 511 // and calling park(). When inflation was complete the thread that accomplished inflation | |
| 512 // would detach the list and set the markword to inflated with a single CAS and | |
| 513 // then for each thread on the list, set the flag and unpark() the thread. | |
| 514 // This is conceptually similar to muxAcquire-muxRelease, except that muxRelease | |
| 515 // wakes at most one thread whereas we need to wake the entire list. | |
| 516 int ix = (intptr_t(obj) >> 5) & (NINFLATIONLOCKS-1) ; | |
| 517 int YieldThenBlock = 0 ; | |
| 518 assert (ix >= 0 && ix < NINFLATIONLOCKS, "invariant") ; | |
| 519 assert ((NINFLATIONLOCKS & (NINFLATIONLOCKS-1)) == 0, "invariant") ; | |
| 520 Thread::muxAcquire (InflationLocks + ix, "InflationLock") ; | |
| 521 while (obj->mark() == markOopDesc::INFLATING()) { | |
| 522 // Beware: NakedYield() is advisory and has almost no effect on some platforms | |
| 523 // so we periodically call Self->_ParkEvent->park(1). | |
| 524 // We use a mixed spin/yield/block mechanism. | |
| 525 if ((YieldThenBlock++) >= 16) { | |
| 526 Thread::current()->_ParkEvent->park(1) ; | |
| 527 } else { | |
| 528 os::NakedYield() ; | |
| 529 } | |
| 530 } | |
| 531 Thread::muxRelease (InflationLocks + ix ) ; | |
| 532 TEVENT (Inflate: INFLATING - yield/park) ; | |
| 533 } | |
| 534 } else { | |
| 535 SpinPause() ; // SMP-polite spinning | |
| 536 } | |
| 537 } | |
| 538 } | |
| 0 | 539 |
| 540 // hashCode() generation : | |
| 541 // | |
| 542 // Possibilities: | |
| 543 // * MD5Digest of {obj,stwRandom} | |
| 544 // * CRC32 of {obj,stwRandom} or any linear-feedback shift register function. | |
| 545 // * A DES- or AES-style SBox[] mechanism | |
| 546 // * One of the Phi-based schemes, such as: | |
| 547 // 2654435761 = 2^32 * Phi (golden ratio) | |
| 548 // HashCodeValue = ((uintptr_t(obj) >> 3) * 2654435761) ^ GVars.stwRandom ; | |
| 549 // * A variation of Marsaglia's shift-xor RNG scheme. | |
| 550 // * (obj ^ stwRandom) is appealing, but can result | |
| 551 // in undesirable regularity in the hashCode values of adjacent objects | |
| 552 // (objects allocated back-to-back, in particular). This could potentially | |
| 553 // result in hashtable collisions and reduced hashtable efficiency. | |
| 554 // There are simple ways to "diffuse" the middle address bits over the | |
| 555 // generated hashCode values: | |
| 556 // | |
| 557 | |
| 558 static inline intptr_t get_next_hash(Thread * Self, oop obj) { | |
| 559 intptr_t value = 0 ; | |
| 560 if (hashCode == 0) { | |
| 561 // This form uses an unguarded global Park-Miller RNG, | |
| 562 // so it's possible for two threads to race and generate the same RNG. | |
| 563 // On MP system we'll have lots of RW access to a global, so the | |
| 564 // mechanism induces lots of coherency traffic. | |
| 565 value = os::random() ; | |
| 566 } else | |
| 567 if (hashCode == 1) { | |
| 568 // This variation has the property of being stable (idempotent) | |
| 569 // between STW operations. This can be useful in some of the 1-0 | |
| 570 // synchronization schemes. | |
| 571 intptr_t addrBits = intptr_t(obj) >> 3 ; | |
| 572 value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ; | |
| 573 } else | |
| 574 if (hashCode == 2) { | |
| 575 value = 1 ; // for sensitivity testing | |
| 576 } else | |
| 577 if (hashCode == 3) { | |
| 578 value = ++GVars.hcSequence ; | |
| 579 } else | |
| 580 if (hashCode == 4) { | |
| 581 value = intptr_t(obj) ; | |
| 582 } else { | |
| 583 // Marsaglia's xor-shift scheme with thread-specific state | |
| 584 // This is probably the best overall implementation -- we'll | |
| 585 // likely make this the default in future releases. | |
| 586 unsigned t = Self->_hashStateX ; | |
| 587 t ^= (t << 11) ; | |
| 588 Self->_hashStateX = Self->_hashStateY ; | |
| 589 Self->_hashStateY = Self->_hashStateZ ; | |
| 590 Self->_hashStateZ = Self->_hashStateW ; | |
| 591 unsigned v = Self->_hashStateW ; | |
| 592 v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ; | |
| 593 Self->_hashStateW = v ; | |
| 594 value = v ; | |
| 595 } | |
| 596 | |
| 597 value &= markOopDesc::hash_mask; | |
| 598 if (value == 0) value = 0xBAD ; | |
| 599 assert (value != markOopDesc::no_hash, "invariant") ; | |
| 600 TEVENT (hashCode: GENERATE) ; | |
| 601 return value; | |
| 602 } | |
| 1878 | 603 // |
| 604 intptr_t ObjectSynchronizer::FastHashCode (Thread * Self, oop obj) { | |
| 605 if (UseBiasedLocking) { | |
| 606 // NOTE: many places throughout the JVM do not expect a safepoint | |
| 607 // to be taken here, in particular most operations on perm gen | |
| 608 // objects. However, we only ever bias Java instances and all of | |
| 609 // the call sites of identity_hash that might revoke biases have | |
| 610 // been checked to make sure they can handle a safepoint. The | |
| 611 // added check of the bias pattern is to avoid useless calls to | |
| 612 // thread-local storage. | |
| 613 if (obj->mark()->has_bias_pattern()) { | |
| 614 // Box and unbox the raw reference just in case we cause a STW safepoint. | |
| 615 Handle hobj (Self, obj) ; | |
| 616 // Relaxing assertion for bug 6320749. | |
| 617 assert (Universe::verify_in_progress() || | |
| 618 !SafepointSynchronize::is_at_safepoint(), | |
| 619 "biases should not be seen by VM thread here"); | |
| 620 BiasedLocking::revoke_and_rebias(hobj, false, JavaThread::current()); | |
| 621 obj = hobj() ; | |
| 622 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 623 } | |
| 624 } | |
| 0 | 625 |
| 1878 | 626 // hashCode() is a heap mutator ... |
| 627 // Relaxing assertion for bug 6320749. | |
| 628 assert (Universe::verify_in_progress() || | |
| 629 !SafepointSynchronize::is_at_safepoint(), "invariant") ; | |
| 630 assert (Universe::verify_in_progress() || | |
| 631 Self->is_Java_thread() , "invariant") ; | |
| 632 assert (Universe::verify_in_progress() || | |
| 633 ((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant") ; | |
| 634 | |
| 635 ObjectMonitor* monitor = NULL; | |
| 636 markOop temp, test; | |
| 637 intptr_t hash; | |
| 638 markOop mark = ReadStableMark (obj); | |
| 639 | |
| 640 // object should remain ineligible for biased locking | |
| 641 assert (!mark->has_bias_pattern(), "invariant") ; | |
| 642 | |
| 643 if (mark->is_neutral()) { | |
| 644 hash = mark->hash(); // this is a normal header | |
| 645 if (hash) { // if it has hash, just return it | |
| 646 return hash; | |
| 647 } | |
| 648 hash = get_next_hash(Self, obj); // allocate a new hash code | |
| 649 temp = mark->copy_set_hash(hash); // merge the hash code into header | |
| 650 // use (machine word version) atomic operation to install the hash | |
| 651 test = (markOop) Atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark); | |
| 652 if (test == mark) { | |
| 653 return hash; | |
| 654 } | |
| 655 // If atomic operation failed, we must inflate the header | |
| 656 // into heavy weight monitor. We could add more code here | |
| 657 // for fast path, but it does not worth the complexity. | |
| 658 } else if (mark->has_monitor()) { | |
| 659 monitor = mark->monitor(); | |
| 660 temp = monitor->header(); | |
| 661 assert (temp->is_neutral(), "invariant") ; | |
| 662 hash = temp->hash(); | |
| 663 if (hash) { | |
| 664 return hash; | |
| 665 } | |
| 666 // Skip to the following code to reduce code size | |
| 667 } else if (Self->is_lock_owned((address)mark->locker())) { | |
| 668 temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned | |
| 669 assert (temp->is_neutral(), "invariant") ; | |
| 670 hash = temp->hash(); // by current thread, check if the displaced | |
| 671 if (hash) { // header contains hash code | |
| 672 return hash; | |
| 673 } | |
| 674 // WARNING: | |
| 675 // The displaced header is strictly immutable. | |
| 676 // It can NOT be changed in ANY cases. So we have | |
| 677 // to inflate the header into heavyweight monitor | |
| 678 // even the current thread owns the lock. The reason | |
| 679 // is the BasicLock (stack slot) will be asynchronously | |
| 680 // read by other threads during the inflate() function. | |
| 681 // Any change to stack may not propagate to other threads | |
| 682 // correctly. | |
| 683 } | |
| 684 | |
| 685 // Inflate the monitor to set hash code | |
| 686 monitor = ObjectSynchronizer::inflate(Self, obj); | |
| 687 // Load displaced header and check it has hash code | |
| 688 mark = monitor->header(); | |
| 689 assert (mark->is_neutral(), "invariant") ; | |
| 690 hash = mark->hash(); | |
| 691 if (hash == 0) { | |
| 692 hash = get_next_hash(Self, obj); | |
| 693 temp = mark->copy_set_hash(hash); // merge hash code into header | |
| 694 assert (temp->is_neutral(), "invariant") ; | |
| 695 test = (markOop) Atomic::cmpxchg_ptr(temp, monitor, mark); | |
| 696 if (test != mark) { | |
| 697 // The only update to the header in the monitor (outside GC) | |
| 698 // is install the hash code. If someone add new usage of | |
| 699 // displaced header, please update this code | |
| 700 hash = test->hash(); | |
| 701 assert (test->is_neutral(), "invariant") ; | |
| 702 assert (hash != 0, "Trivial unexpected object/monitor header usage."); | |
| 703 } | |
| 704 } | |
| 705 // We finally get the hash | |
| 706 return hash; | |
| 0 | 707 } |
| 708 | |
| 1878 | 709 // Deprecated -- use FastHashCode() instead. |
| 0 | 710 |
| 1878 | 711 intptr_t ObjectSynchronizer::identity_hash_value_for(Handle obj) { |
| 712 return FastHashCode (Thread::current(), obj()) ; | |
| 0 | 713 } |
| 714 | |
| 715 | |
| 1878 | 716 bool ObjectSynchronizer::current_thread_holds_lock(JavaThread* thread, |
| 717 Handle h_obj) { | |
| 718 if (UseBiasedLocking) { | |
| 719 BiasedLocking::revoke_and_rebias(h_obj, false, thread); | |
| 720 assert(!h_obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 721 } | |
| 722 | |
| 723 assert(thread == JavaThread::current(), "Can only be called on current thread"); | |
| 724 oop obj = h_obj(); | |
| 725 | |
| 726 markOop mark = ReadStableMark (obj) ; | |
| 0 | 727 |
| 1878 | 728 // Uncontended case, header points to stack |
| 729 if (mark->has_locker()) { | |
| 730 return thread->is_lock_owned((address)mark->locker()); | |
| 0 | 731 } |
| 1878 | 732 // Contended case, header points to ObjectMonitor (tagged pointer) |
| 733 if (mark->has_monitor()) { | |
| 734 ObjectMonitor* monitor = mark->monitor(); | |
| 735 return monitor->is_entered(thread) != 0 ; | |
| 0 | 736 } |
| 1878 | 737 // Unlocked case, header in place |
| 738 assert(mark->is_neutral(), "sanity check"); | |
| 739 return false; | |
| 0 | 740 } |
| 741 | |
| 1878 | 742 // Be aware of this method could revoke bias of the lock object. |
| 743 // This method querys the ownership of the lock handle specified by 'h_obj'. | |
| 744 // If the current thread owns the lock, it returns owner_self. If no | |
| 745 // thread owns the lock, it returns owner_none. Otherwise, it will return | |
| 746 // ower_other. | |
| 747 ObjectSynchronizer::LockOwnership ObjectSynchronizer::query_lock_ownership | |
| 748 (JavaThread *self, Handle h_obj) { | |
| 749 // The caller must beware this method can revoke bias, and | |
| 750 // revocation can result in a safepoint. | |
| 751 assert (!SafepointSynchronize::is_at_safepoint(), "invariant") ; | |
| 752 assert (self->thread_state() != _thread_blocked , "invariant") ; | |
| 0 | 753 |
| 1878 | 754 // Possible mark states: neutral, biased, stack-locked, inflated |
| 755 | |
| 756 if (UseBiasedLocking && h_obj()->mark()->has_bias_pattern()) { | |
| 757 // CASE: biased | |
| 758 BiasedLocking::revoke_and_rebias(h_obj, false, self); | |
| 759 assert(!h_obj->mark()->has_bias_pattern(), | |
| 760 "biases should be revoked by now"); | |
| 761 } | |
| 0 | 762 |
| 1878 | 763 assert(self == JavaThread::current(), "Can only be called on current thread"); |
| 764 oop obj = h_obj(); | |
| 765 markOop mark = ReadStableMark (obj) ; | |
| 766 | |
| 767 // CASE: stack-locked. Mark points to a BasicLock on the owner's stack. | |
| 768 if (mark->has_locker()) { | |
| 769 return self->is_lock_owned((address)mark->locker()) ? | |
| 770 owner_self : owner_other; | |
| 771 } | |
| 0 | 772 |
| 1878 | 773 // CASE: inflated. Mark (tagged pointer) points to an objectMonitor. |
| 774 // The Object:ObjectMonitor relationship is stable as long as we're | |
| 775 // not at a safepoint. | |
| 776 if (mark->has_monitor()) { | |
| 777 void * owner = mark->monitor()->_owner ; | |
| 778 if (owner == NULL) return owner_none ; | |
| 779 return (owner == self || | |
| 780 self->is_lock_owned((address)owner)) ? owner_self : owner_other; | |
| 781 } | |
| 782 | |
| 783 // CASE: neutral | |
| 784 assert(mark->is_neutral(), "sanity check"); | |
| 785 return owner_none ; // it's unlocked | |
| 786 } | |
| 0 | 787 |
| 1878 | 788 // FIXME: jvmti should call this |
| 789 JavaThread* ObjectSynchronizer::get_lock_owner(Handle h_obj, bool doLock) { | |
| 790 if (UseBiasedLocking) { | |
| 791 if (SafepointSynchronize::is_at_safepoint()) { | |
| 792 BiasedLocking::revoke_at_safepoint(h_obj); | |
| 793 } else { | |
| 794 BiasedLocking::revoke_and_rebias(h_obj, false, JavaThread::current()); | |
| 795 } | |
| 796 assert(!h_obj->mark()->has_bias_pattern(), "biases should be revoked by now"); | |
| 797 } | |
| 798 | |
| 799 oop obj = h_obj(); | |
| 800 address owner = NULL; | |
| 801 | |
| 802 markOop mark = ReadStableMark (obj) ; | |
| 803 | |
| 804 // Uncontended case, header points to stack | |
| 805 if (mark->has_locker()) { | |
| 806 owner = (address) mark->locker(); | |
| 807 } | |
| 808 | |
| 809 // Contended case, header points to ObjectMonitor (tagged pointer) | |
| 810 if (mark->has_monitor()) { | |
| 811 ObjectMonitor* monitor = mark->monitor(); | |
| 812 assert(monitor != NULL, "monitor should be non-null"); | |
| 813 owner = (address) monitor->owner(); | |
| 814 } | |
| 815 | |
| 816 if (owner != NULL) { | |
| 817 return Threads::owning_thread_from_monitor_owner(owner, doLock); | |
| 818 } | |
| 819 | |
| 820 // Unlocked case, header in place | |
| 821 // Cannot have assertion since this object may have been | |
| 822 // locked by another thread when reaching here. | |
| 823 // assert(mark->is_neutral(), "sanity check"); | |
| 824 | |
| 825 return NULL; | |
| 826 } | |
| 827 // Visitors ... | |
| 828 | |
| 829 void ObjectSynchronizer::monitors_iterate(MonitorClosure* closure) { | |
| 830 ObjectMonitor* block = gBlockList; | |
| 831 ObjectMonitor* mid; | |
| 832 while (block) { | |
| 833 assert(block->object() == CHAINMARKER, "must be a block header"); | |
| 834 for (int i = _BLOCKSIZE - 1; i > 0; i--) { | |
| 835 mid = block + i; | |
| 836 oop object = (oop) mid->object(); | |
| 837 if (object != NULL) { | |
| 838 closure->do_monitor(mid); | |
| 839 } | |
| 840 } | |
| 841 block = (ObjectMonitor*) block->FreeNext; | |
| 0 | 842 } |
| 843 } | |
| 844 | |
| 1878 | 845 // Get the next block in the block list. |
| 846 static inline ObjectMonitor* next(ObjectMonitor* block) { | |
| 847 assert(block->object() == CHAINMARKER, "must be a block header"); | |
| 848 block = block->FreeNext ; | |
| 849 assert(block == NULL || block->object() == CHAINMARKER, "must be a block header"); | |
| 850 return block; | |
| 0 | 851 } |
| 852 | |
| 853 | |
| 1878 | 854 void ObjectSynchronizer::oops_do(OopClosure* f) { |
| 855 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); | |
| 856 for (ObjectMonitor* block = gBlockList; block != NULL; block = next(block)) { | |
| 857 assert(block->object() == CHAINMARKER, "must be a block header"); | |
| 858 for (int i = 1; i < _BLOCKSIZE; i++) { | |
| 859 ObjectMonitor* mid = &block[i]; | |
| 860 if (mid->object() != NULL) { | |
| 861 f->do_oop((oop*)mid->object_addr()); | |
| 0 | 862 } |
| 863 } | |
| 864 } | |
| 865 } | |
| 866 | |
| 867 | |
| 1878 | 868 // ----------------------------------------------------------------------------- |
| 0 | 869 // ObjectMonitor Lifecycle |
| 870 // ----------------------- | |
| 871 // Inflation unlinks monitors from the global gFreeList and | |
| 872 // associates them with objects. Deflation -- which occurs at | |
| 873 // STW-time -- disassociates idle monitors from objects. Such | |
| 874 // scavenged monitors are returned to the gFreeList. | |
| 875 // | |
| 876 // The global list is protected by ListLock. All the critical sections | |
| 877 // are short and operate in constant-time. | |
| 878 // | |
| 879 // ObjectMonitors reside in type-stable memory (TSM) and are immortal. | |
| 880 // | |
| 881 // Lifecycle: | |
| 882 // -- unassigned and on the global free list | |
| 883 // -- unassigned and on a thread's private omFreeList | |
| 884 // -- assigned to an object. The object is inflated and the mark refers | |
| 885 // to the objectmonitor. | |
| 886 // | |
| 887 | |
| 888 | |
| 1587 | 889 // Constraining monitor pool growth via MonitorBound ... |
| 890 // | |
| 891 // The monitor pool is grow-only. We scavenge at STW safepoint-time, but the | |
| 892 // the rate of scavenging is driven primarily by GC. As such, we can find | |
| 893 // an inordinate number of monitors in circulation. | |
| 894 // To avoid that scenario we can artificially induce a STW safepoint | |
| 895 // if the pool appears to be growing past some reasonable bound. | |
| 896 // Generally we favor time in space-time tradeoffs, but as there's no | |
| 897 // natural back-pressure on the # of extant monitors we need to impose some | |
| 898 // type of limit. Beware that if MonitorBound is set to too low a value | |
| 899 // we could just loop. In addition, if MonitorBound is set to a low value | |
| 900 // we'll incur more safepoints, which are harmful to performance. | |
| 901 // See also: GuaranteedSafepointInterval | |
| 902 // | |
| 903 // The current implementation uses asynchronous VM operations. | |
| 904 // | |
| 905 | |
| 906 static void InduceScavenge (Thread * Self, const char * Whence) { | |
| 907 // Induce STW safepoint to trim monitors | |
| 908 // Ultimately, this results in a call to deflate_idle_monitors() in the near future. | |
| 909 // More precisely, trigger an asynchronous STW safepoint as the number | |
| 910 // of active monitors passes the specified threshold. | |
| 911 // TODO: assert thread state is reasonable | |
| 912 | |
| 913 if (ForceMonitorScavenge == 0 && Atomic::xchg (1, &ForceMonitorScavenge) == 0) { | |
| 1878 | 914 if (ObjectMonitor::Knob_Verbose) { |
| 1587 | 915 ::printf ("Monitor scavenge - Induced STW @%s (%d)\n", Whence, ForceMonitorScavenge) ; |
| 916 ::fflush(stdout) ; | |
| 917 } | |
| 918 // Induce a 'null' safepoint to scavenge monitors | |
| 919 // Must VM_Operation instance be heap allocated as the op will be enqueue and posted | |
| 920 // to the VMthread and have a lifespan longer than that of this activation record. | |
| 921 // The VMThread will delete the op when completed. | |
| 922 VMThread::execute (new VM_ForceAsyncSafepoint()) ; | |
| 923 | |
| 1878 | 924 if (ObjectMonitor::Knob_Verbose) { |
| 1587 | 925 ::printf ("Monitor scavenge - STW posted @%s (%d)\n", Whence, ForceMonitorScavenge) ; |
| 926 ::fflush(stdout) ; | |
| 927 } | |
| 928 } | |
| 929 } | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
930 /* Too slow for general assert or debug |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
931 void ObjectSynchronizer::verifyInUse (Thread *Self) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
932 ObjectMonitor* mid; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
933 int inusetally = 0; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
934 for (mid = Self->omInUseList; mid != NULL; mid = mid->FreeNext) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
935 inusetally ++; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
936 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
937 assert(inusetally == Self->omInUseCount, "inuse count off"); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
938 |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
939 int freetally = 0; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
940 for (mid = Self->omFreeList; mid != NULL; mid = mid->FreeNext) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
941 freetally ++; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
942 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
943 assert(freetally == Self->omFreeCount, "free count off"); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
944 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
945 */ |
| 0 | 946 ObjectMonitor * ATTR ObjectSynchronizer::omAlloc (Thread * Self) { |
| 947 // A large MAXPRIVATE value reduces both list lock contention | |
| 948 // and list coherency traffic, but also tends to increase the | |
| 949 // number of objectMonitors in circulation as well as the STW | |
| 950 // scavenge costs. As usual, we lean toward time in space-time | |
| 951 // tradeoffs. | |
| 952 const int MAXPRIVATE = 1024 ; | |
| 953 for (;;) { | |
| 954 ObjectMonitor * m ; | |
| 955 | |
| 956 // 1: try to allocate from the thread's local omFreeList. | |
| 957 // Threads will attempt to allocate first from their local list, then | |
| 958 // from the global list, and only after those attempts fail will the thread | |
| 959 // attempt to instantiate new monitors. Thread-local free lists take | |
| 960 // heat off the ListLock and improve allocation latency, as well as reducing | |
| 961 // coherency traffic on the shared global list. | |
| 962 m = Self->omFreeList ; | |
| 963 if (m != NULL) { | |
| 964 Self->omFreeList = m->FreeNext ; | |
| 965 Self->omFreeCount -- ; | |
| 966 // CONSIDER: set m->FreeNext = BAD -- diagnostic hygiene | |
| 967 guarantee (m->object() == NULL, "invariant") ; | |
| 1587 | 968 if (MonitorInUseLists) { |
| 969 m->FreeNext = Self->omInUseList; | |
| 970 Self->omInUseList = m; | |
| 971 Self->omInUseCount ++; | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
972 // verifyInUse(Self); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
973 } else { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
974 m->FreeNext = NULL; |
| 1587 | 975 } |
| 0 | 976 return m ; |
| 977 } | |
| 978 | |
| 979 // 2: try to allocate from the global gFreeList | |
| 980 // CONSIDER: use muxTry() instead of muxAcquire(). | |
| 981 // If the muxTry() fails then drop immediately into case 3. | |
| 982 // If we're using thread-local free lists then try | |
| 983 // to reprovision the caller's free list. | |
| 984 if (gFreeList != NULL) { | |
| 985 // Reprovision the thread's omFreeList. | |
| 986 // Use bulk transfers to reduce the allocation rate and heat | |
| 987 // on various locks. | |
| 988 Thread::muxAcquire (&ListLock, "omAlloc") ; | |
| 989 for (int i = Self->omFreeProvision; --i >= 0 && gFreeList != NULL; ) { | |
| 1587 | 990 MonitorFreeCount --; |
| 0 | 991 ObjectMonitor * take = gFreeList ; |
| 992 gFreeList = take->FreeNext ; | |
| 993 guarantee (take->object() == NULL, "invariant") ; | |
| 994 guarantee (!take->is_busy(), "invariant") ; | |
| 995 take->Recycle() ; | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
996 omRelease (Self, take, false) ; |
| 0 | 997 } |
| 998 Thread::muxRelease (&ListLock) ; | |
| 999 Self->omFreeProvision += 1 + (Self->omFreeProvision/2) ; | |
| 1000 if (Self->omFreeProvision > MAXPRIVATE ) Self->omFreeProvision = MAXPRIVATE ; | |
| 1001 TEVENT (omFirst - reprovision) ; | |
| 1587 | 1002 |
| 1003 const int mx = MonitorBound ; | |
| 1004 if (mx > 0 && (MonitorPopulation-MonitorFreeCount) > mx) { | |
| 1005 // We can't safely induce a STW safepoint from omAlloc() as our thread | |
| 1006 // state may not be appropriate for such activities and callers may hold | |
| 1007 // naked oops, so instead we defer the action. | |
| 1008 InduceScavenge (Self, "omAlloc") ; | |
| 1009 } | |
| 1010 continue; | |
| 0 | 1011 } |
| 1012 | |
| 1013 // 3: allocate a block of new ObjectMonitors | |
| 1014 // Both the local and global free lists are empty -- resort to malloc(). | |
| 1015 // In the current implementation objectMonitors are TSM - immortal. | |
| 1016 assert (_BLOCKSIZE > 1, "invariant") ; | |
| 1017 ObjectMonitor * temp = new ObjectMonitor[_BLOCKSIZE]; | |
| 1018 | |
| 1019 // NOTE: (almost) no way to recover if allocation failed. | |
| 1020 // We might be able to induce a STW safepoint and scavenge enough | |
| 1021 // objectMonitors to permit progress. | |
| 1022 if (temp == NULL) { | |
| 1023 vm_exit_out_of_memory (sizeof (ObjectMonitor[_BLOCKSIZE]), "Allocate ObjectMonitors") ; | |
| 1024 } | |
| 1025 | |
| 1026 // Format the block. | |
| 1027 // initialize the linked list, each monitor points to its next | |
| 1028 // forming the single linked free list, the very first monitor | |
| 1029 // will points to next block, which forms the block list. | |
| 1030 // The trick of using the 1st element in the block as gBlockList | |
| 1031 // linkage should be reconsidered. A better implementation would | |
| 1032 // look like: class Block { Block * next; int N; ObjectMonitor Body [N] ; } | |
| 1033 | |
| 1034 for (int i = 1; i < _BLOCKSIZE ; i++) { | |
| 1035 temp[i].FreeNext = &temp[i+1]; | |
| 1036 } | |
| 1037 | |
| 1038 // terminate the last monitor as the end of list | |
| 1039 temp[_BLOCKSIZE - 1].FreeNext = NULL ; | |
| 1040 | |
| 1041 // Element [0] is reserved for global list linkage | |
| 1042 temp[0].set_object(CHAINMARKER); | |
| 1043 | |
| 1044 // Consider carving out this thread's current request from the | |
| 1045 // block in hand. This avoids some lock traffic and redundant | |
| 1046 // list activity. | |
| 1047 | |
| 1048 // Acquire the ListLock to manipulate BlockList and FreeList. | |
| 1049 // An Oyama-Taura-Yonezawa scheme might be more efficient. | |
| 1050 Thread::muxAcquire (&ListLock, "omAlloc [2]") ; | |
| 1587 | 1051 MonitorPopulation += _BLOCKSIZE-1; |
| 1052 MonitorFreeCount += _BLOCKSIZE-1; | |
| 0 | 1053 |
| 1054 // Add the new block to the list of extant blocks (gBlockList). | |
| 1055 // The very first objectMonitor in a block is reserved and dedicated. | |
| 1056 // It serves as blocklist "next" linkage. | |
| 1057 temp[0].FreeNext = gBlockList; | |
| 1058 gBlockList = temp; | |
| 1059 | |
| 1060 // Add the new string of objectMonitors to the global free list | |
| 1061 temp[_BLOCKSIZE - 1].FreeNext = gFreeList ; | |
| 1062 gFreeList = temp + 1; | |
| 1063 Thread::muxRelease (&ListLock) ; | |
| 1064 TEVENT (Allocate block of monitors) ; | |
| 1065 } | |
| 1066 } | |
| 1067 | |
| 1068 // Place "m" on the caller's private per-thread omFreeList. | |
| 1069 // In practice there's no need to clamp or limit the number of | |
| 1070 // monitors on a thread's omFreeList as the only time we'll call | |
| 1071 // omRelease is to return a monitor to the free list after a CAS | |
| 1072 // attempt failed. This doesn't allow unbounded #s of monitors to | |
| 1073 // accumulate on a thread's free list. | |
| 1074 // | |
| 1075 | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1076 void ObjectSynchronizer::omRelease (Thread * Self, ObjectMonitor * m, bool fromPerThreadAlloc) { |
| 0 | 1077 guarantee (m->object() == NULL, "invariant") ; |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1078 |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1079 // Remove from omInUseList |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1080 if (MonitorInUseLists && fromPerThreadAlloc) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1081 ObjectMonitor* curmidinuse = NULL; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1082 for (ObjectMonitor* mid = Self->omInUseList; mid != NULL; ) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1083 if (m == mid) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1084 // extract from per-thread in-use-list |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1085 if (mid == Self->omInUseList) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1086 Self->omInUseList = mid->FreeNext; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1087 } else if (curmidinuse != NULL) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1088 curmidinuse->FreeNext = mid->FreeNext; // maintain the current thread inuselist |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1089 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1090 Self->omInUseCount --; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1091 // verifyInUse(Self); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1092 break; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1093 } else { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1094 curmidinuse = mid; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1095 mid = mid->FreeNext; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1096 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1097 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1098 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1099 |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1100 // FreeNext is used for both onInUseList and omFreeList, so clear old before setting new |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1101 m->FreeNext = Self->omFreeList ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1102 Self->omFreeList = m ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1103 Self->omFreeCount ++ ; |
| 0 | 1104 } |
| 1105 | |
| 1106 // Return the monitors of a moribund thread's local free list to | |
| 1107 // the global free list. Typically a thread calls omFlush() when | |
| 1108 // it's dying. We could also consider having the VM thread steal | |
| 1109 // monitors from threads that have not run java code over a few | |
| 1110 // consecutive STW safepoints. Relatedly, we might decay | |
| 1111 // omFreeProvision at STW safepoints. | |
| 1112 // | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1113 // Also return the monitors of a moribund thread"s omInUseList to |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1114 // a global gOmInUseList under the global list lock so these |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1115 // will continue to be scanned. |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1116 // |
| 0 | 1117 // We currently call omFlush() from the Thread:: dtor _after the thread |
| 1118 // has been excised from the thread list and is no longer a mutator. | |
| 1119 // That means that omFlush() can run concurrently with a safepoint and | |
| 1120 // the scavenge operator. Calling omFlush() from JavaThread::exit() might | |
| 1121 // be a better choice as we could safely reason that that the JVM is | |
| 1122 // not at a safepoint at the time of the call, and thus there could | |
| 1123 // be not inopportune interleavings between omFlush() and the scavenge | |
| 1124 // operator. | |
| 1125 | |
| 1126 void ObjectSynchronizer::omFlush (Thread * Self) { | |
| 1127 ObjectMonitor * List = Self->omFreeList ; // Null-terminated SLL | |
| 1128 Self->omFreeList = NULL ; | |
| 1129 ObjectMonitor * Tail = NULL ; | |
| 1587 | 1130 int Tally = 0; |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1131 if (List != NULL) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1132 ObjectMonitor * s ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1133 for (s = List ; s != NULL ; s = s->FreeNext) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1134 Tally ++ ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1135 Tail = s ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1136 guarantee (s->object() == NULL, "invariant") ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1137 guarantee (!s->is_busy(), "invariant") ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1138 s->set_owner (NULL) ; // redundant but good hygiene |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1139 TEVENT (omFlush - Move one) ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1140 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1141 guarantee (Tail != NULL && List != NULL, "invariant") ; |
| 0 | 1142 } |
| 1143 | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1144 ObjectMonitor * InUseList = Self->omInUseList; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1145 ObjectMonitor * InUseTail = NULL ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1146 int InUseTally = 0; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1147 if (InUseList != NULL) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1148 Self->omInUseList = NULL; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1149 ObjectMonitor *curom; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1150 for (curom = InUseList; curom != NULL; curom = curom->FreeNext) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1151 InUseTail = curom; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1152 InUseTally++; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1153 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1154 // TODO debug |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1155 assert(Self->omInUseCount == InUseTally, "inuse count off"); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1156 Self->omInUseCount = 0; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1157 guarantee (InUseTail != NULL && InUseList != NULL, "invariant"); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1158 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1159 |
| 0 | 1160 Thread::muxAcquire (&ListLock, "omFlush") ; |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1161 if (Tail != NULL) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1162 Tail->FreeNext = gFreeList ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1163 gFreeList = List ; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1164 MonitorFreeCount += Tally; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1165 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1166 |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1167 if (InUseTail != NULL) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1168 InUseTail->FreeNext = gOmInUseList; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1169 gOmInUseList = InUseList; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1170 gOmInUseCount += InUseTally; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1171 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1172 |
| 0 | 1173 Thread::muxRelease (&ListLock) ; |
| 1174 TEVENT (omFlush) ; | |
| 1175 } | |
| 1176 | |
| 1177 // Fast path code shared by multiple functions | |
| 1178 ObjectMonitor* ObjectSynchronizer::inflate_helper(oop obj) { | |
| 1179 markOop mark = obj->mark(); | |
| 1180 if (mark->has_monitor()) { | |
| 1181 assert(ObjectSynchronizer::verify_objmon_isinpool(mark->monitor()), "monitor is invalid"); | |
| 1182 assert(mark->monitor()->header()->is_neutral(), "monitor must record a good object header"); | |
| 1183 return mark->monitor(); | |
| 1184 } | |
| 1185 return ObjectSynchronizer::inflate(Thread::current(), obj); | |
| 1186 } | |
| 1187 | |
| 1878 | 1188 |
| 0 | 1189 // Note that we could encounter some performance loss through false-sharing as |
| 1190 // multiple locks occupy the same $ line. Padding might be appropriate. | |
| 1191 | |
| 1192 | |
| 1193 ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) { | |
| 1194 // Inflate mutates the heap ... | |
| 1195 // Relaxing assertion for bug 6320749. | |
| 1196 assert (Universe::verify_in_progress() || | |
| 1197 !SafepointSynchronize::is_at_safepoint(), "invariant") ; | |
| 1198 | |
| 1199 for (;;) { | |
| 1200 const markOop mark = object->mark() ; | |
| 1201 assert (!mark->has_bias_pattern(), "invariant") ; | |
| 1202 | |
| 1203 // The mark can be in one of the following states: | |
| 1204 // * Inflated - just return | |
| 1205 // * Stack-locked - coerce it to inflated | |
| 1206 // * INFLATING - busy wait for conversion to complete | |
| 1207 // * Neutral - aggressively inflate the object. | |
| 1208 // * BIASED - Illegal. We should never see this | |
| 1209 | |
| 1210 // CASE: inflated | |
| 1211 if (mark->has_monitor()) { | |
| 1212 ObjectMonitor * inf = mark->monitor() ; | |
| 1213 assert (inf->header()->is_neutral(), "invariant"); | |
| 1214 assert (inf->object() == object, "invariant") ; | |
| 1215 assert (ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid"); | |
| 1216 return inf ; | |
| 1217 } | |
| 1218 | |
| 1219 // CASE: inflation in progress - inflating over a stack-lock. | |
| 1220 // Some other thread is converting from stack-locked to inflated. | |
| 1221 // Only that thread can complete inflation -- other threads must wait. | |
| 1222 // The INFLATING value is transient. | |
| 1223 // Currently, we spin/yield/park and poll the markword, waiting for inflation to finish. | |
| 1224 // We could always eliminate polling by parking the thread on some auxiliary list. | |
| 1225 if (mark == markOopDesc::INFLATING()) { | |
| 1226 TEVENT (Inflate: spin while INFLATING) ; | |
| 1227 ReadStableMark(object) ; | |
| 1228 continue ; | |
| 1229 } | |
| 1230 | |
| 1231 // CASE: stack-locked | |
| 1232 // Could be stack-locked either by this thread or by some other thread. | |
| 1233 // | |
| 1234 // Note that we allocate the objectmonitor speculatively, _before_ attempting | |
| 1235 // to install INFLATING into the mark word. We originally installed INFLATING, | |
| 1236 // allocated the objectmonitor, and then finally STed the address of the | |
| 1237 // objectmonitor into the mark. This was correct, but artificially lengthened | |
| 1238 // the interval in which INFLATED appeared in the mark, thus increasing | |
| 1239 // the odds of inflation contention. | |
| 1240 // | |
| 1241 // We now use per-thread private objectmonitor free lists. | |
| 1242 // These list are reprovisioned from the global free list outside the | |
| 1243 // critical INFLATING...ST interval. A thread can transfer | |
| 1244 // multiple objectmonitors en-mass from the global free list to its local free list. | |
| 1245 // This reduces coherency traffic and lock contention on the global free list. | |
| 1246 // Using such local free lists, it doesn't matter if the omAlloc() call appears | |
| 1247 // before or after the CAS(INFLATING) operation. | |
| 1248 // See the comments in omAlloc(). | |
| 1249 | |
| 1250 if (mark->has_locker()) { | |
| 1251 ObjectMonitor * m = omAlloc (Self) ; | |
| 1252 // Optimistically prepare the objectmonitor - anticipate successful CAS | |
| 1253 // We do this before the CAS in order to minimize the length of time | |
| 1254 // in which INFLATING appears in the mark. | |
| 1255 m->Recycle(); | |
| 1256 m->_Responsible = NULL ; | |
| 1257 m->OwnerIsThread = 0 ; | |
| 1258 m->_recursions = 0 ; | |
| 1878 | 1259 m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ; // Consider: maintain by type/class |
| 0 | 1260 |
| 1261 markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ; | |
| 1262 if (cmp != mark) { | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1263 omRelease (Self, m, true) ; |
| 0 | 1264 continue ; // Interference -- just retry |
| 1265 } | |
| 1266 | |
| 1267 // We've successfully installed INFLATING (0) into the mark-word. | |
| 1268 // This is the only case where 0 will appear in a mark-work. | |
| 1269 // Only the singular thread that successfully swings the mark-word | |
| 1270 // to 0 can perform (or more precisely, complete) inflation. | |
| 1271 // | |
| 1272 // Why do we CAS a 0 into the mark-word instead of just CASing the | |
| 1273 // mark-word from the stack-locked value directly to the new inflated state? | |
| 1274 // Consider what happens when a thread unlocks a stack-locked object. | |
| 1275 // It attempts to use CAS to swing the displaced header value from the | |
| 1276 // on-stack basiclock back into the object header. Recall also that the | |
| 1277 // header value (hashcode, etc) can reside in (a) the object header, or | |
| 1278 // (b) a displaced header associated with the stack-lock, or (c) a displaced | |
| 1279 // header in an objectMonitor. The inflate() routine must copy the header | |
| 1280 // value from the basiclock on the owner's stack to the objectMonitor, all | |
| 1281 // the while preserving the hashCode stability invariants. If the owner | |
| 1282 // decides to release the lock while the value is 0, the unlock will fail | |
| 1283 // and control will eventually pass from slow_exit() to inflate. The owner | |
| 1284 // will then spin, waiting for the 0 value to disappear. Put another way, | |
| 1285 // the 0 causes the owner to stall if the owner happens to try to | |
| 1286 // drop the lock (restoring the header from the basiclock to the object) | |
| 1287 // while inflation is in-progress. This protocol avoids races that might | |
| 1288 // would otherwise permit hashCode values to change or "flicker" for an object. | |
| 1289 // Critically, while object->mark is 0 mark->displaced_mark_helper() is stable. | |
| 1290 // 0 serves as a "BUSY" inflate-in-progress indicator. | |
| 1291 | |
| 1292 | |
| 1293 // fetch the displaced mark from the owner's stack. | |
| 1294 // The owner can't die or unwind past the lock while our INFLATING | |
| 1295 // object is in the mark. Furthermore the owner can't complete | |
| 1296 // an unlock on the object, either. | |
| 1297 markOop dmw = mark->displaced_mark_helper() ; | |
| 1298 assert (dmw->is_neutral(), "invariant") ; | |
| 1299 | |
| 1300 // Setup monitor fields to proper values -- prepare the monitor | |
| 1301 m->set_header(dmw) ; | |
| 1302 | |
| 1303 // Optimization: if the mark->locker stack address is associated | |
| 1304 // with this thread we could simply set m->_owner = Self and | |
|
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
579
diff
changeset
|
1305 // m->OwnerIsThread = 1. Note that a thread can inflate an object |
| 0 | 1306 // that it has stack-locked -- as might happen in wait() -- directly |
| 1307 // with CAS. That is, we can avoid the xchg-NULL .... ST idiom. | |
|
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
579
diff
changeset
|
1308 m->set_owner(mark->locker()); |
| 0 | 1309 m->set_object(object); |
| 1310 // TODO-FIXME: assert BasicLock->dhw != 0. | |
| 1311 | |
| 1312 // Must preserve store ordering. The monitor state must | |
| 1313 // be stable at the time of publishing the monitor address. | |
| 1314 guarantee (object->mark() == markOopDesc::INFLATING(), "invariant") ; | |
| 1315 object->release_set_mark(markOopDesc::encode(m)); | |
| 1316 | |
| 1317 // Hopefully the performance counters are allocated on distinct cache lines | |
| 1318 // to avoid false sharing on MP systems ... | |
| 1878 | 1319 if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ; |
| 0 | 1320 TEVENT(Inflate: overwrite stacklock) ; |
| 1321 if (TraceMonitorInflation) { | |
| 1322 if (object->is_instance()) { | |
| 1323 ResourceMark rm; | |
| 1324 tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s", | |
| 1325 (intptr_t) object, (intptr_t) object->mark(), | |
| 1326 Klass::cast(object->klass())->external_name()); | |
| 1327 } | |
| 1328 } | |
| 1329 return m ; | |
| 1330 } | |
| 1331 | |
| 1332 // CASE: neutral | |
| 1333 // TODO-FIXME: for entry we currently inflate and then try to CAS _owner. | |
| 1334 // If we know we're inflating for entry it's better to inflate by swinging a | |
| 1335 // pre-locked objectMonitor pointer into the object header. A successful | |
| 1336 // CAS inflates the object *and* confers ownership to the inflating thread. | |
| 1337 // In the current implementation we use a 2-step mechanism where we CAS() | |
| 1338 // to inflate and then CAS() again to try to swing _owner from NULL to Self. | |
| 1339 // An inflateTry() method that we could call from fast_enter() and slow_enter() | |
| 1340 // would be useful. | |
| 1341 | |
| 1342 assert (mark->is_neutral(), "invariant"); | |
| 1343 ObjectMonitor * m = omAlloc (Self) ; | |
| 1344 // prepare m for installation - set monitor to initial state | |
| 1345 m->Recycle(); | |
| 1346 m->set_header(mark); | |
| 1347 m->set_owner(NULL); | |
| 1348 m->set_object(object); | |
| 1349 m->OwnerIsThread = 1 ; | |
| 1350 m->_recursions = 0 ; | |
| 1351 m->_Responsible = NULL ; | |
| 1878 | 1352 m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ; // consider: keep metastats by type/class |
| 0 | 1353 |
| 1354 if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) { | |
| 1355 m->set_object (NULL) ; | |
| 1356 m->set_owner (NULL) ; | |
| 1357 m->OwnerIsThread = 0 ; | |
| 1358 m->Recycle() ; | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1359 omRelease (Self, m, true) ; |
| 0 | 1360 m = NULL ; |
| 1361 continue ; | |
| 1362 // interference - the markword changed - just retry. | |
| 1363 // The state-transitions are one-way, so there's no chance of | |
| 1364 // live-lock -- "Inflated" is an absorbing state. | |
| 1365 } | |
| 1366 | |
| 1367 // Hopefully the performance counters are allocated on distinct | |
| 1368 // cache lines to avoid false sharing on MP systems ... | |
| 1878 | 1369 if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ; |
| 0 | 1370 TEVENT(Inflate: overwrite neutral) ; |
| 1371 if (TraceMonitorInflation) { | |
| 1372 if (object->is_instance()) { | |
| 1373 ResourceMark rm; | |
| 1374 tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s", | |
| 1375 (intptr_t) object, (intptr_t) object->mark(), | |
| 1376 Klass::cast(object->klass())->external_name()); | |
| 1377 } | |
| 1378 } | |
| 1379 return m ; | |
| 1380 } | |
| 1381 } | |
| 1382 | |
| 1878 | 1383 // Note that we could encounter some performance loss through false-sharing as |
| 1384 // multiple locks occupy the same $ line. Padding might be appropriate. | |
| 0 | 1385 |
| 1386 | |
| 1387 // Deflate_idle_monitors() is called at all safepoints, immediately | |
| 1388 // after all mutators are stopped, but before any objects have moved. | |
| 1389 // It traverses the list of known monitors, deflating where possible. | |
| 1390 // The scavenged monitor are returned to the monitor free list. | |
| 1391 // | |
| 1392 // Beware that we scavenge at *every* stop-the-world point. | |
| 1393 // Having a large number of monitors in-circulation negatively | |
| 1394 // impacts the performance of some applications (e.g., PointBase). | |
| 1395 // Broadly, we want to minimize the # of monitors in circulation. | |
| 1587 | 1396 // |
| 1397 // We have added a flag, MonitorInUseLists, which creates a list | |
| 1398 // of active monitors for each thread. deflate_idle_monitors() | |
| 1399 // only scans the per-thread inuse lists. omAlloc() puts all | |
| 1400 // assigned monitors on the per-thread list. deflate_idle_monitors() | |
| 1401 // returns the non-busy monitors to the global free list. | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1402 // When a thread dies, omFlush() adds the list of active monitors for |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1403 // that thread to a global gOmInUseList acquiring the |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1404 // global list lock. deflate_idle_monitors() acquires the global |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1405 // list lock to scan for non-busy monitors to the global free list. |
| 1587 | 1406 // An alternative could have used a single global inuse list. The |
| 1407 // downside would have been the additional cost of acquiring the global list lock | |
| 1408 // for every omAlloc(). | |
| 0 | 1409 // |
| 1410 // Perversely, the heap size -- and thus the STW safepoint rate -- | |
| 1411 // typically drives the scavenge rate. Large heaps can mean infrequent GC, | |
| 1412 // which in turn can mean large(r) numbers of objectmonitors in circulation. | |
| 1413 // This is an unfortunate aspect of this design. | |
| 1414 // | |
| 1415 | |
| 1878 | 1416 enum ManifestConstants { |
| 1417 ClearResponsibleAtSTW = 0, | |
| 1418 MaximumRecheckInterval = 1000 | |
| 1419 } ; | |
| 1587 | 1420 |
| 1421 // Deflate a single monitor if not in use | |
| 1422 // Return true if deflated, false if in use | |
| 1423 bool ObjectSynchronizer::deflate_monitor(ObjectMonitor* mid, oop obj, | |
| 1424 ObjectMonitor** FreeHeadp, ObjectMonitor** FreeTailp) { | |
| 1425 bool deflated; | |
| 1426 // Normal case ... The monitor is associated with obj. | |
| 1427 guarantee (obj->mark() == markOopDesc::encode(mid), "invariant") ; | |
| 1428 guarantee (mid == obj->mark()->monitor(), "invariant"); | |
| 1429 guarantee (mid->header()->is_neutral(), "invariant"); | |
| 1430 | |
| 1431 if (mid->is_busy()) { | |
| 1432 if (ClearResponsibleAtSTW) mid->_Responsible = NULL ; | |
| 1433 deflated = false; | |
| 1434 } else { | |
| 1435 // Deflate the monitor if it is no longer being used | |
| 1436 // It's idle - scavenge and return to the global free list | |
| 1437 // plain old deflation ... | |
| 1438 TEVENT (deflate_idle_monitors - scavenge1) ; | |
| 1439 if (TraceMonitorInflation) { | |
| 1440 if (obj->is_instance()) { | |
| 1441 ResourceMark rm; | |
| 1442 tty->print_cr("Deflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s", | |
| 1443 (intptr_t) obj, (intptr_t) obj->mark(), Klass::cast(obj->klass())->external_name()); | |
| 1444 } | |
| 1445 } | |
| 1446 | |
| 1447 // Restore the header back to obj | |
| 1448 obj->release_set_mark(mid->header()); | |
| 1449 mid->clear(); | |
| 1450 | |
| 1451 assert (mid->object() == NULL, "invariant") ; | |
| 1452 | |
| 1453 // Move the object to the working free list defined by FreeHead,FreeTail. | |
| 1454 if (*FreeHeadp == NULL) *FreeHeadp = mid; | |
| 1455 if (*FreeTailp != NULL) { | |
| 1456 ObjectMonitor * prevtail = *FreeTailp; | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1457 assert(prevtail->FreeNext == NULL, "cleaned up deflated?"); // TODO KK |
| 1587 | 1458 prevtail->FreeNext = mid; |
| 1459 } | |
| 1460 *FreeTailp = mid; | |
| 1461 deflated = true; | |
| 1462 } | |
| 1463 return deflated; | |
| 1464 } | |
| 1465 | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1466 // Caller acquires ListLock |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1467 int ObjectSynchronizer::walk_monitor_list(ObjectMonitor** listheadp, |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1468 ObjectMonitor** FreeHeadp, ObjectMonitor** FreeTailp) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1469 ObjectMonitor* mid; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1470 ObjectMonitor* next; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1471 ObjectMonitor* curmidinuse = NULL; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1472 int deflatedcount = 0; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1473 |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1474 for (mid = *listheadp; mid != NULL; ) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1475 oop obj = (oop) mid->object(); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1476 bool deflated = false; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1477 if (obj != NULL) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1478 deflated = deflate_monitor(mid, obj, FreeHeadp, FreeTailp); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1479 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1480 if (deflated) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1481 // extract from per-thread in-use-list |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1482 if (mid == *listheadp) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1483 *listheadp = mid->FreeNext; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1484 } else if (curmidinuse != NULL) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1485 curmidinuse->FreeNext = mid->FreeNext; // maintain the current thread inuselist |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1486 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1487 next = mid->FreeNext; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1488 mid->FreeNext = NULL; // This mid is current tail in the FreeHead list |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1489 mid = next; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1490 deflatedcount++; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1491 } else { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1492 curmidinuse = mid; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1493 mid = mid->FreeNext; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1494 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1495 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1496 return deflatedcount; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1497 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1498 |
| 0 | 1499 void ObjectSynchronizer::deflate_idle_monitors() { |
| 1500 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); | |
| 1501 int nInuse = 0 ; // currently associated with objects | |
| 1502 int nInCirculation = 0 ; // extant | |
| 1503 int nScavenged = 0 ; // reclaimed | |
| 1587 | 1504 bool deflated = false; |
| 0 | 1505 |
| 1506 ObjectMonitor * FreeHead = NULL ; // Local SLL of scavenged monitors | |
| 1507 ObjectMonitor * FreeTail = NULL ; | |
| 1508 | |
| 1587 | 1509 TEVENT (deflate_idle_monitors) ; |
| 1510 // Prevent omFlush from changing mids in Thread dtor's during deflation | |
| 1511 // And in case the vm thread is acquiring a lock during a safepoint | |
| 1512 // See e.g. 6320749 | |
| 1513 Thread::muxAcquire (&ListLock, "scavenge - return") ; | |
| 1514 | |
| 1515 if (MonitorInUseLists) { | |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1516 int inUse = 0; |
| 1587 | 1517 for (JavaThread* cur = Threads::first(); cur != NULL; cur = cur->next()) { |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1518 nInCirculation+= cur->omInUseCount; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1519 int deflatedcount = walk_monitor_list(cur->omInUseList_addr(), &FreeHead, &FreeTail); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1520 cur->omInUseCount-= deflatedcount; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1521 // verifyInUse(cur); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1522 nScavenged += deflatedcount; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1523 nInuse += cur->omInUseCount; |
| 1587 | 1524 } |
|
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1525 |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1526 // For moribund threads, scan gOmInUseList |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1527 if (gOmInUseList) { |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1528 nInCirculation += gOmInUseCount; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1529 int deflatedcount = walk_monitor_list((ObjectMonitor **)&gOmInUseList, &FreeHead, &FreeTail); |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1530 gOmInUseCount-= deflatedcount; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1531 nScavenged += deflatedcount; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1532 nInuse += gOmInUseCount; |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1533 } |
|
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
1534 |
| 1587 | 1535 } else for (ObjectMonitor* block = gBlockList; block != NULL; block = next(block)) { |
| 0 | 1536 // Iterate over all extant monitors - Scavenge all idle monitors. |
| 1537 assert(block->object() == CHAINMARKER, "must be a block header"); | |
| 1538 nInCirculation += _BLOCKSIZE ; | |
| 1539 for (int i = 1 ; i < _BLOCKSIZE; i++) { | |
| 1540 ObjectMonitor* mid = &block[i]; | |
| 1541 oop obj = (oop) mid->object(); | |
| 1542 | |
| 1543 if (obj == NULL) { | |
| 1544 // The monitor is not associated with an object. | |
| 1545 // The monitor should either be a thread-specific private | |
| 1546 // free list or the global free list. | |
| 1547 // obj == NULL IMPLIES mid->is_busy() == 0 | |
| 1548 guarantee (!mid->is_busy(), "invariant") ; | |
| 1549 continue ; | |
| 1550 } | |
| 1587 | 1551 deflated = deflate_monitor(mid, obj, &FreeHead, &FreeTail); |
| 1552 | |
| 1553 if (deflated) { | |
| 1554 mid->FreeNext = NULL ; | |
| 1555 nScavenged ++ ; | |
| 0 | 1556 } else { |
| 1587 | 1557 nInuse ++; |
| 0 | 1558 } |
| 1559 } | |
| 1560 } | |
| 1561 | |
| 1587 | 1562 MonitorFreeCount += nScavenged; |
| 1563 | |
| 1564 // Consider: audit gFreeList to ensure that MonitorFreeCount and list agree. | |
| 1565 | |
| 1878 | 1566 if (ObjectMonitor::Knob_Verbose) { |
| 1587 | 1567 ::printf ("Deflate: InCirc=%d InUse=%d Scavenged=%d ForceMonitorScavenge=%d : pop=%d free=%d\n", |
| 1568 nInCirculation, nInuse, nScavenged, ForceMonitorScavenge, | |
| 1569 MonitorPopulation, MonitorFreeCount) ; | |
| 1570 ::fflush(stdout) ; | |
| 1571 } | |
| 1572 | |
| 1573 ForceMonitorScavenge = 0; // Reset | |
| 1574 | |
| 0 | 1575 // Move the scavenged monitors back to the global free list. |
| 1576 if (FreeHead != NULL) { | |
| 1577 guarantee (FreeTail != NULL && nScavenged > 0, "invariant") ; | |
| 1578 assert (FreeTail->FreeNext == NULL, "invariant") ; | |
| 1579 // constant-time list splice - prepend scavenged segment to gFreeList | |
| 1580 FreeTail->FreeNext = gFreeList ; | |
| 1581 gFreeList = FreeHead ; | |
| 1582 } | |
| 1587 | 1583 Thread::muxRelease (&ListLock) ; |
| 0 | 1584 |
| 1878 | 1585 if (ObjectMonitor::_sync_Deflations != NULL) ObjectMonitor::_sync_Deflations->inc(nScavenged) ; |
| 1586 if (ObjectMonitor::_sync_MonExtant != NULL) ObjectMonitor::_sync_MonExtant ->set_value(nInCirculation); | |
| 0 | 1587 |
| 1588 // TODO: Add objectMonitor leak detection. | |
| 1589 // Audit/inventory the objectMonitors -- make sure they're all accounted for. | |
| 1590 GVars.stwRandom = os::random() ; | |
| 1591 GVars.stwCycle ++ ; | |
| 1592 } | |
| 1593 | |
| 1878 | 1594 // Monitor cleanup on JavaThread::exit |
| 0 | 1595 |
| 1878 | 1596 // Iterate through monitor cache and attempt to release thread's monitors |
| 1597 // Gives up on a particular monitor if an exception occurs, but continues | |
| 1598 // the overall iteration, swallowing the exception. | |
| 1599 class ReleaseJavaMonitorsClosure: public MonitorClosure { | |
| 1600 private: | |
| 1601 TRAPS; | |
| 0 | 1602 |
| 1878 | 1603 public: |
| 1604 ReleaseJavaMonitorsClosure(Thread* thread) : THREAD(thread) {} | |
| 1605 void do_monitor(ObjectMonitor* mid) { | |
| 1606 if (mid->owner() == THREAD) { | |
| 1607 (void)mid->complete_exit(CHECK); | |
| 0 | 1608 } |
| 1609 } | |
| 1878 | 1610 }; |
| 0 | 1611 |
| 1878 | 1612 // Release all inflated monitors owned by THREAD. Lightweight monitors are |
| 1613 // ignored. This is meant to be called during JNI thread detach which assumes | |
| 1614 // all remaining monitors are heavyweight. All exceptions are swallowed. | |
| 1615 // Scanning the extant monitor list can be time consuming. | |
| 1616 // A simple optimization is to add a per-thread flag that indicates a thread | |
| 1617 // called jni_monitorenter() during its lifetime. | |
| 0 | 1618 // |
| 1878 | 1619 // Instead of No_Savepoint_Verifier it might be cheaper to |
| 1620 // use an idiom of the form: | |
| 1621 // auto int tmp = SafepointSynchronize::_safepoint_counter ; | |
| 1622 // <code that must not run at safepoint> | |
| 1623 // guarantee (((tmp ^ _safepoint_counter) | (tmp & 1)) == 0) ; | |
| 1624 // Since the tests are extremely cheap we could leave them enabled | |
| 1625 // for normal product builds. | |
| 0 | 1626 |
| 1878 | 1627 void ObjectSynchronizer::release_monitors_owned_by_thread(TRAPS) { |
| 1628 assert(THREAD == JavaThread::current(), "must be current Java thread"); | |
| 1629 No_Safepoint_Verifier nsv ; | |
| 1630 ReleaseJavaMonitorsClosure rjmc(THREAD); | |
| 1631 Thread::muxAcquire(&ListLock, "release_monitors_owned_by_thread"); | |
| 1632 ObjectSynchronizer::monitors_iterate(&rjmc); | |
| 1633 Thread::muxRelease(&ListLock); | |
| 1634 THREAD->clear_pending_exception(); | |
| 0 | 1635 } |
| 1636 | |
| 1637 //------------------------------------------------------------------------------ | |
| 1638 // Non-product code | |
| 1639 | |
| 1640 #ifndef PRODUCT | |
| 1641 | |
| 1642 void ObjectSynchronizer::trace_locking(Handle locking_obj, bool is_compiled, | |
| 1643 bool is_method, bool is_locking) { | |
| 1644 // Don't know what to do here | |
| 1645 } | |
| 1646 | |
| 1647 // Verify all monitors in the monitor cache, the verification is weak. | |
| 1648 void ObjectSynchronizer::verify() { | |
| 1649 ObjectMonitor* block = gBlockList; | |
| 1650 ObjectMonitor* mid; | |
| 1651 while (block) { | |
| 1652 assert(block->object() == CHAINMARKER, "must be a block header"); | |
| 1653 for (int i = 1; i < _BLOCKSIZE; i++) { | |
| 1654 mid = block + i; | |
| 1655 oop object = (oop) mid->object(); | |
| 1656 if (object != NULL) { | |
| 1657 mid->verify(); | |
| 1658 } | |
| 1659 } | |
| 1660 block = (ObjectMonitor*) block->FreeNext; | |
| 1661 } | |
| 1662 } | |
| 1663 | |
| 1664 // Check if monitor belongs to the monitor cache | |
| 1665 // The list is grow-only so it's *relatively* safe to traverse | |
| 1666 // the list of extant blocks without taking a lock. | |
| 1667 | |
| 1668 int ObjectSynchronizer::verify_objmon_isinpool(ObjectMonitor *monitor) { | |
| 1669 ObjectMonitor* block = gBlockList; | |
| 1670 | |
| 1671 while (block) { | |
| 1672 assert(block->object() == CHAINMARKER, "must be a block header"); | |
| 1673 if (monitor > &block[0] && monitor < &block[_BLOCKSIZE]) { | |
| 1674 address mon = (address) monitor; | |
| 1675 address blk = (address) block; | |
| 1676 size_t diff = mon - blk; | |
| 1677 assert((diff % sizeof(ObjectMonitor)) == 0, "check"); | |
| 1678 return 1; | |
| 1679 } | |
| 1680 block = (ObjectMonitor*) block->FreeNext; | |
| 1681 } | |
| 1682 return 0; | |
| 1683 } | |
| 1684 | |
| 1685 #endif |