Merge pull request #22355 from tajila/vt4

(0.54) Add notify to carrier thread wait path

Author: pshipton

runtime/oti/monhelp.h

@@ -48,6 +48,9 @@
 
 #define J9_INFLLOCK_ABSTRACT_MONITOR(lockWord) ((J9ThreadAbstractMonitor*)J9_INFLLOCK_MONITOR(lockWord))
 
-#define J9_LOCK_IS_FLATLOCKED(lockWord) (!J9_LOCK_IS_INFLATED(lockWord) && (J9_FLATLOCK_OWNER(lockWord) != NULL))
+#define J9_LOCK_IS_FLATLOCKED(lockWord) \
+		(!J9_LOCK_IS_INFLATED(lockWord) \
+				&& (NULL != J9_FLATLOCK_OWNER(lockWord)) \
+				&& (J9_FLATLOCK_COUNT(lockWord) > 0))
 
 #endif /*J9_MONHELP_H_*/

runtime/vm/BytecodeInterpreter.hpp

@@ -1581,6 +1581,8 @@ class INTERPRETER_CLASS
 				VM_ContinuationHelpers::sendUnblockerThreadSignal(_vm);
 			}
 			omrthread_monitor_exit(_vm->blockedVirtualThreadsMutex);
+		} else if ((JAVA_LANG_VIRTUALTHREAD_WAITING == newThreadState) || (JAVA_LANG_VIRTUALTHREAD_TIMED_WAITING == newThreadState)) {
+			VM_ContinuationHelpers::sendUnblockerThreadSignal(_vm);
 		}
 
 		/* Enter critical transition after the prepare stage is complete and hooks dispatched. */

runtime/vm/ContinuationHelpers.cpp

@@ -944,6 +944,7 @@ preparePinnedVirtualThreadForUnmount(J9VMThread *currentThread, j9object_t syncO
 	UDATA monitorCount = 0;
 	J9JavaVM *vm = currentThread->javaVM;
 	J9VMContinuation *continuation = currentThread->currentContinuation;
+	IDATA monitorResult = 0;
 
 	if (NULL != syncObj) {
 		j9objectmonitor_t volatile *lwEA = VM_ObjectMonitor::inlineGetLockAddress(currentThread, syncObj);
@@ -1009,7 +1010,8 @@ preparePinnedVirtualThreadForUnmount(J9VMThread *currentThread, j9object_t syncO
 #if defined(J9VM_THR_LOCK_RESERVATION)
 						if (J9_ARE_ANY_BITS_SET(lock, OBJECT_HEADER_LOCK_RESERVED)) {
 							/* Lock is now reserved, exit the inflated monitor and restart to cancel lock reservation. */
-							omrthread_monitor_exit(monitor);
+							monitorResult = omrthread_monitor_exit(monitor);
+							Assert_VM_true(0 == monitorResult);
 							goto restart;
 						}
 #endif /* J9VM_THR_LOCK_RESERVATION */
@@ -1020,6 +1022,8 @@ preparePinnedVirtualThreadForUnmount(J9VMThread *currentThread, j9object_t syncO
 							newLockword = (UDATA)J9_FLATLOCK_OWNER(lock)
 										| ((J9_FLATLOCK_COUNT(lock) - 1) << OBJECT_HEADER_LOCK_V2_RECURSION_OFFSET)
 										| OBJECT_HEADER_LOCK_FLC;
+
+							Assert_VM_true(J9_FLATLOCK_COUNT(lock) == J9_FLATLOCK_COUNT(newLockword));
 						} else {
 							/* Lock is unlocked, so try to directly acquire it as a flatlock. */
 							newLockword = (UDATA)currentThread;
@@ -1033,7 +1037,8 @@ preparePinnedVirtualThreadForUnmount(J9VMThread *currentThread, j9object_t syncO
 							/* CAS succeeded, we can proceed with using the inflated monitor. */
 							VM_ObjectMonitor::incrementCancelCounter(J9OBJECT_CLAZZ(currentThread, syncObj));
 							/* Either the lock is acquired or FLC bit set, safe to release the inflated monitor. */
-							omrthread_monitor_exit(monitor);
+							monitorResult = omrthread_monitor_exit(monitor);
+							Assert_VM_true(0 == monitorResult);
 
 							if (J9_FLATLOCK_OWNER(newLockword) == currentThread) {
 								/* Lock is acquired. */
@@ -1132,7 +1137,8 @@ preparePinnedVirtualThreadForUnmount(J9VMThread *currentThread, j9object_t syncO
 			syncObjectMonitor->waitingContinuations = continuation;
 			omrthread_monitor_exit(vm->blockedVirtualThreadsMutex);
 
-			omrthread_monitor_exit(monitor);
+			monitorResult = omrthread_monitor_exit(monitor);
+			Assert_VM_true(0 == monitorResult);
 		} else {
 			if (NULL != monitor) {
 				/* If we are blocking to wait on a contended monitor then we can't be the owner. */

runtime/vm/montable.c

@@ -146,7 +146,7 @@ initializeMonitorTable(J9JavaVM* vm)
 		return -1;
 	}
 	memset(vm->monitorTables, 0, sizeof(J9HashTable *) * tableCount);
-	
+
 	vm->monitorTableList = NULL;
 
 	for (tableIndex = 0; tableIndex < tableCount; tableIndex++) {
@@ -170,7 +170,7 @@ initializeMonitorTable(J9JavaVM* vm)
 	}
 
 	vm->monitorTableCount = tableCount;
-	
+
 	return 0;
 }
 
@@ -299,20 +299,20 @@ monitorTableAt(J9VMThread* vmStruct, j9object_t object)
 					((J9ThreadAbstractMonitor *)monitor)->spinCount1 = j9threadOptions->customThreeTierSpinCount1;
 					((J9ThreadAbstractMonitor *)monitor)->spinCount2 = j9threadOptions->customThreeTierSpinCount2;
 					((J9ThreadAbstractMonitor *)monitor)->spinCount3 = j9threadOptions->customThreeTierSpinCount3;
-			
+
 					Trc_VM_MonitorTableAt_CustomSpinOption(option->className,
 														   object,
 													   	   ((J9ThreadAbstractMonitor *)monitor)->spinCount1,
 													   	   ((J9ThreadAbstractMonitor *)monitor)->spinCount2,
 													       ((J9ThreadAbstractMonitor *)monitor)->spinCount3);
 #endif /* OMR_THR_THREE_TIER_LOCKING */
-#if defined(OMR_THR_ADAPTIVE_SPIN)													  
+#if defined(OMR_THR_ADAPTIVE_SPIN)
 					Trc_VM_MonitorTableAt_CustomSpinOption2(option->className,
-														    object,													       
+														    object,
 														    j9threadOptions->customAdaptSpin);
-#endif /* OMR_THR_ADAPTIVE_SPIN */							
+#endif /* OMR_THR_ADAPTIVE_SPIN */
 				}
-#endif /* OMR_THR_CUSTOM_SPIN_OPTIONS */				
+#endif /* OMR_THR_CUSTOM_SPIN_OPTIONS */
 #endif /* J9VM_INTERP_CUSTOM_SPIN_OPTIONS */
 
 				key_objectMonitor.monitor = monitor;
@@ -324,6 +324,7 @@ monitorTableAt(J9VMThread* vmStruct, j9object_t object)
 
 #if JAVA_SPEC_VERSION >= 24
 				key_objectMonitor.virtualThreadWaitCount = 0;
+				key_objectMonitor.platformThreadWaitCount = 0;
 				key_objectMonitor.ownerContinuation = NULL;
 				key_objectMonitor.waitingContinuations = NULL;
 				key_objectMonitor.next = NULL;

runtime/vm/threadhelp.cpp

@@ -96,6 +96,7 @@ monitorWaitImpl(J9VMThread *vmThread, j9object_t object, I_64 millis, I_32 nanos
 #if JAVA_SPEC_VERSION >= 24
 		j9objectmonitor_t volatile *lwEA = VM_ObjectMonitor::inlineGetLockAddress(vmThread, object);
 		j9objectmonitor_t lock = J9_LOAD_LOCKWORD(vmThread, lwEA);
+		Assert_VM_true(J9_LOCK_IS_INFLATED(lock));
 		J9ObjectMonitor *objectMonitor = J9_INFLLOCK_OBJECT_MONITOR(lock);
 		VM_AtomicSupport::addU32(&objectMonitor->platformThreadWaitCount, 1);
 #endif /* JAVA_SPEC_VERSION >= 24 */
@@ -112,6 +113,9 @@ monitorWaitImpl(J9VMThread *vmThread, j9object_t object, I_64 millis, I_32 nanos
 #endif
 		J9VMTHREAD_SET_BLOCKINGENTEROBJECT(vmThread, vmThread, object);
 		object = NULL;
+#if JAVA_SPEC_VERSION >= 24
+		J9VM_SEND_VIRTUAL_UNBLOCKER_THREAD_SIGNAL(javaVM);
+#endif /* JAVA_SPEC_VERSION >= 24 */
 		internalReleaseVMAccessSetStatus(vmThread, thrstate);
 		rc = timeCompensationHelper(vmThread,
 			interruptable ? HELPER_TYPE_MONITOR_WAIT_INTERRUPTABLE : HELPER_TYPE_MONITOR_WAIT_TIMED, monitor, millis, nanos);