annotate src/share/vm/runtime/vm_operations.cpp @ 2796:f08d439fab8c

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