8249004: Reduce ThreadsListHandle overhead in relation to direct handshakes

src/hotspot/share/prims/jvmtiEventController.cpp

@@ -616,8 +616,14 @@ JvmtiEventControllerPrivate::recompute_enabled() {
   }
 
   // compute and set thread-filtered events
-  for (JvmtiThreadState *state = JvmtiThreadState::first(); state != NULL; state = state->next()) {
-    any_env_thread_enabled |= recompute_thread_enabled(state);
+  JvmtiThreadState *state = JvmtiThreadState::first();
+  if (state != nullptr) {
+    // If we have a JvmtiThreadState, then we've reached the point where
+    // threads can exist so create a ThreadsListHandle to protect them.
+    ThreadsListHandle tlh;
+    for (; state != NULL; state = state->next()) {
+      any_env_thread_enabled |= recompute_thread_enabled(state);
+    }
   }
 
   // set universal state (across all envs and threads)

src/hotspot/share/prims/whitebox.cpp

@@ -2072,8 +2072,9 @@ WB_ENTRY(jboolean, WB_HandshakeReadMonitors(JNIEnv* env, jobject wb, jobject thr
   ReadMonitorsClosure rmc;
   oop thread_oop = JNIHandles::resolve(thread_handle);
   if (thread_oop != NULL) {
+    ThreadsListHandle tlh;
     JavaThread* target = java_lang_Thread::thread(thread_oop);
-    Handshake::execute(&rmc, target);
+    Handshake::execute(&rmc, &tlh, target);
   }
   return rmc.executed();
 WB_END
@@ -2104,8 +2105,9 @@ WB_ENTRY(jint, WB_HandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_han
   } else {
     oop thread_oop = JNIHandles::resolve(thread_handle);
     if (thread_oop != NULL) {
+      ThreadsListHandle tlh;
       JavaThread* target = java_lang_Thread::thread(thread_oop);
-      Handshake::execute(&tsc, target);
+      Handshake::execute(&tsc, &tlh, target);
     }
   }
   return tsc.num_threads_completed();
@@ -2131,7 +2133,10 @@ WB_ENTRY(void, WB_AsyncHandshakeWalkStack(JNIEnv* env, jobject wb, jobject threa
   };
   oop thread_oop = JNIHandles::resolve(thread_handle);
   if (thread_oop != NULL) {
+    ThreadsListHandle tlh;
     JavaThread* target = java_lang_Thread::thread(thread_oop);
+    // Sometimes 'target' is NULL and this test code expects
+    // Handshake::execute(AsyncHandshakeClosure,...) to handle it.
     TraceSelfClosure* tsc = new TraceSelfClosure(target);
     Handshake::execute(tsc, target);
   }

src/hotspot/share/runtime/handshake.cpp

@@ -342,8 +342,9 @@ void Handshake::execute(HandshakeClosure* hs_cl) {
 }
 
 void Handshake::execute(HandshakeClosure* hs_cl, JavaThread* target) {
-  ThreadsListHandle tlh;
-  Handshake::execute(hs_cl, &tlh, target);
+  // tlh_p == nullptr means we rely on a ThreadsListHandle somewhere
+  // in the caller's context (and we sanity check for that).
+  Handshake::execute(hs_cl, nullptr, target);
 }
 
 void Handshake::execute(HandshakeClosure* hs_cl, ThreadsListHandle* tlh_p, JavaThread* target) {
@@ -352,9 +353,21 @@ void Handshake::execute(HandshakeClosure* hs_cl, ThreadsListHandle* tlh_p, JavaT
 
   jlong start_time_ns = os::javaTimeNanos();
 
-  if (tlh_p->includes(target)) {
-    target->handshake_state()->add_operation(&op);
+  bool target_is_dead = false;
+  if (target == nullptr) {
+    target_is_dead = true;
   } else {
+    if (tlh_p == nullptr) {
+      guarantee(Thread::is_JavaThread_protected_by_my_ThreadsList(target),
+                "missing ThreadsListHandle in calling context.");
+      target->handshake_state()->add_operation(&op);
+    } else if (tlh_p->includes(target)) {
+      target->handshake_state()->add_operation(&op);
+    } else {
+      target_is_dead = true;
+    }
+  }
+  if (target_is_dead) {
     char buf[128];
     jio_snprintf(buf, sizeof(buf),  "(thread= " INTPTR_FORMAT " dead)", p2i(target));
     log_handshake_info(start_time_ns, op.name(), 0, 0, buf);
@@ -400,13 +413,24 @@ void Handshake::execute(AsyncHandshakeClosure* hs_cl, JavaThread* target) {
   jlong start_time_ns = os::javaTimeNanos();
   AsyncHandshakeOperation* op = new AsyncHandshakeOperation(hs_cl, target, start_time_ns);
 
-  ThreadsListHandle tlh;
-  if (tlh.includes(target)) {
-    target->handshake_state()->add_operation(op);
-  } else {
+  if (target == nullptr) {
+    // Stress test that calls WB_AsyncHandshakeWalkStack() can get here:
     log_handshake_info(start_time_ns, op->name(), 0, 0, "(thread dead)");
     delete op;
+    return;
+  }
+
+  Thread* current = Thread::current();
+  if (current != target) {
+    // Another thread is handling the request and it must be protecting
+    // the target.
+    guarantee(Thread::is_JavaThread_protected_by_my_ThreadsList(target),
+              "missing ThreadsListHandle in calling context.");
   }
+  // Implied else:
+  // The target is handling the request itself so it can't be dead.
+
+  target->handshake_state()->add_operation(op);
 }
 
 HandshakeState::HandshakeState(JavaThread* target) :

src/hotspot/share/runtime/thread.cpp

@@ -486,6 +486,29 @@ bool Thread::is_JavaThread_protected(const JavaThread* p) {
   return false;
 }
 
+// Is the target JavaThread protected by a ThreadsList associated
+// with the calling Thread.
+//
+// Thread::is_JavaThread_protected() above is the more general check.
+// This function ONLY checks the ThreadsLists (if any) associated with
+// the calling thread in order to verify proper ThreadsListHandle
+// placement somewhere in the calling context.
+bool Thread::is_JavaThread_protected_by_my_ThreadsList(const JavaThread* p) {
+  Thread* current_thread = Thread::current();
+  // Check the ThreadsLists associated with the calling thread (if any)
+  // to see if one of them protects the target JavaThread:
+  for (SafeThreadsListPtr* stlp = current_thread->_threads_list_ptr;
+       stlp != NULL; stlp = stlp->previous()) {
+    if (stlp->list()->includes(p)) {
+      // The target JavaThread is protected by this ThreadsList:
+      return true;
+    }
+  }
+
+  // The target JavaThread is not protected.
+  return false;
+}
+
 ThreadPriority Thread::get_priority(const Thread* const thread) {
   ThreadPriority priority;
   // Can return an error!
@@ -1743,18 +1766,20 @@ void JavaThread::send_thread_stop(oop java_throwable)  {
 //   - Target thread will not enter any new monitors.
 //
 bool JavaThread::java_suspend() {
-  ThreadsListHandle tlh;
-  if (!tlh.includes(this)) {
-    log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " not on ThreadsList, no suspension", p2i(this));
+  guarantee(Thread::is_JavaThread_protected_by_my_ThreadsList(this),
+            "missing ThreadsListHandle in calling context.");
+  if (is_exiting()) {
+    log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " is exiting, no suspension", p2i(this));
     return false;
   }
   return this->handshake_state()->suspend();
 }
 
 bool JavaThread::java_resume() {
-  ThreadsListHandle tlh;
-  if (!tlh.includes(this)) {
-    log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " not on ThreadsList, nothing to resume", p2i(this));
+  guarantee(Thread::is_JavaThread_protected_by_my_ThreadsList(this),
+            "missing ThreadsListHandle in calling context.");
+  if (is_exiting()) {
+    log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " is exiting, nothing to resume", p2i(this));
     return false;
   }
   return this->handshake_state()->resume();

src/hotspot/share/runtime/thread.hpp

@@ -203,6 +203,9 @@ class Thread: public ThreadShadow {
   // Is the target JavaThread protected by the calling Thread
   // or by some other mechanism:
   static bool is_JavaThread_protected(const JavaThread* p);
+  // Is the target JavaThread protected by a ThreadsList associated
+  // with the calling Thread.
+  static bool is_JavaThread_protected_by_my_ThreadsList(const JavaThread* p);
 
   void* operator new(size_t size) throw() { return allocate(size, true); }
   void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {