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

equal deleted inserted replaced

-:7c9f46e9d37c
+:39a58a50be35
 // plain initialization
 debug_only(_owned_locks = NULL;)
 debug_only(_allow_allocation_count = 0;)
 NOT_PRODUCT(_allow_safepoint_count = 0;)
 CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;)
-_highest_lock = NULL;
 _jvmti_env_iteration_count = 0;
 _vm_operation_started_count = 0;
 _vm_operation_completed_count = 0;
 _current_pending_monitor = NULL;
 _current_pending_monitor_is_from_java = true;
 #endif
 }
 #endif
-bool Thread::lock_is_in_stack(address adr) const {
-assert(Thread::current() == this, "lock_is_in_stack can only be called from current thread");
-// High limit: highest_lock is set during thread execution
-// Low  limit: address of the local variable dummy, rounded to 4K boundary.
-// (The rounding helps finding threads in unsafe mode, even if the particular stack
-// frame has been popped already.  Correct as long as stacks are at least 4K long and aligned.)
-address end = os::current_stack_pointer();
-if (_highest_lock >= adr && adr >= end) return true;
-return false;
-}
 bool Thread::is_in_stack(address adr) const {
 assert(Thread::current() == this, "is_in_stack can only be called from current thread");
 address end = os::current_stack_pointer();
 if (stack_base() >= adr && adr >= end) return true;
 // However, there is a note in JavaThread::is_lock_owned() about the VM threads not being
 // used for compilation in the future. If that change is made, the need for these methods
 // should be revisited, and they should be removed if possible.
 bool Thread::is_lock_owned(address adr) const {
-if (lock_is_in_stack(adr) ) return true;
+return (_stack_base >= adr && adr >= (_stack_base - _stack_size));
-return false;
 }
 bool Thread::set_as_starting_thread() {
 // NOTE: this must be called inside the main thread.
 return os::create_main_thread((JavaThread*)this);
 return ret;
 }
 }
 bool JavaThread::is_lock_owned(address adr) const {
-if (lock_is_in_stack(adr)) return true;
+if (Thread::is_lock_owned(adr)) return true;
 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
 if (chunk->contains(adr)) return true;
 }
 st->print("\"%s\" ", get_thread_name());
 oop thread_oop = threadObj();
 if (thread_oop != NULL && java_lang_Thread::is_daemon(thread_oop))  st->print("daemon ");
 Thread::print_on(st);
 // print guess for valid stack memory region (assume 4K pages); helps lock debugging
-st->print_cr("[" INTPTR_FORMAT ".." INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12), highest_lock());
+st->print_cr("[" INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12));
 if (thread_oop != NULL && JDK_Version::is_gte_jdk15x_version()) {
 st->print_cr("   java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop));
 }
 #ifndef PRODUCT
 print_thread_state_on(st);
 //
 // 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.
 //
-// We can't use Thread::is_lock_owned() or Thread::lock_is_in_stack() because
-// those routines rely on the "current" stack pointer. That would be our
-// stack pointer which is not relevant to the question. Instead we use the
-// highest lock ever entered by the thread and find the thread that is
-// higher than and closest to our target stack address.
-//
-address    least_diff = 0;
-bool       least_diff_initialized = false;
 JavaThread* the_owner = NULL;
 {
 MutexLockerEx ml(doLock ? Threads_lock : NULL);
 ALL_JAVA_THREADS(q) {
-address addr = q->highest_lock();
+if (q->is_lock_owned(owner)) {
-if (addr == NULL || addr < owner) continue;  // thread has entered no monitors or is too low
-address diff = (address)(addr - owner);
-if (!least_diff_initialized || diff < least_diff) {
-least_diff_initialized = true;
-least_diff = diff;
 the_owner = q;
+break;
 }
 }
 }
 assert(the_owner != NULL, "Did not find owning Java thread for lock word address");
 return the_owner;

changeset 2526	39a58a50be35
parent 2336	427ce3320578
child 2995	d8283445992a