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