Merge pull request #22404 from fengxue-IS/054-22068

(v0.54.0) Add -XX:[+|-]UnblockerTimedWait option

Author: tajila

runtime/oti/ContinuationHelpers.hpp

@@ -25,6 +25,9 @@
 #include "j9.h"
 #include "j9consts.h"
 #include "j9vmconstantpool.h"
+#if JAVA_SPEC_VERSION >= 24
+#include "thrtypes.h"
+#endif /* JAVA_SPEC_VERSION >= 24 */
 #include "VMHelpers.hpp"
 
 /* These should match the error code values in enum Pinned within class Continuation. */
@@ -462,6 +465,33 @@ class VM_ContinuationHelpers {
 		/* Virtual can only be in one list at a time. */
 		return !(foundInBlockedContinuationList && foundInMonitorList);
 	}
+
+	static VMINLINE bool
+	isBlockingMonitorUnowned(J9VMThread *currentThread, j9object_t vThreadObject)
+	{
+		bool result = false;
+		j9object_t continuationObject = J9VMJAVALANGVIRTUALTHREAD_CONT(currentThread, vThreadObject);
+		j9object_t blockingObject = J9VMJDKINTERNALVMCONTINUATION_BLOCKER(currentThread, continuationObject);
+
+		/* blockingObject must be non-null. */
+		if (NULL != blockingObject) {
+			j9objectmonitor_t *lockEA = VM_ObjectMonitor::inlineGetLockAddress(currentThread, blockingObject);
+			if (NULL != lockEA) {
+				j9objectmonitor_t lock = J9_LOAD_LOCKWORD(currentThread, lockEA);
+
+				if (J9_LOCK_IS_INFLATED(lock)) {
+					omrthread_monitor_t monitor = J9_INFLLOCK_MONITOR(lock);
+					if (0 == monitor->count) {
+						result = true;
+					}
+				} else if (!J9_LOCK_IS_FLATLOCKED(lock)) {
+					result = true;
+				}
+			}
+		}
+
+		return result;
+	}
 #endif /* JAVA_SPEC_VERSION >= 24 */
 };
 

runtime/oti/j9nonbuilder.h

@@ -6526,6 +6526,7 @@ typedef struct J9JavaVM {
 	J9VMContinuation *blockedContinuations;
 	omrthread_monitor_t blockedVirtualThreadsMutex;
 	BOOLEAN pendingBlockedVirtualThreadsNotify;
+	I_64 unblockerWaitTime;
 #endif /* JAVA_SPEC_VERSION >= 24 */
 } J9JavaVM;
 

runtime/oti/jvminit.h

@@ -476,6 +476,9 @@ enum INIT_STAGE {
 /* Option to toggle on/off the feature to yield pinned virtual threads. */
 #define VMOPT_XXYIELDPINNEDVIRTUALTHREADS "-XX:+YieldPinnedVirtualThreads"
 #define VMOPT_XXNOYIELDPINNEDVIRTUALTHREADS "-XX:-YieldPinnedVirtualThreads"
+
+/* Option to set timed wait on unblocker thread. */
+#define VMOPT_XXUNBLOCKERTHREADWAITTIME_EQUALS "-XX:UnblockerThreadWaitTime="
 #endif /* JAVA_SPEC_VERSION >= 24 */
 
 /* Option to turn on exception on synchronization on instances of value-based classes */

runtime/vm/ContinuationHelpers.cpp

@@ -24,9 +24,6 @@
 #include "j9protos.h"
 #include "j9vmnls.h"
 #include "objhelp.h"
-#if JAVA_SPEC_VERSION >= 24
-#include "thrtypes.h"
-#endif /* JAVA_SPEC_VERSION >= 24 */
 #include "ut_j9vm.h"
 #include "vm_api.h"
 #include "AtomicSupport.hpp"
@@ -1191,7 +1188,7 @@ waitForSignal(J9VMThread *currentThread)
 	 */
 	omrthread_monitor_enter(vm->blockedVirtualThreadsMutex);
 	if (!vm->pendingBlockedVirtualThreadsNotify) {
-		omrthread_monitor_wait_interruptable(vm->blockedVirtualThreadsMutex, 0, 0);
+		omrthread_monitor_wait_interruptable(vm->blockedVirtualThreadsMutex, vm->unblockerWaitTime, 0);
 	}
 	vm->pendingBlockedVirtualThreadsNotify = FALSE;
 	omrthread_monitor_exit(vm->blockedVirtualThreadsMutex);
@@ -1245,18 +1242,18 @@ takeVirtualThreadListToUnblock(J9VMThread *currentThread)
 				switch (state) {
 				case JAVA_LANG_VIRTUALTHREAD_BLOCKING:
 				{
-					omrthread_monitor_t monitor = syncObjectMonitor->monitor;
-					/* For BLOCKING and BLOCKED states, VirtualThread.blockPermit will allow
+					/* For BLOCKING state, VirtualThread.blockPermit will allow
 					 * VirtualThread.afterYield() to reschedule the thread.
 					 *
 					 * Set blockPermit only if the monitor's blocker object is available.
 					 *
-					 * All blocking/waiting monitors have to be inflated. If the monitor has not been inflated,
+					 * All blocking monitors have to be inflated. If the monitor has not been inflated,
 					 * then the owner has not yet released the flat lock.
+					 *
+					 * There is a special case where the FLC bit maybe overwritten by fast exit code,
+					 * so also unblock thread if the blocking object has a unowned flatlock.
 					 */
-					if (J9_ARE_ANY_BITS_SET(((J9ThreadMonitor *)monitor)->flags, J9THREAD_MONITOR_INFLATED)
-						&& (0 == monitor->count)
-					) {
+					if (VM_ContinuationHelpers::isBlockingMonitorUnowned(currentThread, current->vthread)) {
 						J9VMJAVALANGVIRTUALTHREAD_SET_BLOCKPERMIT(currentThread, current->vthread, JNI_TRUE);
 					}
 					previous = current;
@@ -1284,9 +1281,9 @@ takeVirtualThreadListToUnblock(J9VMThread *currentThread)
 					) {
 						Assert_VM_true(syncObjectMonitor->virtualThreadWaitCount > 0);
 						omrthread_monitor_t monitor = syncObjectMonitor->monitor;
-						/* All blocking/waiting monitors have to be inflated. If the monitor has not been inflated,
-						* then the owner has not yet released the flat lock.
-						*/
+						/* All waiting monitors have to be inflated. If the monitor has not been inflated,
+						 * then wait call have not been done correctly.
+						 */
 						if (J9_ARE_ANY_BITS_SET(((J9ThreadMonitor *)monitor)->flags, J9THREAD_MONITOR_INFLATED)
 							&& (0 == monitor->count)
 						) {
@@ -1299,18 +1296,16 @@ takeVirtualThreadListToUnblock(J9VMThread *currentThread)
 				case JAVA_LANG_VIRTUALTHREAD_BLOCKED:
 				{
 					Assert_VM_true(syncObjectMonitor->virtualThreadWaitCount > 0);
-					omrthread_monitor_t monitor = syncObjectMonitor->monitor;
-					/* For BLOCKING and BLOCKED states, VirtualThread.blockPermit will allow
-					 * VirtualThread.afterYield() to reschedule the thread.
+					/* For BLOCKED state, set VirtualThread.onWaitingList and
+					 * add vthread to the unblock list so unblocker can reschedule.
 					 *
-					 * Set blockPermit only if the monitor's blocker object is available.
-					 *
-					 * All blocking/waiting monitors have to be inflated. If the monitor has not been inflated,
+					 * All blocked monitors have to be inflated. If the monitor has not been inflated,
 					 * then the owner has not yet released the flat lock.
+					 *
+					 * There is a special case where the FLC bit maybe overwritten by fast exit code,
+					 * so also unblock thread if the blocking object has a unowned flatlock.
 					 */
-					if (J9_ARE_ANY_BITS_SET(((J9ThreadMonitor *)monitor)->flags, J9THREAD_MONITOR_INFLATED)
-						&& (0 == monitor->count)
-					) {
+					if (VM_ContinuationHelpers::isBlockingMonitorUnowned(currentThread, current->vthread)) {
 						unblocked = true;
 						syncObjectMonitor->virtualThreadWaitCount -= 1;
 						J9VMJAVALANGVIRTUALTHREAD_SET_ONWAITINGLIST(currentThread, current->vthread, JNI_TRUE);

runtime/vm/jvminit.c

@@ -4379,6 +4379,26 @@ processVMArgsFromFirstToLast(J9JavaVM * vm)
 			vm->extendedRuntimeFlags3 &= ~J9_EXTENDED_RUNTIME3_YIELD_PINNED_CONTINUATION;
 		}
 	}
+	{
+		IDATA argIndex = FIND_AND_CONSUME_VMARG(STARTSWITH_MATCH, VMOPT_XXUNBLOCKERTHREADWAITTIME_EQUALS, NULL);
+		if (argIndex >= 0) {
+			UDATA value = 0;
+			char *optname = VMOPT_XXUNBLOCKERTHREADWAITTIME_EQUALS;
+
+			IDATA parseError = GET_INTEGER_VALUE(argIndex, optname, value);
+			if (OPTION_OK != parseError) {
+				PORT_ACCESS_FROM_JAVAVM(vm);
+				j9nls_printf(PORTLIB, J9NLS_ERROR, J9NLS_VM_INVALID_CMD_LINE_OPT, VMOPT_XXUNBLOCKERTHREADWAITTIME_EQUALS);
+				return JNI_ERR;
+			}
+
+			vm->unblockerWaitTime = value;
+		} else {
+#define DEFAULT_UNBLOCKER_WAIT_TIME 64
+			/* Enable timed wait on unblocker thread by default to 64ms. */
+			vm->unblockerWaitTime = DEFAULT_UNBLOCKER_WAIT_TIME;
+		}
+	}
 #endif /* JAVA_SPEC_VERSION >= 24 */
 
 	{