Merge pull request #19229 from fengxue-IS/0.44-19076

(0.44) Refactor virtual thread inspector access

Author: pshipton

runtime/j9vm/javanextvmi.cpp

@@ -274,21 +274,56 @@ enterVThreadTransitionCritical(J9VMThread *currentThread, jobject thread)
 	MM_ObjectAccessBarrierAPI objectAccessBarrier = MM_ObjectAccessBarrierAPI(currentThread);
 	j9object_t threadObj = J9_JNI_UNWRAP_REFERENCE(thread);
 
-	while(!objectAccessBarrier.inlineMixedObjectCompareAndSwapU64(currentThread, threadObj, vm->virtualThreadInspectorCountOffset, 0, (U_64)-1)) {
+retry:
+	while (!objectAccessBarrier.inlineMixedObjectCompareAndSwapU64(currentThread, threadObj, vm->virtualThreadInspectorCountOffset, 0, ~(U_64)0)) {
 		/* Thread is being inspected or unmounted, wait. */
 		vmFuncs->internalReleaseVMAccess(currentThread);
 		VM_AtomicSupport::yieldCPU();
 		/* After wait, the thread may suspend here. */
 		vmFuncs->internalAcquireVMAccess(currentThread);
 		threadObj = J9_JNI_UNWRAP_REFERENCE(thread);
 	}
+
+	/* Link the current J9VMThread with the virtual thread object. */
+	if (!objectAccessBarrier.inlineMixedObjectCompareAndSwapU64(currentThread, threadObj, vm->internalSuspendStateOffset, J9_VIRTUALTHREAD_INTERNAL_STATE_NONE, (U_64)currentThread)) {
+		/* If virtual thread is suspended while unmounted, reset the inspectorCount and do a wait and retry. */
+		if (VM_VMHelpers::isThreadSuspended(currentThread, threadObj)) {
+			J9OBJECT_I64_STORE(currentThread, threadObj, vm->virtualThreadInspectorCountOffset, 0);
+		}
+		vmFuncs->internalReleaseVMAccess(currentThread);
+		/* Spin is used instead of the halt flag as we cannot guarantee suspend flag is still set now.
+		 *
+		 * TODO: Dynamically increase the sleep time to a bounded maximum.
+		 */
+		f_threadSleep(10);
+		/* After wait, the thread may suspend here. */
+		vmFuncs->internalAcquireVMAccess(currentThread);
+		threadObj = J9_JNI_UNWRAP_REFERENCE(thread);
+		goto retry;
+	}
 }
 
 static void
-exitVThreadTransitionCritical(J9VMThread *currentThread, j9object_t vthread)
+exitVThreadTransitionCritical(J9VMThread *currentThread, jobject thread)
 {
-	Assert_SC_true(-1 == J9OBJECT_I64_LOAD(currentThread, vthread, currentThread->javaVM->virtualThreadInspectorCountOffset));
-	J9OBJECT_I64_STORE(currentThread, vthread, currentThread->javaVM->virtualThreadInspectorCountOffset, 0);
+	J9JavaVM *vm = currentThread->javaVM;
+	J9InternalVMFunctions *vmFuncs = vm->internalVMFunctions;
+	j9object_t vthread = J9_JNI_UNWRAP_REFERENCE(thread);
+	MM_ObjectAccessBarrierAPI objectAccessBarrier = MM_ObjectAccessBarrierAPI(currentThread);
+
+	/* Remove J9VMThread address from internalSuspendedState field, as the thread state is no longer in a transition. */
+	while (!objectAccessBarrier.inlineMixedObjectCompareAndSwapU64(currentThread, vthread, vm->internalSuspendStateOffset, (U_64)currentThread, J9_VIRTUALTHREAD_INTERNAL_STATE_NONE)) {
+		/* Wait if the suspend flag is set. */
+		vmFuncs->internalReleaseVMAccess(currentThread);
+		VM_AtomicSupport::yieldCPU();
+		/* After wait, the thread may suspend here. */
+		vmFuncs->internalAcquireVMAccess(currentThread);
+		vthread = J9_JNI_UNWRAP_REFERENCE(thread);
+	}
+
+	/* Update to virtualThreadInspectorCount must be after clearing isSuspendedInternal field to retain sync ordering. */
+	Assert_SC_true(-1 == J9OBJECT_I64_LOAD(currentThread, vthread, vm->virtualThreadInspectorCountOffset));
+	J9OBJECT_I64_STORE(currentThread, vthread, vm->virtualThreadInspectorCountOffset, 0);
 }
 
 static void
@@ -301,7 +336,7 @@ setContinuationStateToLastUnmount(J9VMThread *currentThread, jobject thread)
 	ContinuationState volatile *continuationStatePtr = VM_ContinuationHelpers::getContinuationStateAddress(currentThread, continuationObj);
 	/* Used in JVMTI to not suspend the virtual thread once it enters the last unmount phase. */
 	VM_ContinuationHelpers::setLastUnmount(continuationStatePtr);
-	exitVThreadTransitionCritical(currentThread, threadObj);
+	exitVThreadTransitionCritical(currentThread, thread);
 }
 
 /* Caller must have VMAccess. */
@@ -329,27 +364,6 @@ virtualThreadMountBegin(JNIEnv *env, jobject thread)
 
 	enterVThreadTransitionCritical(currentThread, thread);
 
-	/* Virtual thread is being mounted but it has been suspended. Spin until the
-	 * virtual thread is resumed. The virtual thread should not be mounted until
-	 * it is resumed.
-	 */
-	J9JavaVM *vm = currentThread->javaVM;
-	J9InternalVMFunctions *vmFuncs = vm->internalVMFunctions;
-	threadObj = J9_JNI_UNWRAP_REFERENCE(thread);
-	while (0 != J9OBJECT_U32_LOAD(currentThread, threadObj, vm->isSuspendedInternalOffset)) {
-		exitVThreadTransitionCritical(currentThread, threadObj);
-		vmFuncs->internalReleaseVMAccess(currentThread);
-		/* Spin is used instead of the halt flag; otherwise, the carrier thread will
-		 * show as suspended.
-		 *
-		 * TODO: Dynamically increase the sleep time to a bounded maximum.
-		 */
-		f_threadSleep(10);
-		vmFuncs->internalAcquireVMAccess(currentThread);
-		enterVThreadTransitionCritical(currentThread, thread);
-		threadObj = J9_JNI_UNWRAP_REFERENCE(thread);
-	}
-
 	VM_VMHelpers::virtualThreadHideFrames(currentThread, JNI_TRUE);
 }
 
@@ -378,7 +392,7 @@ virtualThreadMountEnd(JNIEnv *env, jobject thread)
 	VM_VMHelpers::virtualThreadHideFrames(currentThread, JNI_FALSE);
 
 	/* Allow thread to be inspected again. */
-	exitVThreadTransitionCritical(currentThread, threadObj);
+	exitVThreadTransitionCritical(currentThread, thread);
 
 	TRIGGER_J9HOOK_VM_VIRTUAL_THREAD_MOUNT(vm->hookInterface, currentThread);
 }
@@ -412,13 +426,12 @@ virtualThreadUnmountBegin(JNIEnv *env, jobject thread)
 
 	J9InternalVMFunctions *vmFuncs = vm->internalVMFunctions;
 	j9object_t carrierThreadObject = currentThread->carrierThreadObject;
-	threadObj = J9_JNI_UNWRAP_REFERENCE(thread);
 	/* Virtual thread is being umounted. If its carrier thread is suspended, spin until
 	 * the carrier thread is resumed. The carrier thread should not be mounted until it
 	 * is resumed.
 	 */
-	while (0 != J9OBJECT_U32_LOAD(currentThread, carrierThreadObject, vm->isSuspendedInternalOffset)) {
-		exitVThreadTransitionCritical(currentThread, threadObj);
+	while (VM_VMHelpers::isThreadSuspended(currentThread, carrierThreadObject)) {
+		exitVThreadTransitionCritical(currentThread, thread);
 		vmFuncs->internalReleaseVMAccess(currentThread);
 		/* Spin is used instead of the halt flag; otherwise, the virtual thread will
 		 * show as suspended.
@@ -429,7 +442,6 @@ virtualThreadUnmountBegin(JNIEnv *env, jobject thread)
 		vmFuncs->internalAcquireVMAccess(currentThread);
 		enterVThreadTransitionCritical(currentThread, thread);
 		carrierThreadObject = currentThread->carrierThreadObject;
-		threadObj = J9_JNI_UNWRAP_REFERENCE(thread);
 	}
 
 	VM_VMHelpers::virtualThreadHideFrames(currentThread, JNI_TRUE);
@@ -467,7 +479,7 @@ virtualThreadUnmountEnd(JNIEnv *env, jobject thread)
 	VM_VMHelpers::virtualThreadHideFrames(currentThread, JNI_FALSE);
 
 	/* Allow thread to be inspected again. */
-	exitVThreadTransitionCritical(currentThread, threadObj);
+	exitVThreadTransitionCritical(currentThread, thread);
 }
 #endif /* JAVA_SPEC_VERSION >= 19 */
 
@@ -609,7 +621,7 @@ JVM_VirtualThreadHideFrames(
 
 	if (!hide) {
 		Assert_SC_true(hiddenFrames);
-		exitVThreadTransitionCritical(currentThread, vThreadObj);
+		exitVThreadTransitionCritical(currentThread, (jobject)&currentThread->threadObject);
 	}
 
 	vmFuncs->internalExitVMToJNI(currentThread);

runtime/jcl/common/jclcinit.c

@@ -655,8 +655,8 @@ initializeRequiredClasses(J9VMThread *vmThread, char* dllName)
 		return 1;
 	}
 
-	/* Stores a non-zero value if the virtual or carrier thread is suspended by JVMTI. */
-	if (0 != vmFuncs->addHiddenInstanceField(vm, "java/lang/Thread", "isSuspendedInternal", "I", &vm->isSuspendedInternalOffset)) {
+	/* Stores the carrier J9VMThread if thread is in transition, and bit flags for suspend state in the last 8 bits. */
+	if (0 != vmFuncs->addHiddenInstanceField(vm, "java/lang/Thread", "internalSuspendState", "J", &vm->internalSuspendStateOffset)) {
 		return 1;
 	}
 #endif /* JAVA_SPEC_VERSION >= 19 */

runtime/jcl/common/thread.cpp

@@ -213,7 +213,7 @@ Java_java_lang_Thread_resumeImpl(JNIEnv *env, jobject rcv)
 				vmFuncs->clearHaltFlag(targetThread, J9_PUBLIC_FLAGS_HALT_THREAD_JAVA_SUSPEND);
 			}
 #if JAVA_SPEC_VERSION >= 19
-			J9OBJECT_U32_STORE(currentThread, receiverObject, vm->isSuspendedInternalOffset, 0);
+			J9OBJECT_U64_STORE(currentThread, receiverObject, vm->internalSuspendStateOffset, J9_VIRTUALTHREAD_INTERNAL_STATE_NONE);
 #endif /* JAVA_SPEC_VERSION >= 19 */
 		}
 	}
@@ -234,7 +234,7 @@ Java_java_lang_Thread_suspendImpl(JNIEnv *env, jobject rcv)
 	if (J9VMJAVALANGTHREAD_STARTED(currentThread, receiverObject)) {
 		if (NULL != targetThread) {
 #if JAVA_SPEC_VERSION >= 19
-			J9OBJECT_U32_STORE(currentThread, receiverObject, vm->isSuspendedInternalOffset, 1);
+			J9OBJECT_U64_STORE(currentThread, receiverObject, vm->internalSuspendStateOffset, J9_VIRTUALTHREAD_INTERNAL_STATE_SUSPENDED);
 			if (receiverObject == targetThread->threadObject)
 #endif /* JAVA_SPEC_VERSION >= 19 */
 			{

runtime/jvmti/CMakeLists.txt

@@ -32,21 +32,21 @@ j9vm_add_library(j9jvmti SHARED
 	jvmtiEventManagement.c
 	jvmtiExtensionMechanism.c
 	jvmtiField.c
-	jvmtiForceEarlyReturn.c
+	jvmtiForceEarlyReturn.cpp
 	jvmtiFunctionTable.c
 	jvmtiGeneral.c
 	jvmtiHeap.c
 	jvmtiHeap10.c
 	jvmtiHelpers.cpp
 	jvmtiHook.c
 	jvmtiJNIFunctionInterception.c
-	jvmtiLocalVariable.c
+	jvmtiLocalVariable.cpp
 	jvmtiMemory.c
 	jvmtiMethod.c
 	jvmtiModules.c
 	jvmtiObject.c
 	jvmtiRawMonitor.c
-	jvmtiStackFrame.c
+	jvmtiStackFrame.cpp
 	jvmtiStartup.c
 	jvmtiSystemProperties.c
 	jvmtiThread.cpp

runtime/jvmti/jvmtiForceEarlyReturn.c renamed to runtime/jvmti/jvmtiForceEarlyReturn.cpp

@@ -23,6 +23,12 @@
 #include "jvmtiHelpers.h"
 #include "jvmti_internal.h"
 
+#if JAVA_SPEC_VERSION >= 19
+#include "VMHelpers.hpp"
+#endif /* JAVA_SPEC_VERSION >= 19 */
+
+extern "C" {
+
 static jvmtiError JNICALL jvmtiForceEarlyReturn(jvmtiEnv* env, jthread thread, jvmtiParamTypes returnValueType, void *value);
 
 jvmtiError JNICALL
@@ -163,7 +169,7 @@ jvmtiForceEarlyReturn(jvmtiEnv* env,
 
 			if ((currentThread != targetThread)
 #if JAVA_SPEC_VERSION >= 21
-			&& (0 == J9OBJECT_U32_LOAD(currentThread, threadObject, vm->isSuspendedInternalOffset))
+			&& (!VM_VMHelpers::isThreadSuspended(currentThread, threadObject))
 #else /* JAVA_SPEC_VERSION >= 21 */
 			&& OMR_ARE_NO_BITS_SET(targetThread->publicFlags, J9_PUBLIC_FLAGS_HALT_THREAD_JAVA_SUSPEND)
 #endif /* JAVA_SPEC_VERSION >= 21 */
@@ -182,23 +188,23 @@ jvmtiForceEarlyReturn(jvmtiEnv* env,
 					threadToWalk = &stackThread;
 				}
 #endif /* JAVA_SPEC_VERSION >= 21 */
-				rc = findDecompileInfo(currentThread, threadToWalk, 0, &walkState);
-  				if (JVMTI_ERROR_NONE == rc) {
-  					J9Method *method = walkState.userData3;
-  					J9ROMMethod *romMethod = J9_ROM_METHOD_FROM_RAM_METHOD(method);
-  					if (romMethod->modifiers & J9AccNative) {
-  						rc = JVMTI_ERROR_OPAQUE_FRAME;
-  					} else {
-  						J9UTF8 *sig = J9ROMMETHOD_SIGNATURE(romMethod);
-  						U_8 *data = J9UTF8_DATA(sig);
-  						U_16 length = J9UTF8_LENGTH(sig);
-  						char signatureType = data[length - 1];
-  						jvmtiParamTypes methodReturnType = JVMTI_TYPE_CVOID;
-
-  						if (('[' == data[length - 2]) || (';' == signatureType)) {
-  							signatureType = 'L';
-  						}
-  						switch(signatureType) {
+				rc = (jvmtiError)(IDATA)findDecompileInfo(currentThread, threadToWalk, 0, &walkState);
+				if (JVMTI_ERROR_NONE == rc) {
+					J9Method *method = (J9Method *)walkState.userData3;
+					J9ROMMethod *romMethod = J9_ROM_METHOD_FROM_RAM_METHOD(method);
+					if (J9_ARE_ANY_BITS_SET(romMethod->modifiers, J9AccNative)) {
+						rc = JVMTI_ERROR_OPAQUE_FRAME;
+					} else {
+						J9UTF8 *sig = J9ROMMETHOD_SIGNATURE(romMethod);
+						U_8 *data = J9UTF8_DATA(sig);
+						U_16 length = J9UTF8_LENGTH(sig);
+						char signatureType = data[length - 1];
+						jvmtiParamTypes methodReturnType = JVMTI_TYPE_CVOID;
+
+						if (('[' == data[length - 2]) || (';' == signatureType)) {
+							signatureType = 'L';
+						}
+						switch(signatureType) {
 						case 'I':
 						case 'B':
 						case 'C':
@@ -265,3 +271,5 @@ jvmtiForceEarlyReturn(jvmtiEnv* env,
 
 	return rc;
 }
+
+} /* extern "C" */

runtime/jvmti/jvmtiHelpers.cpp

@@ -27,6 +27,7 @@
 #if JAVA_SPEC_VERSION >= 19
 #include "HeapIteratorAPI.h"
 #include "ContinuationHelpers.hpp"
+#include "VMHelpers.hpp"
 #endif /* JAVA_SPEC_VERSION >= 19 */
 
 extern "C" {
@@ -168,6 +169,13 @@ getVMThread(J9VMThread *currentThread, jthread thread, J9VMThread **vmThreadPtr,
 		if (NULL != carrierThread) {
 			targetThread = J9VMJAVALANGTHREAD_THREADREF(currentThread, carrierThread);
 		}
+		if (J9OBJECT_I64_LOAD(currentThread, threadObject, vm->virtualThreadInspectorCountOffset) < -1) {
+			/* If the virtual thread is suspended in transition, check if the mounting process is already completed. */
+			J9VMThread *carrierVMThread = VM_VMHelpers::getCarrierVMThread(currentThread, threadObject);
+			if (NULL != carrierVMThread->currentContinuation) {
+				targetThread = carrierVMThread;
+			}
+		}
 		isThreadAlive = (JVMTI_VTHREAD_STATE_NEW != vthreadState) && (JVMTI_VTHREAD_STATE_TERMINATED != vthreadState);
 	} else
 #endif /* JAVA_SPEC_VERSION >= 19 */
@@ -740,10 +748,10 @@ getThreadStateHelper(J9VMThread *currentThread, j9object_t threadObject, J9VMThr
 			state |= JVMTI_THREAD_STATE_SUSPENDED;
 		}
 #if JAVA_SPEC_VERSION >= 19
-		/* Based on the isSuspendedInternal field, set the JVMTI
+		/* Based on the internalSuspendState field, set the JVMTI
 		 * thread state to suspended for the corresponding thread.
 		 */
-		if (0 != J9OBJECT_U32_LOAD(currentThread, threadObject, currentThread->javaVM->isSuspendedInternalOffset)) {
+		if (VM_VMHelpers::isThreadSuspended(currentThread, threadObject)) {
 			state |= JVMTI_THREAD_STATE_SUSPENDED;
 		} else {
 			state &= ~JVMTI_THREAD_STATE_SUSPENDED;
@@ -884,9 +892,9 @@ getVirtualThreadState(J9VMThread *currentThread, jthread thread)
 				rc = JVMTI_ERROR_INTERNAL;
 			}
 		}
-		/* Re-fetch object to correctly set the isSuspendedInternal field. */
+		/* Re-fetch object to correctly set the internalSuspendState field. */
 		vThreadObject = J9_JNI_UNWRAP_REFERENCE(thread);
-		if (0 != J9OBJECT_U32_LOAD(currentThread, vThreadObject, vm->isSuspendedInternalOffset)) {
+		if (VM_VMHelpers::isThreadSuspended(currentThread, vThreadObject)) {
 			rc |= JVMTI_THREAD_STATE_SUSPENDED;
 		} else {
 			rc &= ~JVMTI_THREAD_STATE_SUSPENDED;

runtime/jvmti/jvmtiLocalVariable.c renamed to runtime/jvmti/jvmtiLocalVariable.cpp

@@ -24,6 +24,12 @@
 #include "jvmti_internal.h"
 #include "objhelp.h"
 
+#if JAVA_SPEC_VERSION >= 19
+#include "VMHelpers.hpp"
+#endif /* JAVA_SPEC_VERSION >= 19 */
+
+extern "C" {
+
 static jvmtiError jvmtiGetOrSetLocal (jvmtiEnv* env, jthread thread, jint depth, jint slot, void* value_ptr, char signature, jboolean isSet, jboolean getLocalInstance);
 
 
@@ -327,7 +333,7 @@ jvmtiGetOrSetLocal(jvmtiEnv *env,
 
 #if JAVA_SPEC_VERSION >= 20
 			if ((currentThread != targetThread)
-			&& (0 == J9OBJECT_U32_LOAD(currentThread, threadObject, vm->isSuspendedInternalOffset))
+			&& (!VM_VMHelpers::isThreadSuspended(currentThread, threadObject))
 			) {
 				rc = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
 				goto release;
@@ -350,12 +356,12 @@ jvmtiGetOrSetLocal(jvmtiEnv *env,
 			}
 #endif /* JAVA_SPEC_VERSION < 20 */
 
-			rc = findDecompileInfo(currentThread, threadToWalk, (UDATA)depth, &walkState);
+			rc = (jvmtiError)(IDATA)findDecompileInfo(currentThread, threadToWalk, (UDATA)depth, &walkState);
 			if (JVMTI_ERROR_NONE == rc) {
 				UDATA validateRC = 0;
 				BOOLEAN slotValid = TRUE;
 				UDATA *slotAddress = NULL;
-				J9Method *ramMethod = walkState.userData3;
+				J9Method *ramMethod = (J9Method *)walkState.userData3;
 				U_32 offsetPC = (U_32)(UDATA)walkState.userData4;
 				J9ROMMethod *romMethod = J9_ROM_METHOD_FROM_RAM_METHOD(ramMethod);
 
@@ -484,3 +490,5 @@ jvmtiGetOrSetLocal(jvmtiEnv *env,
 }
 
 #endif /* J9VM_OPT_DEBUG_INFO_SERVER */
+
+} /* extern "C" */