Merge pull request eclipse-openj9#21273 from fengxue-IS/jep491-3.1

Jep491 VM support

Author: babsingh

jcl/src/java.base/share/classes/jdk/internal/vm/Continuation.java

@@ -38,6 +38,10 @@ public class Continuation {
 	private long vmRef; /* J9VMContinuation */
 	protected Thread vthread; /* Parent VirtualThread */
 
+/*[IF JAVA_SPEC_VERSION >= 24]*/
+	private Object blocker;
+/*[ENDIF] JAVA_SPEC_VERSION >= 24 */
+
 	/* The live thread's scopedValueCache is always kept in J9VMThread->scopedValueCache
 	 * whereas the unmounted thread's scopedValueCache is stored in this field. This
 	 * field is modified in ContinuationHelpers.hpp::swapFieldsWithContinuation. This
@@ -71,7 +75,13 @@ public enum Pinned {
 		/** Holding monitor(s) */
 		MONITOR(2),
 		/** In critical section */
+/*[IF JAVA_SPEC_VERSION >= 24]*/
+		CRITICAL_SECTION(3),
+		/** Exception */
+		EXCEPTION(4);
+/*[ELSE] JAVA_SPEC_VERSION >= 24 */
 		CRITICAL_SECTION(3);
+/*[ENDIF] JAVA_SPEC_VERSION >= 24 */
 
 		private final int errorCode;
 
@@ -250,6 +260,10 @@ private boolean yield0() {
 				reason = Pinned.MONITOR;
 			} else if (rcPinned == Pinned.NATIVE.errorCode()) {
 				reason = Pinned.NATIVE;
+/*[IF JAVA_SPEC_VERSION >= 24]*/
+			} else if (rcPinned == Pinned.EXCEPTION.errorCode()) {
+				reason = Pinned.EXCEPTION;
+/*[ENDIF] JAVA_SPEC_VERSION >= 24 */
 			} else {
 				throw new AssertionError("Unknown pinned error code: " + rcPinned);
 			}

runtime/j9vm/javanextvmi.cpp

@@ -35,6 +35,9 @@
 #include "VMHelpers.hpp"
 #include "ContinuationHelpers.hpp"
 #endif /* JAVA_SPEC_VERSION >= 19 */
+#if JAVA_SPEC_VERSION >= 24
+#include "j9protos.h"
+#endif /* JAVA_SPEC_VERSION >= 24 */
 
 extern "C" {
 
@@ -720,17 +723,19 @@ JVM_IsStaticallyLinked(void)
 }
 
 JNIEXPORT void JNICALL
-JVM_VirtualThreadPinnedEvent(JNIEnv* env, jclass clazz, jstring op)
+JVM_VirtualThreadPinnedEvent(JNIEnv *env, jclass clazz, jstring op)
 {
 	// TODO: emit JFR Event
 	return;
 }
 
 JNIEXPORT jobject JNICALL
-JVM_TakeVirtualThreadListToUnblock(JNIEnv* env, jclass ignored)
+JVM_TakeVirtualThreadListToUnblock(JNIEnv *env, jclass ignored)
 {
-	// TODO: return the unblocked list
-	return NULL;
+	J9VMThread *currentThread = (J9VMThread *)env;
+	J9JavaVM *vm = currentThread->javaVM;
+
+	return vm->internalVMFunctions->takeVirtualThreadListToUnblock(currentThread, vm);
 }
 #endif /* JAVA_SPEC_VERSION >= 24 */
 

runtime/oti/ContinuationHelpers.hpp

@@ -30,6 +30,9 @@
 #define J9VM_CONTINUATION_PINNED_REASON_NATIVE 1
 #define J9VM_CONTINUATION_PINNED_REASON_MONITOR 2
 #define J9VM_CONTINUATION_PINNED_REASON_CRITICAL_SECTION 3
+#if JAVA_SPEC_VERSION >= 24
+#define J9VM_CONTINUATION_PINNED_REASON_EXCEPTION 4
+#endif /* JAVA_SPEC_VERSION >= 24 */
 
 class VM_ContinuationHelpers {
 	/*
@@ -88,6 +91,15 @@ class VM_ContinuationHelpers {
 		j9object_t scopedValueCache = J9VMJDKINTERNALVMCONTINUATION_SCOPEDVALUECACHE(vmThread, continuationObject);
 		J9VMJDKINTERNALVMCONTINUATION_SET_SCOPEDVALUECACHE(vmThread, continuationObject, vmThread->scopedValueCache);
 		vmThread->scopedValueCache = scopedValueCache;
+
+#if JAVA_SPEC_VERSION >= 24
+		if (J9_ARE_ANY_BITS_SET(vmThread->javaVM->extendedRuntimeFlags3, J9_EXTENDED_RUNTIME3_YIELD_PINNED_CONTINUATION)) {
+			SWAP_MEMBER(ownedMonitorCount, UDATA, vmThread, continuation);
+			SWAP_MEMBER(monitorEnterRecordPool, J9Pool*, vmThread, continuation);
+			SWAP_MEMBER(monitorEnterRecords, J9MonitorEnterRecord*, vmThread, continuation);
+			SWAP_MEMBER(jniMonitorEnterRecords, J9MonitorEnterRecord*, vmThread, continuation);
+		}
+#endif /* JAVA_SPEC_VERSION >= 24 */
 	}
 
 	static VMINLINE ContinuationState volatile *
@@ -261,6 +273,24 @@ class VM_ContinuationHelpers {
 
 		return threadObject;
 	}
+
+#if JAVA_SPEC_VERSION >= 24
+	/**
+	 * Check if the threadObject mounted on a J9VMThread is a virtual thread and can be yielded.
+	 *
+	 * @param[in] vmThread the J9VMThread
+	 *
+	 * @return true if the virtual thread is yieldable, otherwise false
+	 */
+	static VMINLINE bool
+	isYieldableVirtualThread(J9VMThread *vmThread)
+	{
+		return (J9_ARE_ANY_BITS_SET(vmThread->javaVM->extendedRuntimeFlags3, J9_EXTENDED_RUNTIME3_YIELD_PINNED_CONTINUATION)
+				&& IS_JAVA_LANG_VIRTUALTHREAD(vmThread, vmThread->threadObject)
+				&& (0 == vmThread->continuationPinCount)
+				&& (0 == vmThread->callOutCount));
+	}
+#endif /* JAVA_SPEC_VERSION >= 24 */
 };
 
 #endif /* CONTINUATIONHELPERS_HPP_ */

runtime/oti/j9consts.h

@@ -371,6 +371,7 @@ extern "C" {
 
 /* constants for J9JavaVM.extendedRuntimeFlags3 */
 #define J9_EXTENDED_RUNTIME3_START_FLIGHT_RECORDING 0x1
+#define J9_EXTENDED_RUNTIME3_YIELD_PINNED_CONTINUATION 0x2
 
 #define J9_OBJECT_HEADER_AGE_DEFAULT 0xA /* OBJECT_HEADER_AGE_DEFAULT */
 #define J9_OBJECT_HEADER_SHAPE_MASK 0xE /* OBJECT_HEADER_SHAPE_MASK */

runtime/oti/j9nonbuilder.h

@@ -298,6 +298,15 @@
 typedef void(*j9_tls_finalizer_t)(void *);
 #endif /* JAVA_SPEC_VERSION >= 19 */
 
+#if JAVA_SPEC_VERSION >= 24
+/* Constants from java.lang.VirutalThread.state that are used by the VM.
+ * The full mapping is under jvmtiInternals.h <JVMTI_VTHREAD_STATE_*>.
+ */
+#define JAVA_LANG_VIRTUALTHREAD_BLOCKING 12
+#define JAVA_LANG_VIRTUALTHREAD_WAITING  13
+#define JAVA_LANG_VIRTUALTHREAD_TIMED_WAITING 17
+#endif /* JAVA_SPEC_VERSION >= 24 */
+
 typedef enum {
 	J9FlushCompQueueDataBreakpoint
 } J9JITFlushCompilationQueueReason;
@@ -1717,6 +1726,11 @@ typedef struct J9ObjectMonitor {
 #endif /* defined(J9VM_THR_SMART_DEFLATION) */
 	j9objectmonitor_t alternateLockword;
 	U_32 hash;
+#if JAVA_SPEC_VERSION >= 24
+	U_32 virtualThreadWaitCount;
+	struct J9VMContinuation* ownerContinuation;
+	struct J9VMContinuation* waitingContinuations;
+#endif /* JAVA_SPEC_VERSION >= 24 */
 } J9ObjectMonitor;
 
 typedef struct J9ClassWalkState {
@@ -5329,6 +5343,10 @@ typedef struct J9InternalVMFunctions {
 	struct J9Class * (*initializeSnapshotClassObject)(struct J9JavaVM *javaVM, struct J9ClassLoader *classLoader, struct J9Class *clazz);
 	BOOLEAN (*loadWarmClassFromSnapshot)(struct J9VMThread *vmThread, struct J9ClassLoader *classLoader, struct J9Class *clazz);
 #endif /* defined(J9VM_OPT_SNAPSHOTS) */
+#if JAVA_SPEC_VERSION >= 24
+	struct J9ObjectMonitor * (*monitorTablePeek)(struct J9JavaVM *vm, j9object_t object);
+	jobject (*takeVirtualThreadListToUnblock)(struct J9VMThread *currentThread, struct J9JavaVM *vm);
+#endif /* JAVA_SPEC_VERSION >= 24 */
 } J9InternalVMFunctions;
 
 /* Jazz 99339: define a new structure to replace JavaVM so as to pass J9NativeLibrary to JVMTIEnv  */
@@ -5407,6 +5425,13 @@ typedef struct J9JITGPRSpillArea {
 typedef uintptr_t ContinuationState;
 
 #if JAVA_SPEC_VERSION >= 19
+#define J9VM_CONTINUATION_RETURN_FROM_YIELD 1
+#if JAVA_SPEC_VERSION >= 24
+#define J9VM_CONTINUATION_RETURN_FROM_MONITOR_ENTER 0
+#define J9VM_CONTINUATION_RETURN_FROM_OBJECT_WAIT   2
+#define J9VM_CONTINUATION_RETURN_FROM_SYNC_METHOD   3
+#endif /* JAVA_SPEC_VERSION >= 24 */
+
 typedef struct J9VMContinuation {
 	UDATA* arg0EA;
 	UDATA* bytecodes;
@@ -5422,6 +5447,16 @@ typedef struct J9VMContinuation {
 	struct J9I2JState i2jState;
 	struct J9VMEntryLocalStorage* oldEntryLocalStorage;
 	UDATA dropFlags;
+	UDATA returnState;
+#if JAVA_SPEC_VERSION >= 24
+	IDATA waitingMonitorEnterCount;
+	UDATA ownedMonitorCount;
+	struct J9Pool* monitorEnterRecordPool;
+	struct J9MonitorEnterRecord* monitorEnterRecords;
+	struct J9MonitorEnterRecord* jniMonitorEnterRecords;
+	j9object_t vthread;
+	struct J9VMContinuation* nextWaitingContinuation;
+#endif /* JAVA_SPEC_VERSION >= 24 */
 } J9VMContinuation;
 #endif /* JAVA_SPEC_VERSION >= 19 */
 
@@ -6341,6 +6376,10 @@ typedef struct J9JavaVM {
 #if defined(J9VM_OPT_JFR)
 	UDATA loadedClassCount;
 #endif /* defined(J9VM_OPT_JFR) */
+#if JAVA_SPEC_VERSION >= 24
+	J9VMContinuation *blockedContinuations;
+	omrthread_monitor_t blockedVirtualThreadsMutex;
+#endif /* JAVA_SPEC_VERSION >= 24 */
 } J9JavaVM;
 
 #define J9JFR_SAMPLER_STATE_UNINITIALIZED 0
@@ -6380,7 +6419,10 @@ typedef struct J9JavaVM {
 #if defined(J9VM_OPT_CRIU_SUPPORT)
 #define J9_OBJECT_MONITOR_CRIU_SINGLE_THREAD_MODE_THROW 2
 #endif /* defined(J9VM_OPT_CRIU_SUPPORT) */
-#define J9_OBJECT_MONITOR_BLOCKING 3
+#if JAVA_SPEC_VERSION >= 24
+#define J9_OBJECT_MONITOR_YIELD_VIRTUAL 3
+#endif /* JAVA_SPEC_VERSION >= 24 */
+#define J9_OBJECT_MONITOR_BLOCKING 4
 
 #if (JAVA_SPEC_VERSION >= 16) || defined(J9VM_OPT_CRIU_SUPPORT)
 #define J9_OBJECT_MONITOR_ENTER_FAILED(rc) ((UDATA)(rc) < J9_OBJECT_MONITOR_BLOCKING)

runtime/oti/jvminit.h

@@ -471,6 +471,12 @@ enum INIT_STAGE {
 #define VMOPT_XXNOSHOWUNMOUNTEDTHREADSTACKS "-XX:-ShowUnmountedThreadStacks"
 #endif /* JAVA_SPEC_VERSION >= 21 */
 
+#if JAVA_SPEC_VERSION >= 24
+/* Option to toggle on/off the feature to yield pinned virtual threads. */
+#define VMOPT_XXYIELDPINNEDVIRTUALTHREADS "-XX:+YieldPinnedVirtualThreads"
+#define VMOPT_XXNOYIELDPINNEDVIRTUALTHREADS "-XX:-YieldPinnedVirtualThreads"
+#endif /* JAVA_SPEC_VERSION >= 24 */
+
 /* Option to turn on exception on synchronization on instances of value-based classes */
 #define VMOPT_XXDIAGNOSE_SYNC_ON_VALUEBASED_CLASSES_EQUALS1 "-XX:DiagnoseSyncOnValueBasedClasses=1"
 /* Option to turn on warning on synchronization on instances of value-based classes */

runtime/oti/vm_api.h

@@ -2451,6 +2451,26 @@ monitorTableAt(J9VMThread* vmStruct, j9object_t object);
 void
 cacheObjectMonitorForLookup(J9JavaVM* vm, J9VMThread* vmStruct, J9ObjectMonitor* objectMonitor);
 
+/* ---------------- thrinfo.c ---------------- */
+
+/**
+ * @brief Search the monitor tables in vm->monitorTable for the inflated monitor corresponding to an
+ * object. Similar to monitorTableAt(), but doesn't add the monitor if it isn't found in the hashtable.
+ *
+ * This function may block on vm->monitorTableMutex.
+ * This function can work out-of-process.
+ *
+ * @param[in] vm the JavaVM. For out-of-process: may be a local or target pointer.
+ * vm->monitorTable must be a target value.
+ * @param[in] object the object. For out-of-process: a target pointer.
+ *
+ * @return a J9ObjectMonitor from the monitor hashtable or a NULL if there is no corresponding monitor
+ * in vm->monitorTable.
+ *
+ * @see monitorTablePeekMonitor in util_internal.h
+ */
+J9ObjectMonitor *
+monitorTablePeek(J9JavaVM *vm, j9object_t object);
 
 /* ---------------- PackageIDHashTable.c ---------------- */
 
@@ -4579,12 +4599,13 @@ enterContinuation(struct J9VMThread *currentThread, j9object_t continuationObjec
 /**
  * @brief Suspends the Continuation runnable.
  *
- * @param currentThread
+ * @param currentThread the thread whose Continuation is being yielded
  * @param isFinished true if it is last unmount
+ * @param returnState thread execution state when it is re-mounted
  * @return BOOLEAN
  */
 BOOLEAN
-yieldContinuation(struct J9VMThread *currentThread, BOOLEAN isFinished);
+yieldContinuation(struct J9VMThread *currentThread, BOOLEAN isFinished, UDATA returnState);
 
 /**
  * @brief Free the native memory allocated by Continuation.
@@ -4669,6 +4690,41 @@ void
 releaseVThreadInspector(J9VMThread *currentThread, jobject thread);
 #endif /* JAVA_SPEC_VERSION >= 19 */
 
+#if JAVA_SPEC_VERSION >= 24
+/**
+ * @brief Attach all yielded VirtualThread monitors to carrier thread.
+ *
+ * @param currentThread the current thread
+ * @param continuationObject the Continuation object
+ */
+void
+preparePinnedVirtualThreadForMount(J9VMThread *currentThread, j9object_t continuationObject);
+
+/**
+ * @brief Inflate all monitors and prepare the VirtualThread to yield.
+ *
+ * @param currentThread the current thread
+ * @param syncObj object to block/wait on
+ * @param isObjectWait if the call is from Object.wait()
+ *
+ * @return J9_OBJECT_MONITOR_YIELD_VIRTUAL if the can be successfully yielded;
+ * otherwise, an error code is returned
+ */
+UDATA
+preparePinnedVirtualThreadForUnmount(J9VMThread *currentThread, j9object_t syncObj, BOOLEAN isObjectWait);
+
+/**
+ * @brief Find a list of virtual thread to be unblocked. This is a helper method for
+ * JVM_TakeVirtualThreadListToUnblock (see javanextvmi.cpp).
+ *
+ * @param currentThread the current thread
+ * @param vm pointer to J9JavaVM
+ *
+ * @return a list of virtual threads to be unblocked
+ */
+jobject
+takeVirtualThreadListToUnblock(J9VMThread *currentThread, J9JavaVM *vm);
+#endif /* JAVA_SPEC_VERSION >= 24 */
 /* ---------------- hookableAsync.c ---------------- */
 
 /**

runtime/oti/vmconstantpool.xml

@@ -265,6 +265,11 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-ex
 	<fieldref class="java/lang/VirtualThread" name="carrierThread" signature="Ljava/lang/Thread;" versions="19-"/>
 	<fieldref class="java/lang/VirtualThread" name="cont" signature="Ljdk/internal/vm/Continuation;" versions="19-"/>
 
+	<!-- Field references for Synchronize Virtual Threads without Pinning (JEP491). -->
+	<fieldref class="java/lang/VirtualThread" name="blockPermit" signature="Z" versions="24-"/>
+	<fieldref class="java/lang/VirtualThread" name="next" signature="Ljava/lang/VirtualThread;" versions="24-"/>
+	<fieldref class="java/lang/VirtualThread" name="onWaitingList" signature="Z" versions="24-"/>
+
 	<fieldref class="java/lang/Throwable" name="cause" signature="Ljava/lang/Throwable;"/>
 	<fieldref class="java/lang/Throwable" name="detailMessage" signature="Ljava/lang/String;"/>
 	<fieldref class="java/lang/Throwable" name="walkback" signature="Ljava/lang/Object;"/>
@@ -426,6 +431,9 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-ex
 	<fieldref class="jdk/internal/vm/Continuation" name="vthread" signature="Ljava/lang/Thread;" versions="19-"/>
 	<fieldref class="jdk/internal/vm/Continuation" name="scopedValueCache" signature="[Ljava/lang/Object;" versions="19-"/>
 
+	<!-- Field references for Synchronize Virtual Threads without Pinning (JEP491). -->
+	<fieldref class="jdk/internal/vm/Continuation" name="blocker" signature="Ljava/lang/Object;" versions="24-"/>
+
 	<!-- Field references needed to support Foreign Linker API. -->
 	<fieldref class="java/lang/invoke/NativeMethodHandle" name="invokeCache" signature="[Ljava/lang/Object;" flags="opt_openjdkFfi" versions="22-"/>
 	<fieldref class="java/lang/invoke/NativeMethodHandle" name="nep" signature="Ljava/lang/invoke/MethodHandle;" flags="opt_openjdkFfi" versions="22-"/>

runtime/util/util_internal.h

@@ -198,24 +198,6 @@ char *node_key(node *aNode);
 J9ThreadAbstractMonitor *
 monitorTablePeekMonitor(J9JavaVM *vm, j9object_t object);
 
-/**
- * Search the monitor tables in vm->monitorTableList for the inflated monitor corresponding to an object.
- * Similar to monitorTableAt(), but doesn't add the monitor if it isn't found in the hashtable.
- *
- * This function may block on vm->monitorTableMutex.
- * This function can work out-of-process.
- *
- * @param[in] vm the JavaVM. For out-of-process: may be a local or target pointer.
- * vm->monitorTable must be a target value.
- * @param[in] object the object. For out-of-process: a target pointer.
- * @returns a J9ObjectMonitor from the monitor hashtable
- * @retval NULL There is no corresponding monitor in vm->monitorTable.
- *
- * @see monitorTablePeekMonitor
- */
-J9ObjectMonitor *
-monitorTablePeek(J9JavaVM *vm, j9object_t object);
-
 #ifdef __cplusplus
 }
 #endif