jdk-sandbox: comparison hotspot/src/share/vm/runtime/thread.cpp

equal deleted inserted replaced

-:a02753d5a0b2
+:d1221849ea3d
 #ifdef DTRACE_ENABLED
 // 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)                             \
+#define DTRACE_THREAD_PROBE(probe, javathread)                           \
-{                                                                        \
+{                                                                      \
-ResourceMark rm(this);                                                 \
+ResourceMark rm(this);                                               \
-int len = 0;                                                           \
+int len = 0;                                                         \
-const char* name = (javathread)->get_thread_name();                    \
+const char* name = (javathread)->get_thread_name();                  \
-len = strlen(name);                                                    \
+len = strlen(name);                                                  \
-HOTSPOT_THREAD_PROBE_##probe(  /* probe = start, stop */               \
+HOTSPOT_THREAD_PROBE_##probe(/* probe = start, stop */               \
-(char *) name, len,                                                           \
+(char *) name, len,                                                \
-java_lang_Thread::thread_id((javathread)->threadObj()),              \
+java_lang_Thread::thread_id((javathread)->threadObj()),            \
-(uintptr_t) (javathread)->osthread()->thread_id(),                               \
+(uintptr_t) (javathread)->osthread()->thread_id(),                 \
-java_lang_Thread::is_daemon((javathread)->threadObj()));             \
+java_lang_Thread::is_daemon((javathread)->threadObj()));           \
 }
 #else //  ndef DTRACE_ENABLED
 #define DTRACE_THREAD_PROBE(probe, javathread)
 #endif // ndef DTRACE_ENABLED
 // Class hierarchy
 void* aligned_addr     = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
 ((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;
 } else {
 return throw_excpt? AllocateHeap(size, flags, CURRENT_PC)
 assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");
 assert(this == _real_malloc_address ||
 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() {
 // Note: Make sure this method only calls
 // non-blocking operations. Otherwise, it might not work
 VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable);
 VMThread::execute(vm_stop);
 }
-//
 // Check if an external suspend request has completed (or has been
 // cancelled). Returns true if the thread is externally suspended and
 // false otherwise.
 //
 // The bits parameter returns information about the code path through
 // 0x00020000 - suspend request cancelled before loop (return false)
 // 0x00040000 - thread suspended before loop (return true)
 // 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.
 //
 // 0x00000100 indicates that the target thread exited before it could
 // self-suspend which is not a wait failure. 0x00000200, 0x00020000 and
 }
 };
 #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
 bool do_trans_retry;           // flag to force the retry
 *bits |= 0x00000010;
 return false;
 }
-//
 // Wait for an external suspend request to complete (or be cancelled).
 // Returns true if the thread is externally suspended and false otherwise.
 //
 bool JavaThread::wait_for_ext_suspend_completion(int retries, int delay,
 uint32_t *bits) {
 *bits |= 0x00200000;
 return false;
 }
 #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
 // The assertion for that is currently too complex to put here:
 bool JavaThread::profile_last_Java_frame(frame* _fr) {
 }
 // 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");
+if (is_VM_thread())                 st->print("VMThread");
-else if (is_Compiler_thread())            st->print("CompilerThread");
+else if (is_Compiler_thread())      st->print("CompilerThread");
-else if (is_Java_thread())                st->print("JavaThread");
+else if (is_Java_thread())          st->print("JavaThread");
-else if (is_GC_task_thread())             st->print("GCTaskThread");
+else if (is_GC_task_thread())       st->print("GCTaskThread");
-else if (is_Watcher_thread())             st->print("WatcherThread");
+else if (is_Watcher_thread())       st->print("WatcherThread");
-else if (is_ConcurrentGC_thread())        st->print("ConcurrentGCThread");
+else if (is_ConcurrentGC_thread())  st->print("ConcurrentGCThread");
-else st->print("Thread");
+else                                st->print("Thread");
 st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]",
 _stack_base - _stack_size, _stack_base);
 if (osthread()) {
 // The flag: potential_vm_operation notifies if this particular safepoint state could potential
 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that
 // 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?");
 }
 #ifdef ASSERT
 }
 return main_instance;
 }
 // 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);
 java_lang_Thread::set_thread(thread_oop(), thread);
 bool found = k != NULL &&
 InstanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_name_name(),
 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));
 return name;
 } else {
 bool found = k != NULL &&
 InstanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_version_name(),
 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));
 return name;
 } else {
 value_str,
 CHECK);
 }
-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");
 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 // another task gets enrolled
 continue;
 }
 remaining -= time_slept;
-if (remaining <= 0)
+if (remaining <= 0) {
 break;
+}
 }
 return time_slept;
 }
 Mutex::_as_suspend_equivalent_flag);
 }
 }
 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();
 }
 void WatcherThread::print_on(outputStream* st) const {
 st->print("\"%s\" ", name());
 #ifndef PRODUCT
 _jmp_ring_index = 0;
 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()) {
 // This is where we would decide to either give each thread it's own profiler
 // or use one global one from FlatProfiler,
 if (check_unsafe_error &&
 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");
 }
 default:
 uint32_t debug_bits = 0;
 // Warning: is_ext_suspend_completed() may temporarily drop the
 // 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;
 }
 }
 VM_ForceSafepoint vm_suspend;
 void JavaThread::verify_not_published() {
 if (!Threads_lock->owned_by_self()) {
 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!");
 }
 }
 #endif
 // Deoptimize only at particular bcis.  DeoptimizeOnlyAt
 // consists of comma or carriage return separated numbers so
 // 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);
 const char * found = strstr(DeoptimizeOnlyAt, buffer);
 while (found != NULL) {
 void JavaThread::print_thread_state_on(outputStream *st) const {
 st->print_cr("   JavaThread state: %s", _get_thread_state_name(_thread_state));
 };
 void JavaThread::print_thread_state() const {
 print_thread_state_on(tty);
-};
+}
 #endif // PRODUCT
 // Called by Threads::print() for VM_PrintThreads operation
 void JavaThread::print_on(outputStream *st) const {
 st->print("\"%s\" ", get_thread_name());
 oop thread_obj = threadObj();
 if (thread_obj != NULL) {
 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());
+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 {
+} else if (is_attaching_via_jni()) { // workaround for 6412693 - see 6404306
-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
 name_str = "<no-name - thread is attaching>";
-}
+} else {
-else {
 name_str = Thread::name();
 }
-}
+} else {
-else {
 name_str = Thread::name();
 }
 assert(name_str != NULL, "unexpected NULL thread name");
 return name_str;
 }
 assert(thread->is_Compiler_thread(), "must be compiler thread");
 CompileBroker::compiler_thread_loop();
 }
 // Create a CompilerThread
-CompilerThread::CompilerThread(CompileQueue* queue, CompilerCounters* counters)
+CompilerThread::CompilerThread(CompileQueue* queue,
-: JavaThread(&compiler_thread_entry) {
+CompilerCounters* counters)
+: JavaThread(&compiler_thread_entry) {
 _env   = NULL;
 _log   = NULL;
 _task  = NULL;
 _queue = queue;
 _counters = counters;
 // considering that WatchThread terminates when the VM is on the way to
 // exit at safepoint, the chance of the above is extremely small. The right
 // 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
 }
 initialize_class(vmSymbols::java_lang_invoke_MemberName(), CHECK);
 initialize_class(vmSymbols::java_lang_invoke_MethodHandleNatives(), CHECK);
 }
 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
 extern void JDK_Version_init();
 // Check version
 if (!is_supported_jni_version(args->version)) return JNI_EVERSION;
 // Create the VMThread
 { TraceTime timer("Start VMThread", TraceStartupTime);
 VMThread::create();
 Thread* vmthread = VMThread::vm_thread();
-if (!os::create_thread(vmthread, os::vm_thread))
+if (!os::create_thread(vmthread, os::vm_thread)) {
-vm_exit_during_initialization("Cannot create VM thread. Out of system resources.");
+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
 {
 MutexLocker ml(Notify_lock);
 typedef jint (JNICALL *OnLoadEntry_t)(JavaVM *, char *, void *);
 }
 // 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;
 if (!agent->valid()) {
 char buffer[JVM_MAXPATHLEN];
 _number_of_non_daemon_threads--;
 daemon = false;
 // 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);
 // Make sure that safepoint code disregard this thread. This is needed since
 // the thread might mess around with locks after this point. This can cause it
 }
 // Get count Java threads that are waiting to enter the specified monitor.
 GrowableArray<JavaThread*>* 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<JavaThread*>* result = new GrowableArray<JavaThread*>(count);
 int i = 0;
 }
 return result;
 }
-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(),
 "must grab Threads_lock or be at safepoint");
 // Cannot assert on lack of success here since this function may be
 // used by code that is trying to report useful problem information
 // 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.
 //
 JavaThread* the_owner = NULL;
 // cannot assert on lack of success here; see above comment
 return the_owner;
 }
 // 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
 // Dump concurrent locks
 ConcurrentLocksDump concurrent_locks;
 // Threads::print_on_error() is called by fatal error handler. It's possible
 // 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) {
 bool is_current = (current == thread);
 found_current = found_current || is_current;
 // cache-coherency traffic.
 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
 }
 // Slow-path : We've encountered contention -- Spin/Yield/Block strategy.
 }
 if (Atomic::cmpxchg(1, adr, 0) == 0) return;
 }
 }
-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.
 // It's safe if subsequent LDs and STs float "up" into the critical section,
 // but prior LDs and STs within the critical section can't be allowed
 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) {
 return;
 }
 Self->park();
 }
 }
 }
-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) {
 return;
 }
 // All paths through muxRelease() will execute a CAS.
 // Release consistency -- We depend on the CAS in muxRelease() to provide full
 // 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");
 if (w == LOCKBIT) return;
 ParkEvent * const List = (ParkEvent *) (w & ~LOCKBIT);

changeset 26684	d1221849ea3d
parent 26683	a02753d5a0b2
child 26834	41332d860d6a