src/hotspot/share/runtime/threadSMR.cpp

*** 24,37 ****
--- 24,39 ----
  
  #include "precompiled.hpp"
  #include "logging/logStream.hpp"
  #include "memory/allocation.inline.hpp"
  #include "runtime/jniHandles.inline.hpp"
+ #include "runtime/sharedRuntime.hpp"
  #include "runtime/thread.inline.hpp"
  #include "runtime/threadSMR.inline.hpp"
  #include "runtime/vmOperations.hpp"
  #include "services/threadService.hpp"
+ #include "services/threadTable.hpp"
  #include "utilities/copy.hpp"
  #include "utilities/globalDefinitions.hpp"
  #include "utilities/ostream.hpp"
  #include "utilities/resourceHash.hpp"
  #include "utilities/vmError.hpp"
*** 605,628 ****
      }
    }
    return -1;
  }
  
  JavaThread* ThreadsList::find_JavaThread_from_java_tid(jlong java_tid) const {
    for (uint i = 0; i < length(); i++) {
      JavaThread* thread = thread_at(i);
!     oop tobj = thread->threadObj();
!     // Ignore the thread if it hasn't run yet, has exited
!     // or is starting to exit.
!     if (tobj != NULL && !thread->is_exiting() &&
!         java_tid == java_lang_Thread::thread_id(tobj)) {
!       // found a match
        return thread;
      }
    }
    return NULL;
  }
  
  void ThreadsList::inc_nested_handle_cnt() {
    // The increment needs to be MO_SEQ_CST so that the reference counter
    // update is seen before the subsequent hazard ptr update.
    Atomic::inc(&_nested_handle_cnt);
--- 607,643 ----
      }
    }
    return -1;
  }
  
+ #define PMIMORDIAL_JAVA_TID 1
+ 
  JavaThread* ThreadsList::find_JavaThread_from_java_tid(jlong java_tid) const {
+     JavaThread* java_thread = ThreadTable::find_thread(java_tid);
+     if (java_thread == NULL && java_tid == PMIMORDIAL_JAVA_TID) {
+         // ThreadsSMRSupport::add_thread() is not called for the primordial
+         // thread. Thus, we find this thread with a linear search and add it
+         // to the thread table.
          for (uint i = 0; i < length(); i++) {
              JavaThread* thread = thread_at(i);
!             if (is_valid_java_thread(java_tid,thread)) {
!                 ThreadTable::add_thread(java_tid, thread);
                  return thread;
              }
          }
+     } else if (java_thread != NULL && is_valid_java_thread(java_tid, java_thread)) {
+         return java_thread;
+     }
      return NULL;
  }
+ bool ThreadsList::is_valid_java_thread(jlong java_tid, JavaThread* java_thread) {
+     oop tobj = java_thread->threadObj();
+     // Ignore the thread if it hasn't run yet, has exited
+     // or is starting to exit.
+     return (tobj != NULL && !java_thread->is_exiting() &&
+             java_tid == java_lang_Thread::thread_id(tobj));
+ }
      
  void ThreadsList::inc_nested_handle_cnt() {
    // The increment needs to be MO_SEQ_CST so that the reference counter
    // update is seen before the subsequent hazard ptr update.
    Atomic::inc(&_nested_handle_cnt);
*** 740,749 ****
--- 755,766 ----
    // Initial _java_thread_list will not generate a "Threads::add" mesg.
    log_debug(thread, smr)("tid=" UINTX_FORMAT ": Threads::add: new ThreadsList=" INTPTR_FORMAT, os::current_thread_id(), p2i(new_list));
  
    ThreadsList *old_list = xchg_java_thread_list(new_list);
    free_list(old_list);
+   jlong tid = SharedRuntime::get_java_tid(thread);
+   ThreadTable::add_thread(tid, thread);
  }
  
  // set_delete_notify() and clear_delete_notify() are called
  // under the protection of the delete_lock, but we also use an
  // Atomic operation to ensure the memory update is seen earlier than
*** 907,916 ****
--- 924,935 ----
      log_debug(thread, smr)("tid=" UINTX_FORMAT ": ThreadsSMRSupport::release_stable_list notified %s", os::current_thread_id(), log_str);
    }
  }
  
  void ThreadsSMRSupport::remove_thread(JavaThread *thread) {
+   jlong tid = SharedRuntime::get_java_tid(thread);
+   ThreadTable::remove_thread(tid);
    ThreadsList *new_list = ThreadsList::remove_thread(ThreadsSMRSupport::get_java_thread_list(), thread);
    if (EnableThreadSMRStatistics) {
      ThreadsSMRSupport::inc_java_thread_list_alloc_cnt();
      // This list is smaller so no need to check for a "longest" update.
    }