8338383: Implement JEP 491: Synchronize Virtual Threads without Pinning

src/hotspot/cpu/riscv/continuationFreezeThaw_riscv.inline.hpp

@@ -269,7 +269,7 @@ template<typename FKind> frame ThawBase::new_stack_frame(const frame& hf, frame&
         // fp always points to the address above the pushed return pc. We need correct address.
         ? frame_sp + fsize - frame::sender_sp_offset
         // we need to re-read fp because it may be an oop and we might have fixed the frame.
-        : *(intptr_t**)(hf.sp() - frame::sender_sp_offset);
+        : *(intptr_t**)(hf.sp() - 2);
     }
     // TODO PERF : this computes deopt state; is it necessary?
     return frame(frame_sp, frame_sp, fp, hf.pc(), hf.cb(), hf.oop_map(), false);

src/hotspot/share/classfile/javaClasses.cpp

@@ -2103,11 +2103,11 @@ void java_lang_VirtualThread::set_notified(oop vthread, jboolean value) {
   vthread->bool_field_put_volatile(_notified_offset, value);
 }
 
-jlong java_lang_VirtualThread::waitTimeout(oop vthread) {
+jlong java_lang_VirtualThread::timeout(oop vthread) {
   return vthread->long_field(_timeout_offset);
 }
 
-void java_lang_VirtualThread::set_waitTimeout(oop vthread, jlong value) {
+void java_lang_VirtualThread::set_timeout(oop vthread, jlong value) {
   vthread->long_field_put(_timeout_offset, value);
 }
 

src/hotspot/share/classfile/javaClasses.hpp

@@ -581,8 +581,8 @@ class java_lang_VirtualThread : AllStatic {
   static oop next(oop vthread);
   static void set_next(oop vthread, oop next_vthread);
   static bool set_onWaitingList(oop vthread, OopHandle& list_head);
-  static jlong waitTimeout(oop vthread);
-  static void set_waitTimeout(oop vthread, jlong value);
+  static jlong timeout(oop vthread);
+  static void set_timeout(oop vthread, jlong value);
   static void set_notified(oop vthread, jboolean value);
   static bool is_preempted(oop vthread);
   static JavaThreadStatus map_state_to_thread_status(int state);

src/hotspot/share/include/jvm.h

@@ -1146,7 +1146,7 @@ JNIEXPORT void JNICALL
 JVM_VirtualThreadDisableSuspend(JNIEnv* env, jclass clazz, jboolean enter);
 
 JNIEXPORT void JNICALL
-JVM_VirtualThreadPinnedEvent(jint reasonCode, jstring reasonString);
+JVM_VirtualThreadPinnedEvent(JNIEnv* env, jclass clazz, jstring op);
 
 JNIEXPORT jobject JNICALL
 JVM_TakeVirtualThreadListToUnblock(JNIEnv* env, jclass ignored);

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

@@ -156,7 +156,8 @@
     <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="blockingOperation" label="Blocking operation" />
     <Field type="string" name="pinnedReason" label="Pinned Reason" />
     <Field type="Thread" name="carrierThread" label="Carrier Thread" />
   </Event>

src/hotspot/share/oops/instanceKlass.cpp

@@ -1105,22 +1105,6 @@ void InstanceKlass::initialize_impl(TRAPS) {
       }
       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
-
       ol.wait_uninterruptibly(jt);
       jt->set_class_to_be_initialized(nullptr);
     }
@@ -1619,6 +1603,7 @@ void InstanceKlass::call_class_initializer(TRAPS) {
                 THREAD->name());
   }
   if (h_method() != nullptr) {
+    ThreadInClassInitializer ticl(THREAD, this); // Track class being initialized
     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

@@ -3959,16 +3959,16 @@ 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(void, JVM_VirtualThreadPinnedEvent(JNIEnv* env, jclass ignored, jstring op))
 #if INCLUDE_JFR
-  EventVirtualThreadPinned e;
-  if (e.should_commit()) {
+  freeze_result result = THREAD->last_freeze_fail_result();
+  assert(result != freeze_ok, "sanity check");
+  EventVirtualThreadPinned event(UNTIMED);
+  event.set_starttime(THREAD->last_freeze_fail_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(op));
+    THREAD->post_vthread_pinned_event(&event, str, result);
   }
 #endif
 JVM_END

src/hotspot/share/runtime/continuation.cpp

@@ -61,12 +61,12 @@ JVM_END
 class JvmtiUnmountBeginMark : public StackObj {
   Handle _vthread;
   JavaThread* _target;
-  int _preempt_result;
+  freeze_result _result;
   bool _failed;
 
  public:
   JvmtiUnmountBeginMark(JavaThread* t) :
-    _vthread(t, t->vthread()), _target(t), _preempt_result(freeze_pinned_native), _failed(false) {
+    _vthread(t, t->vthread()), _target(t), _result(freeze_pinned_native), _failed(false) {
     assert(!_target->is_in_VTMS_transition(), "must be");
 
     if (JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events()) {
@@ -101,7 +101,7 @@ class JvmtiUnmountBeginMark : public StackObj {
     // been set while blocked in the allocation path during freeze.
     bool jvmti_present = JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events();
 
-    if (_preempt_result != freeze_ok) {
+    if (_result != freeze_ok) {
       // Undo transition
       if (jvmti_present) {
         JvmtiVTMSTransitionDisabler::finish_VTMS_transition((jthread)_vthread.raw_value(), false);
@@ -120,7 +120,7 @@ class JvmtiUnmountBeginMark : public StackObj {
       }
     }
   }
-  void set_preempt_result(int res) { _preempt_result = res; }
+  void set_result(freeze_result res) { _result = res; }
   bool failed() { return _failed; }
 };
 
@@ -141,7 +141,7 @@ static bool is_vthread_safe_to_preempt(JavaThread* target, oop vthread) {
   return JVMTI_ONLY(is_vthread_safe_to_preempt_for_jvmti(target, vthread)) NOT_JVMTI(true);
 }
 
-typedef int (*FreezeContFnT)(JavaThread*, intptr_t*);
+typedef freeze_result (*FreezeContFnT)(JavaThread*, intptr_t*);
 
 static void verify_preempt_preconditions(JavaThread* target, oop continuation) {
   assert(target == JavaThread::current(), "no support for external preemption");
@@ -153,7 +153,7 @@ static void verify_preempt_preconditions(JavaThread* target, oop continuation) {
   assert(!target->has_pending_exception(), "");
 }
 
-int Continuation::try_preempt(JavaThread* target, oop continuation) {
+freeze_result Continuation::try_preempt(JavaThread* target, oop continuation) {
   verify_preempt_preconditions(target, continuation);
 
   if (LockingMode == LM_LEGACY) {
@@ -166,9 +166,9 @@ int Continuation::try_preempt(JavaThread* target, oop continuation) {
 
   JVMTI_ONLY(JvmtiUnmountBeginMark jubm(target);)
   JVMTI_ONLY(if (jubm.failed()) return freeze_pinned_native;)
-  int res = CAST_TO_FN_PTR(FreezeContFnT, freeze_preempt_entry())(target, target->last_Java_sp());
+  freeze_result res = CAST_TO_FN_PTR(FreezeContFnT, freeze_preempt_entry())(target, target->last_Java_sp());
   log_trace(continuations, preempt)("try_preempt: %d", res);
-  JVMTI_ONLY(jubm.set_preempt_result(res);)
+  JVMTI_ONLY(jubm.set_result(res);)
   return res;
 }
 

src/hotspot/share/runtime/continuation.hpp

@@ -90,7 +90,7 @@ class Continuation : AllStatic {
   static int prepare_thaw(JavaThread* thread, bool return_barrier);
   static address thaw_entry();
 
-  static int try_preempt(JavaThread* target, oop continuation);
+  static freeze_result try_preempt(JavaThread* target, oop continuation);
 
   static ContinuationEntry* get_continuation_entry_for_continuation(JavaThread* thread, oop continuation);
   static ContinuationEntry* get_continuation_entry_for_sp(JavaThread* thread, intptr_t* const sp);

src/hotspot/share/runtime/continuationFreezeThaw.cpp

@@ -202,7 +202,7 @@ static void verify_continuation(oop continuation) { }
 #endif
 
 static freeze_result is_pinned0(JavaThread* thread, oop cont_scope, bool safepoint);
-template<typename ConfigT, bool preempt> static inline int freeze_internal(JavaThread* current, intptr_t* const sp);
+template<typename ConfigT, bool preempt> static inline freeze_result freeze_internal(JavaThread* current, intptr_t* const sp);
 
 static inline int prepare_thaw_internal(JavaThread* thread, bool return_barrier);
 template<typename ConfigT> static inline intptr_t* thaw_internal(JavaThread* thread, const Continuation::thaw_kind kind);
@@ -218,7 +218,7 @@ static JRT_BLOCK_ENTRY(int, freeze(JavaThread* current, intptr_t* sp))
     current->set_cont_fastpath(nullptr);
   }
 
-  return ConfigT::freeze(current, sp);
+  return checked_cast<int>(ConfigT::freeze(current, sp));
 JRT_END
 
 JRT_LEAF(int, Continuation::prepare_thaw(JavaThread* thread, bool return_barrier))
@@ -255,11 +255,11 @@ class Config {
   typedef Config<oops, BarrierSetT> SelfT;
   using OopT = std::conditional_t<oops == oop_kind::NARROW, narrowOop, oop>;
 
-  static int freeze(JavaThread* thread, intptr_t* const sp) {
+  static freeze_result freeze(JavaThread* thread, intptr_t* const sp) {
     return freeze_internal<SelfT, false>(thread, sp);
   }
 
-  static int freeze_preempt(JavaThread* thread, intptr_t* const sp) {
+  static freeze_result freeze_preempt(JavaThread* thread, intptr_t* const sp) {
     return freeze_internal<SelfT, true>(thread, sp);
   }
 
@@ -1412,7 +1412,9 @@ class StackChunkAllocator : public MemAllocator {
 
     // zero out fields (but not the stack)
     const size_t hs = oopDesc::header_size();
-    oopDesc::set_klass_gap(mem, 0);
+    if (oopDesc::has_klass_gap()) {
+      oopDesc::set_klass_gap(mem, 0);
+    }
     Copy::fill_to_aligned_words(mem + hs, vmClasses::StackChunk_klass()->size_helper() - hs);
 
     int bottom = (int)_stack_size - _argsize_md;
@@ -1666,16 +1668,17 @@ bool FreezeBase::check_valid_fast_path() {
 }
 #endif // ASSERT
 
-static inline int freeze_epilog(ContinuationWrapper& cont) {
+static inline freeze_result freeze_epilog(ContinuationWrapper& cont) {
   verify_continuation(cont.continuation());
   assert(!cont.is_empty(), "");
 
   log_develop_debug(continuations)("=== End of freeze cont ### #" INTPTR_FORMAT, cont.hash());
-  return 0;
+  return freeze_ok;
 }
 
-static int freeze_epilog(JavaThread* thread, ContinuationWrapper& cont, freeze_result res) {
+static freeze_result freeze_epilog(JavaThread* thread, ContinuationWrapper& cont, freeze_result res) {
   if (UNLIKELY(res != freeze_ok)) {
+    JFR_ONLY(thread->set_last_freeze_fail_result(res);)
     verify_continuation(cont.continuation());
     log_develop_trace(continuations)("=== end of freeze (fail %d)", res);
     return res;
@@ -1685,7 +1688,7 @@ static int freeze_epilog(JavaThread* thread, ContinuationWrapper& cont, freeze_r
   return freeze_epilog(cont);
 }
 
-static int preempt_epilog(ContinuationWrapper& cont, freeze_result res, frame& old_last_frame) {
+static freeze_result preempt_epilog(ContinuationWrapper& cont, freeze_result res, frame& old_last_frame) {
   if (UNLIKELY(res != freeze_ok)) {
     verify_continuation(cont.continuation());
     log_develop_trace(continuations)("=== end of freeze (fail %d)", res);
@@ -1699,7 +1702,7 @@ static int preempt_epilog(ContinuationWrapper& cont, freeze_result res, frame& o
 }
 
 template<typename ConfigT, bool preempt>
-static inline int freeze_internal(JavaThread* current, intptr_t* const sp) {
+static inline freeze_result freeze_internal(JavaThread* current, intptr_t* const sp) {
   assert(!current->has_pending_exception(), "");
 
 #ifdef ASSERT

src/hotspot/share/runtime/javaThread.cpp

@@ -515,6 +515,7 @@ JavaThread::JavaThread(MemTag mem_tag) :
   _parker(),
 
   _class_to_be_initialized(nullptr),
+  _class_being_initialized(nullptr),
 
   _SleepEvent(ParkEvent::Allocate(this)),
 
@@ -2327,3 +2328,38 @@ void JavaThread::add_oop_handles_for_release() {
   _oop_handle_list = new_head;
   Service_lock->notify_all();
 }
+
+#if INCLUDE_JFR
+void JavaThread::set_last_freeze_fail_result(freeze_result result) {
+  assert(result != freeze_ok, "sanity check");
+  _last_freeze_fail_result = result;
+  _last_freeze_fail_time = Ticks::now();
+}
+
+// Post jdk.VirtualThreadPinned event
+void JavaThread::post_vthread_pinned_event(EventVirtualThreadPinned* event, const char* op, freeze_result result) {
+  assert(result != freeze_ok, "sanity check");
+  if (event->should_commit()) {
+    char reason[256];
+    if (class_to_be_initialized() != nullptr) {
+      ResourceMark rm(this);
+      jio_snprintf(reason, sizeof reason, "Waited for initialization of %s by another thread",
+                   class_to_be_initialized()->external_name());
+      event->set_pinnedReason(reason);
+    } else if (class_being_initialized() != nullptr) {
+      ResourceMark rm(this);
+      jio_snprintf(reason, sizeof(reason), "VM call to %s.<clinit> on stack",
+                   class_being_initialized()->external_name());
+      event->set_pinnedReason(reason);
+    } else if (result == freeze_pinned_native) {
+      event->set_pinnedReason("Native or VM frame on stack");
+    } else {
+      jio_snprintf(reason, sizeof(reason), "Freeze or preempt failed (%d)", result);
+      event->set_pinnedReason(reason);
+    }
+    event->set_blockingOperation(op);
+    event->set_carrierThread(JFR_JVM_THREAD_ID(this));
+    event->commit();
+  }
+}
+#endif

src/hotspot/share/runtime/javaThread.hpp

@@ -49,6 +49,7 @@
 #include "utilities/macros.hpp"
 #if INCLUDE_JFR
 #include "jfr/support/jfrThreadExtension.hpp"
+#include "utilities/ticks.hpp"
 #endif
 
 class AsyncExceptionHandshake;
@@ -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;
@@ -1212,11 +1215,23 @@ 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
+  freeze_result _last_freeze_fail_result;
+  Ticks _last_freeze_fail_time;
+#endif
+
 public:
   bool sleep(jlong millis);
   bool sleep_nanos(jlong nanos);
@@ -1225,6 +1240,15 @@ class JavaThread: public Thread {
   void interrupt();
   bool is_interrupted(bool clear_interrupted);
 
+#if INCLUDE_JFR
+  // Support for jdk.VirtualThreadPinned event
+  freeze_result last_freeze_fail_result() { return _last_freeze_fail_result; }
+  Ticks& last_freeze_fail_time() { return _last_freeze_fail_time; }
+  void set_last_freeze_fail_result(freeze_result result);
+#endif
+  void post_vthread_pinned_event(EventVirtualThreadPinned* event, const char* op, freeze_result result) NOT_JFR_RETURN();
+
+
   // 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();
@@ -1331,4 +1355,17 @@ class ThreadOnMonitorWaitedEvent {
   ~ThreadOnMonitorWaitedEvent() { JVMTI_ONLY(_thread->set_on_monitor_waited_event(false);) }
 };
 
+class ThreadInClassInitializer : public StackObj {
+  JavaThread* _thread;
+  InstanceKlass* _previous;
+ public:
+  ThreadInClassInitializer(JavaThread* thread, InstanceKlass* ik) : _thread(thread) {
+    _previous = _thread->class_being_initialized();
+    _thread->set_class_being_initialized(ik);
+  }
+  ~ThreadInClassInitializer() {
+    _thread->set_class_being_initialized(_previous);
+  }
+};
+
 #endif // SHARE_RUNTIME_JAVATHREAD_HPP