Merge pull request eclipse-openj9#21384 from babsingh/vt

JEP491: Never Deflate Monitors and Synchronize virtualThreadWaitCount

Author: tajila

runtime/vm/ContinuationHelpers.cpp

@@ -1024,7 +1024,7 @@ preparePinnedVirtualThreadForUnmount(J9VMThread *currentThread, j9object_t syncO
 			currentThread->currentContinuation->objectWaitMonitor = syncObjectMonitor;
 			omrthread_monitor_exit(vm->blockedVirtualThreadsMutex);
 		} else {
-			syncObjectMonitor->virtualThreadWaitCount += 1;
+			VM_AtomicSupport::addU32(&syncObjectMonitor->virtualThreadWaitCount, 1);
 		}
 
 		/* Clear the blocking object on the carrier thread. */
@@ -1096,15 +1096,20 @@ takeVirtualThreadListToUnblock(J9VMThread *currentThread)
 						}
 					} else {
 						lock = J9OBJECT_MONITOR(currentThread, syncObject);
-						syncObjectMonitor = J9_INFLLOCK_OBJECT_MONITOR(lock);
+						if (J9_LOCK_IS_INFLATED(lock)) {
+							syncObjectMonitor = J9_INFLLOCK_OBJECT_MONITOR(lock);
+						}
 					}
-					omrthread_monitor_t monitor = syncObjectMonitor->monitor;
-					if (0 == monitor->count) {
-						unblocked = true;
-						if (syncObjectMonitor->virtualThreadWaitCount >= 1) {
-							syncObjectMonitor->virtualThreadWaitCount -= 1;
+					/* Only perform the below operations for inflated monitors. */
+					if (NULL != syncObjectMonitor) {
+						omrthread_monitor_t monitor = syncObjectMonitor->monitor;
+						if (0 == monitor->count) {
+							unblocked = true;
+							if (syncObjectMonitor->virtualThreadWaitCount >= 1) {
+								VM_AtomicSupport::subtractU32(&syncObjectMonitor->virtualThreadWaitCount, 1);
+							}
+							J9VMJAVALANGVIRTUALTHREAD_SET_ONWAITINGLIST(currentThread, current->vthread, JNI_TRUE);
 						}
-						J9VMJAVALANGVIRTUALTHREAD_SET_ONWAITINGLIST(currentThread, current->vthread, JNI_TRUE);
 					}
 				}
 

runtime/vm/monhelpers.c

@@ -178,12 +178,7 @@ objectMonitorExit(J9VMThread* vmStruct, j9object_t object)
 		 *   iff the deflation policy in effect decides it's ok.
 		 */
 		if (monitor->count == 1) {
-			if ((0 == monitor->pinCount)
-#if JAVA_SPEC_VERSION >= 24
-			&& (0 == objectMonitor->virtualThreadWaitCount)
-			&& (NULL == objectMonitor->waitingContinuations)
-#endif /* JAVA_SPEC_VERSION >= 24 */
-			) {
+			if (0 == monitor->pinCount) {
 				if (deflate) {
 					deflate = 0;
 					switch (vmStruct->javaVM->thrDeflationPolicy) {

runtime/vm/vmthread.cpp

@@ -574,7 +574,23 @@ threadParseArguments(J9JavaVM *vm, char *optArg)
 	vm->thrMaxTryEnterYieldsBeforeBlocking = 45;
 	vm->thrNestedSpinning = 1;
 	vm->thrTryEnterNestedSpinning = 1;
-	vm->thrDeflationPolicy = J9VM_DEFLATION_POLICY_ASAP;
+
+#if JAVA_SPEC_VERSION >= 24
+	/* Currently, there are timing holes between JVM_TakeVirtualThreadListToUnblock and monitor deflation.
+	 * A monitor can be deflated while it is being accessed in JVM_TakeVirtualThreadListToUnblock. This
+	 * leads to a NULL dereference causing a segfault. Adding more synchronization will cause a significant
+	 * overhead in the object monitor exit path. Until an efficient solution is developed, the policy to never
+	 * deflate will be employed in order to support Synchronize Virtual Threads without Pinning (JEP491).
+	 * Since the current JEP491 implementation always inflates monitors before usage, deflating will be
+	 * counter-productive.
+	 */
+	if (J9_ARE_ANY_BITS_SET(vm->extendedRuntimeFlags3, J9_EXTENDED_RUNTIME3_YIELD_PINNED_CONTINUATION)) {
+		vm->thrDeflationPolicy = J9VM_DEFLATION_POLICY_NEVER;
+	} else
+#endif /* JAVA_SPEC_VERSION >= 24 */
+	{
+		vm->thrDeflationPolicy = J9VM_DEFLATION_POLICY_ASAP;
+	}
 
 	if (cpus > 1) {
 #if (defined(LINUXPPC)) && !defined(J9VM_ENV_LITTLE_ENDIAN)