8338383: Implement JEP 491: Synchronize Virtual Threads without Pinning

src/hotspot/share/runtime/javaThread.hpp

@@ -163,7 +163,7 @@ class JavaThread: public Thread {
   // ID used as owner for inflated monitors. Same as the j.l.Thread.tid of the
   // current _vthread object, except during creation of the primordial and JNI
   // attached thread cases where this field can have a temporary value. Also,
-  // calls to VirtualThread.switchToCarrierThread will temporary change _vthread
+  // calls to VirtualThread.switchToCarrierThread will temporarily change _vthread
   // to refer to the carrier while preserving the j.l.Thread.tid of the virtual
   // thread in this field.
   int64_t _lock_id;

src/hotspot/share/runtime/lightweightSynchronizer.cpp

@@ -344,7 +344,7 @@ ObjectMonitor* LightweightSynchronizer::get_or_insert_monitor_from_table(oop obj
   }
 
   ObjectMonitor* alloced_monitor = new ObjectMonitor(object);
-  alloced_monitor->set_owner_anonymous();
+  alloced_monitor->set_anonymous_owner();
 
   // Try insert monitor
   monitor = add_monitor(current, alloced_monitor, object);
@@ -741,7 +741,7 @@ void LightweightSynchronizer::exit(oop object, JavaThread* current) {
   assert(mark.has_monitor(), "must be");
   // The monitor exists
   ObjectMonitor* monitor = ObjectSynchronizer::read_monitor(current, object, mark);
-  if (monitor->has_owner_anonymous()) {
+  if (monitor->has_anonymous_owner()) {
     assert(current->lock_stack().contains(object), "current must have object on its lock stack");
     monitor->set_owner_from_anonymous(current);
     monitor->set_recursions(current->lock_stack().remove(object) - 1);
@@ -786,7 +786,7 @@ ObjectMonitor* LightweightSynchronizer::inflate_locked_or_imse(oop obj, ObjectSy
     assert(mark.has_monitor(), "must be");
     ObjectMonitor* monitor = ObjectSynchronizer::read_monitor(current, obj, mark);
     if (monitor != nullptr) {
-      if (monitor->has_owner_anonymous()) {
+      if (monitor->has_anonymous_owner()) {
         LockStack& lock_stack = current->lock_stack();
         if (lock_stack.contains(obj)) {
           // Current thread owns the lock but someone else inflated it.
@@ -834,7 +834,7 @@ ObjectMonitor* LightweightSynchronizer::inflate_into_object_header(oop object, O
       ObjectMonitor* inf = mark.monitor();
       markWord dmw = inf->header();
       assert(dmw.is_neutral(), "invariant: header=" INTPTR_FORMAT, dmw.value());
-      if (inf->has_owner_anonymous() &&
+      if (inf->has_anonymous_owner() &&
           inflating_thread != nullptr && inflating_thread->lock_stack().contains(object)) {
         inf->set_owner_from_anonymous(inflating_thread);
         size_t removed = inflating_thread->lock_stack().remove(object);
@@ -862,7 +862,7 @@ ObjectMonitor* LightweightSynchronizer::inflate_into_object_header(oop object, O
         monitor->set_owner(inflating_thread);
       } else {
         // Owned by somebody else.
-        monitor->set_owner_anonymous();
+        monitor->set_anonymous_owner();
       }
       markWord monitor_mark = markWord::encode(monitor);
       markWord old_mark = object->cas_set_mark(monitor_mark, mark);
@@ -952,7 +952,7 @@ ObjectMonitor* LightweightSynchronizer::inflate_fast_locked_object(oop object, O
     // ObjectMonitors are always inserted as anonymously owned, this thread is
     // the current holder of the monitor. So unless the entry is stale and
     // contains a deflating monitor it must be anonymously owned.
-    if (monitor->has_owner_anonymous()) {
+    if (monitor->has_anonymous_owner()) {
       // The monitor must be anonymously owned if it was added
       assert(monitor == get_monitor_from_table(current, object), "The monitor must be found");
       // New fresh monitor
@@ -1073,7 +1073,7 @@ ObjectMonitor* LightweightSynchronizer::inflate_and_enter(oop object, ObjectSync
     // CASE: inflated
     if (mark.has_monitor()) {
       LockStack& lock_stack = locking_thread->lock_stack();
-      if (monitor->has_owner_anonymous() && lock_stack.contains(object)) {
+      if (monitor->has_anonymous_owner() && lock_stack.contains(object)) {
         // The lock is fast-locked by the locking thread,
         // convert it to a held monitor with a known owner.
         monitor->set_owner_from_anonymous(locking_thread);

src/hotspot/share/runtime/objectMonitor.cpp

@@ -1536,23 +1536,12 @@ void ObjectMonitor::ExitEpilog(JavaThread* current, ObjectWaiter* Wakee) {
   OM_PERFDATA_OP(Parks, inc());
 }
 
-// complete_exit exits a lock returning recursion count
-// complete_exit requires an inflated monitor
-// The _owner field is not always the Thread addr even with an
-// inflated monitor, e.g. the monitor can be inflated by a non-owning
-// thread due to contention.
+// Exits the monitor returning recursion count. _owner should
+// be set to current's tid, i.e. no ANONYMOUS_OWNER allowed.
 intx ObjectMonitor::complete_exit(JavaThread* current) {
   assert(InitDone, "Unexpectedly not initialized");
-
-  if (!has_owner(current)) {
-    if (LockingMode == LM_LEGACY && has_stack_locker(current)) {
-      assert(_recursions == 0, "internal state error");
-      set_owner_from_BasicLock(current);  // Convert from BasicLock* to Thread*.
-      _recursions = 0;
-    }
-  }
-
   guarantee(has_owner(current), "complete_exit not owner");
+
   intx save = _recursions; // record the old recursion count
   _recursions = 0;         // set the recursion level to be 0
   exit(current);           // exit the monitor

src/hotspot/share/runtime/objectMonitor.hpp

@@ -298,8 +298,6 @@ class ObjectMonitor : public CHeapObj<mtObjectMonitor> {
   void      set_owner_from_raw(int64_t old_value, int64_t new_value);
   // Same as above but uses tid of current as new value.
   void      set_owner_from(int64_t old_value, JavaThread* current);
-  // Set _owner field to tid of current thread; current value must be ANONYMOUS_OWNER.
-  void      set_owner_from_BasicLock(JavaThread* current);
   // Try to set _owner field to new_value if the current value matches
   // old_value, using Atomic::cmpxchg(). Otherwise, does not change the
   // _owner field. Returns the prior value of the _owner field.
@@ -322,17 +320,14 @@ class ObjectMonitor : public CHeapObj<mtObjectMonitor> {
     return try_set_owner_from(NO_OWNER, thread) == NO_OWNER;
   }
 
-  bool has_owner_anonymous() const { return owner_raw() == ANONYMOUS_OWNER; }
-  void set_owner_anonymous() {
+  bool has_anonymous_owner() const { return owner_raw() == ANONYMOUS_OWNER; }
+  void set_anonymous_owner() {
     set_owner_from_raw(NO_OWNER, ANONYMOUS_OWNER);
   }
   void set_owner_from_anonymous(JavaThread* owner) {
     set_owner_from(ANONYMOUS_OWNER, owner);
   }
 
-  // Returns true if BasicLock* stored in _stack_locker
-  // points to current's stack, false otherwise.
-  bool has_stack_locker(JavaThread* current);
   // Get and set _stack_locker.
   BasicLock* stack_locker() const;
   void set_stack_locker(BasicLock* locker);

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

@@ -52,7 +52,7 @@ inline int64_t ObjectMonitor::owner_from(oop vthread) {
 }
 
 inline bool ObjectMonitor::is_entered(JavaThread* current) const {
-  if (has_owner_anonymous()) {
+  if (has_anonymous_owner()) {
     if (LockingMode == LM_LIGHTWEIGHT) {
       return current->lock_stack().contains(object());
     } else {
@@ -125,10 +125,6 @@ inline void ObjectMonitor::set_stack_locker(BasicLock* locker) {
   Atomic::store(&_stack_locker, locker);
 }
 
-inline bool ObjectMonitor::has_stack_locker(JavaThread* current) {
-  return has_owner_anonymous() && current->is_lock_owned((address)stack_locker());
-}
-
 // Returns true if owner field == DEFLATER_MARKER and false otherwise.
 // This accessor is called when we really need to know if the owner
 // field == DEFLATER_MARKER and any non-null value won't do the trick.
@@ -191,22 +187,6 @@ inline void ObjectMonitor::set_owner_from(int64_t old_value, JavaThread* current
   set_owner_from_raw(old_value, owner_from(current));
 }
 
-// Simply set _owner to the tid of current. Current owner must be anonymous.
-inline void ObjectMonitor::set_owner_from_BasicLock(JavaThread* current) {
-  BasicLock* basic_lock_p = stack_locker();
-
-  set_stack_locker(nullptr); // first
-  assert(has_owner_anonymous(), "");
-
-  // Non-null owner field to non-null owner field is safe without
-  // cmpxchg() as long as all readers can tolerate either flavor.
-  Atomic::store(&_owner, owner_from(current));
-  log_trace(monitorinflation, owner)("set_owner_from_BasicLock(): mid="
-                                     INTPTR_FORMAT ", basic_lock_p="
-                                     INTPTR_FORMAT ", new_value=" INT64_FORMAT,
-                                     p2i(this), p2i(basic_lock_p), owner_from(current));
-}
-
 // Try to set _owner field to new_value if the current value matches
 // old_value. Otherwise, does not change the _owner field. Returns
 // the prior value of the _owner field.

src/hotspot/share/runtime/synchronizer.cpp

@@ -657,7 +657,7 @@ void ObjectSynchronizer::exit_legacy(oop object, BasicLock* lock, JavaThread* cu
   // The ObjectMonitor* can't be async deflated until ownership is
   // dropped inside exit() and the ObjectMonitor* must be !is_busy().
   ObjectMonitor* monitor = inflate(current, object, inflate_cause_vm_internal);
-  assert(!monitor->has_owner_anonymous(), "must not be");
+  assert(!monitor->has_anonymous_owner(), "must not be");
   monitor->exit(current);
 }
 
@@ -1464,10 +1464,11 @@ ObjectMonitor* ObjectSynchronizer::inflate_impl(JavaThread* inflating_thread, oo
       ObjectMonitor* inf = mark.monitor();
       markWord dmw = inf->header();
       assert(dmw.is_neutral(), "invariant: header=" INTPTR_FORMAT, dmw.value());
-      if (inf->has_owner_anonymous() && inflating_thread != nullptr) {
+      if (inf->has_anonymous_owner() && inflating_thread != nullptr) {
         assert(LockingMode == LM_LEGACY, "invariant");
         if (inflating_thread->is_lock_owned((address)inf->stack_locker())) {
-          inf->set_owner_from_BasicLock(inflating_thread);
+          inf->set_stack_locker(nullptr);
+          inf->set_owner_from_anonymous(inflating_thread);
         }
       }
       return inf;
@@ -1555,7 +1556,7 @@ ObjectMonitor* ObjectSynchronizer::inflate_impl(JavaThread* inflating_thread, oo
         // Use ANONYMOUS_OWNER to indicate that the owner is the BasicLock on the stack,
         // and set the stack locker field in the monitor.
         m->set_stack_locker(mark.locker());
-        m->set_owner_anonymous();  // second
+        m->set_anonymous_owner();  // second
       }
       // TODO-FIXME: assert BasicLock->dhw != 0.
 

src/hotspot/share/runtime/threads.cpp

@@ -1265,7 +1265,7 @@ JavaThread* Threads::owning_thread_from_object(ThreadsList * t_list, oop obj) {
 }
 
 JavaThread* Threads::owning_thread_from_monitor(ThreadsList* t_list, ObjectMonitor* monitor) {
-  if (monitor->has_owner_anonymous()) {
+  if (monitor->has_anonymous_owner()) {
     if (LockingMode == LM_LIGHTWEIGHT) {
       return owning_thread_from_object(t_list, monitor->object());
     } else {

src/hotspot/share/runtime/vmOperations.cpp

@@ -350,7 +350,7 @@ class ObjectMonitorsDump : public MonitorClosure, public ObjectMonitorsView {
   void do_monitor(ObjectMonitor* monitor) override {
     assert(monitor->has_owner(), "Expects only owned monitors");
 
-    if (monitor->has_owner_anonymous()) {
+    if (monitor->has_anonymous_owner()) {
       // There's no need to collect anonymous owned monitors
       // because the caller of this code is only interested
       // in JNI owned monitors.

src/java.base/share/classes/java/lang/Thread.java

@@ -651,7 +651,7 @@ public static void onSpinWait() {}
      * Helper class to generate thread identifiers. The identifiers start at
      * {@link Thread#PRIMORDIAL_TID} +1 as this class cannot be used during
      * early startup to generate the identifier for the primordial thread. The
-     * counter is off-heap and shared with the VM to allow it assign thread
+     * counter is off-heap and shared with the VM to allow it to assign thread
      * identifiers to non-Java threads.
      * See Thread initialization.
      */

src/java.base/share/classes/java/lang/VirtualThread.java

@@ -628,15 +628,15 @@ private void afterYield() {
 
         // Object.wait
         if (s == WAITING || s == TIMED_WAITING) {
-            byte nonce;
+            byte seqNo;
             int newState;
             if (s == WAITING) {
-                nonce = 0;  // not used
+                seqNo = 0;  // not used
                 setState(newState = WAIT);
             } else {
                 // synchronize with timeout task (previous timed-wait may be running)
                 synchronized (timedWaitLock()) {
-                    nonce = ++timedWaitSeqNo;
+                    seqNo = ++timedWaitSeqNo;
                     setState(newState = TIMED_WAIT);
                 }
             }
@@ -659,7 +659,7 @@ private void afterYield() {
             // schedule wakeup
             if (newState == TIMED_WAIT) {
                 assert waitTimeout > 0;
-                waitTimeoutTask = schedule(() -> waitTimeoutExpired(nonce), waitTimeout, MILLISECONDS);
+                waitTimeoutTask = schedule(() -> waitTimeoutExpired(seqNo), waitTimeout, MILLISECONDS);
             }
             return;
         }
@@ -945,12 +945,12 @@ private void unblock() {
      * and submit its task so that it continues and attempts to reenter the monitor.
      * This method does nothing if the thread has been woken by notify or interrupt.
      */
-    private void waitTimeoutExpired(byte nounce) {
+    private void waitTimeoutExpired(byte seqNo) {
         assert !Thread.currentThread().isVirtual();
         for (;;) {
             boolean unblocked = false;
             synchronized (timedWaitLock()) {
-                if (nounce != timedWaitSeqNo) {
+                if (seqNo != timedWaitSeqNo) {
                     // this timeout task is for a past timed-wait
                     return;
                 }
@@ -1394,7 +1394,7 @@ private Object carrierThreadAccessLock() {
     }
 
     /**
-     * Returns a lock object to coordinating timed-wait setup and timeout handling.
+     * Returns a lock object for coordinating timed-wait setup and timeout handling.
      */
     private Object timedWaitLock() {
         // use this object for now to avoid the overhead of introducing another lock