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