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