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