8344247: Move objectWaiter field to VirtualThread instance

Reviewed-by: dholmes, coleenp

Author: pchilano

src/hotspot/share/classfile/javaClasses.cpp

@@ -2052,6 +2052,7 @@ int java_lang_VirtualThread::_next_offset;
 int java_lang_VirtualThread::_onWaitingList_offset;
 int java_lang_VirtualThread::_notified_offset;
 int java_lang_VirtualThread::_timeout_offset;
+int java_lang_VirtualThread::_objectWaiter_offset;
 
 #define VTHREAD_FIELDS_DO(macro) \
   macro(static_vthread_scope_offset,       k, "VTHREAD_SCOPE",      continuationscope_signature, true);  \
@@ -2067,6 +2068,7 @@ int java_lang_VirtualThread::_timeout_offset;
 void java_lang_VirtualThread::compute_offsets() {
   InstanceKlass* k = vmClasses::VirtualThread_klass();
   VTHREAD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
+  VTHREAD_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
 }
 
 bool java_lang_VirtualThread::is_instance(oop obj) {
@@ -2182,6 +2184,22 @@ JavaThreadStatus java_lang_VirtualThread::map_state_to_thread_status(int state)
   return status;
 }
 
+ObjectMonitor* java_lang_VirtualThread::current_pending_monitor(oop vthread) {
+  ObjectWaiter* waiter = objectWaiter(vthread);
+  if (waiter != nullptr && waiter->at_monitorenter()) {
+    return waiter->monitor();
+  }
+  return nullptr;
+}
+
+ObjectMonitor* java_lang_VirtualThread::current_waiting_monitor(oop vthread) {
+  ObjectWaiter* waiter = objectWaiter(vthread);
+  if (waiter != nullptr && waiter->is_wait()) {
+    return waiter->monitor();
+  }
+  return nullptr;
+}
+
 bool java_lang_VirtualThread::is_preempted(oop vthread) {
   oop continuation = java_lang_VirtualThread::continuation(vthread);
   assert(continuation != nullptr, "vthread with no continuation");
@@ -2192,6 +2210,7 @@ bool java_lang_VirtualThread::is_preempted(oop vthread) {
 #if INCLUDE_CDS
 void java_lang_VirtualThread::serialize_offsets(SerializeClosure* f) {
    VTHREAD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
+   VTHREAD_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
 }
 #endif
 

src/hotspot/share/classfile/javaClasses.hpp

@@ -38,6 +38,8 @@
 class JvmtiThreadState;
 class RecordComponent;
 class SerializeClosure;
+class ObjectWaiter;
+class ObjectMonitor;
 
 #define CHECK_INIT(offset)  assert(offset != 0, "should be initialized"); return offset;
 
@@ -537,6 +539,8 @@ class java_lang_ThreadGroup : AllStatic {
 
 
 // Interface to java.lang.VirtualThread objects
+#define VTHREAD_INJECTED_FIELDS(macro)                                           \
+  macro(java_lang_VirtualThread,   objectWaiter,  intptr_signature,       false)
 
 class java_lang_VirtualThread : AllStatic {
  private:
@@ -549,6 +553,7 @@ class java_lang_VirtualThread : AllStatic {
   static int _notified_offset;
   static int _recheckInterval_offset;
   static int _timeout_offset;
+  static int _objectWaiter_offset;
   JFR_ONLY(static int _jfr_epoch_offset;)
  public:
   enum {
@@ -600,6 +605,11 @@ class java_lang_VirtualThread : AllStatic {
   static void set_notified(oop vthread, jboolean value);
   static bool is_preempted(oop vthread);
   static JavaThreadStatus map_state_to_thread_status(int state);
+
+  static inline ObjectWaiter* objectWaiter(oop vthread);
+  static inline void set_objectWaiter(oop vthread, ObjectWaiter* waiter);
+  static ObjectMonitor* current_pending_monitor(oop vthread);
+  static ObjectMonitor* current_waiting_monitor(oop vthread);
 };
 
 

src/hotspot/share/classfile/javaClasses.inline.hpp

@@ -220,6 +220,14 @@ inline oop java_lang_VirtualThread::vthread_scope() {
   return base->obj_field(static_vthread_scope_offset);
 }
 
+inline ObjectWaiter* java_lang_VirtualThread::objectWaiter(oop vthread) {
+  return (ObjectWaiter*)vthread->address_field(_objectWaiter_offset);
+}
+
+inline void java_lang_VirtualThread::set_objectWaiter(oop vthread, ObjectWaiter* value) {
+  vthread->address_field_put(_objectWaiter_offset, (address)value);
+}
+
 #if INCLUDE_JFR
 inline u2 java_lang_Thread::jfr_epoch(oop ref) {
   return ref->short_field(_jfr_epoch_offset);

src/hotspot/share/classfile/javaClassesImpl.hpp

@@ -40,6 +40,7 @@
   STACKFRAMEINFO_INJECTED_FIELDS(macro)     \
   MODULE_INJECTED_FIELDS(macro)             \
   THREAD_INJECTED_FIELDS(macro)             \
+  VTHREAD_INJECTED_FIELDS(macro)            \
   INTERNALERROR_INJECTED_FIELDS(macro)      \
   STACKCHUNK_INJECTED_FIELDS(macro)
 

src/hotspot/share/oops/stackChunkOop.hpp

@@ -98,12 +98,6 @@ class stackChunkOopDesc : public instanceOopDesc {
   inline uint8_t lockstack_size() const;
   inline void set_lockstack_size(uint8_t value);
 
-  inline ObjectWaiter* object_waiter() const;
-  inline void set_object_waiter(ObjectWaiter* obj_waiter);
-
-  inline ObjectMonitor* current_pending_monitor() const;
-  inline ObjectMonitor* current_waiting_monitor() const;
-
   inline oop cont() const;
   template<typename P>
   inline oop cont() const;

src/hotspot/share/oops/stackChunkOop.inline.hpp

@@ -92,9 +92,6 @@ inline void stackChunkOopDesc::set_max_thawing_size(int value)  {
 inline uint8_t stackChunkOopDesc::lockstack_size() const         { return jdk_internal_vm_StackChunk::lockStackSize(as_oop()); }
 inline void stackChunkOopDesc::set_lockstack_size(uint8_t value) { jdk_internal_vm_StackChunk::set_lockStackSize(this, value); }
 
-inline ObjectWaiter* stackChunkOopDesc::object_waiter() const       { return (ObjectWaiter*)jdk_internal_vm_StackChunk::objectWaiter(as_oop()); }
-inline void stackChunkOopDesc::set_object_waiter(ObjectWaiter* obj) { jdk_internal_vm_StackChunk::set_objectWaiter(this, (address)obj); }
-
 inline oop stackChunkOopDesc::cont() const                { return jdk_internal_vm_StackChunk::cont(as_oop()); }
 inline void stackChunkOopDesc::set_cont(oop value)        { jdk_internal_vm_StackChunk::set_cont(this, value); }
 template<typename P>
@@ -171,22 +168,6 @@ inline void stackChunkOopDesc::set_preempted(bool value) {
   set_flag(FLAG_PREEMPTED, value);
 }
 
-inline ObjectMonitor* stackChunkOopDesc::current_pending_monitor() const {
-  ObjectWaiter* waiter = object_waiter();
-  if (waiter != nullptr && waiter->at_monitorenter()) {
-    return waiter->monitor();
-  }
-  return nullptr;
-}
-
-inline ObjectMonitor* stackChunkOopDesc::current_waiting_monitor() const {
-  ObjectWaiter* waiter = object_waiter();
-  if (waiter != nullptr && waiter->is_wait()) {
-    return waiter->monitor();
-  }
-  return nullptr;
-}
-
 inline bool stackChunkOopDesc::has_lockstack() const         { return is_flag(FLAG_HAS_LOCKSTACK); }
 inline void stackChunkOopDesc::set_has_lockstack(bool value) { set_flag(FLAG_HAS_LOCKSTACK, value); }
 

src/hotspot/share/prims/jvmtiEnvBase.cpp

@@ -1080,12 +1080,7 @@ JvmtiEnvBase::get_locked_objects_in_frame(JavaThread* calling_thread, JavaThread
       ObjectMonitor *mon = target->current_waiting_monitor();
       if (mon != nullptr) wait_obj = mon->object();
     } else {
-      assert(vthread != nullptr, "no vthread oop");
-      oop cont = java_lang_VirtualThread::continuation(vthread);
-      assert(cont != nullptr, "vthread with no continuation");
-      stackChunkOop chunk = jdk_internal_vm_Continuation::tail(cont);
-      assert(chunk != nullptr, "unmounted vthread should have a chunk");
-      ObjectMonitor *mon = chunk->current_waiting_monitor();
+      ObjectMonitor *mon = java_lang_VirtualThread::current_waiting_monitor(vthread);
       if (mon != nullptr) wait_obj = mon->object();
     }
   }
@@ -1099,12 +1094,7 @@ JvmtiEnvBase::get_locked_objects_in_frame(JavaThread* calling_thread, JavaThread
       ObjectMonitor *mon = target->current_pending_monitor();
       if (mon != nullptr) pending_obj = mon->object();
     } else {
-      assert(vthread != nullptr, "no vthread oop");
-      oop cont = java_lang_VirtualThread::continuation(vthread);
-      assert(cont != nullptr, "vthread with no continuation");
-      stackChunkOop chunk = jdk_internal_vm_Continuation::tail(cont);
-      assert(chunk != nullptr, "unmounted vthread should have a chunk");
-      ObjectMonitor *mon = chunk->current_pending_monitor();
+      ObjectMonitor *mon = java_lang_VirtualThread::current_pending_monitor(vthread);
       if (mon != nullptr) pending_obj = mon->object();
     }
   }
@@ -2569,12 +2559,9 @@ GetCurrentContendedMonitorClosure::do_thread(Thread *target) {
 void
 GetCurrentContendedMonitorClosure::do_vthread(Handle target_h) {
   if (_target_jt == nullptr) {
-    oop cont = java_lang_VirtualThread::continuation(target_h());
-    assert(cont != nullptr, "vthread with no continuation");
-    stackChunkOop chunk = jdk_internal_vm_Continuation::tail(cont);
-    assert(chunk != nullptr, "unmounted vthread should have a chunk");
-    if (chunk->current_pending_monitor() != nullptr) {
-      *_owned_monitor_ptr = JNIHandles::make_local(_calling_thread, chunk->current_pending_monitor()->object());
+    ObjectMonitor *mon = java_lang_VirtualThread::current_pending_monitor(target_h());
+    if (mon != nullptr) {
+      *_owned_monitor_ptr = JNIHandles::make_local(_calling_thread, mon->object());
     }
     _result = JVMTI_ERROR_NONE; // target virtual thread is unmounted
     return;

src/hotspot/share/runtime/continuationFreezeThaw.cpp

@@ -1524,7 +1524,6 @@ stackChunkOop Freeze<ConfigT>::allocate_chunk(size_t stack_size, int argsize_md)
   assert(chunk->flags() == 0, "");
   assert(chunk->is_gc_mode() == false, "");
   assert(chunk->lockstack_size() == 0, "");
-  assert(chunk->object_waiter() == nullptr, "");
 
   // fields are uninitialized
   chunk->set_parent_access<IS_DEST_UNINITIALIZED>(_cont.last_nonempty_chunk());
@@ -2214,11 +2213,10 @@ NOINLINE intptr_t* Thaw<ConfigT>::thaw_slow(stackChunkOop chunk, Continuation::t
 
   _preempted_case = chunk->preempted();
   if (_preempted_case) {
-    if (chunk->object_waiter() != nullptr) {
+    ObjectWaiter* waiter = java_lang_VirtualThread::objectWaiter(_thread->vthread());
+    if (waiter != nullptr) {
       // Mounted again after preemption. Resume the pending monitor operation,
       // which will be either a monitorenter or Object.wait() call.
-      assert(chunk->current_pending_monitor() != nullptr || chunk->current_waiting_monitor() != nullptr, "");
-      ObjectWaiter* waiter = chunk->object_waiter();
       ObjectMonitor* mon = waiter->monitor();
       preempt_kind = waiter->is_wait() ? Continuation::freeze_on_wait : Continuation::freeze_on_monitorenter;
 

src/hotspot/share/runtime/continuationJavaClasses.cpp

@@ -88,7 +88,6 @@ int jdk_internal_vm_StackChunk::_bottom_offset;
 int jdk_internal_vm_StackChunk::_flags_offset;
 int jdk_internal_vm_StackChunk::_maxThawingSize_offset;
 int jdk_internal_vm_StackChunk::_lockStackSize_offset;
-int jdk_internal_vm_StackChunk::_objectWaiter_offset;
 int jdk_internal_vm_StackChunk::_cont_offset;
 
 #define STACKCHUNK_FIELDS_DO(macro) \

src/hotspot/share/runtime/continuationJavaClasses.hpp

@@ -76,7 +76,6 @@ class jdk_internal_vm_Continuation: AllStatic {
   macro(jdk_internal_vm_StackChunk, pc,              intptr_signature,       false) \
   macro(jdk_internal_vm_StackChunk, maxThawingSize,  int_signature,          false) \
   macro(jdk_internal_vm_StackChunk, lockStackSize,   byte_signature,         false) \
-  macro(jdk_internal_vm_StackChunk, objectWaiter,    intptr_signature,       false) \
 
 class jdk_internal_vm_StackChunk: AllStatic {
   friend class JavaClasses;
@@ -89,7 +88,6 @@ class jdk_internal_vm_StackChunk: AllStatic {
   static int _flags_offset;
   static int _maxThawingSize_offset;
   static int _lockStackSize_offset;
-  static int _objectWaiter_offset;
   static int _cont_offset;
 
 
@@ -131,9 +129,6 @@ class jdk_internal_vm_StackChunk: AllStatic {
   static inline uint8_t lockStackSize(oop chunk);
   static inline void set_lockStackSize(oop chunk, uint8_t value);
 
-  static inline address objectWaiter(oop chunk);
-  static inline void set_objectWaiter(oop chunk, address mon);
-
   // cont oop's processing is essential for the chunk's GC protocol
   static inline oop cont(oop chunk);
   template<typename P>