Improve JFR event for pinning

Author: AlanBateman

src/hotspot/share/include/jvm.h

@@ -1149,7 +1149,10 @@ JNIEXPORT void JNICALL
 JVM_VirtualThreadDisableSuspend(JNIEnv* env, jclass clazz, jboolean enter);
 
 JNIEXPORT void JNICALL
-JVM_VirtualThreadPinnedEvent(jint reasonCode, jstring reasonString);
+JVM_VirtualThreadPinnedStart(JNIEnv* env, jclass clazz);
+
+JNIEXPORT void JNICALL
+JVM_VirtualThreadPinnedEnd(JNIEnv* env, jclass clazz, jstring reason);
 
 JNIEXPORT jobject JNICALL
 JVM_TakeVirtualThreadListToUnblock(JNIEnv* env, jclass ignored);

src/hotspot/share/jfr/metadata/metadata.xml

@@ -156,7 +156,7 @@
     <Field type="ulong" name="id" label="Continuation ID" />
   </Event>
 
-  <Event name="VirtualThreadPinned" category="Java Virtual Machine, Runtime" label="Virtual Thread Pinned" thread="true" stackTrace="true" startTime="false">
+  <Event name="VirtualThreadPinned" category="Java Virtual Machine, Runtime" label="Virtual Thread Pinned" thread="true" stackTrace="true">
     <Field type="string" name="pinnedReason" label="Pinned Reason" />
     <Field type="Thread" name="carrierThread" label="Carrier Thread" />
   </Event>

src/hotspot/share/oops/instanceKlass.cpp

@@ -175,6 +175,35 @@ static inline bool is_stack_chunk_class(const Symbol* class_name,
           loader_data->is_the_null_class_loader_data());
 }
 
+class WaitForClassInitializer : public StackObj {
+ private:
+  InstanceKlass* _ik;
+  Ticks _start_time;
+ public:
+  WaitForClassInitializer(InstanceKlass* ik) : _ik(ik) {
+    _start_time = Ticks::now();
+    JavaThread* current = JavaThread::current();
+    current->set_class_to_be_initialized(ik);
+  }
+  ~WaitForClassInitializer() {
+    JavaThread* current = JavaThread::current();
+    current->set_class_to_be_initialized(nullptr);
+#if INCLUDE_JFR
+    ContinuationEntry* ce = current->last_continuation();
+    if (ce != nullptr && ce->is_virtual_thread()) {
+      EventVirtualThreadPinned event;
+      event.set_starttime(_start_time);
+      if (event.should_commit()) {
+        ResourceMark rm(current);
+        char reason[256];
+        jio_snprintf(reason, sizeof reason, "Waited for initialization of klass %s", _ik->external_name());
+        current->post_vthread_pinned_event(&event, reason);
+      }
+    }
+#endif
+  }
+};
+
 // private: called to verify that k is a static member of this nest.
 // We know that k is an instance class in the same package and hence the
 // same classloader.
@@ -1104,25 +1133,10 @@ void InstanceKlass::initialize_impl(TRAPS) {
                                jt->name(), external_name(), init_thread_name());
       }
       wait = true;
-      jt->set_class_to_be_initialized(this);
 
-#if INCLUDE_JFR
-      ContinuationEntry* ce = jt->last_continuation();
-      if (ce != nullptr && ce->is_virtual_thread()) {
-        EventVirtualThreadPinned e;
-        if (e.should_commit()) {
-          ResourceMark rm(jt);
-          char reason[256];
-          jio_snprintf(reason, sizeof reason, "Waiting for initialization of klass %s", external_name());
-          e.set_pinnedReason(reason);
-          e.set_carrierThread(JFR_JVM_THREAD_ID(THREAD));
-          e.commit();
-        }
-      }
- #endif
+      WaitForClassInitializer wfcl(this);
 
       ol.wait_uninterruptibly(jt);
-      jt->set_class_to_be_initialized(nullptr);
     }
 
     // Step 3
@@ -1619,6 +1633,7 @@ void InstanceKlass::call_class_initializer(TRAPS) {
                 THREAD->name());
   }
   if (h_method() != nullptr) {
+    ThreadInClassInitializer ticl(this);
     JavaCallArguments args; // No arguments
     JavaValue result(T_VOID);
     JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args)

src/hotspot/share/prims/jvm.cpp

@@ -3975,16 +3975,20 @@ JVM_ENTRY(void, JVM_VirtualThreadDisableSuspend(JNIEnv* env, jclass clazz, jbool
 #endif
 JVM_END
 
-JVM_ENTRY_NO_ENV(void, JVM_VirtualThreadPinnedEvent(jint reasonCode, jstring reasonString))
+JVM_ENTRY_NO_ENV(void, JVM_VirtualThreadPinnedStart(JNIEnv* env, jclass ignored))
 #if INCLUDE_JFR
-  EventVirtualThreadPinned e;
-  if (e.should_commit()) {
+  THREAD->start_vthread_pinned();
+#endif
+JVM_END
+
+JVM_ENTRY_NO_ENV(void, JVM_VirtualThreadPinnedEnd(JNIEnv* env, jclass ignored, jstring reason))
+#if INCLUDE_JFR
+  EventVirtualThreadPinned event;
+  event.set_starttime(THREAD->vthread_pinned_start_time());
+  if (event.should_commit()) {
     ResourceMark rm(THREAD);
-    // ignore reason code for now
-    const char *reason = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(reasonString));
-    e.set_pinnedReason(reason);
-    e.set_carrierThread(JFR_JVM_THREAD_ID(THREAD));
-    e.commit();
+    const char *str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(reason));
+    THREAD->post_vthread_pinned_event(&event, str);
   }
 #endif
 JVM_END

src/hotspot/share/runtime/javaThread.cpp

@@ -516,6 +516,7 @@ JavaThread::JavaThread(MemTag mem_tag) :
   _parker(),
 
   _class_to_be_initialized(nullptr),
+  _class_being_initialized(nullptr),
 
   _SleepEvent(ParkEvent::Allocate(this)),
 
@@ -2335,3 +2336,21 @@ void JavaThread::add_oop_handles_for_release() {
   _oop_handle_list = new_head;
   Service_lock->notify_all();
 }
+
+#if INCLUDE_JFR
+void JavaThread::post_vthread_pinned_event(EventVirtualThreadPinned* event, const char* reason) {
+  if (event->should_commit()) {
+    char long_reason[256];
+    InstanceKlass* ik = class_being_initialized();
+    if (ik != nullptr) {
+      ResourceMark rm(this);
+      jio_snprintf(long_reason, sizeof(long_reason), "%s when initializing %s", reason, ik->external_name());
+    } else {
+      jio_snprintf(long_reason, sizeof(long_reason), "%s when pinned", reason);
+    }
+    event->set_pinnedReason(long_reason);
+    event->set_carrierThread(JFR_JVM_THREAD_ID(this));
+    event->commit();
+  }
+}
+#endif

src/hotspot/share/runtime/javaThread.hpp

@@ -37,6 +37,7 @@
 #include "runtime/javaFrameAnchor.hpp"
 #include "runtime/lockStack.hpp"
 #include "runtime/park.hpp"
+#include "utilities/ticks.hpp"
 #include "runtime/safepointMechanism.hpp"
 #include "runtime/stackWatermarkSet.hpp"
 #include "runtime/stackOverflow.hpp"
@@ -78,6 +79,8 @@ class javaVFrame;
 class JavaThread;
 typedef void (*ThreadFunction)(JavaThread*, TRAPS);
 
+class EventVirtualThreadPinned;
+
 class JavaThread: public Thread {
   friend class VMStructs;
   friend class JVMCIVMStructs;
@@ -1221,11 +1224,22 @@ class JavaThread: public Thread {
   void set_class_to_be_initialized(InstanceKlass* k);
   InstanceKlass* class_to_be_initialized() const;
 
+  // Track executing class initializer, see ThreadInClassInitializer
+  void set_class_being_initialized(InstanceKlass* k);
+  InstanceKlass* class_being_initialized() const;
+
 private:
   InstanceKlass* _class_to_be_initialized;
+  InstanceKlass* _class_being_initialized;
 
   // java.lang.Thread.sleep support
   ParkEvent * _SleepEvent;
+
+#if INCLUDE_JFR
+  // Support for jdk.VirtualThreadPinned event
+  Ticks _pinned_start_time;
+#endif
+
 public:
   bool sleep(jlong millis);
   bool sleep_nanos(jlong nanos);
@@ -1234,6 +1248,12 @@ class JavaThread: public Thread {
   void interrupt();
   bool is_interrupted(bool clear_interrupted);
 
+#if INCLUDE_JFR
+  Ticks& vthread_pinned_start_time() { return _pinned_start_time; }
+  void start_vthread_pinned() { _pinned_start_time = Ticks::now(); }
+  void post_vthread_pinned_event(EventVirtualThreadPinned* event, const char* reason);
+#endif
+
   // This is only for use by JVMTI RawMonitorWait. It emulates the actions of
   // the Java code in Object::wait which are not present in RawMonitorWait.
   bool get_and_clear_interrupted();
@@ -1340,4 +1360,18 @@ class ThreadOnMonitorWaitedEvent {
   ~ThreadOnMonitorWaitedEvent() { JVMTI_ONLY(_thread->set_on_monitor_waited_event(false);) }
 };
 
+class ThreadInClassInitializer : public StackObj {
+  InstanceKlass* _previous;
+ public:
+  ThreadInClassInitializer(InstanceKlass* ik) {
+    JavaThread* current = JavaThread::current();
+    _previous = current->class_being_initialized();
+    current->set_class_being_initialized(ik);
+  }
+  ~ThreadInClassInitializer() {
+    JavaThread* current = JavaThread::current();
+    current->set_class_being_initialized(_previous);
+  }
+};
+
 #endif // SHARE_RUNTIME_JAVATHREAD_HPP

src/hotspot/share/runtime/javaThread.inline.hpp

@@ -241,6 +241,15 @@ inline InstanceKlass* JavaThread::class_to_be_initialized() const {
   return _class_to_be_initialized;
 }
 
+inline void JavaThread::set_class_being_initialized(InstanceKlass* k) {
+  assert(this == Thread::current(), "Only the current thread can set this field");
+  _class_being_initialized = k;
+}
+
+inline InstanceKlass* JavaThread::class_being_initialized() const {
+  return _class_being_initialized;
+}
+
 inline void JavaThread::om_set_monitor_cache(ObjectMonitor* monitor) {
   assert(UseObjectMonitorTable, "must be");
   assert(monitor != nullptr, "use om_clear_monitor_cache to clear");

src/hotspot/share/runtime/objectMonitor.cpp

@@ -119,15 +119,6 @@ OopStorage* ObjectMonitor::_oop_storage = nullptr;
 OopHandle ObjectMonitor::_vthread_cxq_head;
 ParkEvent* ObjectMonitor::_vthread_unparker_ParkEvent = nullptr;
 
-static void post_virtual_thread_pinned_event(JavaThread* current, const char* reason) {
-  EventVirtualThreadPinned e;
-  if (e.should_commit()) {
-    e.set_pinnedReason(reason);
-    e.set_carrierThread(JFR_JVM_THREAD_ID(current));
-    e.commit();
-  }
-}
-
 // -----------------------------------------------------------------------------
 // Theory of operations -- Monitors lists, thread residency, etc:
 //
@@ -480,14 +471,15 @@ void ObjectMonitor::enter_with_contention_mark(JavaThread *current, ObjectMonito
   assert(!is_being_async_deflated(), "must be");
 
   JFR_ONLY(JfrConditionalFlush<EventJavaMonitorEnter> flush(current);)
-  EventJavaMonitorEnter event;
-  if (event.is_started()) {
-    event.set_monitorClass(object()->klass());
+  EventJavaMonitorEnter enter_event;
+  if (enter_event.is_started()) {
+    enter_event.set_monitorClass(object()->klass());
     // Set an address that is 'unique enough', such that events close in
     // time and with the same address are likely (but not guaranteed) to
     // belong to the same object.
-    event.set_address((uintptr_t)this);
+    enter_event.set_address((uintptr_t)this);
   }
+  EventVirtualThreadPinned vthread_pinned_event;
 
   { // Change java thread status to indicate blocked on monitor enter.
     JavaThreadBlockedOnMonitorEnterState jtbmes(current, this);
@@ -528,11 +520,6 @@ void ObjectMonitor::enter_with_contention_mark(JavaThread *current, ObjectMonito
                (!acquired && !current->preemption_cancelled() && state == java_lang_VirtualThread::BLOCKING), "invariant");
         return;
       }
-      if (result == freeze_pinned_native) {
-        post_virtual_thread_pinned_event(current, "Native frame or <clinit> on stack");
-      } else if (result == freeze_unsupported) {
-        post_virtual_thread_pinned_event(current, "Native frame or <clinit> or monitors on stack");
-      }
     }
 
     OSThreadContendState osts(current->osthread());
@@ -594,10 +581,16 @@ void ObjectMonitor::enter_with_contention_mark(JavaThread *current, ObjectMonito
     // event handler consumed an unpark() issued by the thread that
     // just exited the monitor.
   }
-  if (event.should_commit()) {
-    event.set_previousOwner(_previous_owner_tid);
-    event.commit();
+  if (enter_event.should_commit()) {
+    enter_event.set_previousOwner(_previous_owner_tid);
+    enter_event.commit();
+  }
+
+  ContinuationEntry* ce = current->last_continuation();
+  if (ce != nullptr && ce->is_virtual_thread()) {
+    current->post_vthread_pinned_event(&vthread_pinned_event, "Blocked on monitor enter");
   }
+
   OM_PERFDATA_OP(ContendedLockAttempts, inc());
 }
 
@@ -1646,7 +1639,8 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
 
   CHECK_OWNER();  // Throws IMSE if not owner.
 
-  EventJavaMonitorWait event;
+  EventJavaMonitorWait wait_event;
+  EventVirtualThreadPinned vthread_pinned_event;
 
   // check for a pending interrupt
   if (interruptible && current->is_interrupted(true) && !HAS_PENDING_EXCEPTION) {
@@ -1664,8 +1658,8 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
       // consume an unpark() meant for the ParkEvent associated with
       // this ObjectMonitor.
     }
-    if (event.should_commit()) {
-      post_monitor_wait_event(&event, this, 0, millis, false);
+    if (wait_event.should_commit()) {
+      post_monitor_wait_event(&wait_event, this, 0, millis, false);
     }
     THROW(vmSymbols::java_lang_InterruptedException());
     return;
@@ -1681,16 +1675,6 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
       current->set_current_waiting_monitor(nullptr);
       return;
     }
-    if (result == freeze_pinned_native || result == freeze_unsupported) {
-      const Klass* monitor_klass = object()->klass();
-      if (!is_excluded(monitor_klass)) {
-        if (result == freeze_pinned_native) {
-          post_virtual_thread_pinned_event(current,"Native frame or <clinit> on stack");
-        } else if (result == freeze_unsupported) {
-          post_virtual_thread_pinned_event(current, "Native frame or <clinit> or monitors on stack");
-        }
-      }
-    }
   }
 
   // create a node to be put into the queue
@@ -1816,8 +1800,12 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
       }
     }
 
-    if (event.should_commit()) {
-      post_monitor_wait_event(&event, this, node._notifier_tid, millis, ret == OS_TIMEOUT);
+    if (wait_event.should_commit()) {
+      post_monitor_wait_event(&wait_event, this, node._notifier_tid, millis, ret == OS_TIMEOUT);
+    }
+
+    if (ce != nullptr && ce->is_virtual_thread()) {
+      current->post_vthread_pinned_event(&vthread_pinned_event, "Waited in Object.wait");
     }
 
     OrderAccess::fence();
@@ -2049,9 +2037,9 @@ bool ObjectMonitor::VThreadWaitReenter(JavaThread* current, ObjectWaiter* node,
   node->_interrupted = !was_notified && current->is_interrupted(false);
 
   // Post JFR and JVMTI events.
-  EventJavaMonitorWait event;
-  if (event.should_commit() || JvmtiExport::should_post_monitor_waited()) {
-    vthread_monitor_waited_event(current, node, cont, &event, !was_notified && !node->_interrupted);
+  EventJavaMonitorWait wait_event;
+  if (wait_event.should_commit() || JvmtiExport::should_post_monitor_waited()) {
+    vthread_monitor_waited_event(current, node, cont, &wait_event, !was_notified && !node->_interrupted);
   }
 
   // Mark that we are at reenter so that we don't call this method again.