loom locking stuff

Signed-off-by: Tobi Ajila <atobia@ca.ibm.com>

make/data/hotspot-symbols/symbols-unix

@@ -224,6 +224,7 @@ JVM_VirtualThreadMount
 JVM_VirtualThreadUnmount
 JVM_VirtualThreadHideFrames
 JVM_VirtualThreadDisableSuspend
+JVM_VirtualThreadWaitForPendingList
 
 # Scoped values
 JVM_EnsureMaterializedForStackWalk_func

src/hotspot/share/include/jvm.h

@@ -1157,6 +1157,9 @@ JVM_VirtualThreadHideFrames(JNIEnv* env, jobject vthread, jboolean hide);
 JNIEXPORT void JNICALL
 JVM_VirtualThreadDisableSuspend(JNIEnv* env, jobject vthread, jboolean enter);
 
+JNIEXPORT jobject JNICALL
+JVM_VirtualThreadWaitForPendingList(JNIEnv* env);
+
 /*
  * Core reflection support.
  */

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

@@ -81,6 +81,7 @@ final class VirtualThread extends BaseVirtualThread {
  private static final long PARK_PERMIT = U.objectFieldOffset(VirtualThread.class, "parkPermit");
  private static final long CARRIER_THREAD = U.objectFieldOffset(VirtualThread.class, "carrierThread");
  private static final long TERMINATION = U.objectFieldOffset(VirtualThread.class, "termination");
+ private static final long ON_WAITING_LIST = U.objectFieldOffset(VirtualThread.class, "onWaitingList");
 
  // scheduler and continuation
  private final Executor scheduler;
@@ -132,6 +133,9 @@ final class VirtualThread extends BaseVirtualThread {
  // Thread.yield
  private static final int YIELDING = 10;
  private static final int YIELDED = 11; // unmounted but runnable
+ // monitor enter
+ private static final int BLOCKING = 12;
+ private static final int BLOCKED = 13;
 
  private static final int TERMINATED = 99; // final state
 
@@ -141,12 +145,20 @@ final class VirtualThread extends BaseVirtualThread {
  // parking permit
  private volatile boolean parkPermit;
 
+
+ // unblocked
+ private volatile boolean unblocked;
+
  // carrier thread when mounted, accessed by VM
  private volatile Thread carrierThread;
 
  // termination object when joining, created lazily if needed
  private volatile CountDownLatch termination;
 
+ // Next waiting vthread to unpark()
+ private VirtualThread next;
+ private byte onWaitingList;
+
  /**
  * Returns the continuation scope used for virtual threads.
  */
@@ -499,6 +511,16 @@ private void afterYield() {
  return;
  }
 
+ // blocking on monitorenter
+ if (s == BLOCKING) {
+ setState(BLOCKED);
+ if (unblocked && compareAndSetState(BLOCKED, UNPARKED)) {
+ unblocked = false;
+ submitRunContinuation();
+ }
+ return;
+ }
+
  assert false;
  }
 
@@ -772,6 +794,19 @@ void unpark() {
  }
  }
 
+ /**
+ * Re-enables this virtual thread for scheduling after blocking on monitor enter.
+ * @throws RejectedExecutionException if the scheduler cannot accept a task
+ */
+ private void unblock() {
+ assert !Thread.currentThread().isVirtual();
+ unblocked = true;
+ if (state() == BLOCKED && compareAndSetState(BLOCKED, UNPARKED)) {
+ unblocked = false;
+ submitRunContinuation();
+ }
+ }
+
  /**
  * Attempts to yield the current virtual thread (Thread.yield).
  */
@@ -924,6 +959,7 @@ Thread.State threadState() {
  }
  case UNPARKED:
  case YIELDED:
+ case BLOCKING:
  // runnable, not mounted
  return Thread.State.RUNNABLE;
  case RUNNING:
@@ -952,6 +988,8 @@ Thread.State threadState() {
  case TIMED_PARKED:
  case TIMED_PINNED:
  return State.TIMED_WAITING;
+ case BLOCKED:
+ return State.BLOCKED;
  case TERMINATED:
  return Thread.State.TERMINATED;
  default:
@@ -997,7 +1035,7 @@ private StackTraceElement[] tryGetStackTrace() {
  case RUNNING, PINNED, TIMED_PINNED -> {
  return null; // mounted
  }
- case PARKED, TIMED_PARKED -> {
+ case PARKED, BLOCKED, TIMED_PARKED -> {
  // unmounted, not runnable
  }
  case UNPARKED, YIELDED -> {
@@ -1028,9 +1066,9 @@ private StackTraceElement[] tryGetStackTrace() {
  // resubmit as task may have run while suspended
  yield true;
  }
- case PARKED, TIMED_PARKED -> {
+ case PARKED, BLOCKED, TIMED_PARKED -> {
  // resubmit if unparked while suspended
- yield parkPermit && compareAndSetState(initialState, UNPARKED);
+ yield (parkPermit || unblocked) && compareAndSetState(initialState, UNPARKED);
  }
  default -> throw new InternalError();
  };
@@ -1119,6 +1157,16 @@ private void setState(int newValue) {
  state = newValue; // volatile write
  }
 
+ private VirtualThread next() {
+ return next;
+ }
+
+ private void removeFromWaitingList() {
+ next = null;
+ boolean res = U.compareAndSetByte(this, ON_WAITING_LIST, (byte)0x01, (byte)0x00);
+ assert res;
+ }
+
  private boolean compareAndSetState(int expectedValue, int newValue) {
  return U.compareAndSetInt(this, STATE, expectedValue, newValue);
  }
@@ -1244,4 +1292,28 @@ private static int tracePinningMode() {
  }
  return 0;
  }
+
+ /**
+ * Unblock virtual threads that are ready to scheduled again.
+ */
+ private static void processPendingList() {
+ while (true) {
+ VirtualThread currentWaitingVThread = waitForPendingList();
+ VirtualThread nextWaitingVThread = null;
+ while (currentWaitingVThread != null) {
+ nextWaitingVThread = currentWaitingVThread.next();
+ currentWaitingVThread.removeFromWaitingList();
+ currentWaitingVThread.unpark();
+ currentWaitingVThread = nextWaitingVThread;
+ }
+ }
+ }
+
+ private static native VirtualThread waitForPendingList();
+
+ static {
+ var unblocker = InnocuousThread.newThread("VirtualThread-unblocker",
+ VirtualThread::processPendingList);
+ unblocker.start();
+ }
 }

src/java.base/share/native/libjava/VirtualThread.c

@@ -38,6 +38,7 @@ static JNINativeMethod methods[] = {
  { "notifyJvmtiUnmount", "(Z)V", (void *)&JVM_VirtualThreadUnmount },
  { "notifyJvmtiHideFrames", "(Z)V", (void *)&JVM_VirtualThreadHideFrames },
  { "notifyJvmtiDisableSuspend", "(Z)V", (void *)&JVM_VirtualThreadDisableSuspend },
+ { "waitForPendingList", "()" VIRTUAL_THREAD, (void *)&JVM_VirtualThreadWaitForPendingList },
 };
 
 JNIEXPORT void JNICALL