diff -r a02753d5a0b2 -r d1221849ea3d hotspot/src/share/vm/runtime/thread.cpp --- a/hotspot/src/share/vm/runtime/thread.cpp Wed Sep 10 11:48:20 2014 -0600 +++ b/hotspot/src/share/vm/runtime/thread.cpp Wed Sep 10 11:52:16 2014 -0600 @@ -109,25 +109,25 @@ // Only bother with this argument setup if dtrace is available -#define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START -#define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_STOP - -#define DTRACE_THREAD_PROBE(probe, javathread) \ - { \ - ResourceMark rm(this); \ - int len = 0; \ - const char* name = (javathread)->get_thread_name(); \ - len = strlen(name); \ - HOTSPOT_THREAD_PROBE_##probe( /* probe = start, stop */ \ - (char *) name, len, \ - java_lang_Thread::thread_id((javathread)->threadObj()), \ - (uintptr_t) (javathread)->osthread()->thread_id(), \ - java_lang_Thread::is_daemon((javathread)->threadObj())); \ - } + #define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START + #define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_STOP + + #define DTRACE_THREAD_PROBE(probe, javathread) \ + { \ + ResourceMark rm(this); \ + int len = 0; \ + const char* name = (javathread)->get_thread_name(); \ + len = strlen(name); \ + HOTSPOT_THREAD_PROBE_##probe(/* probe = start, stop */ \ + (char *) name, len, \ + java_lang_Thread::thread_id((javathread)->threadObj()), \ + (uintptr_t) (javathread)->osthread()->thread_id(), \ + java_lang_Thread::is_daemon((javathread)->threadObj())); \ + } #else // ndef DTRACE_ENABLED -#define DTRACE_THREAD_PROBE(probe, javathread) + #define DTRACE_THREAD_PROBE(probe, javathread) #endif // ndef DTRACE_ENABLED @@ -154,9 +154,10 @@ ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size), "JavaThread alignment code overflowed allocated storage"); if (TraceBiasedLocking) { - if (aligned_addr != real_malloc_addr) + if (aligned_addr != real_malloc_addr) { tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT, real_malloc_addr, aligned_addr); + } } ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr; return aligned_addr; @@ -264,7 +265,7 @@ this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment), "bug in forced alignment of thread objects"); } -#endif /* ASSERT */ +#endif // ASSERT } void Thread::initialize_thread_local_storage() { @@ -445,7 +446,6 @@ } -// // Check if an external suspend request has completed (or has been // cancelled). Returns true if the thread is externally suspended and // false otherwise. @@ -470,7 +470,6 @@ // 0x00080000 - suspend request cancelled in loop (return false) // 0x00100000 - thread suspended in loop (return true) // 0x00200000 - suspend not completed during retry loop (return false) -// // Helper class for tracing suspend wait debug bits. // @@ -528,7 +527,8 @@ #undef DEBUG_FALSE_BITS -bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) { +bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, + uint32_t *bits) { TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits); bool did_trans_retry = false; // only do thread_in_native_trans retry once @@ -649,7 +649,6 @@ return false; } -// // Wait for an external suspend request to complete (or be cancelled). // Returns true if the thread is externally suspended and false otherwise. // @@ -737,20 +736,21 @@ } #ifndef PRODUCT -void JavaThread::record_jump(address target, address instr, const char* file, int line) { +void JavaThread::record_jump(address target, address instr, const char* file, + int line) { // This should not need to be atomic as the only way for simultaneous // updates is via interrupts. Even then this should be rare or non-existent // and we don't care that much anyway. int index = _jmp_ring_index; - _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1); + _jmp_ring_index = (index + 1) & (jump_ring_buffer_size - 1); _jmp_ring[index]._target = (intptr_t) target; _jmp_ring[index]._instruction = (intptr_t) instr; _jmp_ring[index]._file = file; _jmp_ring[index]._line = line; } -#endif /* PRODUCT */ +#endif // PRODUCT // Called by flat profiler // Callers have already called wait_for_ext_suspend_completion @@ -834,13 +834,13 @@ // Thread::print_on_error() is called by fatal error handler. Don't use // any lock or allocate memory. void Thread::print_on_error(outputStream* st, char* buf, int buflen) const { - if (is_VM_thread()) st->print("VMThread"); - else if (is_Compiler_thread()) st->print("CompilerThread"); - else if (is_Java_thread()) st->print("JavaThread"); - else if (is_GC_task_thread()) st->print("GCTaskThread"); - else if (is_Watcher_thread()) st->print("WatcherThread"); - else if (is_ConcurrentGC_thread()) st->print("ConcurrentGCThread"); - else st->print("Thread"); + if (is_VM_thread()) st->print("VMThread"); + else if (is_Compiler_thread()) st->print("CompilerThread"); + else if (is_Java_thread()) st->print("JavaThread"); + else if (is_GC_task_thread()) st->print("GCTaskThread"); + else if (is_Watcher_thread()) st->print("WatcherThread"); + else if (is_ConcurrentGC_thread()) st->print("ConcurrentGCThread"); + else st->print("Thread"); st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]", _stack_base - _stack_size, _stack_base); @@ -883,8 +883,9 @@ // no threads which allow_vm_block's are held void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) { // Check if current thread is allowed to block at a safepoint - if (!(_allow_safepoint_count == 0)) + if (!(_allow_safepoint_count == 0)) { fatal("Possible safepoint reached by thread that does not allow it"); + } if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) { fatal("LEAF method calling lock?"); } @@ -991,7 +992,8 @@ } // Creates the initial Thread -static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) { +static oop create_initial_thread(Handle thread_group, JavaThread* thread, + TRAPS) { Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK_NULL); instanceKlassHandle klass (THREAD, k); instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL); @@ -1035,8 +1037,9 @@ vmSymbols::string_signature(), &fd); if (found) { oop name_oop = k->java_mirror()->obj_field(fd.offset()); - if (name_oop == NULL) + if (name_oop == NULL) { return NULL; + } const char* name = java_lang_String::as_utf8_string(name_oop, java_runtime_name, sizeof(java_runtime_name)); @@ -1056,8 +1059,9 @@ vmSymbols::string_signature(), &fd); if (found) { oop name_oop = k->java_mirror()->obj_field(fd.offset()); - if (name_oop == NULL) + if (name_oop == NULL) { return NULL; + } const char* name = java_lang_String::as_utf8_string(name_oop, java_runtime_version, sizeof(java_runtime_version)); @@ -1107,7 +1111,8 @@ } -void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) { +void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, + bool daemon, TRAPS) { assert(thread_group.not_null(), "thread group should be specified"); assert(threadObj() == NULL, "should only create Java thread object once"); @@ -1268,8 +1273,9 @@ } remaining -= time_slept; - if (remaining <= 0) + if (remaining <= 0) { break; + } } return time_slept; @@ -1387,7 +1393,9 @@ } void WatcherThread::unpark() { - MutexLockerEx ml(PeriodicTask_lock->owned_by_self() ? NULL : PeriodicTask_lock, Mutex::_no_safepoint_check_flag); + MutexLockerEx ml(PeriodicTask_lock->owned_by_self() + ? NULL + : PeriodicTask_lock, Mutex::_no_safepoint_check_flag); PeriodicTask_lock->notify(); } @@ -1455,7 +1463,7 @@ for (int ji = 0; ji < jump_ring_buffer_size; ji++) { record_jump(NULL, NULL, NULL, 0); } -#endif /* PRODUCT */ +#endif // PRODUCT set_thread_profiler(NULL); if (FlatProfiler::is_active()) { @@ -2061,19 +2069,16 @@ condition == _async_unsafe_access_error && !has_pending_exception()) { condition = _no_async_condition; // done switch (thread_state()) { - case _thread_in_vm: - { + case _thread_in_vm: { JavaThread* THREAD = this; THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); } - case _thread_in_native: - { + case _thread_in_native: { ThreadInVMfromNative tiv(this); JavaThread* THREAD = this; THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); } - case _thread_in_Java: - { + case _thread_in_Java: { ThreadInVMfromJava tiv(this); JavaThread* THREAD = this; THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code"); @@ -2214,7 +2219,7 @@ // SR_lock to allow the thread to reach a stable thread state if // it is currently in a transient thread state. if (is_ext_suspend_completed(false /* !called_by_wait */, - SuspendRetryDelay, &debug_bits) ) { + SuspendRetryDelay, &debug_bits)) { return; } } @@ -2292,8 +2297,7 @@ MutexLockerEx ml(Threads_lock, Mutex::_no_safepoint_check_flag); assert(!Threads::includes(this), "java thread shouldn't have been published yet!"); - } - else { + } else { assert(!Threads::includes(this), "java thread shouldn't have been published yet!"); } @@ -2570,7 +2574,7 @@ // search for the current bci in that string. address pc = fst.current()->pc(); nmethod* nm = (nmethod*) fst.current()->cb(); - ScopeDesc* sd = nm->scope_desc_at( pc); + ScopeDesc* sd = nm->scope_desc_at(pc); char buffer[8]; jio_snprintf(buffer, sizeof(buffer), "%d", sd->bci()); size_t len = strlen(buffer); @@ -2779,7 +2783,7 @@ }; void JavaThread::print_thread_state() const { print_thread_state_on(tty); -}; +} #endif // PRODUCT // Called by Threads::print() for VM_PrintThreads operation @@ -2865,20 +2869,18 @@ typeArrayOop name = java_lang_Thread::name(thread_obj); if (name != NULL) { if (buf == NULL) { - name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); - } - else { - name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length(), buf, buflen); + name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), + name->length()); + } else { + name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), + name->length(), buf, buflen); } - } - else if (is_attaching_via_jni()) { // workaround for 6412693 - see 6404306 + } else if (is_attaching_via_jni()) { // workaround for 6412693 - see 6404306 name_str = ""; - } - else { + } else { name_str = Thread::name(); } - } - else { + } else { name_str = Thread::name(); } assert(name_str != NULL, "unexpected NULL thread name"); @@ -3165,8 +3167,9 @@ } // Create a CompilerThread -CompilerThread::CompilerThread(CompileQueue* queue, CompilerCounters* counters) -: JavaThread(&compiler_thread_entry) { +CompilerThread::CompilerThread(CompileQueue* queue, + CompilerCounters* counters) + : JavaThread(&compiler_thread_entry) { _env = NULL; _log = NULL; _task = NULL; @@ -3231,8 +3234,9 @@ // way to prevent termination of WatcherThread would be to acquire // Terminator_lock, but we can't do that without violating the lock rank // checking in some cases. - if (wt != NULL) + if (wt != NULL) { tc->do_thread(wt); + } // If CompilerThreads ever become non-JavaThreads, add them here } @@ -3290,7 +3294,6 @@ } jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { - extern void JDK_Version_init(); // Check version @@ -3422,8 +3425,10 @@ VMThread::create(); Thread* vmthread = VMThread::vm_thread(); - if (!os::create_thread(vmthread, os::vm_thread)) - vm_exit_during_initialization("Cannot create VM thread. Out of system resources."); + if (!os::create_thread(vmthread, os::vm_thread)) { + vm_exit_during_initialization("Cannot create VM thread. " + "Out of system resources."); + } // Wait for the VM thread to become ready, and VMThread::run to initialize // Monitors can have spurious returns, must always check another state flag @@ -3613,7 +3618,9 @@ // Find a command line agent library and return its entry point for // -agentlib: -agentpath: -Xrun // num_symbol_entries must be passed-in since only the caller knows the number of symbols in the array. -static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_symbols[], size_t num_symbol_entries) { +static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, + const char *on_load_symbols[], + size_t num_symbol_entries) { OnLoadEntry_t on_load_entry = NULL; void *library = NULL; @@ -4006,8 +4013,9 @@ // Only one thread left, do a notify on the Threads_lock so a thread waiting // on destroy_vm will wake up. - if (number_of_non_daemon_threads() == 1) + if (number_of_non_daemon_threads() == 1) { Threads_lock->notify_all(); + } } ThreadService::remove_thread(p, daemon); @@ -4113,7 +4121,8 @@ // Get count Java threads that are waiting to enter the specified monitor. GrowableArray* Threads::get_pending_threads(int count, - address monitor, bool doLock) { + address monitor, + bool doLock) { assert(doLock || SafepointSynchronize::is_at_safepoint(), "must grab Threads_lock or be at safepoint"); GrowableArray* result = new GrowableArray(count); @@ -4135,7 +4144,8 @@ } -JavaThread *Threads::owning_thread_from_monitor_owner(address owner, bool doLock) { +JavaThread *Threads::owning_thread_from_monitor_owner(address owner, + bool doLock) { assert(doLock || Threads_lock->owned_by_self() || SafepointSynchronize::is_at_safepoint(), @@ -4156,7 +4166,6 @@ // like deadlock detection. if (UseHeavyMonitors) return NULL; - // // If we didn't find a matching Java thread and we didn't force use of // heavyweight monitors, then the owner is the stack address of the // Lock Word in the owning Java thread's stack. @@ -4176,15 +4185,15 @@ } // Threads::print_on() is called at safepoint by VM_PrintThreads operation. -void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) { +void Threads::print_on(outputStream* st, bool print_stacks, + bool internal_format, bool print_concurrent_locks) { char buf[32]; st->print_cr("%s", os::local_time_string(buf, sizeof(buf))); st->print_cr("Full thread dump %s (%s %s):", Abstract_VM_Version::vm_name(), Abstract_VM_Version::vm_release(), - Abstract_VM_Version::vm_info_string() - ); + Abstract_VM_Version::vm_info_string()); st->cr(); #if INCLUDE_ALL_GCS @@ -4229,7 +4238,8 @@ // that VM is not at safepoint and/or current thread is inside signal handler. // Don't print stack trace, as the stack may not be walkable. Don't allocate // memory (even in resource area), it might deadlock the error handler. -void Threads::print_on_error(outputStream* st, Thread* current, char* buf, int buflen) { +void Threads::print_on_error(outputStream* st, Thread* current, char* buf, + int buflen) { bool found_current = false; st->print_cr("Java Threads: ( => current thread )"); ALL_JAVA_THREADS(thread) { @@ -4301,7 +4311,7 @@ typedef volatile int SpinLockT; -void Thread::SpinAcquire (volatile int * adr, const char * LockName) { +void Thread::SpinAcquire(volatile int * adr, const char * LockName) { if (Atomic::cmpxchg (1, adr, 0) == 0) { return; // normal fast-path return } @@ -4328,7 +4338,7 @@ } } -void Thread::SpinRelease (volatile int * adr) { +void Thread::SpinRelease(volatile int * adr) { assert(*adr != 0, "invariant"); OrderAccess::fence(); // guarantee at least release consistency. // Roach-motel semantics. @@ -4397,7 +4407,7 @@ typedef volatile intptr_t MutexT; // Mux Lock-word enum MuxBits { LOCKBIT = 1 }; -void Thread::muxAcquire (volatile intptr_t * Lock, const char * LockName) { +void Thread::muxAcquire(volatile intptr_t * Lock, const char * LockName) { intptr_t w = Atomic::cmpxchg_ptr(LOCKBIT, Lock, 0); if (w == 0) return; if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) { @@ -4443,7 +4453,7 @@ } } -void Thread::muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) { +void Thread::muxAcquireW(volatile intptr_t * Lock, ParkEvent * ev) { intptr_t w = Atomic::cmpxchg_ptr(LOCKBIT, Lock, 0); if (w == 0) return; if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) { @@ -4528,7 +4538,7 @@ // bidirectional fence/MEMBAR semantics, ensuring that all prior memory operations // executed within the critical section are complete and globally visible before the // store (CAS) to the lock-word that releases the lock becomes globally visible. -void Thread::muxRelease (volatile intptr_t * Lock) { +void Thread::muxRelease(volatile intptr_t * Lock) { for (;;) { const intptr_t w = Atomic::cmpxchg_ptr(0, Lock, LOCKBIT); assert(w & LOCKBIT, "invariant");