Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/vm_operations.cpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
| author | johnc |
|---|---|
| date | Thu, 22 Sep 2011 10:57:37 -0700 |
| parents | 1d1603768966 |
| children | f08d439fab8c |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2177
diff
changeset
|
2 * Copyright (c) 1997, 2011, 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:
1202
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1202
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:
1202
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
26 #include "classfile/symbolTable.hpp" |
| 1972 | 27 #include "classfile/vmSymbols.hpp" |
| 28 #include "compiler/compileBroker.hpp" | |
| 29 #include "compiler/compilerOracle.hpp" | |
| 30 #include "gc_implementation/shared/isGCActiveMark.hpp" | |
| 31 #include "memory/resourceArea.hpp" | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
32 #include "oops/symbol.hpp" |
| 1972 | 33 #include "runtime/arguments.hpp" |
| 34 #include "runtime/deoptimization.hpp" | |
| 35 #include "runtime/interfaceSupport.hpp" | |
| 36 #include "runtime/sweeper.hpp" | |
| 37 #include "runtime/vm_operations.hpp" | |
| 38 #include "services/threadService.hpp" | |
| 39 #ifdef TARGET_OS_FAMILY_linux | |
| 40 # include "thread_linux.inline.hpp" | |
| 41 #endif | |
| 42 #ifdef TARGET_OS_FAMILY_solaris | |
| 43 # include "thread_solaris.inline.hpp" | |
| 44 #endif | |
| 45 #ifdef TARGET_OS_FAMILY_windows | |
| 46 # include "thread_windows.inline.hpp" | |
| 47 #endif | |
| 0 | 48 |
| 49 #define VM_OP_NAME_INITIALIZE(name) #name, | |
| 50 | |
| 51 const char* VM_Operation::_names[VM_Operation::VMOp_Terminating] = \ | |
| 52 { VM_OPS_DO(VM_OP_NAME_INITIALIZE) }; | |
| 53 | |
| 54 void VM_Operation::set_calling_thread(Thread* thread, ThreadPriority priority) { | |
| 55 _calling_thread = thread; | |
| 56 assert(MinPriority <= priority && priority <= MaxPriority, "sanity check"); | |
| 57 _priority = priority; | |
| 58 } | |
| 59 | |
| 60 | |
| 61 void VM_Operation::evaluate() { | |
| 62 ResourceMark rm; | |
| 63 if (TraceVMOperation) { | |
| 64 tty->print("["); | |
| 65 NOT_PRODUCT(print();) | |
| 66 } | |
| 67 doit(); | |
| 68 if (TraceVMOperation) { | |
| 69 tty->print_cr("]"); | |
| 70 } | |
| 71 } | |
| 72 | |
| 73 // Called by fatal error handler. | |
| 74 void VM_Operation::print_on_error(outputStream* st) const { | |
| 75 st->print("VM_Operation (" PTR_FORMAT "): ", this); | |
| 76 st->print("%s", name()); | |
| 77 | |
| 78 const char* mode; | |
| 79 switch(evaluation_mode()) { | |
| 80 case _safepoint : mode = "safepoint"; break; | |
| 81 case _no_safepoint : mode = "no safepoint"; break; | |
| 82 case _concurrent : mode = "concurrent"; break; | |
| 83 case _async_safepoint: mode = "async safepoint"; break; | |
| 84 default : mode = "unknown"; break; | |
| 85 } | |
| 86 st->print(", mode: %s", mode); | |
| 87 | |
| 88 if (calling_thread()) { | |
| 89 st->print(", requested by thread " PTR_FORMAT, calling_thread()); | |
| 90 } | |
| 91 } | |
| 92 | |
| 93 void VM_ThreadStop::doit() { | |
| 94 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); | |
| 95 JavaThread* target = java_lang_Thread::thread(target_thread()); | |
| 96 // Note that this now allows multiple ThreadDeath exceptions to be | |
| 97 // thrown at a thread. | |
| 98 if (target != NULL) { | |
| 99 // the thread has run and is not already in the process of exiting | |
| 100 target->send_thread_stop(throwable()); | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 void VM_Deoptimize::doit() { | |
| 105 // We do not want any GCs to happen while we are in the middle of this VM operation | |
| 106 ResourceMark rm; | |
| 107 DeoptimizationMarker dm; | |
| 108 | |
| 109 // Deoptimize all activations depending on marked nmethods | |
| 110 Deoptimization::deoptimize_dependents(); | |
| 111 | |
| 112 // Make the dependent methods zombies | |
| 113 CodeCache::make_marked_nmethods_zombies(); | |
| 114 } | |
| 115 | |
| 116 | |
| 117 VM_DeoptimizeFrame::VM_DeoptimizeFrame(JavaThread* thread, intptr_t* id) { | |
| 118 _thread = thread; | |
| 119 _id = id; | |
| 120 } | |
| 121 | |
| 122 | |
| 123 void VM_DeoptimizeFrame::doit() { | |
|
1905
ce6848d0666d
6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents:
1552
diff
changeset
|
124 Deoptimization::deoptimize_frame_internal(_thread, _id); |
| 0 | 125 } |
| 126 | |
| 127 | |
| 128 #ifndef PRODUCT | |
| 129 | |
| 130 void VM_DeoptimizeAll::doit() { | |
| 131 DeoptimizationMarker dm; | |
| 132 // deoptimize all java threads in the system | |
| 133 if (DeoptimizeALot) { | |
| 134 for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) { | |
| 135 if (thread->has_last_Java_frame()) { | |
| 136 thread->deoptimize(); | |
| 137 } | |
| 138 } | |
| 139 } else if (DeoptimizeRandom) { | |
| 140 | |
| 141 // Deoptimize some selected threads and frames | |
| 142 int tnum = os::random() & 0x3; | |
| 143 int fnum = os::random() & 0x3; | |
| 144 int tcount = 0; | |
| 145 for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) { | |
| 146 if (thread->has_last_Java_frame()) { | |
| 147 if (tcount++ == tnum) { | |
| 148 tcount = 0; | |
| 149 int fcount = 0; | |
| 150 // Deoptimize some selected frames. | |
| 151 // Biased llocking wants a updated register map | |
| 152 for(StackFrameStream fst(thread, UseBiasedLocking); !fst.is_done(); fst.next()) { | |
| 153 if (fst.current()->can_be_deoptimized()) { | |
| 154 if (fcount++ == fnum) { | |
| 155 fcount = 0; | |
| 156 Deoptimization::deoptimize(thread, *fst.current(), fst.register_map()); | |
| 157 } | |
| 158 } | |
| 159 } | |
| 160 } | |
| 161 } | |
| 162 } | |
| 163 } | |
| 164 } | |
| 165 | |
| 166 | |
| 167 void VM_ZombieAll::doit() { | |
| 168 JavaThread *thread = (JavaThread *)calling_thread(); | |
| 169 assert(thread->is_Java_thread(), "must be a Java thread"); | |
| 170 thread->make_zombies(); | |
| 171 } | |
| 172 | |
| 173 #endif // !PRODUCT | |
| 174 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
175 void VM_UnlinkSymbols::doit() { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
176 JavaThread *thread = (JavaThread *)calling_thread(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
177 assert(thread->is_Java_thread(), "must be a Java thread"); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
178 SymbolTable::unlink(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
179 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
180 |
| 1202 | 181 void VM_HandleFullCodeCache::doit() { |
| 182 NMethodSweeper::speculative_disconnect_nmethods(_is_full); | |
| 183 } | |
| 184 | |
| 0 | 185 void VM_Verify::doit() { |
| 186 Universe::verify(); | |
| 187 } | |
| 188 | |
| 189 bool VM_PrintThreads::doit_prologue() { | |
| 190 assert(Thread::current()->is_Java_thread(), "just checking"); | |
| 191 | |
| 192 // Make sure AbstractOwnableSynchronizer is loaded | |
| 193 if (JDK_Version::is_gte_jdk16x_version()) { | |
| 194 java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current()); | |
| 195 } | |
| 196 | |
| 197 // Get Heap_lock if concurrent locks will be dumped | |
| 198 if (_print_concurrent_locks) { | |
| 199 Heap_lock->lock(); | |
| 200 } | |
| 201 return true; | |
| 202 } | |
| 203 | |
| 204 void VM_PrintThreads::doit() { | |
| 205 Threads::print_on(_out, true, false, _print_concurrent_locks); | |
| 206 } | |
| 207 | |
| 208 void VM_PrintThreads::doit_epilogue() { | |
| 209 if (_print_concurrent_locks) { | |
| 210 // Release Heap_lock | |
| 211 Heap_lock->unlock(); | |
| 212 } | |
| 213 } | |
| 214 | |
| 215 void VM_PrintJNI::doit() { | |
| 216 JNIHandles::print_on(_out); | |
| 217 } | |
| 218 | |
| 219 VM_FindDeadlocks::~VM_FindDeadlocks() { | |
| 220 if (_deadlocks != NULL) { | |
| 221 DeadlockCycle* cycle = _deadlocks; | |
| 222 while (cycle != NULL) { | |
| 223 DeadlockCycle* d = cycle; | |
| 224 cycle = cycle->next(); | |
| 225 delete d; | |
| 226 } | |
| 227 } | |
| 228 } | |
| 229 | |
| 230 bool VM_FindDeadlocks::doit_prologue() { | |
| 231 assert(Thread::current()->is_Java_thread(), "just checking"); | |
| 232 | |
| 233 // Load AbstractOwnableSynchronizer class | |
| 234 if (_concurrent_locks && JDK_Version::is_gte_jdk16x_version()) { | |
| 235 java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current()); | |
| 236 } | |
| 237 | |
| 238 return true; | |
| 239 } | |
| 240 | |
| 241 void VM_FindDeadlocks::doit() { | |
| 242 _deadlocks = ThreadService::find_deadlocks_at_safepoint(_concurrent_locks); | |
| 243 if (_out != NULL) { | |
| 244 int num_deadlocks = 0; | |
| 245 for (DeadlockCycle* cycle = _deadlocks; cycle != NULL; cycle = cycle->next()) { | |
| 246 num_deadlocks++; | |
| 247 cycle->print_on(_out); | |
| 248 } | |
| 249 | |
| 250 if (num_deadlocks == 1) { | |
| 251 _out->print_cr("\nFound 1 deadlock.\n"); | |
| 252 _out->flush(); | |
| 253 } else if (num_deadlocks > 1) { | |
| 254 _out->print_cr("\nFound %d deadlocks.\n", num_deadlocks); | |
| 255 _out->flush(); | |
| 256 } | |
| 257 } | |
| 258 } | |
| 259 | |
| 260 VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result, | |
| 261 int max_depth, | |
| 262 bool with_locked_monitors, | |
| 263 bool with_locked_synchronizers) { | |
| 264 _result = result; | |
| 265 _num_threads = 0; // 0 indicates all threads | |
| 266 _threads = NULL; | |
| 267 _result = result; | |
| 268 _max_depth = max_depth; | |
| 269 _with_locked_monitors = with_locked_monitors; | |
| 270 _with_locked_synchronizers = with_locked_synchronizers; | |
| 271 } | |
| 272 | |
| 273 VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result, | |
| 274 GrowableArray<instanceHandle>* threads, | |
| 275 int num_threads, | |
| 276 int max_depth, | |
| 277 bool with_locked_monitors, | |
| 278 bool with_locked_synchronizers) { | |
| 279 _result = result; | |
| 280 _num_threads = num_threads; | |
| 281 _threads = threads; | |
| 282 _result = result; | |
| 283 _max_depth = max_depth; | |
| 284 _with_locked_monitors = with_locked_monitors; | |
| 285 _with_locked_synchronizers = with_locked_synchronizers; | |
| 286 } | |
| 287 | |
| 288 bool VM_ThreadDump::doit_prologue() { | |
| 289 assert(Thread::current()->is_Java_thread(), "just checking"); | |
| 290 | |
| 291 // Load AbstractOwnableSynchronizer class before taking thread snapshots | |
| 292 if (JDK_Version::is_gte_jdk16x_version()) { | |
| 293 java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current()); | |
| 294 } | |
| 295 | |
| 296 if (_with_locked_synchronizers) { | |
| 297 // Acquire Heap_lock to dump concurrent locks | |
| 298 Heap_lock->lock(); | |
| 299 } | |
| 300 | |
| 301 return true; | |
| 302 } | |
| 303 | |
| 304 void VM_ThreadDump::doit_epilogue() { | |
| 305 if (_with_locked_synchronizers) { | |
| 306 // Release Heap_lock | |
| 307 Heap_lock->unlock(); | |
| 308 } | |
| 309 } | |
| 310 | |
| 311 void VM_ThreadDump::doit() { | |
| 312 ResourceMark rm; | |
| 313 | |
| 314 ConcurrentLocksDump concurrent_locks(true); | |
| 315 if (_with_locked_synchronizers) { | |
| 316 concurrent_locks.dump_at_safepoint(); | |
| 317 } | |
| 318 | |
| 319 if (_num_threads == 0) { | |
| 320 // Snapshot all live threads | |
| 321 for (JavaThread* jt = Threads::first(); jt != NULL; jt = jt->next()) { | |
| 322 if (jt->is_exiting() || | |
| 323 jt->is_hidden_from_external_view()) { | |
| 324 // skip terminating threads and hidden threads | |
| 325 continue; | |
| 326 } | |
| 327 ThreadConcurrentLocks* tcl = NULL; | |
| 328 if (_with_locked_synchronizers) { | |
| 329 tcl = concurrent_locks.thread_concurrent_locks(jt); | |
| 330 } | |
| 331 ThreadSnapshot* ts = snapshot_thread(jt, tcl); | |
| 332 _result->add_thread_snapshot(ts); | |
| 333 } | |
| 334 } else { | |
| 335 // Snapshot threads in the given _threads array | |
| 336 // A dummy snapshot is created if a thread doesn't exist | |
| 337 for (int i = 0; i < _num_threads; i++) { | |
| 338 instanceHandle th = _threads->at(i); | |
| 339 if (th() == NULL) { | |
| 340 // skip if the thread doesn't exist | |
| 341 // Add a dummy snapshot | |
| 342 _result->add_thread_snapshot(new ThreadSnapshot()); | |
| 343 continue; | |
| 344 } | |
| 345 | |
| 346 // Dump thread stack only if the thread is alive and not exiting | |
| 347 // and not VM internal thread. | |
| 348 JavaThread* jt = java_lang_Thread::thread(th()); | |
| 349 if (jt == NULL || /* thread not alive */ | |
| 350 jt->is_exiting() || | |
| 351 jt->is_hidden_from_external_view()) { | |
| 352 // add a NULL snapshot if skipped | |
| 353 _result->add_thread_snapshot(new ThreadSnapshot()); | |
| 354 continue; | |
| 355 } | |
| 356 ThreadConcurrentLocks* tcl = NULL; | |
| 357 if (_with_locked_synchronizers) { | |
| 358 tcl = concurrent_locks.thread_concurrent_locks(jt); | |
| 359 } | |
| 360 ThreadSnapshot* ts = snapshot_thread(jt, tcl); | |
| 361 _result->add_thread_snapshot(ts); | |
| 362 } | |
| 363 } | |
| 364 } | |
| 365 | |
| 366 ThreadSnapshot* VM_ThreadDump::snapshot_thread(JavaThread* java_thread, ThreadConcurrentLocks* tcl) { | |
| 367 ThreadSnapshot* snapshot = new ThreadSnapshot(java_thread); | |
| 368 snapshot->dump_stack_at_safepoint(_max_depth, _with_locked_monitors); | |
| 369 snapshot->set_concurrent_locks(tcl); | |
| 370 return snapshot; | |
| 371 } | |
| 372 | |
| 373 volatile bool VM_Exit::_vm_exited = false; | |
| 374 Thread * VM_Exit::_shutdown_thread = NULL; | |
| 375 | |
| 376 int VM_Exit::set_vm_exited() { | |
| 377 Thread * thr_cur = ThreadLocalStorage::get_thread_slow(); | |
| 378 | |
| 379 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint already"); | |
| 380 | |
| 381 int num_active = 0; | |
| 382 | |
| 383 _shutdown_thread = thr_cur; | |
| 384 _vm_exited = true; // global flag | |
| 385 for(JavaThread *thr = Threads::first(); thr != NULL; thr = thr->next()) | |
| 386 if (thr!=thr_cur && thr->thread_state() == _thread_in_native) { | |
| 387 ++num_active; | |
| 388 thr->set_terminated(JavaThread::_vm_exited); // per-thread flag | |
| 389 } | |
| 390 | |
| 391 return num_active; | |
| 392 } | |
| 393 | |
| 394 int VM_Exit::wait_for_threads_in_native_to_block() { | |
| 395 // VM exits at safepoint. This function must be called at the final safepoint | |
| 396 // to wait for threads in _thread_in_native state to be quiescent. | |
| 397 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint already"); | |
| 398 | |
| 399 Thread * thr_cur = ThreadLocalStorage::get_thread_slow(); | |
| 400 Monitor timer(Mutex::leaf, "VM_Exit timer", true); | |
| 401 | |
| 402 // Compiler threads need longer wait because they can access VM data directly | |
| 403 // while in native. If they are active and some structures being used are | |
| 404 // deleted by the shutdown sequence, they will crash. On the other hand, user | |
| 405 // threads must go through native=>Java/VM transitions first to access VM | |
| 406 // data, and they will be stopped during state transition. In theory, we | |
| 407 // don't have to wait for user threads to be quiescent, but it's always | |
| 408 // better to terminate VM when current thread is the only active thread, so | |
| 409 // wait for user threads too. Numbers are in 10 milliseconds. | |
| 410 int max_wait_user_thread = 30; // at least 300 milliseconds | |
| 411 int max_wait_compiler_thread = 1000; // at least 10 seconds | |
| 412 | |
| 413 int max_wait = max_wait_compiler_thread; | |
| 414 | |
| 415 int attempts = 0; | |
| 416 while (true) { | |
| 417 int num_active = 0; | |
| 418 int num_active_compiler_thread = 0; | |
| 419 | |
| 420 for(JavaThread *thr = Threads::first(); thr != NULL; thr = thr->next()) { | |
| 421 if (thr!=thr_cur && thr->thread_state() == _thread_in_native) { | |
| 422 num_active++; | |
| 423 if (thr->is_Compiler_thread()) { | |
| 424 num_active_compiler_thread++; | |
| 425 } | |
| 426 } | |
| 427 } | |
| 428 | |
| 429 if (num_active == 0) { | |
| 430 return 0; | |
| 431 } else if (attempts > max_wait) { | |
| 432 return num_active; | |
| 433 } else if (num_active_compiler_thread == 0 && attempts > max_wait_user_thread) { | |
| 434 return num_active; | |
| 435 } | |
| 436 | |
| 437 attempts++; | |
| 438 | |
| 439 MutexLockerEx ml(&timer, Mutex::_no_safepoint_check_flag); | |
| 440 timer.wait(Mutex::_no_safepoint_check_flag, 10); | |
| 441 } | |
| 442 } | |
| 443 | |
| 444 void VM_Exit::doit() { | |
| 445 CompileBroker::set_should_block(); | |
| 446 | |
| 447 // Wait for a short period for threads in native to block. Any thread | |
| 448 // still executing native code after the wait will be stopped at | |
| 449 // native==>Java/VM barriers. | |
| 450 // Among 16276 JCK tests, 94% of them come here without any threads still | |
| 451 // running in native; the other 6% are quiescent within 250ms (Ultra 80). | |
| 452 wait_for_threads_in_native_to_block(); | |
| 453 | |
| 454 set_vm_exited(); | |
| 455 | |
| 456 // cleanup globals resources before exiting. exit_globals() currently | |
| 457 // cleans up outputStream resources and PerfMemory resources. | |
| 458 exit_globals(); | |
| 459 | |
| 460 // Check for exit hook | |
| 461 exit_hook_t exit_hook = Arguments::exit_hook(); | |
| 462 if (exit_hook != NULL) { | |
| 463 // exit hook should exit. | |
| 464 exit_hook(_exit_code); | |
| 465 // ... but if it didn't, we must do it here | |
| 466 vm_direct_exit(_exit_code); | |
| 467 } else { | |
| 468 vm_direct_exit(_exit_code); | |
| 469 } | |
| 470 } | |
| 471 | |
| 472 | |
| 473 void VM_Exit::wait_if_vm_exited() { | |
| 474 if (_vm_exited && | |
| 475 ThreadLocalStorage::get_thread_slow() != _shutdown_thread) { | |
| 476 // _vm_exited is set at safepoint, and the Threads_lock is never released | |
| 477 // we will block here until the process dies | |
| 478 Threads_lock->lock_without_safepoint_check(); | |
| 479 ShouldNotReachHere(); | |
| 480 } | |
| 481 } |