Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/thread.cpp @ 452:00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery.
Reviewed-by: apetrusenko, jcoomes
| author | ysr |
|---|---|
| date | Thu, 20 Nov 2008 12:27:41 -0800 |
| parents | da9cb4e97a5f |
| children | eca19a8425b5 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 1997-2008 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 # include "incls/_precompiled.incl" | |
| 26 # include "incls/_thread.cpp.incl" | |
| 27 | |
| 28 #ifdef DTRACE_ENABLED | |
| 29 | |
| 30 // Only bother with this argument setup if dtrace is available | |
| 31 | |
| 32 HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin); | |
| 33 HS_DTRACE_PROBE_DECL(hotspot, vm__init__end); | |
| 34 HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t, | |
| 35 intptr_t, intptr_t, bool); | |
| 36 HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t, | |
| 37 intptr_t, intptr_t, bool); | |
| 38 | |
| 39 #define DTRACE_THREAD_PROBE(probe, javathread) \ | |
| 40 { \ | |
| 41 ResourceMark rm(this); \ | |
| 42 int len = 0; \ | |
| 43 const char* name = (javathread)->get_thread_name(); \ | |
| 44 len = strlen(name); \ | |
| 45 HS_DTRACE_PROBE5(hotspot, thread__##probe, \ | |
| 46 name, len, \ | |
| 47 java_lang_Thread::thread_id((javathread)->threadObj()), \ | |
| 48 (javathread)->osthread()->thread_id(), \ | |
| 49 java_lang_Thread::is_daemon((javathread)->threadObj())); \ | |
| 50 } | |
| 51 | |
| 52 #else // ndef DTRACE_ENABLED | |
| 53 | |
| 54 #define DTRACE_THREAD_PROBE(probe, javathread) | |
| 55 | |
| 56 #endif // ndef DTRACE_ENABLED | |
| 57 | |
| 58 // Class hierarchy | |
| 59 // - Thread | |
| 60 // - VMThread | |
| 61 // - WatcherThread | |
| 62 // - ConcurrentMarkSweepThread | |
| 63 // - JavaThread | |
| 64 // - CompilerThread | |
| 65 | |
| 66 // ======= Thread ======== | |
| 67 | |
| 68 // Support for forcing alignment of thread objects for biased locking | |
| 69 void* Thread::operator new(size_t size) { | |
| 70 if (UseBiasedLocking) { | |
| 71 const int alignment = markOopDesc::biased_lock_alignment; | |
| 72 size_t aligned_size = size + (alignment - sizeof(intptr_t)); | |
| 73 void* real_malloc_addr = CHeapObj::operator new(aligned_size); | |
| 74 void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment); | |
| 75 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <= | |
| 76 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size), | |
| 77 "JavaThread alignment code overflowed allocated storage"); | |
| 78 if (TraceBiasedLocking) { | |
| 79 if (aligned_addr != real_malloc_addr) | |
| 80 tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT, | |
| 81 real_malloc_addr, aligned_addr); | |
| 82 } | |
| 83 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr; | |
| 84 return aligned_addr; | |
| 85 } else { | |
| 86 return CHeapObj::operator new(size); | |
| 87 } | |
| 88 } | |
| 89 | |
| 90 void Thread::operator delete(void* p) { | |
| 91 if (UseBiasedLocking) { | |
| 92 void* real_malloc_addr = ((Thread*) p)->_real_malloc_address; | |
| 93 CHeapObj::operator delete(real_malloc_addr); | |
| 94 } else { | |
| 95 CHeapObj::operator delete(p); | |
| 96 } | |
| 97 } | |
| 98 | |
| 99 | |
| 100 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread, | |
| 101 // JavaThread | |
| 102 | |
| 103 | |
| 104 Thread::Thread() { | |
| 105 // stack | |
| 106 _stack_base = NULL; | |
| 107 _stack_size = 0; | |
| 108 _self_raw_id = 0; | |
| 109 _lgrp_id = -1; | |
| 110 _osthread = NULL; | |
| 111 | |
| 112 // allocated data structures | |
| 113 set_resource_area(new ResourceArea()); | |
| 114 set_handle_area(new HandleArea(NULL)); | |
| 115 set_active_handles(NULL); | |
| 116 set_free_handle_block(NULL); | |
| 117 set_last_handle_mark(NULL); | |
| 118 set_osthread(NULL); | |
| 119 | |
| 120 // This initial value ==> never claimed. | |
| 121 _oops_do_parity = 0; | |
| 122 | |
| 123 // the handle mark links itself to last_handle_mark | |
| 124 new HandleMark(this); | |
| 125 | |
| 126 // plain initialization | |
| 127 debug_only(_owned_locks = NULL;) | |
| 128 debug_only(_allow_allocation_count = 0;) | |
| 129 NOT_PRODUCT(_allow_safepoint_count = 0;) | |
| 130 CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;) | |
| 131 _highest_lock = NULL; | |
| 132 _jvmti_env_iteration_count = 0; | |
| 133 _vm_operation_started_count = 0; | |
| 134 _vm_operation_completed_count = 0; | |
| 135 _current_pending_monitor = NULL; | |
| 136 _current_pending_monitor_is_from_java = true; | |
| 137 _current_waiting_monitor = NULL; | |
| 138 _num_nested_signal = 0; | |
| 139 omFreeList = NULL ; | |
| 140 omFreeCount = 0 ; | |
| 141 omFreeProvision = 32 ; | |
| 142 | |
| 143 _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true); | |
| 144 _suspend_flags = 0; | |
| 145 | |
| 146 // thread-specific hashCode stream generator state - Marsaglia shift-xor form | |
| 147 _hashStateX = os::random() ; | |
| 148 _hashStateY = 842502087 ; | |
| 149 _hashStateZ = 0x8767 ; // (int)(3579807591LL & 0xffff) ; | |
| 150 _hashStateW = 273326509 ; | |
| 151 | |
| 152 _OnTrap = 0 ; | |
| 153 _schedctl = NULL ; | |
| 154 _Stalled = 0 ; | |
| 155 _TypeTag = 0x2BAD ; | |
| 156 | |
| 157 // Many of the following fields are effectively final - immutable | |
| 158 // Note that nascent threads can't use the Native Monitor-Mutex | |
| 159 // construct until the _MutexEvent is initialized ... | |
| 160 // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents | |
| 161 // we might instead use a stack of ParkEvents that we could provision on-demand. | |
| 162 // The stack would act as a cache to avoid calls to ParkEvent::Allocate() | |
| 163 // and ::Release() | |
| 164 _ParkEvent = ParkEvent::Allocate (this) ; | |
| 165 _SleepEvent = ParkEvent::Allocate (this) ; | |
| 166 _MutexEvent = ParkEvent::Allocate (this) ; | |
| 167 _MuxEvent = ParkEvent::Allocate (this) ; | |
| 168 | |
| 169 #ifdef CHECK_UNHANDLED_OOPS | |
| 170 if (CheckUnhandledOops) { | |
| 171 _unhandled_oops = new UnhandledOops(this); | |
| 172 } | |
| 173 #endif // CHECK_UNHANDLED_OOPS | |
| 174 #ifdef ASSERT | |
| 175 if (UseBiasedLocking) { | |
| 176 assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed"); | |
| 177 assert(this == _real_malloc_address || | |
| 178 this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment), | |
| 179 "bug in forced alignment of thread objects"); | |
| 180 } | |
| 181 #endif /* ASSERT */ | |
| 182 } | |
| 183 | |
| 184 void Thread::initialize_thread_local_storage() { | |
| 185 // Note: Make sure this method only calls | |
| 186 // non-blocking operations. Otherwise, it might not work | |
| 187 // with the thread-startup/safepoint interaction. | |
| 188 | |
| 189 // During Java thread startup, safepoint code should allow this | |
| 190 // method to complete because it may need to allocate memory to | |
| 191 // store information for the new thread. | |
| 192 | |
| 193 // initialize structure dependent on thread local storage | |
| 194 ThreadLocalStorage::set_thread(this); | |
| 195 | |
| 196 // set up any platform-specific state. | |
| 197 os::initialize_thread(); | |
| 198 | |
| 199 } | |
| 200 | |
| 201 void Thread::record_stack_base_and_size() { | |
| 202 set_stack_base(os::current_stack_base()); | |
| 203 set_stack_size(os::current_stack_size()); | |
| 204 } | |
| 205 | |
| 206 | |
| 207 Thread::~Thread() { | |
| 208 // Reclaim the objectmonitors from the omFreeList of the moribund thread. | |
| 209 ObjectSynchronizer::omFlush (this) ; | |
| 210 | |
| 211 // deallocate data structures | |
| 212 delete resource_area(); | |
| 213 // since the handle marks are using the handle area, we have to deallocated the root | |
| 214 // handle mark before deallocating the thread's handle area, | |
| 215 assert(last_handle_mark() != NULL, "check we have an element"); | |
| 216 delete last_handle_mark(); | |
| 217 assert(last_handle_mark() == NULL, "check we have reached the end"); | |
| 218 | |
| 219 // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads. | |
| 220 // We NULL out the fields for good hygiene. | |
| 221 ParkEvent::Release (_ParkEvent) ; _ParkEvent = NULL ; | |
| 222 ParkEvent::Release (_SleepEvent) ; _SleepEvent = NULL ; | |
| 223 ParkEvent::Release (_MutexEvent) ; _MutexEvent = NULL ; | |
| 224 ParkEvent::Release (_MuxEvent) ; _MuxEvent = NULL ; | |
| 225 | |
| 226 delete handle_area(); | |
| 227 | |
| 228 // osthread() can be NULL, if creation of thread failed. | |
| 229 if (osthread() != NULL) os::free_thread(osthread()); | |
| 230 | |
| 231 delete _SR_lock; | |
| 232 | |
| 233 // clear thread local storage if the Thread is deleting itself | |
| 234 if (this == Thread::current()) { | |
| 235 ThreadLocalStorage::set_thread(NULL); | |
| 236 } else { | |
| 237 // In the case where we're not the current thread, invalidate all the | |
| 238 // caches in case some code tries to get the current thread or the | |
| 239 // thread that was destroyed, and gets stale information. | |
| 240 ThreadLocalStorage::invalidate_all(); | |
| 241 } | |
| 242 CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();) | |
| 243 } | |
| 244 | |
| 245 // NOTE: dummy function for assertion purpose. | |
| 246 void Thread::run() { | |
| 247 ShouldNotReachHere(); | |
| 248 } | |
| 249 | |
| 250 #ifdef ASSERT | |
| 251 // Private method to check for dangling thread pointer | |
| 252 void check_for_dangling_thread_pointer(Thread *thread) { | |
| 253 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), | |
| 254 "possibility of dangling Thread pointer"); | |
| 255 } | |
| 256 #endif | |
| 257 | |
| 258 | |
| 259 #ifndef PRODUCT | |
| 260 // Tracing method for basic thread operations | |
| 261 void Thread::trace(const char* msg, const Thread* const thread) { | |
| 262 if (!TraceThreadEvents) return; | |
| 263 ResourceMark rm; | |
| 264 ThreadCritical tc; | |
| 265 const char *name = "non-Java thread"; | |
| 266 int prio = -1; | |
| 267 if (thread->is_Java_thread() | |
| 268 && !thread->is_Compiler_thread()) { | |
| 269 // The Threads_lock must be held to get information about | |
| 270 // this thread but may not be in some situations when | |
| 271 // tracing thread events. | |
| 272 bool release_Threads_lock = false; | |
| 273 if (!Threads_lock->owned_by_self()) { | |
| 274 Threads_lock->lock(); | |
| 275 release_Threads_lock = true; | |
| 276 } | |
| 277 JavaThread* jt = (JavaThread *)thread; | |
| 278 name = (char *)jt->get_thread_name(); | |
| 279 oop thread_oop = jt->threadObj(); | |
| 280 if (thread_oop != NULL) { | |
| 281 prio = java_lang_Thread::priority(thread_oop); | |
| 282 } | |
| 283 if (release_Threads_lock) { | |
| 284 Threads_lock->unlock(); | |
| 285 } | |
| 286 } | |
| 287 tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio); | |
| 288 } | |
| 289 #endif | |
| 290 | |
| 291 | |
| 292 ThreadPriority Thread::get_priority(const Thread* const thread) { | |
| 293 trace("get priority", thread); | |
| 294 ThreadPriority priority; | |
| 295 // Can return an error! | |
| 296 (void)os::get_priority(thread, priority); | |
| 297 assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found"); | |
| 298 return priority; | |
| 299 } | |
| 300 | |
| 301 void Thread::set_priority(Thread* thread, ThreadPriority priority) { | |
| 302 trace("set priority", thread); | |
| 303 debug_only(check_for_dangling_thread_pointer(thread);) | |
| 304 // Can return an error! | |
| 305 (void)os::set_priority(thread, priority); | |
| 306 } | |
| 307 | |
| 308 | |
| 309 void Thread::start(Thread* thread) { | |
| 310 trace("start", thread); | |
| 311 // Start is different from resume in that its safety is guaranteed by context or | |
| 312 // being called from a Java method synchronized on the Thread object. | |
| 313 if (!DisableStartThread) { | |
| 314 if (thread->is_Java_thread()) { | |
| 315 // Initialize the thread state to RUNNABLE before starting this thread. | |
| 316 // Can not set it after the thread started because we do not know the | |
| 317 // exact thread state at that time. It could be in MONITOR_WAIT or | |
| 318 // in SLEEPING or some other state. | |
| 319 java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(), | |
| 320 java_lang_Thread::RUNNABLE); | |
| 321 } | |
| 322 os::start_thread(thread); | |
| 323 } | |
| 324 } | |
| 325 | |
| 326 // Enqueue a VM_Operation to do the job for us - sometime later | |
| 327 void Thread::send_async_exception(oop java_thread, oop java_throwable) { | |
| 328 VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable); | |
| 329 VMThread::execute(vm_stop); | |
| 330 } | |
| 331 | |
| 332 | |
| 333 // | |
| 334 // Check if an external suspend request has completed (or has been | |
| 335 // cancelled). Returns true if the thread is externally suspended and | |
| 336 // false otherwise. | |
| 337 // | |
| 338 // The bits parameter returns information about the code path through | |
| 339 // the routine. Useful for debugging: | |
| 340 // | |
| 341 // set in is_ext_suspend_completed(): | |
| 342 // 0x00000001 - routine was entered | |
| 343 // 0x00000010 - routine return false at end | |
| 344 // 0x00000100 - thread exited (return false) | |
| 345 // 0x00000200 - suspend request cancelled (return false) | |
| 346 // 0x00000400 - thread suspended (return true) | |
| 347 // 0x00001000 - thread is in a suspend equivalent state (return true) | |
| 348 // 0x00002000 - thread is native and walkable (return true) | |
| 349 // 0x00004000 - thread is native_trans and walkable (needed retry) | |
| 350 // | |
| 351 // set in wait_for_ext_suspend_completion(): | |
| 352 // 0x00010000 - routine was entered | |
| 353 // 0x00020000 - suspend request cancelled before loop (return false) | |
| 354 // 0x00040000 - thread suspended before loop (return true) | |
| 355 // 0x00080000 - suspend request cancelled in loop (return false) | |
| 356 // 0x00100000 - thread suspended in loop (return true) | |
| 357 // 0x00200000 - suspend not completed during retry loop (return false) | |
| 358 // | |
| 359 | |
| 360 // Helper class for tracing suspend wait debug bits. | |
| 361 // | |
| 362 // 0x00000100 indicates that the target thread exited before it could | |
| 363 // self-suspend which is not a wait failure. 0x00000200, 0x00020000 and | |
| 364 // 0x00080000 each indicate a cancelled suspend request so they don't | |
| 365 // count as wait failures either. | |
| 366 #define DEBUG_FALSE_BITS (0x00000010 | 0x00200000) | |
| 367 | |
| 368 class TraceSuspendDebugBits : public StackObj { | |
| 369 private: | |
| 370 JavaThread * jt; | |
| 371 bool is_wait; | |
| 372 bool called_by_wait; // meaningful when !is_wait | |
| 373 uint32_t * bits; | |
| 374 | |
| 375 public: | |
| 376 TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait, | |
| 377 uint32_t *_bits) { | |
| 378 jt = _jt; | |
| 379 is_wait = _is_wait; | |
| 380 called_by_wait = _called_by_wait; | |
| 381 bits = _bits; | |
| 382 } | |
| 383 | |
| 384 ~TraceSuspendDebugBits() { | |
| 385 if (!is_wait) { | |
| 386 #if 1 | |
| 387 // By default, don't trace bits for is_ext_suspend_completed() calls. | |
| 388 // That trace is very chatty. | |
| 389 return; | |
| 390 #else | |
| 391 if (!called_by_wait) { | |
| 392 // If tracing for is_ext_suspend_completed() is enabled, then only | |
| 393 // trace calls to it from wait_for_ext_suspend_completion() | |
| 394 return; | |
| 395 } | |
| 396 #endif | |
| 397 } | |
| 398 | |
| 399 if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) { | |
| 400 if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) { | |
| 401 MutexLocker ml(Threads_lock); // needed for get_thread_name() | |
| 402 ResourceMark rm; | |
| 403 | |
| 404 tty->print_cr( | |
| 405 "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)", | |
| 406 jt->get_thread_name(), *bits); | |
| 407 | |
| 408 guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed"); | |
| 409 } | |
| 410 } | |
| 411 } | |
| 412 }; | |
| 413 #undef DEBUG_FALSE_BITS | |
| 414 | |
| 415 | |
| 416 bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) { | |
| 417 TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits); | |
| 418 | |
| 419 bool did_trans_retry = false; // only do thread_in_native_trans retry once | |
| 420 bool do_trans_retry; // flag to force the retry | |
| 421 | |
| 422 *bits |= 0x00000001; | |
| 423 | |
| 424 do { | |
| 425 do_trans_retry = false; | |
| 426 | |
| 427 if (is_exiting()) { | |
| 428 // Thread is in the process of exiting. This is always checked | |
| 429 // first to reduce the risk of dereferencing a freed JavaThread. | |
| 430 *bits |= 0x00000100; | |
| 431 return false; | |
| 432 } | |
| 433 | |
| 434 if (!is_external_suspend()) { | |
| 435 // Suspend request is cancelled. This is always checked before | |
| 436 // is_ext_suspended() to reduce the risk of a rogue resume | |
| 437 // confusing the thread that made the suspend request. | |
| 438 *bits |= 0x00000200; | |
| 439 return false; | |
| 440 } | |
| 441 | |
| 442 if (is_ext_suspended()) { | |
| 443 // thread is suspended | |
| 444 *bits |= 0x00000400; | |
| 445 return true; | |
| 446 } | |
| 447 | |
| 448 // Now that we no longer do hard suspends of threads running | |
| 449 // native code, the target thread can be changing thread state | |
| 450 // while we are in this routine: | |
| 451 // | |
| 452 // _thread_in_native -> _thread_in_native_trans -> _thread_blocked | |
| 453 // | |
| 454 // We save a copy of the thread state as observed at this moment | |
| 455 // and make our decision about suspend completeness based on the | |
| 456 // copy. This closes the race where the thread state is seen as | |
| 457 // _thread_in_native_trans in the if-thread_blocked check, but is | |
| 458 // seen as _thread_blocked in if-thread_in_native_trans check. | |
| 459 JavaThreadState save_state = thread_state(); | |
| 460 | |
| 461 if (save_state == _thread_blocked && is_suspend_equivalent()) { | |
| 462 // If the thread's state is _thread_blocked and this blocking | |
| 463 // condition is known to be equivalent to a suspend, then we can | |
| 464 // consider the thread to be externally suspended. This means that | |
| 465 // the code that sets _thread_blocked has been modified to do | |
| 466 // self-suspension if the blocking condition releases. We also | |
| 467 // used to check for CONDVAR_WAIT here, but that is now covered by | |
| 468 // the _thread_blocked with self-suspension check. | |
| 469 // | |
| 470 // Return true since we wouldn't be here unless there was still an | |
| 471 // external suspend request. | |
| 472 *bits |= 0x00001000; | |
| 473 return true; | |
| 474 } else if (save_state == _thread_in_native && frame_anchor()->walkable()) { | |
| 475 // Threads running native code will self-suspend on native==>VM/Java | |
| 476 // transitions. If its stack is walkable (should always be the case | |
| 477 // unless this function is called before the actual java_suspend() | |
| 478 // call), then the wait is done. | |
| 479 *bits |= 0x00002000; | |
| 480 return true; | |
| 481 } else if (!called_by_wait && !did_trans_retry && | |
| 482 save_state == _thread_in_native_trans && | |
| 483 frame_anchor()->walkable()) { | |
| 484 // The thread is transitioning from thread_in_native to another | |
| 485 // thread state. check_safepoint_and_suspend_for_native_trans() | |
| 486 // will force the thread to self-suspend. If it hasn't gotten | |
| 487 // there yet we may have caught the thread in-between the native | |
| 488 // code check above and the self-suspend. Lucky us. If we were | |
| 489 // called by wait_for_ext_suspend_completion(), then it | |
| 490 // will be doing the retries so we don't have to. | |
| 491 // | |
| 492 // Since we use the saved thread state in the if-statement above, | |
| 493 // there is a chance that the thread has already transitioned to | |
| 494 // _thread_blocked by the time we get here. In that case, we will | |
| 495 // make a single unnecessary pass through the logic below. This | |
| 496 // doesn't hurt anything since we still do the trans retry. | |
| 497 | |
| 498 *bits |= 0x00004000; | |
| 499 | |
| 500 // Once the thread leaves thread_in_native_trans for another | |
| 501 // thread state, we break out of this retry loop. We shouldn't | |
| 502 // need this flag to prevent us from getting back here, but | |
| 503 // sometimes paranoia is good. | |
| 504 did_trans_retry = true; | |
| 505 | |
| 506 // We wait for the thread to transition to a more usable state. | |
| 507 for (int i = 1; i <= SuspendRetryCount; i++) { | |
| 508 // We used to do an "os::yield_all(i)" call here with the intention | |
| 509 // that yielding would increase on each retry. However, the parameter | |
| 510 // is ignored on Linux which means the yield didn't scale up. Waiting | |
| 511 // on the SR_lock below provides a much more predictable scale up for | |
| 512 // the delay. It also provides a simple/direct point to check for any | |
| 513 // safepoint requests from the VMThread | |
| 514 | |
| 515 // temporarily drops SR_lock while doing wait with safepoint check | |
| 516 // (if we're a JavaThread - the WatcherThread can also call this) | |
| 517 // and increase delay with each retry | |
| 518 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay); | |
| 519 | |
| 520 // check the actual thread state instead of what we saved above | |
| 521 if (thread_state() != _thread_in_native_trans) { | |
| 522 // the thread has transitioned to another thread state so | |
| 523 // try all the checks (except this one) one more time. | |
| 524 do_trans_retry = true; | |
| 525 break; | |
| 526 } | |
| 527 } // end retry loop | |
| 528 | |
| 529 | |
| 530 } | |
| 531 } while (do_trans_retry); | |
| 532 | |
| 533 *bits |= 0x00000010; | |
| 534 return false; | |
| 535 } | |
| 536 | |
| 537 // | |
| 538 // Wait for an external suspend request to complete (or be cancelled). | |
| 539 // Returns true if the thread is externally suspended and false otherwise. | |
| 540 // | |
| 541 bool JavaThread::wait_for_ext_suspend_completion(int retries, int delay, | |
| 542 uint32_t *bits) { | |
| 543 TraceSuspendDebugBits tsdb(this, true /* is_wait */, | |
| 544 false /* !called_by_wait */, bits); | |
| 545 | |
| 546 // local flag copies to minimize SR_lock hold time | |
| 547 bool is_suspended; | |
| 548 bool pending; | |
| 549 uint32_t reset_bits; | |
| 550 | |
| 551 // set a marker so is_ext_suspend_completed() knows we are the caller | |
| 552 *bits |= 0x00010000; | |
| 553 | |
| 554 // We use reset_bits to reinitialize the bits value at the top of | |
| 555 // each retry loop. This allows the caller to make use of any | |
| 556 // unused bits for their own marking purposes. | |
| 557 reset_bits = *bits; | |
| 558 | |
| 559 { | |
| 560 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 561 is_suspended = is_ext_suspend_completed(true /* called_by_wait */, | |
| 562 delay, bits); | |
| 563 pending = is_external_suspend(); | |
| 564 } | |
| 565 // must release SR_lock to allow suspension to complete | |
| 566 | |
| 567 if (!pending) { | |
| 568 // A cancelled suspend request is the only false return from | |
| 569 // is_ext_suspend_completed() that keeps us from entering the | |
| 570 // retry loop. | |
| 571 *bits |= 0x00020000; | |
| 572 return false; | |
| 573 } | |
| 574 | |
| 575 if (is_suspended) { | |
| 576 *bits |= 0x00040000; | |
| 577 return true; | |
| 578 } | |
| 579 | |
| 580 for (int i = 1; i <= retries; i++) { | |
| 581 *bits = reset_bits; // reinit to only track last retry | |
| 582 | |
| 583 // We used to do an "os::yield_all(i)" call here with the intention | |
| 584 // that yielding would increase on each retry. However, the parameter | |
| 585 // is ignored on Linux which means the yield didn't scale up. Waiting | |
| 586 // on the SR_lock below provides a much more predictable scale up for | |
| 587 // the delay. It also provides a simple/direct point to check for any | |
| 588 // safepoint requests from the VMThread | |
| 589 | |
| 590 { | |
| 591 MutexLocker ml(SR_lock()); | |
| 592 // wait with safepoint check (if we're a JavaThread - the WatcherThread | |
| 593 // can also call this) and increase delay with each retry | |
| 594 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay); | |
| 595 | |
| 596 is_suspended = is_ext_suspend_completed(true /* called_by_wait */, | |
| 597 delay, bits); | |
| 598 | |
| 599 // It is possible for the external suspend request to be cancelled | |
| 600 // (by a resume) before the actual suspend operation is completed. | |
| 601 // Refresh our local copy to see if we still need to wait. | |
| 602 pending = is_external_suspend(); | |
| 603 } | |
| 604 | |
| 605 if (!pending) { | |
| 606 // A cancelled suspend request is the only false return from | |
| 607 // is_ext_suspend_completed() that keeps us from staying in the | |
| 608 // retry loop. | |
| 609 *bits |= 0x00080000; | |
| 610 return false; | |
| 611 } | |
| 612 | |
| 613 if (is_suspended) { | |
| 614 *bits |= 0x00100000; | |
| 615 return true; | |
| 616 } | |
| 617 } // end retry loop | |
| 618 | |
| 619 // thread did not suspend after all our retries | |
| 620 *bits |= 0x00200000; | |
| 621 return false; | |
| 622 } | |
| 623 | |
| 624 #ifndef PRODUCT | |
| 625 void JavaThread::record_jump(address target, address instr, const char* file, int line) { | |
| 626 | |
| 627 // This should not need to be atomic as the only way for simultaneous | |
| 628 // updates is via interrupts. Even then this should be rare or non-existant | |
| 629 // and we don't care that much anyway. | |
| 630 | |
| 631 int index = _jmp_ring_index; | |
| 632 _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1); | |
| 633 _jmp_ring[index]._target = (intptr_t) target; | |
| 634 _jmp_ring[index]._instruction = (intptr_t) instr; | |
| 635 _jmp_ring[index]._file = file; | |
| 636 _jmp_ring[index]._line = line; | |
| 637 } | |
| 638 #endif /* PRODUCT */ | |
| 639 | |
| 640 // Called by flat profiler | |
| 641 // Callers have already called wait_for_ext_suspend_completion | |
| 642 // The assertion for that is currently too complex to put here: | |
| 643 bool JavaThread::profile_last_Java_frame(frame* _fr) { | |
| 644 bool gotframe = false; | |
| 645 // self suspension saves needed state. | |
| 646 if (has_last_Java_frame() && _anchor.walkable()) { | |
| 647 *_fr = pd_last_frame(); | |
| 648 gotframe = true; | |
| 649 } | |
| 650 return gotframe; | |
| 651 } | |
| 652 | |
| 653 void Thread::interrupt(Thread* thread) { | |
| 654 trace("interrupt", thread); | |
| 655 debug_only(check_for_dangling_thread_pointer(thread);) | |
| 656 os::interrupt(thread); | |
| 657 } | |
| 658 | |
| 659 bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) { | |
| 660 trace("is_interrupted", thread); | |
| 661 debug_only(check_for_dangling_thread_pointer(thread);) | |
| 662 // Note: If clear_interrupted==false, this simply fetches and | |
| 663 // returns the value of the field osthread()->interrupted(). | |
| 664 return os::is_interrupted(thread, clear_interrupted); | |
| 665 } | |
| 666 | |
| 667 | |
| 668 // GC Support | |
| 669 bool Thread::claim_oops_do_par_case(int strong_roots_parity) { | |
| 670 jint thread_parity = _oops_do_parity; | |
| 671 if (thread_parity != strong_roots_parity) { | |
| 672 jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity); | |
| 673 if (res == thread_parity) return true; | |
| 674 else { | |
| 675 guarantee(res == strong_roots_parity, "Or else what?"); | |
| 676 assert(SharedHeap::heap()->n_par_threads() > 0, | |
| 677 "Should only fail when parallel."); | |
| 678 return false; | |
| 679 } | |
| 680 } | |
| 681 assert(SharedHeap::heap()->n_par_threads() > 0, | |
| 682 "Should only fail when parallel."); | |
| 683 return false; | |
| 684 } | |
| 685 | |
| 686 void Thread::oops_do(OopClosure* f) { | |
| 687 active_handles()->oops_do(f); | |
| 688 // Do oop for ThreadShadow | |
| 689 f->do_oop((oop*)&_pending_exception); | |
| 690 handle_area()->oops_do(f); | |
| 691 } | |
| 692 | |
| 693 void Thread::nmethods_do() { | |
| 694 } | |
| 695 | |
| 696 void Thread::print_on(outputStream* st) const { | |
| 697 // get_priority assumes osthread initialized | |
| 698 if (osthread() != NULL) { | |
| 699 st->print("prio=%d tid=" INTPTR_FORMAT " ", get_priority(this), this); | |
| 700 osthread()->print_on(st); | |
| 701 } | |
| 702 debug_only(if (WizardMode) print_owned_locks_on(st);) | |
| 703 } | |
| 704 | |
| 705 // Thread::print_on_error() is called by fatal error handler. Don't use | |
| 706 // any lock or allocate memory. | |
| 707 void Thread::print_on_error(outputStream* st, char* buf, int buflen) const { | |
| 708 if (is_VM_thread()) st->print("VMThread"); | |
| 709 else if (is_Compiler_thread()) st->print("CompilerThread"); | |
| 710 else if (is_Java_thread()) st->print("JavaThread"); | |
| 711 else if (is_GC_task_thread()) st->print("GCTaskThread"); | |
| 712 else if (is_Watcher_thread()) st->print("WatcherThread"); | |
| 713 else if (is_ConcurrentGC_thread()) st->print("ConcurrentGCThread"); | |
| 714 else st->print("Thread"); | |
| 715 | |
| 716 st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]", | |
| 717 _stack_base - _stack_size, _stack_base); | |
| 718 | |
| 719 if (osthread()) { | |
| 720 st->print(" [id=%d]", osthread()->thread_id()); | |
| 721 } | |
| 722 } | |
| 723 | |
| 724 #ifdef ASSERT | |
| 725 void Thread::print_owned_locks_on(outputStream* st) const { | |
| 726 Monitor *cur = _owned_locks; | |
| 727 if (cur == NULL) { | |
| 728 st->print(" (no locks) "); | |
| 729 } else { | |
| 730 st->print_cr(" Locks owned:"); | |
| 731 while(cur) { | |
| 732 cur->print_on(st); | |
| 733 cur = cur->next(); | |
| 734 } | |
| 735 } | |
| 736 } | |
| 737 | |
| 738 static int ref_use_count = 0; | |
| 739 | |
| 740 bool Thread::owns_locks_but_compiled_lock() const { | |
| 741 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) { | |
| 742 if (cur != Compile_lock) return true; | |
| 743 } | |
| 744 return false; | |
| 745 } | |
| 746 | |
| 747 | |
| 748 #endif | |
| 749 | |
| 750 #ifndef PRODUCT | |
| 751 | |
| 752 // The flag: potential_vm_operation notifies if this particular safepoint state could potential | |
| 753 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that | |
| 754 // no threads which allow_vm_block's are held | |
| 755 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) { | |
| 756 // Check if current thread is allowed to block at a safepoint | |
| 757 if (!(_allow_safepoint_count == 0)) | |
| 758 fatal("Possible safepoint reached by thread that does not allow it"); | |
| 759 if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) { | |
| 760 fatal("LEAF method calling lock?"); | |
| 761 } | |
| 762 | |
| 763 #ifdef ASSERT | |
| 764 if (potential_vm_operation && is_Java_thread() | |
| 765 && !Universe::is_bootstrapping()) { | |
| 766 // Make sure we do not hold any locks that the VM thread also uses. | |
| 767 // This could potentially lead to deadlocks | |
| 768 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) { | |
| 769 // Threads_lock is special, since the safepoint synchronization will not start before this is | |
| 770 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock, | |
| 771 // since it is used to transfer control between JavaThreads and the VMThread | |
| 772 // Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first! | |
| 773 if ( (cur->allow_vm_block() && | |
| 774 cur != Threads_lock && | |
| 775 cur != Compile_lock && // Temporary: should not be necessary when we get spearate compilation | |
| 776 cur != VMOperationRequest_lock && | |
| 777 cur != VMOperationQueue_lock) || | |
| 778 cur->rank() == Mutex::special) { | |
| 779 warning("Thread holding lock at safepoint that vm can block on: %s", cur->name()); | |
| 780 } | |
| 781 } | |
| 782 } | |
| 783 | |
| 784 if (GCALotAtAllSafepoints) { | |
| 785 // We could enter a safepoint here and thus have a gc | |
| 786 InterfaceSupport::check_gc_alot(); | |
| 787 } | |
| 788 | |
| 789 #endif | |
| 790 } | |
| 791 #endif | |
| 792 | |
| 793 bool Thread::lock_is_in_stack(address adr) const { | |
| 794 assert(Thread::current() == this, "lock_is_in_stack can only be called from current thread"); | |
| 795 // High limit: highest_lock is set during thread execution | |
| 796 // Low limit: address of the local variable dummy, rounded to 4K boundary. | |
| 797 // (The rounding helps finding threads in unsafe mode, even if the particular stack | |
| 798 // frame has been popped already. Correct as long as stacks are at least 4K long and aligned.) | |
| 799 address end = os::current_stack_pointer(); | |
| 800 if (_highest_lock >= adr && adr >= end) return true; | |
| 801 | |
| 802 return false; | |
| 803 } | |
| 804 | |
| 805 | |
| 806 bool Thread::is_in_stack(address adr) const { | |
| 807 assert(Thread::current() == this, "is_in_stack can only be called from current thread"); | |
| 808 address end = os::current_stack_pointer(); | |
| 809 if (stack_base() >= adr && adr >= end) return true; | |
| 810 | |
| 811 return false; | |
| 812 } | |
| 813 | |
| 814 | |
| 815 // We had to move these methods here, because vm threads get into ObjectSynchronizer::enter | |
| 816 // However, there is a note in JavaThread::is_lock_owned() about the VM threads not being | |
| 817 // used for compilation in the future. If that change is made, the need for these methods | |
| 818 // should be revisited, and they should be removed if possible. | |
| 819 | |
| 820 bool Thread::is_lock_owned(address adr) const { | |
| 821 if (lock_is_in_stack(adr) ) return true; | |
| 822 return false; | |
| 823 } | |
| 824 | |
| 825 bool Thread::set_as_starting_thread() { | |
| 826 // NOTE: this must be called inside the main thread. | |
| 827 return os::create_main_thread((JavaThread*)this); | |
| 828 } | |
| 829 | |
| 830 static void initialize_class(symbolHandle class_name, TRAPS) { | |
| 831 klassOop klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK); | |
| 832 instanceKlass::cast(klass)->initialize(CHECK); | |
| 833 } | |
| 834 | |
| 835 | |
| 836 // Creates the initial ThreadGroup | |
| 837 static Handle create_initial_thread_group(TRAPS) { | |
| 838 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ThreadGroup(), true, CHECK_NH); | |
| 839 instanceKlassHandle klass (THREAD, k); | |
| 840 | |
| 841 Handle system_instance = klass->allocate_instance_handle(CHECK_NH); | |
| 842 { | |
| 843 JavaValue result(T_VOID); | |
| 844 JavaCalls::call_special(&result, | |
| 845 system_instance, | |
| 846 klass, | |
| 847 vmSymbolHandles::object_initializer_name(), | |
| 848 vmSymbolHandles::void_method_signature(), | |
| 849 CHECK_NH); | |
| 850 } | |
| 851 Universe::set_system_thread_group(system_instance()); | |
| 852 | |
| 853 Handle main_instance = klass->allocate_instance_handle(CHECK_NH); | |
| 854 { | |
| 855 JavaValue result(T_VOID); | |
| 856 Handle string = java_lang_String::create_from_str("main", CHECK_NH); | |
| 857 JavaCalls::call_special(&result, | |
| 858 main_instance, | |
| 859 klass, | |
| 860 vmSymbolHandles::object_initializer_name(), | |
| 861 vmSymbolHandles::threadgroup_string_void_signature(), | |
| 862 system_instance, | |
| 863 string, | |
| 864 CHECK_NH); | |
| 865 } | |
| 866 return main_instance; | |
| 867 } | |
| 868 | |
| 869 // Creates the initial Thread | |
| 870 static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) { | |
| 871 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK_NULL); | |
| 872 instanceKlassHandle klass (THREAD, k); | |
| 873 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL); | |
| 874 | |
| 875 java_lang_Thread::set_thread(thread_oop(), thread); | |
| 876 java_lang_Thread::set_priority(thread_oop(), NormPriority); | |
| 877 thread->set_threadObj(thread_oop()); | |
| 878 | |
| 879 Handle string = java_lang_String::create_from_str("main", CHECK_NULL); | |
| 880 | |
| 881 JavaValue result(T_VOID); | |
| 882 JavaCalls::call_special(&result, thread_oop, | |
| 883 klass, | |
| 884 vmSymbolHandles::object_initializer_name(), | |
| 885 vmSymbolHandles::threadgroup_string_void_signature(), | |
| 886 thread_group, | |
| 887 string, | |
| 888 CHECK_NULL); | |
| 889 return thread_oop(); | |
| 890 } | |
| 891 | |
| 892 static void call_initializeSystemClass(TRAPS) { | |
| 893 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK); | |
| 894 instanceKlassHandle klass (THREAD, k); | |
| 895 | |
| 896 JavaValue result(T_VOID); | |
| 897 JavaCalls::call_static(&result, klass, vmSymbolHandles::initializeSystemClass_name(), | |
| 898 vmSymbolHandles::void_method_signature(), CHECK); | |
| 899 } | |
| 900 | |
| 901 static void reset_vm_info_property(TRAPS) { | |
| 902 // the vm info string | |
| 903 ResourceMark rm(THREAD); | |
| 904 const char *vm_info = VM_Version::vm_info_string(); | |
| 905 | |
| 906 // java.lang.System class | |
| 907 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK); | |
| 908 instanceKlassHandle klass (THREAD, k); | |
| 909 | |
| 910 // setProperty arguments | |
| 911 Handle key_str = java_lang_String::create_from_str("java.vm.info", CHECK); | |
| 912 Handle value_str = java_lang_String::create_from_str(vm_info, CHECK); | |
| 913 | |
| 914 // return value | |
| 915 JavaValue r(T_OBJECT); | |
| 916 | |
| 917 // public static String setProperty(String key, String value); | |
| 918 JavaCalls::call_static(&r, | |
| 919 klass, | |
| 920 vmSymbolHandles::setProperty_name(), | |
| 921 vmSymbolHandles::string_string_string_signature(), | |
| 922 key_str, | |
| 923 value_str, | |
| 924 CHECK); | |
| 925 } | |
| 926 | |
| 927 | |
| 928 void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) { | |
| 929 assert(thread_group.not_null(), "thread group should be specified"); | |
| 930 assert(threadObj() == NULL, "should only create Java thread object once"); | |
| 931 | |
| 932 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK); | |
| 933 instanceKlassHandle klass (THREAD, k); | |
| 934 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK); | |
| 935 | |
| 936 java_lang_Thread::set_thread(thread_oop(), this); | |
| 937 java_lang_Thread::set_priority(thread_oop(), NormPriority); | |
| 938 set_threadObj(thread_oop()); | |
| 939 | |
| 940 JavaValue result(T_VOID); | |
| 941 if (thread_name != NULL) { | |
| 942 Handle name = java_lang_String::create_from_str(thread_name, CHECK); | |
| 943 // Thread gets assigned specified name and null target | |
| 944 JavaCalls::call_special(&result, | |
| 945 thread_oop, | |
| 946 klass, | |
| 947 vmSymbolHandles::object_initializer_name(), | |
| 948 vmSymbolHandles::threadgroup_string_void_signature(), | |
| 949 thread_group, // Argument 1 | |
| 950 name, // Argument 2 | |
| 951 THREAD); | |
| 952 } else { | |
| 953 // Thread gets assigned name "Thread-nnn" and null target | |
| 954 // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument) | |
| 955 JavaCalls::call_special(&result, | |
| 956 thread_oop, | |
| 957 klass, | |
| 958 vmSymbolHandles::object_initializer_name(), | |
| 959 vmSymbolHandles::threadgroup_runnable_void_signature(), | |
| 960 thread_group, // Argument 1 | |
| 961 Handle(), // Argument 2 | |
| 962 THREAD); | |
| 963 } | |
| 964 | |
| 965 | |
| 966 if (daemon) { | |
| 967 java_lang_Thread::set_daemon(thread_oop()); | |
| 968 } | |
| 969 | |
| 970 if (HAS_PENDING_EXCEPTION) { | |
| 971 return; | |
| 972 } | |
| 973 | |
| 974 KlassHandle group(this, SystemDictionary::threadGroup_klass()); | |
| 975 Handle threadObj(this, this->threadObj()); | |
| 976 | |
| 977 JavaCalls::call_special(&result, | |
| 978 thread_group, | |
| 979 group, | |
| 980 vmSymbolHandles::add_method_name(), | |
| 981 vmSymbolHandles::thread_void_signature(), | |
| 982 threadObj, // Arg 1 | |
| 983 THREAD); | |
| 984 | |
| 985 | |
| 986 } | |
| 987 | |
| 988 // NamedThread -- non-JavaThread subclasses with multiple | |
| 989 // uniquely named instances should derive from this. | |
| 990 NamedThread::NamedThread() : Thread() { | |
| 991 _name = NULL; | |
| 992 } | |
| 993 | |
| 994 NamedThread::~NamedThread() { | |
| 995 if (_name != NULL) { | |
| 996 FREE_C_HEAP_ARRAY(char, _name); | |
| 997 _name = NULL; | |
| 998 } | |
| 999 } | |
| 1000 | |
| 1001 void NamedThread::set_name(const char* format, ...) { | |
| 1002 guarantee(_name == NULL, "Only get to set name once."); | |
| 1003 _name = NEW_C_HEAP_ARRAY(char, max_name_len); | |
| 1004 guarantee(_name != NULL, "alloc failure"); | |
| 1005 va_list ap; | |
| 1006 va_start(ap, format); | |
| 1007 jio_vsnprintf(_name, max_name_len, format, ap); | |
| 1008 va_end(ap); | |
| 1009 } | |
| 1010 | |
| 1011 // ======= WatcherThread ======== | |
| 1012 | |
| 1013 // The watcher thread exists to simulate timer interrupts. It should | |
| 1014 // be replaced by an abstraction over whatever native support for | |
| 1015 // timer interrupts exists on the platform. | |
| 1016 | |
| 1017 WatcherThread* WatcherThread::_watcher_thread = NULL; | |
| 1018 bool WatcherThread::_should_terminate = false; | |
| 1019 | |
| 1020 WatcherThread::WatcherThread() : Thread() { | |
| 1021 assert(watcher_thread() == NULL, "we can only allocate one WatcherThread"); | |
| 1022 if (os::create_thread(this, os::watcher_thread)) { | |
| 1023 _watcher_thread = this; | |
| 1024 | |
| 1025 // Set the watcher thread to the highest OS priority which should not be | |
| 1026 // used, unless a Java thread with priority java.lang.Thread.MAX_PRIORITY | |
| 1027 // is created. The only normal thread using this priority is the reference | |
| 1028 // handler thread, which runs for very short intervals only. | |
| 1029 // If the VMThread's priority is not lower than the WatcherThread profiling | |
| 1030 // will be inaccurate. | |
| 1031 os::set_priority(this, MaxPriority); | |
| 1032 if (!DisableStartThread) { | |
| 1033 os::start_thread(this); | |
| 1034 } | |
| 1035 } | |
| 1036 } | |
| 1037 | |
| 1038 void WatcherThread::run() { | |
| 1039 assert(this == watcher_thread(), "just checking"); | |
| 1040 | |
| 1041 this->record_stack_base_and_size(); | |
| 1042 this->initialize_thread_local_storage(); | |
| 1043 this->set_active_handles(JNIHandleBlock::allocate_block()); | |
| 1044 while(!_should_terminate) { | |
| 1045 assert(watcher_thread() == Thread::current(), "thread consistency check"); | |
| 1046 assert(watcher_thread() == this, "thread consistency check"); | |
| 1047 | |
| 1048 // Calculate how long it'll be until the next PeriodicTask work | |
| 1049 // should be done, and sleep that amount of time. | |
| 1050 const size_t time_to_wait = PeriodicTask::time_to_wait(); | |
| 1051 os::sleep(this, time_to_wait, false); | |
| 1052 | |
| 1053 if (is_error_reported()) { | |
| 1054 // A fatal error has happened, the error handler(VMError::report_and_die) | |
| 1055 // should abort JVM after creating an error log file. However in some | |
| 1056 // rare cases, the error handler itself might deadlock. Here we try to | |
| 1057 // kill JVM if the fatal error handler fails to abort in 2 minutes. | |
| 1058 // | |
| 1059 // This code is in WatcherThread because WatcherThread wakes up | |
| 1060 // periodically so the fatal error handler doesn't need to do anything; | |
| 1061 // also because the WatcherThread is less likely to crash than other | |
| 1062 // threads. | |
| 1063 | |
| 1064 for (;;) { | |
| 1065 if (!ShowMessageBoxOnError | |
| 1066 && (OnError == NULL || OnError[0] == '\0') | |
| 1067 && Arguments::abort_hook() == NULL) { | |
| 1068 os::sleep(this, 2 * 60 * 1000, false); | |
| 1069 fdStream err(defaultStream::output_fd()); | |
| 1070 err.print_raw_cr("# [ timer expired, abort... ]"); | |
| 1071 // skip atexit/vm_exit/vm_abort hooks | |
| 1072 os::die(); | |
| 1073 } | |
| 1074 | |
| 1075 // Wake up 5 seconds later, the fatal handler may reset OnError or | |
| 1076 // ShowMessageBoxOnError when it is ready to abort. | |
| 1077 os::sleep(this, 5 * 1000, false); | |
| 1078 } | |
| 1079 } | |
| 1080 | |
| 1081 PeriodicTask::real_time_tick(time_to_wait); | |
| 1082 | |
| 1083 // If we have no more tasks left due to dynamic disenrollment, | |
| 1084 // shut down the thread since we don't currently support dynamic enrollment | |
| 1085 if (PeriodicTask::num_tasks() == 0) { | |
| 1086 _should_terminate = true; | |
| 1087 } | |
| 1088 } | |
| 1089 | |
| 1090 // Signal that it is terminated | |
| 1091 { | |
| 1092 MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag); | |
| 1093 _watcher_thread = NULL; | |
| 1094 Terminator_lock->notify(); | |
| 1095 } | |
| 1096 | |
| 1097 // Thread destructor usually does this.. | |
| 1098 ThreadLocalStorage::set_thread(NULL); | |
| 1099 } | |
| 1100 | |
| 1101 void WatcherThread::start() { | |
| 1102 if (watcher_thread() == NULL) { | |
| 1103 _should_terminate = false; | |
| 1104 // Create the single instance of WatcherThread | |
| 1105 new WatcherThread(); | |
| 1106 } | |
| 1107 } | |
| 1108 | |
| 1109 void WatcherThread::stop() { | |
| 1110 // it is ok to take late safepoints here, if needed | |
| 1111 MutexLocker mu(Terminator_lock); | |
| 1112 _should_terminate = true; | |
| 1113 while(watcher_thread() != NULL) { | |
| 1114 // This wait should make safepoint checks, wait without a timeout, | |
| 1115 // and wait as a suspend-equivalent condition. | |
| 1116 // | |
| 1117 // Note: If the FlatProfiler is running, then this thread is waiting | |
| 1118 // for the WatcherThread to terminate and the WatcherThread, via the | |
| 1119 // FlatProfiler task, is waiting for the external suspend request on | |
| 1120 // this thread to complete. wait_for_ext_suspend_completion() will | |
| 1121 // eventually timeout, but that takes time. Making this wait a | |
| 1122 // suspend-equivalent condition solves that timeout problem. | |
| 1123 // | |
| 1124 Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0, | |
| 1125 Mutex::_as_suspend_equivalent_flag); | |
| 1126 } | |
| 1127 } | |
| 1128 | |
| 1129 void WatcherThread::print_on(outputStream* st) const { | |
| 1130 st->print("\"%s\" ", name()); | |
| 1131 Thread::print_on(st); | |
| 1132 st->cr(); | |
| 1133 } | |
| 1134 | |
| 1135 // ======= JavaThread ======== | |
| 1136 | |
| 1137 // A JavaThread is a normal Java thread | |
| 1138 | |
| 1139 void JavaThread::initialize() { | |
| 1140 // Initialize fields | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1141 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1142 // Set the claimed par_id to -1 (ie not claiming any par_ids) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1143 set_claimed_par_id(-1); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1144 |
| 0 | 1145 set_saved_exception_pc(NULL); |
| 1146 set_threadObj(NULL); | |
| 1147 _anchor.clear(); | |
| 1148 set_entry_point(NULL); | |
| 1149 set_jni_functions(jni_functions()); | |
| 1150 set_callee_target(NULL); | |
| 1151 set_vm_result(NULL); | |
| 1152 set_vm_result_2(NULL); | |
| 1153 set_vframe_array_head(NULL); | |
| 1154 set_vframe_array_last(NULL); | |
| 1155 set_deferred_locals(NULL); | |
| 1156 set_deopt_mark(NULL); | |
| 1157 clear_must_deopt_id(); | |
| 1158 set_monitor_chunks(NULL); | |
| 1159 set_next(NULL); | |
| 1160 set_thread_state(_thread_new); | |
| 1161 _terminated = _not_terminated; | |
| 1162 _privileged_stack_top = NULL; | |
| 1163 _array_for_gc = NULL; | |
| 1164 _suspend_equivalent = false; | |
| 1165 _in_deopt_handler = 0; | |
| 1166 _doing_unsafe_access = false; | |
| 1167 _stack_guard_state = stack_guard_unused; | |
| 1168 _exception_oop = NULL; | |
| 1169 _exception_pc = 0; | |
| 1170 _exception_handler_pc = 0; | |
| 1171 _exception_stack_size = 0; | |
| 1172 _jvmti_thread_state= NULL; | |
| 1173 _jvmti_get_loaded_classes_closure = NULL; | |
| 1174 _interp_only_mode = 0; | |
| 1175 _special_runtime_exit_condition = _no_async_condition; | |
| 1176 _pending_async_exception = NULL; | |
| 1177 _is_compiling = false; | |
| 1178 _thread_stat = NULL; | |
| 1179 _thread_stat = new ThreadStatistics(); | |
| 1180 _blocked_on_compilation = false; | |
| 1181 _jni_active_critical = 0; | |
| 1182 _do_not_unlock_if_synchronized = false; | |
| 1183 _cached_monitor_info = NULL; | |
| 1184 _parker = Parker::Allocate(this) ; | |
| 1185 | |
| 1186 #ifndef PRODUCT | |
| 1187 _jmp_ring_index = 0; | |
| 1188 for (int ji = 0 ; ji < jump_ring_buffer_size ; ji++ ) { | |
| 1189 record_jump(NULL, NULL, NULL, 0); | |
| 1190 } | |
| 1191 #endif /* PRODUCT */ | |
| 1192 | |
| 1193 set_thread_profiler(NULL); | |
| 1194 if (FlatProfiler::is_active()) { | |
| 1195 // This is where we would decide to either give each thread it's own profiler | |
| 1196 // or use one global one from FlatProfiler, | |
| 1197 // or up to some count of the number of profiled threads, etc. | |
| 1198 ThreadProfiler* pp = new ThreadProfiler(); | |
| 1199 pp->engage(); | |
| 1200 set_thread_profiler(pp); | |
| 1201 } | |
| 1202 | |
| 1203 // Setup safepoint state info for this thread | |
| 1204 ThreadSafepointState::create(this); | |
| 1205 | |
| 1206 debug_only(_java_call_counter = 0); | |
| 1207 | |
| 1208 // JVMTI PopFrame support | |
| 1209 _popframe_condition = popframe_inactive; | |
| 1210 _popframe_preserved_args = NULL; | |
| 1211 _popframe_preserved_args_size = 0; | |
| 1212 | |
| 1213 pd_initialize(); | |
| 1214 } | |
| 1215 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1216 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1217 SATBMarkQueueSet JavaThread::_satb_mark_queue_set; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1218 DirtyCardQueueSet JavaThread::_dirty_card_queue_set; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1219 #endif // !SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1220 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1221 JavaThread::JavaThread(bool is_attaching) : |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1222 Thread() |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1223 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1224 , _satb_mark_queue(&_satb_mark_queue_set), |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1225 _dirty_card_queue(&_dirty_card_queue_set) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1226 #endif // !SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1227 { |
| 0 | 1228 initialize(); |
| 1229 _is_attaching = is_attaching; | |
| 1230 } | |
| 1231 | |
| 1232 bool JavaThread::reguard_stack(address cur_sp) { | |
| 1233 if (_stack_guard_state != stack_guard_yellow_disabled) { | |
| 1234 return true; // Stack already guarded or guard pages not needed. | |
| 1235 } | |
| 1236 | |
| 1237 if (register_stack_overflow()) { | |
| 1238 // For those architectures which have separate register and | |
| 1239 // memory stacks, we must check the register stack to see if | |
| 1240 // it has overflowed. | |
| 1241 return false; | |
| 1242 } | |
| 1243 | |
| 1244 // Java code never executes within the yellow zone: the latter is only | |
| 1245 // there to provoke an exception during stack banging. If java code | |
| 1246 // is executing there, either StackShadowPages should be larger, or | |
| 1247 // some exception code in c1, c2 or the interpreter isn't unwinding | |
| 1248 // when it should. | |
| 1249 guarantee(cur_sp > stack_yellow_zone_base(), "not enough space to reguard - increase StackShadowPages"); | |
| 1250 | |
| 1251 enable_stack_yellow_zone(); | |
| 1252 return true; | |
| 1253 } | |
| 1254 | |
| 1255 bool JavaThread::reguard_stack(void) { | |
| 1256 return reguard_stack(os::current_stack_pointer()); | |
| 1257 } | |
| 1258 | |
| 1259 | |
| 1260 void JavaThread::block_if_vm_exited() { | |
| 1261 if (_terminated == _vm_exited) { | |
| 1262 // _vm_exited is set at safepoint, and Threads_lock is never released | |
| 1263 // we will block here forever | |
| 1264 Threads_lock->lock_without_safepoint_check(); | |
| 1265 ShouldNotReachHere(); | |
| 1266 } | |
| 1267 } | |
| 1268 | |
| 1269 | |
| 1270 // Remove this ifdef when C1 is ported to the compiler interface. | |
| 1271 static void compiler_thread_entry(JavaThread* thread, TRAPS); | |
| 1272 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1273 JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) : |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1274 Thread() |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1275 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1276 , _satb_mark_queue(&_satb_mark_queue_set), |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1277 _dirty_card_queue(&_dirty_card_queue_set) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1278 #endif // !SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1279 { |
| 0 | 1280 if (TraceThreadEvents) { |
| 1281 tty->print_cr("creating thread %p", this); | |
| 1282 } | |
| 1283 initialize(); | |
| 1284 _is_attaching = false; | |
| 1285 set_entry_point(entry_point); | |
| 1286 // Create the native thread itself. | |
| 1287 // %note runtime_23 | |
| 1288 os::ThreadType thr_type = os::java_thread; | |
| 1289 thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread : | |
| 1290 os::java_thread; | |
| 1291 os::create_thread(this, thr_type, stack_sz); | |
| 1292 | |
| 1293 // The _osthread may be NULL here because we ran out of memory (too many threads active). | |
| 1294 // We need to throw and OutOfMemoryError - however we cannot do this here because the caller | |
| 1295 // may hold a lock and all locks must be unlocked before throwing the exception (throwing | |
| 1296 // the exception consists of creating the exception object & initializing it, initialization | |
| 1297 // will leave the VM via a JavaCall and then all locks must be unlocked). | |
| 1298 // | |
| 1299 // The thread is still suspended when we reach here. Thread must be explicit started | |
| 1300 // by creator! Furthermore, the thread must also explicitly be added to the Threads list | |
| 1301 // by calling Threads:add. The reason why this is not done here, is because the thread | |
| 1302 // object must be fully initialized (take a look at JVM_Start) | |
| 1303 } | |
| 1304 | |
| 1305 JavaThread::~JavaThread() { | |
| 1306 if (TraceThreadEvents) { | |
| 1307 tty->print_cr("terminate thread %p", this); | |
| 1308 } | |
| 1309 | |
| 1310 // JSR166 -- return the parker to the free list | |
| 1311 Parker::Release(_parker); | |
| 1312 _parker = NULL ; | |
| 1313 | |
| 1314 // Free any remaining previous UnrollBlock | |
| 1315 vframeArray* old_array = vframe_array_last(); | |
| 1316 | |
| 1317 if (old_array != NULL) { | |
| 1318 Deoptimization::UnrollBlock* old_info = old_array->unroll_block(); | |
| 1319 old_array->set_unroll_block(NULL); | |
| 1320 delete old_info; | |
| 1321 delete old_array; | |
| 1322 } | |
| 1323 | |
| 1324 GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred = deferred_locals(); | |
| 1325 if (deferred != NULL) { | |
| 1326 // This can only happen if thread is destroyed before deoptimization occurs. | |
| 1327 assert(deferred->length() != 0, "empty array!"); | |
| 1328 do { | |
| 1329 jvmtiDeferredLocalVariableSet* dlv = deferred->at(0); | |
| 1330 deferred->remove_at(0); | |
| 1331 // individual jvmtiDeferredLocalVariableSet are CHeapObj's | |
| 1332 delete dlv; | |
| 1333 } while (deferred->length() != 0); | |
| 1334 delete deferred; | |
| 1335 } | |
| 1336 | |
| 1337 // All Java related clean up happens in exit | |
| 1338 ThreadSafepointState::destroy(this); | |
| 1339 if (_thread_profiler != NULL) delete _thread_profiler; | |
| 1340 if (_thread_stat != NULL) delete _thread_stat; | |
| 1341 } | |
| 1342 | |
| 1343 | |
| 1344 // The first routine called by a new Java thread | |
| 1345 void JavaThread::run() { | |
| 1346 // initialize thread-local alloc buffer related fields | |
| 1347 this->initialize_tlab(); | |
| 1348 | |
| 1349 // used to test validitity of stack trace backs | |
| 1350 this->record_base_of_stack_pointer(); | |
| 1351 | |
| 1352 // Record real stack base and size. | |
| 1353 this->record_stack_base_and_size(); | |
| 1354 | |
| 1355 // Initialize thread local storage; set before calling MutexLocker | |
| 1356 this->initialize_thread_local_storage(); | |
| 1357 | |
| 1358 this->create_stack_guard_pages(); | |
| 1359 | |
| 1360 // Thread is now sufficient initialized to be handled by the safepoint code as being | |
| 1361 // in the VM. Change thread state from _thread_new to _thread_in_vm | |
| 1362 ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm); | |
| 1363 | |
| 1364 assert(JavaThread::current() == this, "sanity check"); | |
| 1365 assert(!Thread::current()->owns_locks(), "sanity check"); | |
| 1366 | |
| 1367 DTRACE_THREAD_PROBE(start, this); | |
| 1368 | |
| 1369 // This operation might block. We call that after all safepoint checks for a new thread has | |
| 1370 // been completed. | |
| 1371 this->set_active_handles(JNIHandleBlock::allocate_block()); | |
| 1372 | |
| 1373 if (JvmtiExport::should_post_thread_life()) { | |
| 1374 JvmtiExport::post_thread_start(this); | |
| 1375 } | |
| 1376 | |
| 1377 // We call another function to do the rest so we are sure that the stack addresses used | |
| 1378 // from there will be lower than the stack base just computed | |
| 1379 thread_main_inner(); | |
| 1380 | |
| 1381 // Note, thread is no longer valid at this point! | |
| 1382 } | |
| 1383 | |
| 1384 | |
| 1385 void JavaThread::thread_main_inner() { | |
| 1386 assert(JavaThread::current() == this, "sanity check"); | |
| 1387 assert(this->threadObj() != NULL, "just checking"); | |
| 1388 | |
| 1389 // Execute thread entry point. If this thread is being asked to restart, | |
| 1390 // or has been stopped before starting, do not reexecute entry point. | |
| 1391 // Note: Due to JVM_StopThread we can have pending exceptions already! | |
| 1392 if (!this->has_pending_exception() && !java_lang_Thread::is_stillborn(this->threadObj())) { | |
| 1393 // enter the thread's entry point only if we have no pending exceptions | |
| 1394 HandleMark hm(this); | |
| 1395 this->entry_point()(this, this); | |
| 1396 } | |
| 1397 | |
| 1398 DTRACE_THREAD_PROBE(stop, this); | |
| 1399 | |
| 1400 this->exit(false); | |
| 1401 delete this; | |
| 1402 } | |
| 1403 | |
| 1404 | |
| 1405 static void ensure_join(JavaThread* thread) { | |
| 1406 // We do not need to grap the Threads_lock, since we are operating on ourself. | |
| 1407 Handle threadObj(thread, thread->threadObj()); | |
| 1408 assert(threadObj.not_null(), "java thread object must exist"); | |
| 1409 ObjectLocker lock(threadObj, thread); | |
| 1410 // Ignore pending exception (ThreadDeath), since we are exiting anyway | |
| 1411 thread->clear_pending_exception(); | |
| 1412 // It is of profound importance that we set the stillborn bit and reset the thread object, | |
| 1413 // before we do the notify. Since, changing these two variable will make JVM_IsAlive return | |
| 1414 // false. So in case another thread is doing a join on this thread , it will detect that the thread | |
| 1415 // is dead when it gets notified. | |
| 1416 java_lang_Thread::set_stillborn(threadObj()); | |
| 1417 // Thread is exiting. So set thread_status field in java.lang.Thread class to TERMINATED. | |
| 1418 java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED); | |
| 1419 java_lang_Thread::set_thread(threadObj(), NULL); | |
| 1420 lock.notify_all(thread); | |
| 1421 // Ignore pending exception (ThreadDeath), since we are exiting anyway | |
| 1422 thread->clear_pending_exception(); | |
| 1423 } | |
| 1424 | |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1425 |
| 0 | 1426 // For any new cleanup additions, please check to see if they need to be applied to |
| 1427 // cleanup_failed_attach_current_thread as well. | |
| 1428 void JavaThread::exit(bool destroy_vm, ExitType exit_type) { | |
| 1429 assert(this == JavaThread::current(), "thread consistency check"); | |
| 1430 if (!InitializeJavaLangSystem) return; | |
| 1431 | |
| 1432 HandleMark hm(this); | |
| 1433 Handle uncaught_exception(this, this->pending_exception()); | |
| 1434 this->clear_pending_exception(); | |
| 1435 Handle threadObj(this, this->threadObj()); | |
| 1436 assert(threadObj.not_null(), "Java thread object should be created"); | |
| 1437 | |
| 1438 if (get_thread_profiler() != NULL) { | |
| 1439 get_thread_profiler()->disengage(); | |
| 1440 ResourceMark rm; | |
| 1441 get_thread_profiler()->print(get_thread_name()); | |
| 1442 } | |
| 1443 | |
| 1444 | |
| 1445 // FIXIT: This code should be moved into else part, when reliable 1.2/1.3 check is in place | |
| 1446 { | |
| 1447 EXCEPTION_MARK; | |
| 1448 | |
| 1449 CLEAR_PENDING_EXCEPTION; | |
| 1450 } | |
| 1451 // FIXIT: The is_null check is only so it works better on JDK1.2 VM's. This | |
| 1452 // has to be fixed by a runtime query method | |
| 1453 if (!destroy_vm || JDK_Version::is_jdk12x_version()) { | |
| 1454 // JSR-166: change call from from ThreadGroup.uncaughtException to | |
| 1455 // java.lang.Thread.dispatchUncaughtException | |
| 1456 if (uncaught_exception.not_null()) { | |
| 1457 Handle group(this, java_lang_Thread::threadGroup(threadObj())); | |
| 1458 Events::log("uncaught exception INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT", | |
| 1459 (address)uncaught_exception(), (address)threadObj(), (address)group()); | |
| 1460 { | |
| 1461 EXCEPTION_MARK; | |
| 1462 // Check if the method Thread.dispatchUncaughtException() exists. If so | |
| 1463 // call it. Otherwise we have an older library without the JSR-166 changes, | |
| 1464 // so call ThreadGroup.uncaughtException() | |
| 1465 KlassHandle recvrKlass(THREAD, threadObj->klass()); | |
| 1466 CallInfo callinfo; | |
| 1467 KlassHandle thread_klass(THREAD, SystemDictionary::thread_klass()); | |
| 1468 LinkResolver::resolve_virtual_call(callinfo, threadObj, recvrKlass, thread_klass, | |
| 1469 vmSymbolHandles::dispatchUncaughtException_name(), | |
| 1470 vmSymbolHandles::throwable_void_signature(), | |
| 1471 KlassHandle(), false, false, THREAD); | |
| 1472 CLEAR_PENDING_EXCEPTION; | |
| 1473 methodHandle method = callinfo.selected_method(); | |
| 1474 if (method.not_null()) { | |
| 1475 JavaValue result(T_VOID); | |
| 1476 JavaCalls::call_virtual(&result, | |
| 1477 threadObj, thread_klass, | |
| 1478 vmSymbolHandles::dispatchUncaughtException_name(), | |
| 1479 vmSymbolHandles::throwable_void_signature(), | |
| 1480 uncaught_exception, | |
| 1481 THREAD); | |
| 1482 } else { | |
| 1483 KlassHandle thread_group(THREAD, SystemDictionary::threadGroup_klass()); | |
| 1484 JavaValue result(T_VOID); | |
| 1485 JavaCalls::call_virtual(&result, | |
| 1486 group, thread_group, | |
| 1487 vmSymbolHandles::uncaughtException_name(), | |
| 1488 vmSymbolHandles::thread_throwable_void_signature(), | |
| 1489 threadObj, // Arg 1 | |
| 1490 uncaught_exception, // Arg 2 | |
| 1491 THREAD); | |
| 1492 } | |
| 1493 CLEAR_PENDING_EXCEPTION; | |
| 1494 } | |
| 1495 } | |
| 1496 | |
| 1497 // Call Thread.exit(). We try 3 times in case we got another Thread.stop during | |
| 1498 // the execution of the method. If that is not enough, then we don't really care. Thread.stop | |
| 1499 // is deprecated anyhow. | |
| 1500 { int count = 3; | |
| 1501 while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) { | |
| 1502 EXCEPTION_MARK; | |
| 1503 JavaValue result(T_VOID); | |
| 1504 KlassHandle thread_klass(THREAD, SystemDictionary::thread_klass()); | |
| 1505 JavaCalls::call_virtual(&result, | |
| 1506 threadObj, thread_klass, | |
| 1507 vmSymbolHandles::exit_method_name(), | |
| 1508 vmSymbolHandles::void_method_signature(), | |
| 1509 THREAD); | |
| 1510 CLEAR_PENDING_EXCEPTION; | |
| 1511 } | |
| 1512 } | |
| 1513 | |
| 1514 // notify JVMTI | |
| 1515 if (JvmtiExport::should_post_thread_life()) { | |
| 1516 JvmtiExport::post_thread_end(this); | |
| 1517 } | |
| 1518 | |
| 1519 // We have notified the agents that we are exiting, before we go on, | |
| 1520 // we must check for a pending external suspend request and honor it | |
| 1521 // in order to not surprise the thread that made the suspend request. | |
| 1522 while (true) { | |
| 1523 { | |
| 1524 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 1525 if (!is_external_suspend()) { | |
| 1526 set_terminated(_thread_exiting); | |
| 1527 ThreadService::current_thread_exiting(this); | |
| 1528 break; | |
| 1529 } | |
| 1530 // Implied else: | |
| 1531 // Things get a little tricky here. We have a pending external | |
| 1532 // suspend request, but we are holding the SR_lock so we | |
| 1533 // can't just self-suspend. So we temporarily drop the lock | |
| 1534 // and then self-suspend. | |
| 1535 } | |
| 1536 | |
| 1537 ThreadBlockInVM tbivm(this); | |
| 1538 java_suspend_self(); | |
| 1539 | |
| 1540 // We're done with this suspend request, but we have to loop around | |
| 1541 // and check again. Eventually we will get SR_lock without a pending | |
| 1542 // external suspend request and will be able to mark ourselves as | |
| 1543 // exiting. | |
| 1544 } | |
| 1545 // no more external suspends are allowed at this point | |
| 1546 } else { | |
| 1547 // before_exit() has already posted JVMTI THREAD_END events | |
| 1548 } | |
| 1549 | |
| 1550 // Notify waiters on thread object. This has to be done after exit() is called | |
| 1551 // on the thread (if the thread is the last thread in a daemon ThreadGroup the | |
| 1552 // group should have the destroyed bit set before waiters are notified). | |
| 1553 ensure_join(this); | |
| 1554 assert(!this->has_pending_exception(), "ensure_join should have cleared"); | |
| 1555 | |
| 1556 // 6282335 JNI DetachCurrentThread spec states that all Java monitors | |
| 1557 // held by this thread must be released. A detach operation must only | |
| 1558 // get here if there are no Java frames on the stack. Therefore, any | |
| 1559 // owned monitors at this point MUST be JNI-acquired monitors which are | |
| 1560 // pre-inflated and in the monitor cache. | |
| 1561 // | |
| 1562 // ensure_join() ignores IllegalThreadStateExceptions, and so does this. | |
| 1563 if (exit_type == jni_detach && JNIDetachReleasesMonitors) { | |
| 1564 assert(!this->has_last_Java_frame(), "detaching with Java frames?"); | |
| 1565 ObjectSynchronizer::release_monitors_owned_by_thread(this); | |
| 1566 assert(!this->has_pending_exception(), "release_monitors should have cleared"); | |
| 1567 } | |
| 1568 | |
| 1569 // These things needs to be done while we are still a Java Thread. Make sure that thread | |
| 1570 // is in a consistent state, in case GC happens | |
| 1571 assert(_privileged_stack_top == NULL, "must be NULL when we get here"); | |
| 1572 | |
| 1573 if (active_handles() != NULL) { | |
| 1574 JNIHandleBlock* block = active_handles(); | |
| 1575 set_active_handles(NULL); | |
| 1576 JNIHandleBlock::release_block(block); | |
| 1577 } | |
| 1578 | |
| 1579 if (free_handle_block() != NULL) { | |
| 1580 JNIHandleBlock* block = free_handle_block(); | |
| 1581 set_free_handle_block(NULL); | |
| 1582 JNIHandleBlock::release_block(block); | |
| 1583 } | |
| 1584 | |
| 1585 // These have to be removed while this is still a valid thread. | |
| 1586 remove_stack_guard_pages(); | |
| 1587 | |
| 1588 if (UseTLAB) { | |
| 1589 tlab().make_parsable(true); // retire TLAB | |
| 1590 } | |
| 1591 | |
|
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1592 if (jvmti_thread_state() != NULL) { |
|
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1593 JvmtiExport::cleanup_thread(this); |
|
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1594 } |
|
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1595 |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1596 #ifndef SERIALGC |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1597 // We must flush G1-related buffers before removing a thread from |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1598 // the list of active threads. |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1599 if (UseG1GC) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1600 flush_barrier_queues(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1601 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1602 #endif |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1603 |
| 0 | 1604 // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread |
| 1605 Threads::remove(this); | |
| 1606 } | |
| 1607 | |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1608 #ifndef SERIALGC |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1609 // Flush G1-related queues. |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1610 void JavaThread::flush_barrier_queues() { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1611 satb_mark_queue().flush(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1612 dirty_card_queue().flush(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1613 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1614 #endif |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1615 |
| 0 | 1616 void JavaThread::cleanup_failed_attach_current_thread() { |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1617 if (get_thread_profiler() != NULL) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1618 get_thread_profiler()->disengage(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1619 ResourceMark rm; |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1620 get_thread_profiler()->print(get_thread_name()); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1621 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1622 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1623 if (active_handles() != NULL) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1624 JNIHandleBlock* block = active_handles(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1625 set_active_handles(NULL); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1626 JNIHandleBlock::release_block(block); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1627 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1628 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1629 if (free_handle_block() != NULL) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1630 JNIHandleBlock* block = free_handle_block(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1631 set_free_handle_block(NULL); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1632 JNIHandleBlock::release_block(block); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1633 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1634 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1635 if (UseTLAB) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1636 tlab().make_parsable(true); // retire TLAB, if any |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1637 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1638 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1639 #ifndef SERIALGC |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1640 if (UseG1GC) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1641 flush_barrier_queues(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1642 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1643 #endif |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1644 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1645 Threads::remove(this); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1646 delete this; |
| 0 | 1647 } |
| 1648 | |
| 1649 | |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1650 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1651 |
| 0 | 1652 JavaThread* JavaThread::active() { |
| 1653 Thread* thread = ThreadLocalStorage::thread(); | |
| 1654 assert(thread != NULL, "just checking"); | |
| 1655 if (thread->is_Java_thread()) { | |
| 1656 return (JavaThread*) thread; | |
| 1657 } else { | |
| 1658 assert(thread->is_VM_thread(), "this must be a vm thread"); | |
| 1659 VM_Operation* op = ((VMThread*) thread)->vm_operation(); | |
| 1660 JavaThread *ret=op == NULL ? NULL : (JavaThread *)op->calling_thread(); | |
| 1661 assert(ret->is_Java_thread(), "must be a Java thread"); | |
| 1662 return ret; | |
| 1663 } | |
| 1664 } | |
| 1665 | |
| 1666 bool JavaThread::is_lock_owned(address adr) const { | |
| 1667 if (lock_is_in_stack(adr)) return true; | |
| 1668 | |
| 1669 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) { | |
| 1670 if (chunk->contains(adr)) return true; | |
| 1671 } | |
| 1672 | |
| 1673 return false; | |
| 1674 } | |
| 1675 | |
| 1676 | |
| 1677 void JavaThread::add_monitor_chunk(MonitorChunk* chunk) { | |
| 1678 chunk->set_next(monitor_chunks()); | |
| 1679 set_monitor_chunks(chunk); | |
| 1680 } | |
| 1681 | |
| 1682 void JavaThread::remove_monitor_chunk(MonitorChunk* chunk) { | |
| 1683 guarantee(monitor_chunks() != NULL, "must be non empty"); | |
| 1684 if (monitor_chunks() == chunk) { | |
| 1685 set_monitor_chunks(chunk->next()); | |
| 1686 } else { | |
| 1687 MonitorChunk* prev = monitor_chunks(); | |
| 1688 while (prev->next() != chunk) prev = prev->next(); | |
| 1689 prev->set_next(chunk->next()); | |
| 1690 } | |
| 1691 } | |
| 1692 | |
| 1693 // JVM support. | |
| 1694 | |
| 1695 // Note: this function shouldn't block if it's called in | |
| 1696 // _thread_in_native_trans state (such as from | |
| 1697 // check_special_condition_for_native_trans()). | |
| 1698 void JavaThread::check_and_handle_async_exceptions(bool check_unsafe_error) { | |
| 1699 | |
| 1700 if (has_last_Java_frame() && has_async_condition()) { | |
| 1701 // If we are at a polling page safepoint (not a poll return) | |
| 1702 // then we must defer async exception because live registers | |
| 1703 // will be clobbered by the exception path. Poll return is | |
| 1704 // ok because the call we a returning from already collides | |
| 1705 // with exception handling registers and so there is no issue. | |
| 1706 // (The exception handling path kills call result registers but | |
| 1707 // this is ok since the exception kills the result anyway). | |
| 1708 | |
| 1709 if (is_at_poll_safepoint()) { | |
| 1710 // if the code we are returning to has deoptimized we must defer | |
| 1711 // the exception otherwise live registers get clobbered on the | |
| 1712 // exception path before deoptimization is able to retrieve them. | |
| 1713 // | |
| 1714 RegisterMap map(this, false); | |
| 1715 frame caller_fr = last_frame().sender(&map); | |
| 1716 assert(caller_fr.is_compiled_frame(), "what?"); | |
| 1717 if (caller_fr.is_deoptimized_frame()) { | |
| 1718 if (TraceExceptions) { | |
| 1719 ResourceMark rm; | |
| 1720 tty->print_cr("deferred async exception at compiled safepoint"); | |
| 1721 } | |
| 1722 return; | |
| 1723 } | |
| 1724 } | |
| 1725 } | |
| 1726 | |
| 1727 JavaThread::AsyncRequests condition = clear_special_runtime_exit_condition(); | |
| 1728 if (condition == _no_async_condition) { | |
| 1729 // Conditions have changed since has_special_runtime_exit_condition() | |
| 1730 // was called: | |
| 1731 // - if we were here only because of an external suspend request, | |
| 1732 // then that was taken care of above (or cancelled) so we are done | |
| 1733 // - if we were here because of another async request, then it has | |
| 1734 // been cleared between the has_special_runtime_exit_condition() | |
| 1735 // and now so again we are done | |
| 1736 return; | |
| 1737 } | |
| 1738 | |
| 1739 // Check for pending async. exception | |
| 1740 if (_pending_async_exception != NULL) { | |
| 1741 // Only overwrite an already pending exception, if it is not a threadDeath. | |
| 1742 if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::threaddeath_klass())) { | |
| 1743 | |
| 1744 // We cannot call Exceptions::_throw(...) here because we cannot block | |
| 1745 set_pending_exception(_pending_async_exception, __FILE__, __LINE__); | |
| 1746 | |
| 1747 if (TraceExceptions) { | |
| 1748 ResourceMark rm; | |
| 1749 tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this); | |
| 1750 if (has_last_Java_frame() ) { | |
| 1751 frame f = last_frame(); | |
| 1752 tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp()); | |
| 1753 } | |
| 1754 tty->print_cr(" of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name()); | |
| 1755 } | |
| 1756 _pending_async_exception = NULL; | |
| 1757 clear_has_async_exception(); | |
| 1758 } | |
| 1759 } | |
| 1760 | |
| 1761 if (check_unsafe_error && | |
| 1762 condition == _async_unsafe_access_error && !has_pending_exception()) { | |
| 1763 condition = _no_async_condition; // done | |
| 1764 switch (thread_state()) { | |
| 1765 case _thread_in_vm: | |
| 1766 { | |
| 1767 JavaThread* THREAD = this; | |
| 1768 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); | |
| 1769 } | |
| 1770 case _thread_in_native: | |
| 1771 { | |
| 1772 ThreadInVMfromNative tiv(this); | |
| 1773 JavaThread* THREAD = this; | |
| 1774 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); | |
| 1775 } | |
| 1776 case _thread_in_Java: | |
| 1777 { | |
| 1778 ThreadInVMfromJava tiv(this); | |
| 1779 JavaThread* THREAD = this; | |
| 1780 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code"); | |
| 1781 } | |
| 1782 default: | |
| 1783 ShouldNotReachHere(); | |
| 1784 } | |
| 1785 } | |
| 1786 | |
| 1787 assert(condition == _no_async_condition || has_pending_exception() || | |
| 1788 (!check_unsafe_error && condition == _async_unsafe_access_error), | |
| 1789 "must have handled the async condition, if no exception"); | |
| 1790 } | |
| 1791 | |
| 1792 void JavaThread::handle_special_runtime_exit_condition(bool check_asyncs) { | |
| 1793 // | |
| 1794 // Check for pending external suspend. Internal suspend requests do | |
| 1795 // not use handle_special_runtime_exit_condition(). | |
| 1796 // If JNIEnv proxies are allowed, don't self-suspend if the target | |
| 1797 // thread is not the current thread. In older versions of jdbx, jdbx | |
| 1798 // threads could call into the VM with another thread's JNIEnv so we | |
| 1799 // can be here operating on behalf of a suspended thread (4432884). | |
| 1800 bool do_self_suspend = is_external_suspend_with_lock(); | |
| 1801 if (do_self_suspend && (!AllowJNIEnvProxy || this == JavaThread::current())) { | |
| 1802 // | |
| 1803 // Because thread is external suspended the safepoint code will count | |
| 1804 // thread as at a safepoint. This can be odd because we can be here | |
| 1805 // as _thread_in_Java which would normally transition to _thread_blocked | |
| 1806 // at a safepoint. We would like to mark the thread as _thread_blocked | |
| 1807 // before calling java_suspend_self like all other callers of it but | |
| 1808 // we must then observe proper safepoint protocol. (We can't leave | |
| 1809 // _thread_blocked with a safepoint in progress). However we can be | |
| 1810 // here as _thread_in_native_trans so we can't use a normal transition | |
| 1811 // constructor/destructor pair because they assert on that type of | |
| 1812 // transition. We could do something like: | |
| 1813 // | |
| 1814 // JavaThreadState state = thread_state(); | |
| 1815 // set_thread_state(_thread_in_vm); | |
| 1816 // { | |
| 1817 // ThreadBlockInVM tbivm(this); | |
| 1818 // java_suspend_self() | |
| 1819 // } | |
| 1820 // set_thread_state(_thread_in_vm_trans); | |
| 1821 // if (safepoint) block; | |
| 1822 // set_thread_state(state); | |
| 1823 // | |
| 1824 // but that is pretty messy. Instead we just go with the way the | |
| 1825 // code has worked before and note that this is the only path to | |
| 1826 // java_suspend_self that doesn't put the thread in _thread_blocked | |
| 1827 // mode. | |
| 1828 | |
| 1829 frame_anchor()->make_walkable(this); | |
| 1830 java_suspend_self(); | |
| 1831 | |
| 1832 // We might be here for reasons in addition to the self-suspend request | |
| 1833 // so check for other async requests. | |
| 1834 } | |
| 1835 | |
| 1836 if (check_asyncs) { | |
| 1837 check_and_handle_async_exceptions(); | |
| 1838 } | |
| 1839 } | |
| 1840 | |
| 1841 void JavaThread::send_thread_stop(oop java_throwable) { | |
| 1842 assert(Thread::current()->is_VM_thread(), "should be in the vm thread"); | |
| 1843 assert(Threads_lock->is_locked(), "Threads_lock should be locked by safepoint code"); | |
| 1844 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped"); | |
| 1845 | |
| 1846 // Do not throw asynchronous exceptions against the compiler thread | |
| 1847 // (the compiler thread should not be a Java thread -- fix in 1.4.2) | |
| 1848 if (is_Compiler_thread()) return; | |
| 1849 | |
| 1850 // This is a change from JDK 1.1, but JDK 1.2 will also do it: | |
| 1851 if (java_throwable->is_a(SystemDictionary::threaddeath_klass())) { | |
| 1852 java_lang_Thread::set_stillborn(threadObj()); | |
| 1853 } | |
| 1854 | |
| 1855 { | |
| 1856 // Actually throw the Throwable against the target Thread - however | |
| 1857 // only if there is no thread death exception installed already. | |
| 1858 if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::threaddeath_klass())) { | |
| 1859 // If the topmost frame is a runtime stub, then we are calling into | |
| 1860 // OptoRuntime from compiled code. Some runtime stubs (new, monitor_exit..) | |
| 1861 // must deoptimize the caller before continuing, as the compiled exception handler table | |
| 1862 // may not be valid | |
| 1863 if (has_last_Java_frame()) { | |
| 1864 frame f = last_frame(); | |
| 1865 if (f.is_runtime_frame() || f.is_safepoint_blob_frame()) { | |
| 1866 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
| 1867 RegisterMap reg_map(this, UseBiasedLocking); | |
| 1868 frame compiled_frame = f.sender(®_map); | |
| 1869 if (compiled_frame.can_be_deoptimized()) { | |
| 1870 Deoptimization::deoptimize(this, compiled_frame, ®_map); | |
| 1871 } | |
| 1872 } | |
| 1873 } | |
| 1874 | |
| 1875 // Set async. pending exception in thread. | |
| 1876 set_pending_async_exception(java_throwable); | |
| 1877 | |
| 1878 if (TraceExceptions) { | |
| 1879 ResourceMark rm; | |
| 1880 tty->print_cr("Pending Async. exception installed of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name()); | |
| 1881 } | |
| 1882 // for AbortVMOnException flag | |
| 1883 NOT_PRODUCT(Exceptions::debug_check_abort(instanceKlass::cast(_pending_async_exception->klass())->external_name())); | |
| 1884 } | |
| 1885 } | |
| 1886 | |
| 1887 | |
| 1888 // Interrupt thread so it will wake up from a potential wait() | |
| 1889 Thread::interrupt(this); | |
| 1890 } | |
| 1891 | |
| 1892 // External suspension mechanism. | |
| 1893 // | |
| 1894 // Tell the VM to suspend a thread when ever it knows that it does not hold on | |
| 1895 // to any VM_locks and it is at a transition | |
| 1896 // Self-suspension will happen on the transition out of the vm. | |
| 1897 // Catch "this" coming in from JNIEnv pointers when the thread has been freed | |
| 1898 // | |
| 1899 // Guarantees on return: | |
| 1900 // + Target thread will not execute any new bytecode (that's why we need to | |
| 1901 // force a safepoint) | |
| 1902 // + Target thread will not enter any new monitors | |
| 1903 // | |
| 1904 void JavaThread::java_suspend() { | |
| 1905 { MutexLocker mu(Threads_lock); | |
| 1906 if (!Threads::includes(this) || is_exiting() || this->threadObj() == NULL) { | |
| 1907 return; | |
| 1908 } | |
| 1909 } | |
| 1910 | |
| 1911 { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 1912 if (!is_external_suspend()) { | |
| 1913 // a racing resume has cancelled us; bail out now | |
| 1914 return; | |
| 1915 } | |
| 1916 | |
| 1917 // suspend is done | |
| 1918 uint32_t debug_bits = 0; | |
| 1919 // Warning: is_ext_suspend_completed() may temporarily drop the | |
| 1920 // SR_lock to allow the thread to reach a stable thread state if | |
| 1921 // it is currently in a transient thread state. | |
| 1922 if (is_ext_suspend_completed(false /* !called_by_wait */, | |
| 1923 SuspendRetryDelay, &debug_bits) ) { | |
| 1924 return; | |
| 1925 } | |
| 1926 } | |
| 1927 | |
| 1928 VM_ForceSafepoint vm_suspend; | |
| 1929 VMThread::execute(&vm_suspend); | |
| 1930 } | |
| 1931 | |
| 1932 // Part II of external suspension. | |
| 1933 // A JavaThread self suspends when it detects a pending external suspend | |
| 1934 // request. This is usually on transitions. It is also done in places | |
| 1935 // where continuing to the next transition would surprise the caller, | |
| 1936 // e.g., monitor entry. | |
| 1937 // | |
| 1938 // Returns the number of times that the thread self-suspended. | |
| 1939 // | |
| 1940 // Note: DO NOT call java_suspend_self() when you just want to block current | |
| 1941 // thread. java_suspend_self() is the second stage of cooperative | |
| 1942 // suspension for external suspend requests and should only be used | |
| 1943 // to complete an external suspend request. | |
| 1944 // | |
| 1945 int JavaThread::java_suspend_self() { | |
| 1946 int ret = 0; | |
| 1947 | |
| 1948 // we are in the process of exiting so don't suspend | |
| 1949 if (is_exiting()) { | |
| 1950 clear_external_suspend(); | |
| 1951 return ret; | |
| 1952 } | |
| 1953 | |
| 1954 assert(_anchor.walkable() || | |
| 1955 (is_Java_thread() && !((JavaThread*)this)->has_last_Java_frame()), | |
| 1956 "must have walkable stack"); | |
| 1957 | |
| 1958 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 1959 | |
| 1960 assert(!this->is_any_suspended(), | |
| 1961 "a thread trying to self-suspend should not already be suspended"); | |
| 1962 | |
| 1963 if (this->is_suspend_equivalent()) { | |
| 1964 // If we are self-suspending as a result of the lifting of a | |
| 1965 // suspend equivalent condition, then the suspend_equivalent | |
| 1966 // flag is not cleared until we set the ext_suspended flag so | |
| 1967 // that wait_for_ext_suspend_completion() returns consistent | |
| 1968 // results. | |
| 1969 this->clear_suspend_equivalent(); | |
| 1970 } | |
| 1971 | |
| 1972 // A racing resume may have cancelled us before we grabbed SR_lock | |
| 1973 // above. Or another external suspend request could be waiting for us | |
| 1974 // by the time we return from SR_lock()->wait(). The thread | |
| 1975 // that requested the suspension may already be trying to walk our | |
| 1976 // stack and if we return now, we can change the stack out from under | |
| 1977 // it. This would be a "bad thing (TM)" and cause the stack walker | |
| 1978 // to crash. We stay self-suspended until there are no more pending | |
| 1979 // external suspend requests. | |
| 1980 while (is_external_suspend()) { | |
| 1981 ret++; | |
| 1982 this->set_ext_suspended(); | |
| 1983 | |
| 1984 // _ext_suspended flag is cleared by java_resume() | |
| 1985 while (is_ext_suspended()) { | |
| 1986 this->SR_lock()->wait(Mutex::_no_safepoint_check_flag); | |
| 1987 } | |
| 1988 } | |
| 1989 | |
| 1990 return ret; | |
| 1991 } | |
| 1992 | |
| 1993 #ifdef ASSERT | |
| 1994 // verify the JavaThread has not yet been published in the Threads::list, and | |
| 1995 // hence doesn't need protection from concurrent access at this stage | |
| 1996 void JavaThread::verify_not_published() { | |
| 1997 if (!Threads_lock->owned_by_self()) { | |
| 1998 MutexLockerEx ml(Threads_lock, Mutex::_no_safepoint_check_flag); | |
| 1999 assert( !Threads::includes(this), | |
| 2000 "java thread shouldn't have been published yet!"); | |
| 2001 } | |
| 2002 else { | |
| 2003 assert( !Threads::includes(this), | |
| 2004 "java thread shouldn't have been published yet!"); | |
| 2005 } | |
| 2006 } | |
| 2007 #endif | |
| 2008 | |
| 2009 // Slow path when the native==>VM/Java barriers detect a safepoint is in | |
| 2010 // progress or when _suspend_flags is non-zero. | |
| 2011 // Current thread needs to self-suspend if there is a suspend request and/or | |
| 2012 // block if a safepoint is in progress. | |
| 2013 // Async exception ISN'T checked. | |
| 2014 // Note only the ThreadInVMfromNative transition can call this function | |
| 2015 // directly and when thread state is _thread_in_native_trans | |
| 2016 void JavaThread::check_safepoint_and_suspend_for_native_trans(JavaThread *thread) { | |
| 2017 assert(thread->thread_state() == _thread_in_native_trans, "wrong state"); | |
| 2018 | |
| 2019 JavaThread *curJT = JavaThread::current(); | |
| 2020 bool do_self_suspend = thread->is_external_suspend(); | |
| 2021 | |
| 2022 assert(!curJT->has_last_Java_frame() || curJT->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition"); | |
| 2023 | |
| 2024 // If JNIEnv proxies are allowed, don't self-suspend if the target | |
| 2025 // thread is not the current thread. In older versions of jdbx, jdbx | |
| 2026 // threads could call into the VM with another thread's JNIEnv so we | |
| 2027 // can be here operating on behalf of a suspended thread (4432884). | |
| 2028 if (do_self_suspend && (!AllowJNIEnvProxy || curJT == thread)) { | |
| 2029 JavaThreadState state = thread->thread_state(); | |
| 2030 | |
| 2031 // We mark this thread_blocked state as a suspend-equivalent so | |
| 2032 // that a caller to is_ext_suspend_completed() won't be confused. | |
| 2033 // The suspend-equivalent state is cleared by java_suspend_self(). | |
| 2034 thread->set_suspend_equivalent(); | |
| 2035 | |
| 2036 // If the safepoint code sees the _thread_in_native_trans state, it will | |
| 2037 // wait until the thread changes to other thread state. There is no | |
| 2038 // guarantee on how soon we can obtain the SR_lock and complete the | |
| 2039 // self-suspend request. It would be a bad idea to let safepoint wait for | |
| 2040 // too long. Temporarily change the state to _thread_blocked to | |
| 2041 // let the VM thread know that this thread is ready for GC. The problem | |
| 2042 // of changing thread state is that safepoint could happen just after | |
| 2043 // java_suspend_self() returns after being resumed, and VM thread will | |
| 2044 // see the _thread_blocked state. We must check for safepoint | |
| 2045 // after restoring the state and make sure we won't leave while a safepoint | |
| 2046 // is in progress. | |
| 2047 thread->set_thread_state(_thread_blocked); | |
| 2048 thread->java_suspend_self(); | |
| 2049 thread->set_thread_state(state); | |
| 2050 // Make sure new state is seen by VM thread | |
| 2051 if (os::is_MP()) { | |
| 2052 if (UseMembar) { | |
| 2053 // Force a fence between the write above and read below | |
| 2054 OrderAccess::fence(); | |
| 2055 } else { | |
| 2056 // Must use this rather than serialization page in particular on Windows | |
| 2057 InterfaceSupport::serialize_memory(thread); | |
| 2058 } | |
| 2059 } | |
| 2060 } | |
| 2061 | |
| 2062 if (SafepointSynchronize::do_call_back()) { | |
| 2063 // If we are safepointing, then block the caller which may not be | |
| 2064 // the same as the target thread (see above). | |
| 2065 SafepointSynchronize::block(curJT); | |
| 2066 } | |
| 2067 | |
| 2068 if (thread->is_deopt_suspend()) { | |
| 2069 thread->clear_deopt_suspend(); | |
| 2070 RegisterMap map(thread, false); | |
| 2071 frame f = thread->last_frame(); | |
| 2072 while ( f.id() != thread->must_deopt_id() && ! f.is_first_frame()) { | |
| 2073 f = f.sender(&map); | |
| 2074 } | |
| 2075 if (f.id() == thread->must_deopt_id()) { | |
| 2076 thread->clear_must_deopt_id(); | |
| 2077 // Since we know we're safe to deopt the current state is a safe state | |
| 2078 f.deoptimize(thread, true); | |
| 2079 } else { | |
| 2080 fatal("missed deoptimization!"); | |
| 2081 } | |
| 2082 } | |
| 2083 } | |
| 2084 | |
| 2085 // Slow path when the native==>VM/Java barriers detect a safepoint is in | |
| 2086 // progress or when _suspend_flags is non-zero. | |
| 2087 // Current thread needs to self-suspend if there is a suspend request and/or | |
| 2088 // block if a safepoint is in progress. | |
| 2089 // Also check for pending async exception (not including unsafe access error). | |
| 2090 // Note only the native==>VM/Java barriers can call this function and when | |
| 2091 // thread state is _thread_in_native_trans. | |
| 2092 void JavaThread::check_special_condition_for_native_trans(JavaThread *thread) { | |
| 2093 check_safepoint_and_suspend_for_native_trans(thread); | |
| 2094 | |
| 2095 if (thread->has_async_exception()) { | |
| 2096 // We are in _thread_in_native_trans state, don't handle unsafe | |
| 2097 // access error since that may block. | |
| 2098 thread->check_and_handle_async_exceptions(false); | |
| 2099 } | |
| 2100 } | |
| 2101 | |
| 2102 // We need to guarantee the Threads_lock here, since resumes are not | |
| 2103 // allowed during safepoint synchronization | |
| 2104 // Can only resume from an external suspension | |
| 2105 void JavaThread::java_resume() { | |
| 2106 assert_locked_or_safepoint(Threads_lock); | |
| 2107 | |
| 2108 // Sanity check: thread is gone, has started exiting or the thread | |
| 2109 // was not externally suspended. | |
| 2110 if (!Threads::includes(this) || is_exiting() || !is_external_suspend()) { | |
| 2111 return; | |
| 2112 } | |
| 2113 | |
| 2114 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 2115 | |
| 2116 clear_external_suspend(); | |
| 2117 | |
| 2118 if (is_ext_suspended()) { | |
| 2119 clear_ext_suspended(); | |
| 2120 SR_lock()->notify_all(); | |
| 2121 } | |
| 2122 } | |
| 2123 | |
| 2124 void JavaThread::create_stack_guard_pages() { | |
| 2125 if (! os::uses_stack_guard_pages() || _stack_guard_state != stack_guard_unused) return; | |
| 2126 address low_addr = stack_base() - stack_size(); | |
| 2127 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size(); | |
| 2128 | |
| 2129 int allocate = os::allocate_stack_guard_pages(); | |
| 2130 // warning("Guarding at " PTR_FORMAT " for len " SIZE_FORMAT "\n", low_addr, len); | |
| 2131 | |
| 2132 if (allocate && !os::commit_memory((char *) low_addr, len)) { | |
| 2133 warning("Attempt to allocate stack guard pages failed."); | |
| 2134 return; | |
| 2135 } | |
| 2136 | |
| 2137 if (os::guard_memory((char *) low_addr, len)) { | |
| 2138 _stack_guard_state = stack_guard_enabled; | |
| 2139 } else { | |
| 2140 warning("Attempt to protect stack guard pages failed."); | |
| 2141 if (os::uncommit_memory((char *) low_addr, len)) { | |
| 2142 warning("Attempt to deallocate stack guard pages failed."); | |
| 2143 } | |
| 2144 } | |
| 2145 } | |
| 2146 | |
| 2147 void JavaThread::remove_stack_guard_pages() { | |
| 2148 if (_stack_guard_state == stack_guard_unused) return; | |
| 2149 address low_addr = stack_base() - stack_size(); | |
| 2150 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size(); | |
| 2151 | |
| 2152 if (os::allocate_stack_guard_pages()) { | |
| 2153 if (os::uncommit_memory((char *) low_addr, len)) { | |
| 2154 _stack_guard_state = stack_guard_unused; | |
| 2155 } else { | |
| 2156 warning("Attempt to deallocate stack guard pages failed."); | |
| 2157 } | |
| 2158 } else { | |
| 2159 if (_stack_guard_state == stack_guard_unused) return; | |
| 2160 if (os::unguard_memory((char *) low_addr, len)) { | |
| 2161 _stack_guard_state = stack_guard_unused; | |
| 2162 } else { | |
| 2163 warning("Attempt to unprotect stack guard pages failed."); | |
| 2164 } | |
| 2165 } | |
| 2166 } | |
| 2167 | |
| 2168 void JavaThread::enable_stack_yellow_zone() { | |
| 2169 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
| 2170 assert(_stack_guard_state != stack_guard_enabled, "already enabled"); | |
| 2171 | |
| 2172 // The base notation is from the stacks point of view, growing downward. | |
| 2173 // We need to adjust it to work correctly with guard_memory() | |
| 2174 address base = stack_yellow_zone_base() - stack_yellow_zone_size(); | |
| 2175 | |
| 2176 guarantee(base < stack_base(),"Error calculating stack yellow zone"); | |
| 2177 guarantee(base < os::current_stack_pointer(),"Error calculating stack yellow zone"); | |
| 2178 | |
| 2179 if (os::guard_memory((char *) base, stack_yellow_zone_size())) { | |
| 2180 _stack_guard_state = stack_guard_enabled; | |
| 2181 } else { | |
| 2182 warning("Attempt to guard stack yellow zone failed."); | |
| 2183 } | |
| 2184 enable_register_stack_guard(); | |
| 2185 } | |
| 2186 | |
| 2187 void JavaThread::disable_stack_yellow_zone() { | |
| 2188 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
| 2189 assert(_stack_guard_state != stack_guard_yellow_disabled, "already disabled"); | |
| 2190 | |
| 2191 // Simply return if called for a thread that does not use guard pages. | |
| 2192 if (_stack_guard_state == stack_guard_unused) return; | |
| 2193 | |
| 2194 // The base notation is from the stacks point of view, growing downward. | |
| 2195 // We need to adjust it to work correctly with guard_memory() | |
| 2196 address base = stack_yellow_zone_base() - stack_yellow_zone_size(); | |
| 2197 | |
| 2198 if (os::unguard_memory((char *)base, stack_yellow_zone_size())) { | |
| 2199 _stack_guard_state = stack_guard_yellow_disabled; | |
| 2200 } else { | |
| 2201 warning("Attempt to unguard stack yellow zone failed."); | |
| 2202 } | |
| 2203 disable_register_stack_guard(); | |
| 2204 } | |
| 2205 | |
| 2206 void JavaThread::enable_stack_red_zone() { | |
| 2207 // The base notation is from the stacks point of view, growing downward. | |
| 2208 // We need to adjust it to work correctly with guard_memory() | |
| 2209 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
| 2210 address base = stack_red_zone_base() - stack_red_zone_size(); | |
| 2211 | |
| 2212 guarantee(base < stack_base(),"Error calculating stack red zone"); | |
| 2213 guarantee(base < os::current_stack_pointer(),"Error calculating stack red zone"); | |
| 2214 | |
| 2215 if(!os::guard_memory((char *) base, stack_red_zone_size())) { | |
| 2216 warning("Attempt to guard stack red zone failed."); | |
| 2217 } | |
| 2218 } | |
| 2219 | |
| 2220 void JavaThread::disable_stack_red_zone() { | |
| 2221 // The base notation is from the stacks point of view, growing downward. | |
| 2222 // We need to adjust it to work correctly with guard_memory() | |
| 2223 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
| 2224 address base = stack_red_zone_base() - stack_red_zone_size(); | |
| 2225 if (!os::unguard_memory((char *)base, stack_red_zone_size())) { | |
| 2226 warning("Attempt to unguard stack red zone failed."); | |
| 2227 } | |
| 2228 } | |
| 2229 | |
| 2230 void JavaThread::frames_do(void f(frame*, const RegisterMap* map)) { | |
| 2231 // ignore is there is no stack | |
| 2232 if (!has_last_Java_frame()) return; | |
| 2233 // traverse the stack frames. Starts from top frame. | |
| 2234 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
| 2235 frame* fr = fst.current(); | |
| 2236 f(fr, fst.register_map()); | |
| 2237 } | |
| 2238 } | |
| 2239 | |
| 2240 | |
| 2241 #ifndef PRODUCT | |
| 2242 // Deoptimization | |
| 2243 // Function for testing deoptimization | |
| 2244 void JavaThread::deoptimize() { | |
| 2245 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
| 2246 StackFrameStream fst(this, UseBiasedLocking); | |
| 2247 bool deopt = false; // Dump stack only if a deopt actually happens. | |
| 2248 bool only_at = strlen(DeoptimizeOnlyAt) > 0; | |
| 2249 // Iterate over all frames in the thread and deoptimize | |
| 2250 for(; !fst.is_done(); fst.next()) { | |
| 2251 if(fst.current()->can_be_deoptimized()) { | |
| 2252 | |
| 2253 if (only_at) { | |
| 2254 // Deoptimize only at particular bcis. DeoptimizeOnlyAt | |
| 2255 // consists of comma or carriage return separated numbers so | |
| 2256 // search for the current bci in that string. | |
| 2257 address pc = fst.current()->pc(); | |
| 2258 nmethod* nm = (nmethod*) fst.current()->cb(); | |
| 2259 ScopeDesc* sd = nm->scope_desc_at( pc); | |
| 2260 char buffer[8]; | |
| 2261 jio_snprintf(buffer, sizeof(buffer), "%d", sd->bci()); | |
| 2262 size_t len = strlen(buffer); | |
| 2263 const char * found = strstr(DeoptimizeOnlyAt, buffer); | |
| 2264 while (found != NULL) { | |
| 2265 if ((found[len] == ',' || found[len] == '\n' || found[len] == '\0') && | |
| 2266 (found == DeoptimizeOnlyAt || found[-1] == ',' || found[-1] == '\n')) { | |
| 2267 // Check that the bci found is bracketed by terminators. | |
| 2268 break; | |
| 2269 } | |
| 2270 found = strstr(found + 1, buffer); | |
| 2271 } | |
| 2272 if (!found) { | |
| 2273 continue; | |
| 2274 } | |
| 2275 } | |
| 2276 | |
| 2277 if (DebugDeoptimization && !deopt) { | |
| 2278 deopt = true; // One-time only print before deopt | |
| 2279 tty->print_cr("[BEFORE Deoptimization]"); | |
| 2280 trace_frames(); | |
| 2281 trace_stack(); | |
| 2282 } | |
| 2283 Deoptimization::deoptimize(this, *fst.current(), fst.register_map()); | |
| 2284 } | |
| 2285 } | |
| 2286 | |
| 2287 if (DebugDeoptimization && deopt) { | |
| 2288 tty->print_cr("[AFTER Deoptimization]"); | |
| 2289 trace_frames(); | |
| 2290 } | |
| 2291 } | |
| 2292 | |
| 2293 | |
| 2294 // Make zombies | |
| 2295 void JavaThread::make_zombies() { | |
| 2296 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
| 2297 if (fst.current()->can_be_deoptimized()) { | |
| 2298 // it is a Java nmethod | |
| 2299 nmethod* nm = CodeCache::find_nmethod(fst.current()->pc()); | |
| 2300 nm->make_not_entrant(); | |
| 2301 } | |
| 2302 } | |
| 2303 } | |
| 2304 #endif // PRODUCT | |
| 2305 | |
| 2306 | |
| 2307 void JavaThread::deoptimized_wrt_marked_nmethods() { | |
| 2308 if (!has_last_Java_frame()) return; | |
| 2309 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
| 2310 StackFrameStream fst(this, UseBiasedLocking); | |
| 2311 for(; !fst.is_done(); fst.next()) { | |
| 2312 if (fst.current()->should_be_deoptimized()) { | |
| 2313 Deoptimization::deoptimize(this, *fst.current(), fst.register_map()); | |
| 2314 } | |
| 2315 } | |
| 2316 } | |
| 2317 | |
| 2318 | |
| 2319 // GC support | |
| 2320 static void frame_gc_epilogue(frame* f, const RegisterMap* map) { f->gc_epilogue(); } | |
| 2321 | |
| 2322 void JavaThread::gc_epilogue() { | |
| 2323 frames_do(frame_gc_epilogue); | |
| 2324 } | |
| 2325 | |
| 2326 | |
| 2327 static void frame_gc_prologue(frame* f, const RegisterMap* map) { f->gc_prologue(); } | |
| 2328 | |
| 2329 void JavaThread::gc_prologue() { | |
| 2330 frames_do(frame_gc_prologue); | |
| 2331 } | |
| 2332 | |
| 2333 | |
| 2334 void JavaThread::oops_do(OopClosure* f) { | |
| 2335 // The ThreadProfiler oops_do is done from FlatProfiler::oops_do | |
| 2336 // since there may be more than one thread using each ThreadProfiler. | |
| 2337 | |
| 2338 // Traverse the GCHandles | |
| 2339 Thread::oops_do(f); | |
| 2340 | |
| 2341 assert( (!has_last_Java_frame() && java_call_counter() == 0) || | |
| 2342 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!"); | |
| 2343 | |
| 2344 if (has_last_Java_frame()) { | |
| 2345 | |
| 2346 // Traverse the privileged stack | |
| 2347 if (_privileged_stack_top != NULL) { | |
| 2348 _privileged_stack_top->oops_do(f); | |
| 2349 } | |
| 2350 | |
| 2351 // traverse the registered growable array | |
| 2352 if (_array_for_gc != NULL) { | |
| 2353 for (int index = 0; index < _array_for_gc->length(); index++) { | |
| 2354 f->do_oop(_array_for_gc->adr_at(index)); | |
| 2355 } | |
| 2356 } | |
| 2357 | |
| 2358 // Traverse the monitor chunks | |
| 2359 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) { | |
| 2360 chunk->oops_do(f); | |
| 2361 } | |
| 2362 | |
| 2363 // Traverse the execution stack | |
| 2364 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
| 2365 fst.current()->oops_do(f, fst.register_map()); | |
| 2366 } | |
| 2367 } | |
| 2368 | |
| 2369 // callee_target is never live across a gc point so NULL it here should | |
| 2370 // it still contain a methdOop. | |
| 2371 | |
| 2372 set_callee_target(NULL); | |
| 2373 | |
| 2374 assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!"); | |
| 2375 // If we have deferred set_locals there might be oops waiting to be | |
| 2376 // written | |
| 2377 GrowableArray<jvmtiDeferredLocalVariableSet*>* list = deferred_locals(); | |
| 2378 if (list != NULL) { | |
| 2379 for (int i = 0; i < list->length(); i++) { | |
| 2380 list->at(i)->oops_do(f); | |
| 2381 } | |
| 2382 } | |
| 2383 | |
| 2384 // Traverse instance variables at the end since the GC may be moving things | |
| 2385 // around using this function | |
| 2386 f->do_oop((oop*) &_threadObj); | |
| 2387 f->do_oop((oop*) &_vm_result); | |
| 2388 f->do_oop((oop*) &_vm_result_2); | |
| 2389 f->do_oop((oop*) &_exception_oop); | |
| 2390 f->do_oop((oop*) &_pending_async_exception); | |
| 2391 | |
| 2392 if (jvmti_thread_state() != NULL) { | |
| 2393 jvmti_thread_state()->oops_do(f); | |
| 2394 } | |
| 2395 } | |
| 2396 | |
| 2397 void JavaThread::nmethods_do() { | |
| 2398 // Traverse the GCHandles | |
| 2399 Thread::nmethods_do(); | |
| 2400 | |
| 2401 assert( (!has_last_Java_frame() && java_call_counter() == 0) || | |
| 2402 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!"); | |
| 2403 | |
| 2404 if (has_last_Java_frame()) { | |
| 2405 // Traverse the execution stack | |
| 2406 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
| 2407 fst.current()->nmethods_do(); | |
| 2408 } | |
| 2409 } | |
| 2410 } | |
| 2411 | |
| 2412 // Printing | |
| 2413 const char* _get_thread_state_name(JavaThreadState _thread_state) { | |
| 2414 switch (_thread_state) { | |
| 2415 case _thread_uninitialized: return "_thread_uninitialized"; | |
| 2416 case _thread_new: return "_thread_new"; | |
| 2417 case _thread_new_trans: return "_thread_new_trans"; | |
| 2418 case _thread_in_native: return "_thread_in_native"; | |
| 2419 case _thread_in_native_trans: return "_thread_in_native_trans"; | |
| 2420 case _thread_in_vm: return "_thread_in_vm"; | |
| 2421 case _thread_in_vm_trans: return "_thread_in_vm_trans"; | |
| 2422 case _thread_in_Java: return "_thread_in_Java"; | |
| 2423 case _thread_in_Java_trans: return "_thread_in_Java_trans"; | |
| 2424 case _thread_blocked: return "_thread_blocked"; | |
| 2425 case _thread_blocked_trans: return "_thread_blocked_trans"; | |
| 2426 default: return "unknown thread state"; | |
| 2427 } | |
| 2428 } | |
| 2429 | |
| 2430 #ifndef PRODUCT | |
| 2431 void JavaThread::print_thread_state_on(outputStream *st) const { | |
| 2432 st->print_cr(" JavaThread state: %s", _get_thread_state_name(_thread_state)); | |
| 2433 }; | |
| 2434 void JavaThread::print_thread_state() const { | |
| 2435 print_thread_state_on(tty); | |
| 2436 }; | |
| 2437 #endif // PRODUCT | |
| 2438 | |
| 2439 // Called by Threads::print() for VM_PrintThreads operation | |
| 2440 void JavaThread::print_on(outputStream *st) const { | |
| 2441 st->print("\"%s\" ", get_thread_name()); | |
| 2442 oop thread_oop = threadObj(); | |
| 2443 if (thread_oop != NULL && java_lang_Thread::is_daemon(thread_oop)) st->print("daemon "); | |
| 2444 Thread::print_on(st); | |
| 2445 // print guess for valid stack memory region (assume 4K pages); helps lock debugging | |
| 2446 st->print_cr("[" INTPTR_FORMAT ".." INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12), highest_lock()); | |
| 2447 if (thread_oop != NULL && JDK_Version::is_gte_jdk15x_version()) { | |
| 2448 st->print_cr(" java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop)); | |
| 2449 } | |
| 2450 #ifndef PRODUCT | |
| 2451 print_thread_state_on(st); | |
| 2452 _safepoint_state->print_on(st); | |
| 2453 #endif // PRODUCT | |
| 2454 } | |
| 2455 | |
| 2456 // Called by fatal error handler. The difference between this and | |
| 2457 // JavaThread::print() is that we can't grab lock or allocate memory. | |
| 2458 void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const { | |
| 2459 st->print("JavaThread \"%s\"", get_thread_name_string(buf, buflen)); | |
| 2460 oop thread_obj = threadObj(); | |
| 2461 if (thread_obj != NULL) { | |
| 2462 if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon"); | |
| 2463 } | |
| 2464 st->print(" ["); | |
| 2465 st->print("%s", _get_thread_state_name(_thread_state)); | |
| 2466 if (osthread()) { | |
| 2467 st->print(", id=%d", osthread()->thread_id()); | |
| 2468 } | |
| 2469 st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")", | |
| 2470 _stack_base - _stack_size, _stack_base); | |
| 2471 st->print("]"); | |
| 2472 return; | |
| 2473 } | |
| 2474 | |
| 2475 // Verification | |
| 2476 | |
| 2477 static void frame_verify(frame* f, const RegisterMap *map) { f->verify(map); } | |
| 2478 | |
| 2479 void JavaThread::verify() { | |
| 2480 // Verify oops in the thread. | |
| 2481 oops_do(&VerifyOopClosure::verify_oop); | |
| 2482 | |
| 2483 // Verify the stack frames. | |
| 2484 frames_do(frame_verify); | |
| 2485 } | |
| 2486 | |
| 2487 // CR 6300358 (sub-CR 2137150) | |
| 2488 // Most callers of this method assume that it can't return NULL but a | |
| 2489 // thread may not have a name whilst it is in the process of attaching to | |
| 2490 // the VM - see CR 6412693, and there are places where a JavaThread can be | |
| 2491 // seen prior to having it's threadObj set (eg JNI attaching threads and | |
| 2492 // if vm exit occurs during initialization). These cases can all be accounted | |
| 2493 // for such that this method never returns NULL. | |
| 2494 const char* JavaThread::get_thread_name() const { | |
| 2495 #ifdef ASSERT | |
| 2496 // early safepoints can hit while current thread does not yet have TLS | |
| 2497 if (!SafepointSynchronize::is_at_safepoint()) { | |
| 2498 Thread *cur = Thread::current(); | |
| 2499 if (!(cur->is_Java_thread() && cur == this)) { | |
| 2500 // Current JavaThreads are allowed to get their own name without | |
| 2501 // the Threads_lock. | |
| 2502 assert_locked_or_safepoint(Threads_lock); | |
| 2503 } | |
| 2504 } | |
| 2505 #endif // ASSERT | |
| 2506 return get_thread_name_string(); | |
| 2507 } | |
| 2508 | |
| 2509 // Returns a non-NULL representation of this thread's name, or a suitable | |
| 2510 // descriptive string if there is no set name | |
| 2511 const char* JavaThread::get_thread_name_string(char* buf, int buflen) const { | |
| 2512 const char* name_str; | |
| 2513 oop thread_obj = threadObj(); | |
| 2514 if (thread_obj != NULL) { | |
| 2515 typeArrayOop name = java_lang_Thread::name(thread_obj); | |
| 2516 if (name != NULL) { | |
| 2517 if (buf == NULL) { | |
| 2518 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
| 2519 } | |
| 2520 else { | |
| 2521 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length(), buf, buflen); | |
| 2522 } | |
| 2523 } | |
| 2524 else if (is_attaching()) { // workaround for 6412693 - see 6404306 | |
| 2525 name_str = "<no-name - thread is attaching>"; | |
| 2526 } | |
| 2527 else { | |
| 2528 name_str = Thread::name(); | |
| 2529 } | |
| 2530 } | |
| 2531 else { | |
| 2532 name_str = Thread::name(); | |
| 2533 } | |
| 2534 assert(name_str != NULL, "unexpected NULL thread name"); | |
| 2535 return name_str; | |
| 2536 } | |
| 2537 | |
| 2538 | |
| 2539 const char* JavaThread::get_threadgroup_name() const { | |
| 2540 debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);) | |
| 2541 oop thread_obj = threadObj(); | |
| 2542 if (thread_obj != NULL) { | |
| 2543 oop thread_group = java_lang_Thread::threadGroup(thread_obj); | |
| 2544 if (thread_group != NULL) { | |
| 2545 typeArrayOop name = java_lang_ThreadGroup::name(thread_group); | |
| 2546 // ThreadGroup.name can be null | |
| 2547 if (name != NULL) { | |
| 2548 const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
| 2549 return str; | |
| 2550 } | |
| 2551 } | |
| 2552 } | |
| 2553 return NULL; | |
| 2554 } | |
| 2555 | |
| 2556 const char* JavaThread::get_parent_name() const { | |
| 2557 debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);) | |
| 2558 oop thread_obj = threadObj(); | |
| 2559 if (thread_obj != NULL) { | |
| 2560 oop thread_group = java_lang_Thread::threadGroup(thread_obj); | |
| 2561 if (thread_group != NULL) { | |
| 2562 oop parent = java_lang_ThreadGroup::parent(thread_group); | |
| 2563 if (parent != NULL) { | |
| 2564 typeArrayOop name = java_lang_ThreadGroup::name(parent); | |
| 2565 // ThreadGroup.name can be null | |
| 2566 if (name != NULL) { | |
| 2567 const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
| 2568 return str; | |
| 2569 } | |
| 2570 } | |
| 2571 } | |
| 2572 } | |
| 2573 return NULL; | |
| 2574 } | |
| 2575 | |
| 2576 ThreadPriority JavaThread::java_priority() const { | |
| 2577 oop thr_oop = threadObj(); | |
| 2578 if (thr_oop == NULL) return NormPriority; // Bootstrapping | |
| 2579 ThreadPriority priority = java_lang_Thread::priority(thr_oop); | |
| 2580 assert(MinPriority <= priority && priority <= MaxPriority, "sanity check"); | |
| 2581 return priority; | |
| 2582 } | |
| 2583 | |
| 2584 void JavaThread::prepare(jobject jni_thread, ThreadPriority prio) { | |
| 2585 | |
| 2586 assert(Threads_lock->owner() == Thread::current(), "must have threads lock"); | |
| 2587 // Link Java Thread object <-> C++ Thread | |
| 2588 | |
| 2589 // Get the C++ thread object (an oop) from the JNI handle (a jthread) | |
| 2590 // and put it into a new Handle. The Handle "thread_oop" can then | |
| 2591 // be used to pass the C++ thread object to other methods. | |
| 2592 | |
| 2593 // Set the Java level thread object (jthread) field of the | |
| 2594 // new thread (a JavaThread *) to C++ thread object using the | |
| 2595 // "thread_oop" handle. | |
| 2596 | |
| 2597 // Set the thread field (a JavaThread *) of the | |
| 2598 // oop representing the java_lang_Thread to the new thread (a JavaThread *). | |
| 2599 | |
| 2600 Handle thread_oop(Thread::current(), | |
| 2601 JNIHandles::resolve_non_null(jni_thread)); | |
| 2602 assert(instanceKlass::cast(thread_oop->klass())->is_linked(), | |
| 2603 "must be initialized"); | |
| 2604 set_threadObj(thread_oop()); | |
| 2605 java_lang_Thread::set_thread(thread_oop(), this); | |
| 2606 | |
| 2607 if (prio == NoPriority) { | |
| 2608 prio = java_lang_Thread::priority(thread_oop()); | |
| 2609 assert(prio != NoPriority, "A valid priority should be present"); | |
| 2610 } | |
| 2611 | |
| 2612 // Push the Java priority down to the native thread; needs Threads_lock | |
| 2613 Thread::set_priority(this, prio); | |
| 2614 | |
| 2615 // Add the new thread to the Threads list and set it in motion. | |
| 2616 // We must have threads lock in order to call Threads::add. | |
| 2617 // It is crucial that we do not block before the thread is | |
| 2618 // added to the Threads list for if a GC happens, then the java_thread oop | |
| 2619 // will not be visited by GC. | |
| 2620 Threads::add(this); | |
| 2621 } | |
| 2622 | |
| 2623 oop JavaThread::current_park_blocker() { | |
| 2624 // Support for JSR-166 locks | |
| 2625 oop thread_oop = threadObj(); | |
| 242 | 2626 if (thread_oop != NULL && |
| 2627 JDK_Version::current().supports_thread_park_blocker()) { | |
| 0 | 2628 return java_lang_Thread::park_blocker(thread_oop); |
| 2629 } | |
| 2630 return NULL; | |
| 2631 } | |
| 2632 | |
| 2633 | |
| 2634 void JavaThread::print_stack_on(outputStream* st) { | |
| 2635 if (!has_last_Java_frame()) return; | |
| 2636 ResourceMark rm; | |
| 2637 HandleMark hm; | |
| 2638 | |
| 2639 RegisterMap reg_map(this); | |
| 2640 vframe* start_vf = last_java_vframe(®_map); | |
| 2641 int count = 0; | |
| 2642 for (vframe* f = start_vf; f; f = f->sender() ) { | |
| 2643 if (f->is_java_frame()) { | |
| 2644 javaVFrame* jvf = javaVFrame::cast(f); | |
| 2645 java_lang_Throwable::print_stack_element(st, jvf->method(), jvf->bci()); | |
| 2646 | |
| 2647 // Print out lock information | |
| 2648 if (JavaMonitorsInStackTrace) { | |
| 2649 jvf->print_lock_info_on(st, count); | |
| 2650 } | |
| 2651 } else { | |
| 2652 // Ignore non-Java frames | |
| 2653 } | |
| 2654 | |
| 2655 // Bail-out case for too deep stacks | |
| 2656 count++; | |
| 2657 if (MaxJavaStackTraceDepth == count) return; | |
| 2658 } | |
| 2659 } | |
| 2660 | |
| 2661 | |
| 2662 // JVMTI PopFrame support | |
| 2663 void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) { | |
| 2664 assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments"); | |
| 2665 if (in_bytes(size_in_bytes) != 0) { | |
| 2666 _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes)); | |
| 2667 _popframe_preserved_args_size = in_bytes(size_in_bytes); | |
| 2668 Copy::conjoint_bytes(start, _popframe_preserved_args, _popframe_preserved_args_size); | |
| 2669 } | |
| 2670 } | |
| 2671 | |
| 2672 void* JavaThread::popframe_preserved_args() { | |
| 2673 return _popframe_preserved_args; | |
| 2674 } | |
| 2675 | |
| 2676 ByteSize JavaThread::popframe_preserved_args_size() { | |
| 2677 return in_ByteSize(_popframe_preserved_args_size); | |
| 2678 } | |
| 2679 | |
| 2680 WordSize JavaThread::popframe_preserved_args_size_in_words() { | |
| 2681 int sz = in_bytes(popframe_preserved_args_size()); | |
| 2682 assert(sz % wordSize == 0, "argument size must be multiple of wordSize"); | |
| 2683 return in_WordSize(sz / wordSize); | |
| 2684 } | |
| 2685 | |
| 2686 void JavaThread::popframe_free_preserved_args() { | |
| 2687 assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice"); | |
| 2688 FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args); | |
| 2689 _popframe_preserved_args = NULL; | |
| 2690 _popframe_preserved_args_size = 0; | |
| 2691 } | |
| 2692 | |
| 2693 #ifndef PRODUCT | |
| 2694 | |
| 2695 void JavaThread::trace_frames() { | |
| 2696 tty->print_cr("[Describe stack]"); | |
| 2697 int frame_no = 1; | |
| 2698 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
| 2699 tty->print(" %d. ", frame_no++); | |
| 2700 fst.current()->print_value_on(tty,this); | |
| 2701 tty->cr(); | |
| 2702 } | |
| 2703 } | |
| 2704 | |
| 2705 | |
| 2706 void JavaThread::trace_stack_from(vframe* start_vf) { | |
| 2707 ResourceMark rm; | |
| 2708 int vframe_no = 1; | |
| 2709 for (vframe* f = start_vf; f; f = f->sender() ) { | |
| 2710 if (f->is_java_frame()) { | |
| 2711 javaVFrame::cast(f)->print_activation(vframe_no++); | |
| 2712 } else { | |
| 2713 f->print(); | |
| 2714 } | |
| 2715 if (vframe_no > StackPrintLimit) { | |
| 2716 tty->print_cr("...<more frames>..."); | |
| 2717 return; | |
| 2718 } | |
| 2719 } | |
| 2720 } | |
| 2721 | |
| 2722 | |
| 2723 void JavaThread::trace_stack() { | |
| 2724 if (!has_last_Java_frame()) return; | |
| 2725 ResourceMark rm; | |
| 2726 HandleMark hm; | |
| 2727 RegisterMap reg_map(this); | |
| 2728 trace_stack_from(last_java_vframe(®_map)); | |
| 2729 } | |
| 2730 | |
| 2731 | |
| 2732 #endif // PRODUCT | |
| 2733 | |
| 2734 | |
| 2735 javaVFrame* JavaThread::last_java_vframe(RegisterMap *reg_map) { | |
| 2736 assert(reg_map != NULL, "a map must be given"); | |
| 2737 frame f = last_frame(); | |
| 2738 for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender() ) { | |
| 2739 if (vf->is_java_frame()) return javaVFrame::cast(vf); | |
| 2740 } | |
| 2741 return NULL; | |
| 2742 } | |
| 2743 | |
| 2744 | |
| 2745 klassOop JavaThread::security_get_caller_class(int depth) { | |
| 2746 vframeStream vfst(this); | |
| 2747 vfst.security_get_caller_frame(depth); | |
| 2748 if (!vfst.at_end()) { | |
| 2749 return vfst.method()->method_holder(); | |
| 2750 } | |
| 2751 return NULL; | |
| 2752 } | |
| 2753 | |
| 2754 static void compiler_thread_entry(JavaThread* thread, TRAPS) { | |
| 2755 assert(thread->is_Compiler_thread(), "must be compiler thread"); | |
| 2756 CompileBroker::compiler_thread_loop(); | |
| 2757 } | |
| 2758 | |
| 2759 // Create a CompilerThread | |
| 2760 CompilerThread::CompilerThread(CompileQueue* queue, CompilerCounters* counters) | |
| 2761 : JavaThread(&compiler_thread_entry) { | |
| 2762 _env = NULL; | |
| 2763 _log = NULL; | |
| 2764 _task = NULL; | |
| 2765 _queue = queue; | |
| 2766 _counters = counters; | |
| 2767 | |
| 2768 #ifndef PRODUCT | |
| 2769 _ideal_graph_printer = NULL; | |
| 2770 #endif | |
| 2771 } | |
| 2772 | |
| 2773 | |
| 2774 // ======= Threads ======== | |
| 2775 | |
| 2776 // The Threads class links together all active threads, and provides | |
| 2777 // operations over all threads. It is protected by its own Mutex | |
| 2778 // lock, which is also used in other contexts to protect thread | |
| 2779 // operations from having the thread being operated on from exiting | |
| 2780 // and going away unexpectedly (e.g., safepoint synchronization) | |
| 2781 | |
| 2782 JavaThread* Threads::_thread_list = NULL; | |
| 2783 int Threads::_number_of_threads = 0; | |
| 2784 int Threads::_number_of_non_daemon_threads = 0; | |
| 2785 int Threads::_return_code = 0; | |
| 2786 size_t JavaThread::_stack_size_at_create = 0; | |
| 2787 | |
| 2788 // All JavaThreads | |
| 2789 #define ALL_JAVA_THREADS(X) for (JavaThread* X = _thread_list; X; X = X->next()) | |
| 2790 | |
| 2791 void os_stream(); | |
| 2792 | |
| 2793 // All JavaThreads + all non-JavaThreads (i.e., every thread in the system) | |
| 2794 void Threads::threads_do(ThreadClosure* tc) { | |
| 2795 assert_locked_or_safepoint(Threads_lock); | |
| 2796 // ALL_JAVA_THREADS iterates through all JavaThreads | |
| 2797 ALL_JAVA_THREADS(p) { | |
| 2798 tc->do_thread(p); | |
| 2799 } | |
| 2800 // Someday we could have a table or list of all non-JavaThreads. | |
| 2801 // For now, just manually iterate through them. | |
| 2802 tc->do_thread(VMThread::vm_thread()); | |
| 2803 Universe::heap()->gc_threads_do(tc); | |
|
323
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2804 WatcherThread *wt = WatcherThread::watcher_thread(); |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2805 // Strictly speaking, the following NULL check isn't sufficient to make sure |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2806 // the data for WatcherThread is still valid upon being examined. However, |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2807 // considering that WatchThread terminates when the VM is on the way to |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2808 // exit at safepoint, the chance of the above is extremely small. The right |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2809 // way to prevent termination of WatcherThread would be to acquire |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2810 // Terminator_lock, but we can't do that without violating the lock rank |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2811 // checking in some cases. |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2812 if (wt != NULL) |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2813 tc->do_thread(wt); |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2814 |
| 0 | 2815 // If CompilerThreads ever become non-JavaThreads, add them here |
| 2816 } | |
| 2817 | |
| 2818 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { | |
| 2819 | |
| 242 | 2820 extern void JDK_Version_init(); |
| 2821 | |
| 0 | 2822 // Check version |
| 2823 if (!is_supported_jni_version(args->version)) return JNI_EVERSION; | |
| 2824 | |
| 2825 // Initialize the output stream module | |
| 2826 ostream_init(); | |
| 2827 | |
| 2828 // Process java launcher properties. | |
| 2829 Arguments::process_sun_java_launcher_properties(args); | |
| 2830 | |
| 2831 // Initialize the os module before using TLS | |
| 2832 os::init(); | |
| 2833 | |
| 2834 // Initialize system properties. | |
| 2835 Arguments::init_system_properties(); | |
| 2836 | |
| 242 | 2837 // So that JDK version can be used as a discrimintor when parsing arguments |
| 2838 JDK_Version_init(); | |
| 2839 | |
| 0 | 2840 // Parse arguments |
| 2841 jint parse_result = Arguments::parse(args); | |
| 2842 if (parse_result != JNI_OK) return parse_result; | |
| 2843 | |
| 2844 if (PauseAtStartup) { | |
| 2845 os::pause(); | |
| 2846 } | |
| 2847 | |
| 2848 HS_DTRACE_PROBE(hotspot, vm__init__begin); | |
| 2849 | |
| 2850 // Record VM creation timing statistics | |
| 2851 TraceVmCreationTime create_vm_timer; | |
| 2852 create_vm_timer.start(); | |
| 2853 | |
| 2854 // Timing (must come after argument parsing) | |
| 2855 TraceTime timer("Create VM", TraceStartupTime); | |
| 2856 | |
| 2857 // Initialize the os module after parsing the args | |
| 2858 jint os_init_2_result = os::init_2(); | |
| 2859 if (os_init_2_result != JNI_OK) return os_init_2_result; | |
| 2860 | |
| 2861 // Initialize output stream logging | |
| 2862 ostream_init_log(); | |
| 2863 | |
| 2864 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad | |
| 2865 // Must be before create_vm_init_agents() | |
| 2866 if (Arguments::init_libraries_at_startup()) { | |
| 2867 convert_vm_init_libraries_to_agents(); | |
| 2868 } | |
| 2869 | |
| 2870 // Launch -agentlib/-agentpath and converted -Xrun agents | |
| 2871 if (Arguments::init_agents_at_startup()) { | |
| 2872 create_vm_init_agents(); | |
| 2873 } | |
| 2874 | |
| 2875 // Initialize Threads state | |
| 2876 _thread_list = NULL; | |
| 2877 _number_of_threads = 0; | |
| 2878 _number_of_non_daemon_threads = 0; | |
| 2879 | |
| 2880 // Initialize TLS | |
| 2881 ThreadLocalStorage::init(); | |
| 2882 | |
| 2883 // Initialize global data structures and create system classes in heap | |
| 2884 vm_init_globals(); | |
| 2885 | |
| 2886 // Attach the main thread to this os thread | |
| 2887 JavaThread* main_thread = new JavaThread(); | |
| 2888 main_thread->set_thread_state(_thread_in_vm); | |
| 2889 // must do this before set_active_handles and initialize_thread_local_storage | |
| 2890 // Note: on solaris initialize_thread_local_storage() will (indirectly) | |
| 2891 // change the stack size recorded here to one based on the java thread | |
| 2892 // stacksize. This adjusted size is what is used to figure the placement | |
| 2893 // of the guard pages. | |
| 2894 main_thread->record_stack_base_and_size(); | |
| 2895 main_thread->initialize_thread_local_storage(); | |
| 2896 | |
| 2897 main_thread->set_active_handles(JNIHandleBlock::allocate_block()); | |
| 2898 | |
| 2899 if (!main_thread->set_as_starting_thread()) { | |
| 2900 vm_shutdown_during_initialization( | |
| 2901 "Failed necessary internal allocation. Out of swap space"); | |
| 2902 delete main_thread; | |
| 2903 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again | |
| 2904 return JNI_ENOMEM; | |
| 2905 } | |
| 2906 | |
| 2907 // Enable guard page *after* os::create_main_thread(), otherwise it would | |
| 2908 // crash Linux VM, see notes in os_linux.cpp. | |
| 2909 main_thread->create_stack_guard_pages(); | |
| 2910 | |
| 2911 // Initialize Java-Leve synchronization subsystem | |
| 2912 ObjectSynchronizer::Initialize() ; | |
| 2913 | |
| 2914 // Initialize global modules | |
| 2915 jint status = init_globals(); | |
| 2916 if (status != JNI_OK) { | |
| 2917 delete main_thread; | |
| 2918 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again | |
| 2919 return status; | |
| 2920 } | |
| 2921 | |
| 2922 HandleMark hm; | |
| 2923 | |
| 2924 { MutexLocker mu(Threads_lock); | |
| 2925 Threads::add(main_thread); | |
| 2926 } | |
| 2927 | |
| 2928 // Any JVMTI raw monitors entered in onload will transition into | |
| 2929 // real raw monitor. VM is setup enough here for raw monitor enter. | |
| 2930 JvmtiExport::transition_pending_onload_raw_monitors(); | |
| 2931 | |
| 2932 if (VerifyBeforeGC && | |
| 2933 Universe::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2934 Universe::heap()->prepare_for_verify(); | |
| 2935 Universe::verify(); // make sure we're starting with a clean slate | |
| 2936 } | |
| 2937 | |
| 2938 // Create the VMThread | |
| 2939 { TraceTime timer("Start VMThread", TraceStartupTime); | |
| 2940 VMThread::create(); | |
| 2941 Thread* vmthread = VMThread::vm_thread(); | |
| 2942 | |
| 2943 if (!os::create_thread(vmthread, os::vm_thread)) | |
| 2944 vm_exit_during_initialization("Cannot create VM thread. Out of system resources."); | |
| 2945 | |
| 2946 // Wait for the VM thread to become ready, and VMThread::run to initialize | |
| 2947 // Monitors can have spurious returns, must always check another state flag | |
| 2948 { | |
| 2949 MutexLocker ml(Notify_lock); | |
| 2950 os::start_thread(vmthread); | |
| 2951 while (vmthread->active_handles() == NULL) { | |
| 2952 Notify_lock->wait(); | |
| 2953 } | |
| 2954 } | |
| 2955 } | |
| 2956 | |
| 2957 assert (Universe::is_fully_initialized(), "not initialized"); | |
| 2958 EXCEPTION_MARK; | |
| 2959 | |
| 2960 // At this point, the Universe is initialized, but we have not executed | |
| 2961 // any byte code. Now is a good time (the only time) to dump out the | |
| 2962 // internal state of the JVM for sharing. | |
| 2963 | |
| 2964 if (DumpSharedSpaces) { | |
| 2965 Universe::heap()->preload_and_dump(CHECK_0); | |
| 2966 ShouldNotReachHere(); | |
| 2967 } | |
| 2968 | |
| 2969 // Always call even when there are not JVMTI environments yet, since environments | |
| 2970 // may be attached late and JVMTI must track phases of VM execution | |
| 2971 JvmtiExport::enter_start_phase(); | |
| 2972 | |
| 2973 // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents. | |
| 2974 JvmtiExport::post_vm_start(); | |
| 2975 | |
| 2976 { | |
| 2977 TraceTime timer("Initialize java.lang classes", TraceStartupTime); | |
| 2978 | |
| 2979 if (EagerXrunInit && Arguments::init_libraries_at_startup()) { | |
| 2980 create_vm_init_libraries(); | |
| 2981 } | |
| 2982 | |
| 2983 if (InitializeJavaLangString) { | |
| 2984 initialize_class(vmSymbolHandles::java_lang_String(), CHECK_0); | |
| 2985 } else { | |
| 2986 warning("java.lang.String not initialized"); | |
| 2987 } | |
| 2988 | |
|
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
2989 if (AggressiveOpts) { |
|
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
2990 { |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
2991 // Forcibly initialize java/util/HashMap and mutate the private |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
2992 // static final "frontCacheEnabled" field before we start creating instances |
|
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
2993 #ifdef ASSERT |
|
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
2994 klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
2995 assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet"); |
|
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
2996 #endif |
|
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
2997 klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
2998 KlassHandle k = KlassHandle(THREAD, k_o); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
2999 guarantee(k.not_null(), "Must find java/util/HashMap"); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3000 instanceKlassHandle ik = instanceKlassHandle(THREAD, k()); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3001 ik->initialize(CHECK_0); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3002 fieldDescriptor fd; |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3003 // Possible we might not find this field; if so, don't break |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3004 if (ik->find_local_field(vmSymbols::frontCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) { |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3005 k()->bool_field_put(fd.offset(), true); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3006 } |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3007 } |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3008 |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3009 if (UseStringCache) { |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3010 // Forcibly initialize java/lang/String and mutate the private |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3011 // static final "stringCacheEnabled" field before we start creating instances |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3012 klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_String(), Handle(), Handle(), CHECK_0); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3013 KlassHandle k = KlassHandle(THREAD, k_o); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3014 guarantee(k.not_null(), "Must find java/lang/String"); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3015 instanceKlassHandle ik = instanceKlassHandle(THREAD, k()); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3016 ik->initialize(CHECK_0); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3017 fieldDescriptor fd; |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3018 // Possible we might not find this field; if so, don't break |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3019 if (ik->find_local_field(vmSymbols::stringCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) { |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3020 k()->bool_field_put(fd.offset(), true); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3021 } |
|
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3022 } |
|
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3023 } |
|
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3024 |
| 0 | 3025 // Initialize java_lang.System (needed before creating the thread) |
| 3026 if (InitializeJavaLangSystem) { | |
| 3027 initialize_class(vmSymbolHandles::java_lang_System(), CHECK_0); | |
| 3028 initialize_class(vmSymbolHandles::java_lang_ThreadGroup(), CHECK_0); | |
| 3029 Handle thread_group = create_initial_thread_group(CHECK_0); | |
| 3030 Universe::set_main_thread_group(thread_group()); | |
| 3031 initialize_class(vmSymbolHandles::java_lang_Thread(), CHECK_0); | |
| 3032 oop thread_object = create_initial_thread(thread_group, main_thread, CHECK_0); | |
| 3033 main_thread->set_threadObj(thread_object); | |
| 3034 // Set thread status to running since main thread has | |
| 3035 // been started and running. | |
| 3036 java_lang_Thread::set_thread_status(thread_object, | |
| 3037 java_lang_Thread::RUNNABLE); | |
| 3038 | |
| 3039 // The VM preresolve methods to these classes. Make sure that get initialized | |
| 3040 initialize_class(vmSymbolHandles::java_lang_reflect_Method(), CHECK_0); | |
| 3041 initialize_class(vmSymbolHandles::java_lang_ref_Finalizer(), CHECK_0); | |
| 3042 // The VM creates & returns objects of this class. Make sure it's initialized. | |
| 3043 initialize_class(vmSymbolHandles::java_lang_Class(), CHECK_0); | |
| 3044 call_initializeSystemClass(CHECK_0); | |
| 3045 } else { | |
| 3046 warning("java.lang.System not initialized"); | |
| 3047 } | |
| 3048 | |
| 3049 // an instance of OutOfMemory exception has been allocated earlier | |
| 3050 if (InitializeJavaLangExceptionsErrors) { | |
| 3051 initialize_class(vmSymbolHandles::java_lang_OutOfMemoryError(), CHECK_0); | |
| 3052 initialize_class(vmSymbolHandles::java_lang_NullPointerException(), CHECK_0); | |
| 3053 initialize_class(vmSymbolHandles::java_lang_ClassCastException(), CHECK_0); | |
| 3054 initialize_class(vmSymbolHandles::java_lang_ArrayStoreException(), CHECK_0); | |
| 3055 initialize_class(vmSymbolHandles::java_lang_ArithmeticException(), CHECK_0); | |
| 3056 initialize_class(vmSymbolHandles::java_lang_StackOverflowError(), CHECK_0); | |
| 3057 initialize_class(vmSymbolHandles::java_lang_IllegalMonitorStateException(), CHECK_0); | |
| 3058 } else { | |
| 3059 warning("java.lang.OutOfMemoryError has not been initialized"); | |
| 3060 warning("java.lang.NullPointerException has not been initialized"); | |
| 3061 warning("java.lang.ClassCastException has not been initialized"); | |
| 3062 warning("java.lang.ArrayStoreException has not been initialized"); | |
| 3063 warning("java.lang.ArithmeticException has not been initialized"); | |
| 3064 warning("java.lang.StackOverflowError has not been initialized"); | |
| 3065 } | |
| 3066 } | |
| 3067 | |
| 3068 // See : bugid 4211085. | |
| 3069 // Background : the static initializer of java.lang.Compiler tries to read | |
| 3070 // property"java.compiler" and read & write property "java.vm.info". | |
| 3071 // When a security manager is installed through the command line | |
| 3072 // option "-Djava.security.manager", the above properties are not | |
| 3073 // readable and the static initializer for java.lang.Compiler fails | |
| 3074 // resulting in a NoClassDefFoundError. This can happen in any | |
| 3075 // user code which calls methods in java.lang.Compiler. | |
| 3076 // Hack : the hack is to pre-load and initialize this class, so that only | |
| 3077 // system domains are on the stack when the properties are read. | |
| 3078 // Currently even the AWT code has calls to methods in java.lang.Compiler. | |
| 3079 // On the classic VM, java.lang.Compiler is loaded very early to load the JIT. | |
| 3080 // Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and | |
| 3081 // read and write"java.vm.info" in the default policy file. See bugid 4211383 | |
| 3082 // Once that is done, we should remove this hack. | |
| 3083 initialize_class(vmSymbolHandles::java_lang_Compiler(), CHECK_0); | |
| 3084 | |
| 3085 // More hackery - the static initializer of java.lang.Compiler adds the string "nojit" to | |
| 3086 // the java.vm.info property if no jit gets loaded through java.lang.Compiler (the hotspot | |
| 3087 // compiler does not get loaded through java.lang.Compiler). "java -version" with the | |
| 3088 // hotspot vm says "nojit" all the time which is confusing. So, we reset it here. | |
| 3089 // This should also be taken out as soon as 4211383 gets fixed. | |
| 3090 reset_vm_info_property(CHECK_0); | |
| 3091 | |
| 3092 quicken_jni_functions(); | |
| 3093 | |
| 3094 // Set flag that basic initialization has completed. Used by exceptions and various | |
| 3095 // debug stuff, that does not work until all basic classes have been initialized. | |
| 3096 set_init_completed(); | |
| 3097 | |
| 3098 HS_DTRACE_PROBE(hotspot, vm__init__end); | |
| 3099 | |
| 3100 // record VM initialization completion time | |
| 3101 Management::record_vm_init_completed(); | |
| 3102 | |
| 3103 // Compute system loader. Note that this has to occur after set_init_completed, since | |
| 3104 // valid exceptions may be thrown in the process. | |
| 3105 // Note that we do not use CHECK_0 here since we are inside an EXCEPTION_MARK and | |
| 3106 // set_init_completed has just been called, causing exceptions not to be shortcut | |
| 3107 // anymore. We call vm_exit_during_initialization directly instead. | |
| 3108 SystemDictionary::compute_java_system_loader(THREAD); | |
| 3109 if (HAS_PENDING_EXCEPTION) { | |
| 3110 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION)); | |
| 3111 } | |
| 3112 | |
| 3113 #ifndef SERIALGC | |
| 3114 // Support for ConcurrentMarkSweep. This should be cleaned up | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3115 // and better encapsulated. The ugly nested if test would go away |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3116 // once things are properly refactored. XXX YSR |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3117 if (UseConcMarkSweepGC || UseG1GC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3118 if (UseConcMarkSweepGC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3119 ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3120 } else { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3121 ConcurrentMarkThread::makeSurrogateLockerThread(THREAD); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3122 } |
| 0 | 3123 if (HAS_PENDING_EXCEPTION) { |
| 3124 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION)); | |
| 3125 } | |
| 3126 } | |
| 3127 #endif // SERIALGC | |
| 3128 | |
| 3129 // Always call even when there are not JVMTI environments yet, since environments | |
| 3130 // may be attached late and JVMTI must track phases of VM execution | |
| 3131 JvmtiExport::enter_live_phase(); | |
| 3132 | |
| 3133 // Signal Dispatcher needs to be started before VMInit event is posted | |
| 3134 os::signal_init(); | |
| 3135 | |
| 3136 // Start Attach Listener if +StartAttachListener or it can't be started lazily | |
| 3137 if (!DisableAttachMechanism) { | |
| 3138 if (StartAttachListener || AttachListener::init_at_startup()) { | |
| 3139 AttachListener::init(); | |
| 3140 } | |
| 3141 } | |
| 3142 | |
| 3143 // Launch -Xrun agents | |
| 3144 // Must be done in the JVMTI live phase so that for backward compatibility the JDWP | |
| 3145 // back-end can launch with -Xdebug -Xrunjdwp. | |
| 3146 if (!EagerXrunInit && Arguments::init_libraries_at_startup()) { | |
| 3147 create_vm_init_libraries(); | |
| 3148 } | |
| 3149 | |
| 3150 // Notify JVMTI agents that VM initialization is complete - nop if no agents. | |
| 3151 JvmtiExport::post_vm_initialized(); | |
| 3152 | |
| 3153 Chunk::start_chunk_pool_cleaner_task(); | |
| 3154 | |
| 3155 // initialize compiler(s) | |
| 3156 CompileBroker::compilation_init(); | |
| 3157 | |
| 3158 Management::initialize(THREAD); | |
| 3159 if (HAS_PENDING_EXCEPTION) { | |
| 3160 // management agent fails to start possibly due to | |
| 3161 // configuration problem and is responsible for printing | |
| 3162 // stack trace if appropriate. Simply exit VM. | |
| 3163 vm_exit(1); | |
| 3164 } | |
| 3165 | |
| 3166 if (Arguments::has_profile()) FlatProfiler::engage(main_thread, true); | |
| 3167 if (Arguments::has_alloc_profile()) AllocationProfiler::engage(); | |
| 3168 if (MemProfiling) MemProfiler::engage(); | |
| 3169 StatSampler::engage(); | |
| 3170 if (CheckJNICalls) JniPeriodicChecker::engage(); | |
| 3171 | |
| 3172 BiasedLocking::init(); | |
| 3173 | |
| 3174 | |
| 3175 // Start up the WatcherThread if there are any periodic tasks | |
| 3176 // NOTE: All PeriodicTasks should be registered by now. If they | |
| 3177 // aren't, late joiners might appear to start slowly (we might | |
| 3178 // take a while to process their first tick). | |
| 3179 if (PeriodicTask::num_tasks() > 0) { | |
| 3180 WatcherThread::start(); | |
| 3181 } | |
| 3182 | |
| 3183 create_vm_timer.end(); | |
| 3184 return JNI_OK; | |
| 3185 } | |
| 3186 | |
| 3187 // type for the Agent_OnLoad and JVM_OnLoad entry points | |
| 3188 extern "C" { | |
| 3189 typedef jint (JNICALL *OnLoadEntry_t)(JavaVM *, char *, void *); | |
| 3190 } | |
| 3191 // Find a command line agent library and return its entry point for | |
| 3192 // -agentlib: -agentpath: -Xrun | |
| 3193 // num_symbol_entries must be passed-in since only the caller knows the number of symbols in the array. | |
| 3194 static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_symbols[], size_t num_symbol_entries) { | |
| 3195 OnLoadEntry_t on_load_entry = NULL; | |
| 3196 void *library = agent->os_lib(); // check if we have looked it up before | |
| 3197 | |
| 3198 if (library == NULL) { | |
| 3199 char buffer[JVM_MAXPATHLEN]; | |
| 3200 char ebuf[1024]; | |
| 3201 const char *name = agent->name(); | |
| 3202 | |
| 3203 if (agent->is_absolute_path()) { | |
| 3204 library = hpi::dll_load(name, ebuf, sizeof ebuf); | |
| 3205 if (library == NULL) { | |
| 3206 // If we can't find the agent, exit. | |
| 3207 vm_exit_during_initialization("Could not find agent library in absolute path", name); | |
| 3208 } | |
| 3209 } else { | |
| 3210 // Try to load the agent from the standard dll directory | |
| 3211 hpi::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), name); | |
| 3212 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
| 3213 #ifdef KERNEL | |
| 3214 // Download instrument dll | |
| 3215 if (library == NULL && strcmp(name, "instrument") == 0) { | |
| 3216 char *props = Arguments::get_kernel_properties(); | |
| 3217 char *home = Arguments::get_java_home(); | |
| 3218 const char *fmt = "%s/bin/java %s -Dkernel.background.download=false" | |
| 3219 " sun.jkernel.DownloadManager -download client_jvm"; | |
| 3220 int length = strlen(props) + strlen(home) + strlen(fmt) + 1; | |
| 3221 char *cmd = AllocateHeap(length); | |
| 3222 jio_snprintf(cmd, length, fmt, home, props); | |
| 3223 int status = os::fork_and_exec(cmd); | |
| 3224 FreeHeap(props); | |
| 3225 FreeHeap(cmd); | |
| 3226 if (status == -1) { | |
| 3227 warning(cmd); | |
| 3228 vm_exit_during_initialization("fork_and_exec failed: %s", | |
| 3229 strerror(errno)); | |
| 3230 } | |
| 3231 // when this comes back the instrument.dll should be where it belongs. | |
| 3232 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
| 3233 } | |
| 3234 #endif // KERNEL | |
| 3235 if (library == NULL) { // Try the local directory | |
| 3236 char ns[1] = {0}; | |
| 3237 hpi::dll_build_name(buffer, sizeof(buffer), ns, name); | |
| 3238 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
| 3239 if (library == NULL) { | |
| 3240 // If we can't find the agent, exit. | |
| 3241 vm_exit_during_initialization("Could not find agent library on the library path or in the local directory", name); | |
| 3242 } | |
| 3243 } | |
| 3244 } | |
| 3245 agent->set_os_lib(library); | |
| 3246 } | |
| 3247 | |
| 3248 // Find the OnLoad function. | |
| 3249 for (size_t symbol_index = 0; symbol_index < num_symbol_entries; symbol_index++) { | |
| 3250 on_load_entry = CAST_TO_FN_PTR(OnLoadEntry_t, hpi::dll_lookup(library, on_load_symbols[symbol_index])); | |
| 3251 if (on_load_entry != NULL) break; | |
| 3252 } | |
| 3253 return on_load_entry; | |
| 3254 } | |
| 3255 | |
| 3256 // Find the JVM_OnLoad entry point | |
| 3257 static OnLoadEntry_t lookup_jvm_on_load(AgentLibrary* agent) { | |
| 3258 const char *on_load_symbols[] = JVM_ONLOAD_SYMBOLS; | |
| 3259 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*)); | |
| 3260 } | |
| 3261 | |
| 3262 // Find the Agent_OnLoad entry point | |
| 3263 static OnLoadEntry_t lookup_agent_on_load(AgentLibrary* agent) { | |
| 3264 const char *on_load_symbols[] = AGENT_ONLOAD_SYMBOLS; | |
| 3265 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*)); | |
| 3266 } | |
| 3267 | |
| 3268 // For backwards compatibility with -Xrun | |
| 3269 // Convert libraries with no JVM_OnLoad, but which have Agent_OnLoad to be | |
| 3270 // treated like -agentpath: | |
| 3271 // Must be called before agent libraries are created | |
| 3272 void Threads::convert_vm_init_libraries_to_agents() { | |
| 3273 AgentLibrary* agent; | |
| 3274 AgentLibrary* next; | |
| 3275 | |
| 3276 for (agent = Arguments::libraries(); agent != NULL; agent = next) { | |
| 3277 next = agent->next(); // cache the next agent now as this agent may get moved off this list | |
| 3278 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent); | |
| 3279 | |
| 3280 // If there is an JVM_OnLoad function it will get called later, | |
| 3281 // otherwise see if there is an Agent_OnLoad | |
| 3282 if (on_load_entry == NULL) { | |
| 3283 on_load_entry = lookup_agent_on_load(agent); | |
| 3284 if (on_load_entry != NULL) { | |
| 3285 // switch it to the agent list -- so that Agent_OnLoad will be called, | |
| 3286 // JVM_OnLoad won't be attempted and Agent_OnUnload will | |
| 3287 Arguments::convert_library_to_agent(agent); | |
| 3288 } else { | |
| 3289 vm_exit_during_initialization("Could not find JVM_OnLoad or Agent_OnLoad function in the library", agent->name()); | |
| 3290 } | |
| 3291 } | |
| 3292 } | |
| 3293 } | |
| 3294 | |
| 3295 // Create agents for -agentlib: -agentpath: and converted -Xrun | |
| 3296 // Invokes Agent_OnLoad | |
| 3297 // Called very early -- before JavaThreads exist | |
| 3298 void Threads::create_vm_init_agents() { | |
| 3299 extern struct JavaVM_ main_vm; | |
| 3300 AgentLibrary* agent; | |
| 3301 | |
| 3302 JvmtiExport::enter_onload_phase(); | |
| 3303 for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) { | |
| 3304 OnLoadEntry_t on_load_entry = lookup_agent_on_load(agent); | |
| 3305 | |
| 3306 if (on_load_entry != NULL) { | |
| 3307 // Invoke the Agent_OnLoad function | |
| 3308 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL); | |
| 3309 if (err != JNI_OK) { | |
| 3310 vm_exit_during_initialization("agent library failed to init", agent->name()); | |
| 3311 } | |
| 3312 } else { | |
| 3313 vm_exit_during_initialization("Could not find Agent_OnLoad function in the agent library", agent->name()); | |
| 3314 } | |
| 3315 } | |
| 3316 JvmtiExport::enter_primordial_phase(); | |
| 3317 } | |
| 3318 | |
| 3319 extern "C" { | |
| 3320 typedef void (JNICALL *Agent_OnUnload_t)(JavaVM *); | |
| 3321 } | |
| 3322 | |
| 3323 void Threads::shutdown_vm_agents() { | |
| 3324 // Send any Agent_OnUnload notifications | |
| 3325 const char *on_unload_symbols[] = AGENT_ONUNLOAD_SYMBOLS; | |
| 3326 extern struct JavaVM_ main_vm; | |
| 3327 for (AgentLibrary* agent = Arguments::agents(); agent != NULL; agent = agent->next()) { | |
| 3328 | |
| 3329 // Find the Agent_OnUnload function. | |
| 3330 for (uint symbol_index = 0; symbol_index < ARRAY_SIZE(on_unload_symbols); symbol_index++) { | |
| 3331 Agent_OnUnload_t unload_entry = CAST_TO_FN_PTR(Agent_OnUnload_t, | |
| 3332 hpi::dll_lookup(agent->os_lib(), on_unload_symbols[symbol_index])); | |
| 3333 | |
| 3334 // Invoke the Agent_OnUnload function | |
| 3335 if (unload_entry != NULL) { | |
| 3336 JavaThread* thread = JavaThread::current(); | |
| 3337 ThreadToNativeFromVM ttn(thread); | |
| 3338 HandleMark hm(thread); | |
| 3339 (*unload_entry)(&main_vm); | |
| 3340 break; | |
| 3341 } | |
| 3342 } | |
| 3343 } | |
| 3344 } | |
| 3345 | |
| 3346 // Called for after the VM is initialized for -Xrun libraries which have not been converted to agent libraries | |
| 3347 // Invokes JVM_OnLoad | |
| 3348 void Threads::create_vm_init_libraries() { | |
| 3349 extern struct JavaVM_ main_vm; | |
| 3350 AgentLibrary* agent; | |
| 3351 | |
| 3352 for (agent = Arguments::libraries(); agent != NULL; agent = agent->next()) { | |
| 3353 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent); | |
| 3354 | |
| 3355 if (on_load_entry != NULL) { | |
| 3356 // Invoke the JVM_OnLoad function | |
| 3357 JavaThread* thread = JavaThread::current(); | |
| 3358 ThreadToNativeFromVM ttn(thread); | |
| 3359 HandleMark hm(thread); | |
| 3360 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL); | |
| 3361 if (err != JNI_OK) { | |
| 3362 vm_exit_during_initialization("-Xrun library failed to init", agent->name()); | |
| 3363 } | |
| 3364 } else { | |
| 3365 vm_exit_during_initialization("Could not find JVM_OnLoad function in -Xrun library", agent->name()); | |
| 3366 } | |
| 3367 } | |
| 3368 } | |
| 3369 | |
| 3370 // Last thread running calls java.lang.Shutdown.shutdown() | |
| 3371 void JavaThread::invoke_shutdown_hooks() { | |
| 3372 HandleMark hm(this); | |
| 3373 | |
| 3374 // We could get here with a pending exception, if so clear it now. | |
| 3375 if (this->has_pending_exception()) { | |
| 3376 this->clear_pending_exception(); | |
| 3377 } | |
| 3378 | |
| 3379 EXCEPTION_MARK; | |
| 3380 klassOop k = | |
| 3381 SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_Shutdown(), | |
| 3382 THREAD); | |
| 3383 if (k != NULL) { | |
| 3384 // SystemDictionary::resolve_or_null will return null if there was | |
| 3385 // an exception. If we cannot load the Shutdown class, just don't | |
| 3386 // call Shutdown.shutdown() at all. This will mean the shutdown hooks | |
| 3387 // and finalizers (if runFinalizersOnExit is set) won't be run. | |
| 3388 // Note that if a shutdown hook was registered or runFinalizersOnExit | |
| 3389 // was called, the Shutdown class would have already been loaded | |
| 3390 // (Runtime.addShutdownHook and runFinalizersOnExit will load it). | |
| 3391 instanceKlassHandle shutdown_klass (THREAD, k); | |
| 3392 JavaValue result(T_VOID); | |
| 3393 JavaCalls::call_static(&result, | |
| 3394 shutdown_klass, | |
| 3395 vmSymbolHandles::shutdown_method_name(), | |
| 3396 vmSymbolHandles::void_method_signature(), | |
| 3397 THREAD); | |
| 3398 } | |
| 3399 CLEAR_PENDING_EXCEPTION; | |
| 3400 } | |
| 3401 | |
| 3402 // Threads::destroy_vm() is normally called from jni_DestroyJavaVM() when | |
| 3403 // the program falls off the end of main(). Another VM exit path is through | |
| 3404 // vm_exit() when the program calls System.exit() to return a value or when | |
| 3405 // there is a serious error in VM. The two shutdown paths are not exactly | |
| 3406 // the same, but they share Shutdown.shutdown() at Java level and before_exit() | |
| 3407 // and VM_Exit op at VM level. | |
| 3408 // | |
| 3409 // Shutdown sequence: | |
| 3410 // + Wait until we are the last non-daemon thread to execute | |
| 3411 // <-- every thing is still working at this moment --> | |
| 3412 // + Call java.lang.Shutdown.shutdown(), which will invoke Java level | |
| 3413 // shutdown hooks, run finalizers if finalization-on-exit | |
| 3414 // + Call before_exit(), prepare for VM exit | |
| 3415 // > run VM level shutdown hooks (they are registered through JVM_OnExit(), | |
| 3416 // currently the only user of this mechanism is File.deleteOnExit()) | |
| 3417 // > stop flat profiler, StatSampler, watcher thread, CMS threads, | |
| 3418 // post thread end and vm death events to JVMTI, | |
| 3419 // stop signal thread | |
| 3420 // + Call JavaThread::exit(), it will: | |
| 3421 // > release JNI handle blocks, remove stack guard pages | |
| 3422 // > remove this thread from Threads list | |
| 3423 // <-- no more Java code from this thread after this point --> | |
| 3424 // + Stop VM thread, it will bring the remaining VM to a safepoint and stop | |
| 3425 // the compiler threads at safepoint | |
| 3426 // <-- do not use anything that could get blocked by Safepoint --> | |
| 3427 // + Disable tracing at JNI/JVM barriers | |
| 3428 // + Set _vm_exited flag for threads that are still running native code | |
| 3429 // + Delete this thread | |
| 3430 // + Call exit_globals() | |
| 3431 // > deletes tty | |
| 3432 // > deletes PerfMemory resources | |
| 3433 // + Return to caller | |
| 3434 | |
| 3435 bool Threads::destroy_vm() { | |
| 3436 JavaThread* thread = JavaThread::current(); | |
| 3437 | |
| 3438 // Wait until we are the last non-daemon thread to execute | |
| 3439 { MutexLocker nu(Threads_lock); | |
| 3440 while (Threads::number_of_non_daemon_threads() > 1 ) | |
| 3441 // This wait should make safepoint checks, wait without a timeout, | |
| 3442 // and wait as a suspend-equivalent condition. | |
| 3443 // | |
| 3444 // Note: If the FlatProfiler is running and this thread is waiting | |
| 3445 // for another non-daemon thread to finish, then the FlatProfiler | |
| 3446 // is waiting for the external suspend request on this thread to | |
| 3447 // complete. wait_for_ext_suspend_completion() will eventually | |
| 3448 // timeout, but that takes time. Making this wait a suspend- | |
| 3449 // equivalent condition solves that timeout problem. | |
| 3450 // | |
| 3451 Threads_lock->wait(!Mutex::_no_safepoint_check_flag, 0, | |
| 3452 Mutex::_as_suspend_equivalent_flag); | |
| 3453 } | |
| 3454 | |
| 3455 // Hang forever on exit if we are reporting an error. | |
| 3456 if (ShowMessageBoxOnError && is_error_reported()) { | |
| 3457 os::infinite_sleep(); | |
| 3458 } | |
| 3459 | |
| 3460 if (JDK_Version::is_jdk12x_version()) { | |
| 3461 // We are the last thread running, so check if finalizers should be run. | |
| 3462 // For 1.3 or later this is done in thread->invoke_shutdown_hooks() | |
| 3463 HandleMark rm(thread); | |
| 3464 Universe::run_finalizers_on_exit(); | |
| 3465 } else { | |
| 3466 // run Java level shutdown hooks | |
| 3467 thread->invoke_shutdown_hooks(); | |
| 3468 } | |
| 3469 | |
| 3470 before_exit(thread); | |
| 3471 | |
| 3472 thread->exit(true); | |
| 3473 | |
| 3474 // Stop VM thread. | |
| 3475 { | |
| 3476 // 4945125 The vm thread comes to a safepoint during exit. | |
| 3477 // GC vm_operations can get caught at the safepoint, and the | |
| 3478 // heap is unparseable if they are caught. Grab the Heap_lock | |
| 3479 // to prevent this. The GC vm_operations will not be able to | |
| 3480 // queue until after the vm thread is dead. | |
| 3481 MutexLocker ml(Heap_lock); | |
| 3482 | |
| 3483 VMThread::wait_for_vm_thread_exit(); | |
| 3484 assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint"); | |
| 3485 VMThread::destroy(); | |
| 3486 } | |
| 3487 | |
| 3488 // clean up ideal graph printers | |
| 3489 #if defined(COMPILER2) && !defined(PRODUCT) | |
| 3490 IdealGraphPrinter::clean_up(); | |
| 3491 #endif | |
| 3492 | |
| 3493 // Now, all Java threads are gone except daemon threads. Daemon threads | |
| 3494 // running Java code or in VM are stopped by the Safepoint. However, | |
| 3495 // daemon threads executing native code are still running. But they | |
| 3496 // will be stopped at native=>Java/VM barriers. Note that we can't | |
| 3497 // simply kill or suspend them, as it is inherently deadlock-prone. | |
| 3498 | |
| 3499 #ifndef PRODUCT | |
| 3500 // disable function tracing at JNI/JVM barriers | |
| 3501 TraceHPI = false; | |
| 3502 TraceJNICalls = false; | |
| 3503 TraceJVMCalls = false; | |
| 3504 TraceRuntimeCalls = false; | |
| 3505 #endif | |
| 3506 | |
| 3507 VM_Exit::set_vm_exited(); | |
| 3508 | |
| 3509 notify_vm_shutdown(); | |
| 3510 | |
| 3511 delete thread; | |
| 3512 | |
| 3513 // exit_globals() will delete tty | |
| 3514 exit_globals(); | |
| 3515 | |
| 3516 return true; | |
| 3517 } | |
| 3518 | |
| 3519 | |
| 3520 jboolean Threads::is_supported_jni_version_including_1_1(jint version) { | |
| 3521 if (version == JNI_VERSION_1_1) return JNI_TRUE; | |
| 3522 return is_supported_jni_version(version); | |
| 3523 } | |
| 3524 | |
| 3525 | |
| 3526 jboolean Threads::is_supported_jni_version(jint version) { | |
| 3527 if (version == JNI_VERSION_1_2) return JNI_TRUE; | |
| 3528 if (version == JNI_VERSION_1_4) return JNI_TRUE; | |
| 3529 if (version == JNI_VERSION_1_6) return JNI_TRUE; | |
| 3530 return JNI_FALSE; | |
| 3531 } | |
| 3532 | |
| 3533 | |
| 3534 void Threads::add(JavaThread* p, bool force_daemon) { | |
| 3535 // The threads lock must be owned at this point | |
| 3536 assert_locked_or_safepoint(Threads_lock); | |
| 3537 p->set_next(_thread_list); | |
| 3538 _thread_list = p; | |
| 3539 _number_of_threads++; | |
| 3540 oop threadObj = p->threadObj(); | |
| 3541 bool daemon = true; | |
| 3542 // Bootstrapping problem: threadObj can be null for initial | |
| 3543 // JavaThread (or for threads attached via JNI) | |
| 3544 if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) { | |
| 3545 _number_of_non_daemon_threads++; | |
| 3546 daemon = false; | |
| 3547 } | |
| 3548 | |
| 3549 ThreadService::add_thread(p, daemon); | |
| 3550 | |
| 3551 // Possible GC point. | |
| 3552 Events::log("Thread added: " INTPTR_FORMAT, p); | |
| 3553 } | |
| 3554 | |
| 3555 void Threads::remove(JavaThread* p) { | |
| 3556 // Extra scope needed for Thread_lock, so we can check | |
| 3557 // that we do not remove thread without safepoint code notice | |
| 3558 { MutexLocker ml(Threads_lock); | |
| 3559 | |
| 3560 assert(includes(p), "p must be present"); | |
| 3561 | |
| 3562 JavaThread* current = _thread_list; | |
| 3563 JavaThread* prev = NULL; | |
| 3564 | |
| 3565 while (current != p) { | |
| 3566 prev = current; | |
| 3567 current = current->next(); | |
| 3568 } | |
| 3569 | |
| 3570 if (prev) { | |
| 3571 prev->set_next(current->next()); | |
| 3572 } else { | |
| 3573 _thread_list = p->next(); | |
| 3574 } | |
| 3575 _number_of_threads--; | |
| 3576 oop threadObj = p->threadObj(); | |
| 3577 bool daemon = true; | |
| 3578 if (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj)) { | |
| 3579 _number_of_non_daemon_threads--; | |
| 3580 daemon = false; | |
| 3581 | |
| 3582 // Only one thread left, do a notify on the Threads_lock so a thread waiting | |
| 3583 // on destroy_vm will wake up. | |
| 3584 if (number_of_non_daemon_threads() == 1) | |
| 3585 Threads_lock->notify_all(); | |
| 3586 } | |
| 3587 ThreadService::remove_thread(p, daemon); | |
| 3588 | |
| 3589 // Make sure that safepoint code disregard this thread. This is needed since | |
| 3590 // the thread might mess around with locks after this point. This can cause it | |
| 3591 // to do callbacks into the safepoint code. However, the safepoint code is not aware | |
| 3592 // of this thread since it is removed from the queue. | |
| 3593 p->set_terminated_value(); | |
| 3594 } // unlock Threads_lock | |
| 3595 | |
| 3596 // Since Events::log uses a lock, we grab it outside the Threads_lock | |
| 3597 Events::log("Thread exited: " INTPTR_FORMAT, p); | |
| 3598 } | |
| 3599 | |
| 3600 // Threads_lock must be held when this is called (or must be called during a safepoint) | |
| 3601 bool Threads::includes(JavaThread* p) { | |
| 3602 assert(Threads_lock->is_locked(), "sanity check"); | |
| 3603 ALL_JAVA_THREADS(q) { | |
| 3604 if (q == p ) { | |
| 3605 return true; | |
| 3606 } | |
| 3607 } | |
| 3608 return false; | |
| 3609 } | |
| 3610 | |
| 3611 // Operations on the Threads list for GC. These are not explicitly locked, | |
| 3612 // but the garbage collector must provide a safe context for them to run. | |
| 3613 // In particular, these things should never be called when the Threads_lock | |
| 3614 // is held by some other thread. (Note: the Safepoint abstraction also | |
| 3615 // uses the Threads_lock to gurantee this property. It also makes sure that | |
| 3616 // all threads gets blocked when exiting or starting). | |
| 3617 | |
| 3618 void Threads::oops_do(OopClosure* f) { | |
| 3619 ALL_JAVA_THREADS(p) { | |
| 3620 p->oops_do(f); | |
| 3621 } | |
| 3622 VMThread::vm_thread()->oops_do(f); | |
| 3623 } | |
| 3624 | |
| 3625 void Threads::possibly_parallel_oops_do(OopClosure* f) { | |
| 3626 // Introduce a mechanism allowing parallel threads to claim threads as | |
| 3627 // root groups. Overhead should be small enough to use all the time, | |
| 3628 // even in sequential code. | |
| 3629 SharedHeap* sh = SharedHeap::heap(); | |
| 3630 bool is_par = (sh->n_par_threads() > 0); | |
| 3631 int cp = SharedHeap::heap()->strong_roots_parity(); | |
| 3632 ALL_JAVA_THREADS(p) { | |
| 3633 if (p->claim_oops_do(is_par, cp)) { | |
| 3634 p->oops_do(f); | |
| 3635 } | |
| 3636 } | |
| 3637 VMThread* vmt = VMThread::vm_thread(); | |
| 3638 if (vmt->claim_oops_do(is_par, cp)) | |
| 3639 vmt->oops_do(f); | |
| 3640 } | |
| 3641 | |
| 3642 #ifndef SERIALGC | |
| 3643 // Used by ParallelScavenge | |
| 3644 void Threads::create_thread_roots_tasks(GCTaskQueue* q) { | |
| 3645 ALL_JAVA_THREADS(p) { | |
| 3646 q->enqueue(new ThreadRootsTask(p)); | |
| 3647 } | |
| 3648 q->enqueue(new ThreadRootsTask(VMThread::vm_thread())); | |
| 3649 } | |
| 3650 | |
| 3651 // Used by Parallel Old | |
| 3652 void Threads::create_thread_roots_marking_tasks(GCTaskQueue* q) { | |
| 3653 ALL_JAVA_THREADS(p) { | |
| 3654 q->enqueue(new ThreadRootsMarkingTask(p)); | |
| 3655 } | |
| 3656 q->enqueue(new ThreadRootsMarkingTask(VMThread::vm_thread())); | |
| 3657 } | |
| 3658 #endif // SERIALGC | |
| 3659 | |
| 3660 void Threads::nmethods_do() { | |
| 3661 ALL_JAVA_THREADS(p) { | |
| 3662 p->nmethods_do(); | |
| 3663 } | |
| 3664 VMThread::vm_thread()->nmethods_do(); | |
| 3665 } | |
| 3666 | |
| 3667 void Threads::gc_epilogue() { | |
| 3668 ALL_JAVA_THREADS(p) { | |
| 3669 p->gc_epilogue(); | |
| 3670 } | |
| 3671 } | |
| 3672 | |
| 3673 void Threads::gc_prologue() { | |
| 3674 ALL_JAVA_THREADS(p) { | |
| 3675 p->gc_prologue(); | |
| 3676 } | |
| 3677 } | |
| 3678 | |
| 3679 void Threads::deoptimized_wrt_marked_nmethods() { | |
| 3680 ALL_JAVA_THREADS(p) { | |
| 3681 p->deoptimized_wrt_marked_nmethods(); | |
| 3682 } | |
| 3683 } | |
| 3684 | |
| 3685 | |
| 3686 // Get count Java threads that are waiting to enter the specified monitor. | |
| 3687 GrowableArray<JavaThread*>* Threads::get_pending_threads(int count, | |
| 3688 address monitor, bool doLock) { | |
| 3689 assert(doLock || SafepointSynchronize::is_at_safepoint(), | |
| 3690 "must grab Threads_lock or be at safepoint"); | |
| 3691 GrowableArray<JavaThread*>* result = new GrowableArray<JavaThread*>(count); | |
| 3692 | |
| 3693 int i = 0; | |
| 3694 { | |
| 3695 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
| 3696 ALL_JAVA_THREADS(p) { | |
| 3697 if (p->is_Compiler_thread()) continue; | |
| 3698 | |
| 3699 address pending = (address)p->current_pending_monitor(); | |
| 3700 if (pending == monitor) { // found a match | |
| 3701 if (i < count) result->append(p); // save the first count matches | |
| 3702 i++; | |
| 3703 } | |
| 3704 } | |
| 3705 } | |
| 3706 return result; | |
| 3707 } | |
| 3708 | |
| 3709 | |
| 3710 JavaThread *Threads::owning_thread_from_monitor_owner(address owner, bool doLock) { | |
| 3711 assert(doLock || | |
| 3712 Threads_lock->owned_by_self() || | |
| 3713 SafepointSynchronize::is_at_safepoint(), | |
| 3714 "must grab Threads_lock or be at safepoint"); | |
| 3715 | |
| 3716 // NULL owner means not locked so we can skip the search | |
| 3717 if (owner == NULL) return NULL; | |
| 3718 | |
| 3719 { | |
| 3720 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
| 3721 ALL_JAVA_THREADS(p) { | |
| 3722 // first, see if owner is the address of a Java thread | |
| 3723 if (owner == (address)p) return p; | |
| 3724 } | |
| 3725 } | |
| 3726 assert(UseHeavyMonitors == false, "Did not find owning Java thread with UseHeavyMonitors enabled"); | |
| 3727 if (UseHeavyMonitors) return NULL; | |
| 3728 | |
| 3729 // | |
| 3730 // If we didn't find a matching Java thread and we didn't force use of | |
| 3731 // heavyweight monitors, then the owner is the stack address of the | |
| 3732 // Lock Word in the owning Java thread's stack. | |
| 3733 // | |
| 3734 // We can't use Thread::is_lock_owned() or Thread::lock_is_in_stack() because | |
| 3735 // those routines rely on the "current" stack pointer. That would be our | |
| 3736 // stack pointer which is not relevant to the question. Instead we use the | |
| 3737 // highest lock ever entered by the thread and find the thread that is | |
| 3738 // higher than and closest to our target stack address. | |
| 3739 // | |
| 3740 address least_diff = 0; | |
| 3741 bool least_diff_initialized = false; | |
| 3742 JavaThread* the_owner = NULL; | |
| 3743 { | |
| 3744 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
| 3745 ALL_JAVA_THREADS(q) { | |
| 3746 address addr = q->highest_lock(); | |
| 3747 if (addr == NULL || addr < owner) continue; // thread has entered no monitors or is too low | |
| 3748 address diff = (address)(addr - owner); | |
| 3749 if (!least_diff_initialized || diff < least_diff) { | |
| 3750 least_diff_initialized = true; | |
| 3751 least_diff = diff; | |
| 3752 the_owner = q; | |
| 3753 } | |
| 3754 } | |
| 3755 } | |
| 3756 assert(the_owner != NULL, "Did not find owning Java thread for lock word address"); | |
| 3757 return the_owner; | |
| 3758 } | |
| 3759 | |
| 3760 // Threads::print_on() is called at safepoint by VM_PrintThreads operation. | |
| 3761 void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) { | |
| 3762 char buf[32]; | |
| 3763 st->print_cr(os::local_time_string(buf, sizeof(buf))); | |
| 3764 | |
| 3765 st->print_cr("Full thread dump %s (%s %s):", | |
| 3766 Abstract_VM_Version::vm_name(), | |
| 3767 Abstract_VM_Version::vm_release(), | |
| 3768 Abstract_VM_Version::vm_info_string() | |
| 3769 ); | |
| 3770 st->cr(); | |
| 3771 | |
| 3772 #ifndef SERIALGC | |
| 3773 // Dump concurrent locks | |
| 3774 ConcurrentLocksDump concurrent_locks; | |
| 3775 if (print_concurrent_locks) { | |
| 3776 concurrent_locks.dump_at_safepoint(); | |
| 3777 } | |
| 3778 #endif // SERIALGC | |
| 3779 | |
| 3780 ALL_JAVA_THREADS(p) { | |
| 3781 ResourceMark rm; | |
| 3782 p->print_on(st); | |
| 3783 if (print_stacks) { | |
| 3784 if (internal_format) { | |
| 3785 p->trace_stack(); | |
| 3786 } else { | |
| 3787 p->print_stack_on(st); | |
| 3788 } | |
| 3789 } | |
| 3790 st->cr(); | |
| 3791 #ifndef SERIALGC | |
| 3792 if (print_concurrent_locks) { | |
| 3793 concurrent_locks.print_locks_on(p, st); | |
| 3794 } | |
| 3795 #endif // SERIALGC | |
| 3796 } | |
| 3797 | |
| 3798 VMThread::vm_thread()->print_on(st); | |
| 3799 st->cr(); | |
| 3800 Universe::heap()->print_gc_threads_on(st); | |
| 3801 WatcherThread* wt = WatcherThread::watcher_thread(); | |
| 3802 if (wt != NULL) wt->print_on(st); | |
| 3803 st->cr(); | |
| 3804 CompileBroker::print_compiler_threads_on(st); | |
| 3805 st->flush(); | |
| 3806 } | |
| 3807 | |
| 3808 // Threads::print_on_error() is called by fatal error handler. It's possible | |
| 3809 // that VM is not at safepoint and/or current thread is inside signal handler. | |
| 3810 // Don't print stack trace, as the stack may not be walkable. Don't allocate | |
| 3811 // memory (even in resource area), it might deadlock the error handler. | |
| 3812 void Threads::print_on_error(outputStream* st, Thread* current, char* buf, int buflen) { | |
| 3813 bool found_current = false; | |
| 3814 st->print_cr("Java Threads: ( => current thread )"); | |
| 3815 ALL_JAVA_THREADS(thread) { | |
| 3816 bool is_current = (current == thread); | |
| 3817 found_current = found_current || is_current; | |
| 3818 | |
| 3819 st->print("%s", is_current ? "=>" : " "); | |
| 3820 | |
| 3821 st->print(PTR_FORMAT, thread); | |
| 3822 st->print(" "); | |
| 3823 thread->print_on_error(st, buf, buflen); | |
| 3824 st->cr(); | |
| 3825 } | |
| 3826 st->cr(); | |
| 3827 | |
| 3828 st->print_cr("Other Threads:"); | |
| 3829 if (VMThread::vm_thread()) { | |
| 3830 bool is_current = (current == VMThread::vm_thread()); | |
| 3831 found_current = found_current || is_current; | |
| 3832 st->print("%s", current == VMThread::vm_thread() ? "=>" : " "); | |
| 3833 | |
| 3834 st->print(PTR_FORMAT, VMThread::vm_thread()); | |
| 3835 st->print(" "); | |
| 3836 VMThread::vm_thread()->print_on_error(st, buf, buflen); | |
| 3837 st->cr(); | |
| 3838 } | |
| 3839 WatcherThread* wt = WatcherThread::watcher_thread(); | |
| 3840 if (wt != NULL) { | |
| 3841 bool is_current = (current == wt); | |
| 3842 found_current = found_current || is_current; | |
| 3843 st->print("%s", is_current ? "=>" : " "); | |
| 3844 | |
| 3845 st->print(PTR_FORMAT, wt); | |
| 3846 st->print(" "); | |
| 3847 wt->print_on_error(st, buf, buflen); | |
| 3848 st->cr(); | |
| 3849 } | |
| 3850 if (!found_current) { | |
| 3851 st->cr(); | |
| 3852 st->print("=>" PTR_FORMAT " (exited) ", current); | |
| 3853 current->print_on_error(st, buf, buflen); | |
| 3854 st->cr(); | |
| 3855 } | |
| 3856 } | |
| 3857 | |
| 3858 | |
| 3859 // Lifecycle management for TSM ParkEvents. | |
| 3860 // ParkEvents are type-stable (TSM). | |
| 3861 // In our particular implementation they happen to be immortal. | |
| 3862 // | |
| 3863 // We manage concurrency on the FreeList with a CAS-based | |
| 3864 // detach-modify-reattach idiom that avoids the ABA problems | |
| 3865 // that would otherwise be present in a simple CAS-based | |
| 3866 // push-pop implementation. (push-one and pop-all) | |
| 3867 // | |
| 3868 // Caveat: Allocate() and Release() may be called from threads | |
| 3869 // other than the thread associated with the Event! | |
| 3870 // If we need to call Allocate() when running as the thread in | |
| 3871 // question then look for the PD calls to initialize native TLS. | |
| 3872 // Native TLS (Win32/Linux/Solaris) can only be initialized or | |
| 3873 // accessed by the associated thread. | |
| 3874 // See also pd_initialize(). | |
| 3875 // | |
| 3876 // Note that we could defer associating a ParkEvent with a thread | |
| 3877 // until the 1st time the thread calls park(). unpark() calls to | |
| 3878 // an unprovisioned thread would be ignored. The first park() call | |
| 3879 // for a thread would allocate and associate a ParkEvent and return | |
| 3880 // immediately. | |
| 3881 | |
| 3882 volatile int ParkEvent::ListLock = 0 ; | |
| 3883 ParkEvent * volatile ParkEvent::FreeList = NULL ; | |
| 3884 | |
| 3885 ParkEvent * ParkEvent::Allocate (Thread * t) { | |
| 3886 // In rare cases -- JVM_RawMonitor* operations -- we can find t == null. | |
| 3887 ParkEvent * ev ; | |
| 3888 | |
| 3889 // Start by trying to recycle an existing but unassociated | |
| 3890 // ParkEvent from the global free list. | |
| 3891 for (;;) { | |
| 3892 ev = FreeList ; | |
| 3893 if (ev == NULL) break ; | |
| 3894 // 1: Detach - sequester or privatize the list | |
| 3895 // Tantamount to ev = Swap (&FreeList, NULL) | |
| 3896 if (Atomic::cmpxchg_ptr (NULL, &FreeList, ev) != ev) { | |
| 3897 continue ; | |
| 3898 } | |
| 3899 | |
| 3900 // We've detached the list. The list in-hand is now | |
| 3901 // local to this thread. This thread can operate on the | |
| 3902 // list without risk of interference from other threads. | |
| 3903 // 2: Extract -- pop the 1st element from the list. | |
| 3904 ParkEvent * List = ev->FreeNext ; | |
| 3905 if (List == NULL) break ; | |
| 3906 for (;;) { | |
| 3907 // 3: Try to reattach the residual list | |
| 3908 guarantee (List != NULL, "invariant") ; | |
| 3909 ParkEvent * Arv = (ParkEvent *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ; | |
| 3910 if (Arv == NULL) break ; | |
| 3911 | |
| 3912 // New nodes arrived. Try to detach the recent arrivals. | |
| 3913 if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) { | |
| 3914 continue ; | |
| 3915 } | |
| 3916 guarantee (Arv != NULL, "invariant") ; | |
| 3917 // 4: Merge Arv into List | |
| 3918 ParkEvent * Tail = List ; | |
| 3919 while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ; | |
| 3920 Tail->FreeNext = Arv ; | |
| 3921 } | |
| 3922 break ; | |
| 3923 } | |
| 3924 | |
| 3925 if (ev != NULL) { | |
| 3926 guarantee (ev->AssociatedWith == NULL, "invariant") ; | |
| 3927 } else { | |
| 3928 // Do this the hard way -- materialize a new ParkEvent. | |
| 3929 // In rare cases an allocating thread might detach a long list -- | |
| 3930 // installing null into FreeList -- and then stall or be obstructed. | |
| 3931 // A 2nd thread calling Allocate() would see FreeList == null. | |
| 3932 // The list held privately by the 1st thread is unavailable to the 2nd thread. | |
| 3933 // In that case the 2nd thread would have to materialize a new ParkEvent, | |
| 3934 // even though free ParkEvents existed in the system. In this case we end up | |
| 3935 // with more ParkEvents in circulation than we need, but the race is | |
| 3936 // rare and the outcome is benign. Ideally, the # of extant ParkEvents | |
| 3937 // is equal to the maximum # of threads that existed at any one time. | |
| 3938 // Because of the race mentioned above, segments of the freelist | |
| 3939 // can be transiently inaccessible. At worst we may end up with the | |
| 3940 // # of ParkEvents in circulation slightly above the ideal. | |
| 3941 // Note that if we didn't have the TSM/immortal constraint, then | |
| 3942 // when reattaching, above, we could trim the list. | |
| 3943 ev = new ParkEvent () ; | |
| 3944 guarantee ((intptr_t(ev) & 0xFF) == 0, "invariant") ; | |
| 3945 } | |
| 3946 ev->reset() ; // courtesy to caller | |
| 3947 ev->AssociatedWith = t ; // Associate ev with t | |
| 3948 ev->FreeNext = NULL ; | |
| 3949 return ev ; | |
| 3950 } | |
| 3951 | |
| 3952 void ParkEvent::Release (ParkEvent * ev) { | |
| 3953 if (ev == NULL) return ; | |
| 3954 guarantee (ev->FreeNext == NULL , "invariant") ; | |
| 3955 ev->AssociatedWith = NULL ; | |
| 3956 for (;;) { | |
| 3957 // Push ev onto FreeList | |
| 3958 // The mechanism is "half" lock-free. | |
| 3959 ParkEvent * List = FreeList ; | |
| 3960 ev->FreeNext = List ; | |
| 3961 if (Atomic::cmpxchg_ptr (ev, &FreeList, List) == List) break ; | |
| 3962 } | |
| 3963 } | |
| 3964 | |
| 3965 // Override operator new and delete so we can ensure that the | |
| 3966 // least significant byte of ParkEvent addresses is 0. | |
| 3967 // Beware that excessive address alignment is undesirable | |
| 3968 // as it can result in D$ index usage imbalance as | |
| 3969 // well as bank access imbalance on Niagara-like platforms, | |
| 3970 // although Niagara's hash function should help. | |
| 3971 | |
| 3972 void * ParkEvent::operator new (size_t sz) { | |
| 3973 return (void *) ((intptr_t (CHeapObj::operator new (sz + 256)) + 256) & -256) ; | |
| 3974 } | |
| 3975 | |
| 3976 void ParkEvent::operator delete (void * a) { | |
| 3977 // ParkEvents are type-stable and immortal ... | |
| 3978 ShouldNotReachHere(); | |
| 3979 } | |
| 3980 | |
| 3981 | |
| 3982 // 6399321 As a temporary measure we copied & modified the ParkEvent:: | |
| 3983 // allocate() and release() code for use by Parkers. The Parker:: forms | |
| 3984 // will eventually be removed as we consolide and shift over to ParkEvents | |
| 3985 // for both builtin synchronization and JSR166 operations. | |
| 3986 | |
| 3987 volatile int Parker::ListLock = 0 ; | |
| 3988 Parker * volatile Parker::FreeList = NULL ; | |
| 3989 | |
| 3990 Parker * Parker::Allocate (JavaThread * t) { | |
| 3991 guarantee (t != NULL, "invariant") ; | |
| 3992 Parker * p ; | |
| 3993 | |
| 3994 // Start by trying to recycle an existing but unassociated | |
| 3995 // Parker from the global free list. | |
| 3996 for (;;) { | |
| 3997 p = FreeList ; | |
| 3998 if (p == NULL) break ; | |
| 3999 // 1: Detach | |
| 4000 // Tantamount to p = Swap (&FreeList, NULL) | |
| 4001 if (Atomic::cmpxchg_ptr (NULL, &FreeList, p) != p) { | |
| 4002 continue ; | |
| 4003 } | |
| 4004 | |
| 4005 // We've detached the list. The list in-hand is now | |
| 4006 // local to this thread. This thread can operate on the | |
| 4007 // list without risk of interference from other threads. | |
| 4008 // 2: Extract -- pop the 1st element from the list. | |
| 4009 Parker * List = p->FreeNext ; | |
| 4010 if (List == NULL) break ; | |
| 4011 for (;;) { | |
| 4012 // 3: Try to reattach the residual list | |
| 4013 guarantee (List != NULL, "invariant") ; | |
| 4014 Parker * Arv = (Parker *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ; | |
| 4015 if (Arv == NULL) break ; | |
| 4016 | |
| 4017 // New nodes arrived. Try to detach the recent arrivals. | |
| 4018 if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) { | |
| 4019 continue ; | |
| 4020 } | |
| 4021 guarantee (Arv != NULL, "invariant") ; | |
| 4022 // 4: Merge Arv into List | |
| 4023 Parker * Tail = List ; | |
| 4024 while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ; | |
| 4025 Tail->FreeNext = Arv ; | |
| 4026 } | |
| 4027 break ; | |
| 4028 } | |
| 4029 | |
| 4030 if (p != NULL) { | |
| 4031 guarantee (p->AssociatedWith == NULL, "invariant") ; | |
| 4032 } else { | |
| 4033 // Do this the hard way -- materialize a new Parker.. | |
| 4034 // In rare cases an allocating thread might detach | |
| 4035 // a long list -- installing null into FreeList --and | |
| 4036 // then stall. Another thread calling Allocate() would see | |
| 4037 // FreeList == null and then invoke the ctor. In this case we | |
| 4038 // end up with more Parkers in circulation than we need, but | |
| 4039 // the race is rare and the outcome is benign. | |
| 4040 // Ideally, the # of extant Parkers is equal to the | |
| 4041 // maximum # of threads that existed at any one time. | |
| 4042 // Because of the race mentioned above, segments of the | |
| 4043 // freelist can be transiently inaccessible. At worst | |
| 4044 // we may end up with the # of Parkers in circulation | |
| 4045 // slightly above the ideal. | |
| 4046 p = new Parker() ; | |
| 4047 } | |
| 4048 p->AssociatedWith = t ; // Associate p with t | |
| 4049 p->FreeNext = NULL ; | |
| 4050 return p ; | |
| 4051 } | |
| 4052 | |
| 4053 | |
| 4054 void Parker::Release (Parker * p) { | |
| 4055 if (p == NULL) return ; | |
| 4056 guarantee (p->AssociatedWith != NULL, "invariant") ; | |
| 4057 guarantee (p->FreeNext == NULL , "invariant") ; | |
| 4058 p->AssociatedWith = NULL ; | |
| 4059 for (;;) { | |
| 4060 // Push p onto FreeList | |
| 4061 Parker * List = FreeList ; | |
| 4062 p->FreeNext = List ; | |
| 4063 if (Atomic::cmpxchg_ptr (p, &FreeList, List) == List) break ; | |
| 4064 } | |
| 4065 } | |
| 4066 | |
| 4067 void Threads::verify() { | |
| 4068 ALL_JAVA_THREADS(p) { | |
| 4069 p->verify(); | |
| 4070 } | |
| 4071 VMThread* thread = VMThread::vm_thread(); | |
| 4072 if (thread != NULL) thread->verify(); | |
| 4073 } |