Fix missing concurrent continuation scanning issue

LinHu2016 · LinHu2016 · commit 13ebc10cda94 · 2023-02-03T13:48:20.000-05:00
The issue is caused by concurrent scavenger scanning and concurrent
marking scanning overlap for the same continuation Object, during
concurrent continuation scanning, the current synchronization control
would block the continuation mounting and ignore another concurrent
scanning, but the concurrent scavenger scanning and concurrent marking
are irrelevant, ignore another could cause missing scanning and the
related "live" object is recycled.

- updated J9VMContinuation-&gt;state, use two low bits for recording
 concurrentScanning(bit0 for concurrentScanningLocal and bit1 for
 concurrentScanningGlobal) instead of only one low bit.

- pass flag isConcurrentGC and flag isGlobalGC for
GC_VMThreadStackSlotIterator::scanSlots().

- handle J9_GC_CONTINUATION_STATE_CONCURRENT_SCAN_LOCAL and
J9_GC_CONTINUATION_STATE_CONCURRENT_SCAN_GLOBAL independently

- only both J9_GC_CONTINUATION_STATE_CONCURRENT_SCAN_LOCAL and
J9_GC_CONTINUATION_STATE_CONCURRENT_SCAN_GLOBAL bits has been cleared
we can notify blocked the continuation mounting thread.

Signed-off-by: Lin Hu &lt;linhu@ca.ibm.com&gt;
diff --git a/runtime/gc_base/GCExtensions.cpp b/runtime/gc_base/GCExtensions.cpp
@@ -320,7 +320,7 @@ MM_GCExtensions::releaseNativesForContinuationObject(MM_EnvironmentBase* env, j9
 }
 
 bool
-MM_GCExtensions::needScanStacksForContinuationObject(J9VMThread *vmThread, j9object_t objectPtr)
+MM_GCExtensions::needScanStacksForContinuationObject(J9VMThread *vmThread, j9object_t objectPtr, bool isGlobalGC)
 {
 	bool needScan = false;
 #if JAVA_SPEC_VERSION >= 19
@@ -335,12 +335,14 @@ MM_GCExtensions::needScanStacksForContinuationObject(J9VMThread *vmThread, j9obj
 	 *
 	 * For fully STW GCs, there is no harm to scan them, but it's a waste of time since they are scanned during root scanning already.
 	 *
-	 * We don't scan currently scanned either - one scan is enough.
+	 * We don't scan currently scanned for the same collector either - one scan is enough for the same collector, but there could be concurrent scavenger(local collector) and concurrent marking(global collector) overlapping,
+	 * they are irrelevant and both are concurrent, we handle them independently and separately, they are not blocked or ignored each other.
+	 *
 	 * we don't scan the continuation object before started and after finished - java stack does not exist.
 	 */
 	if (started && !finished) {
 		Assert_MM_true(NULL != continuation);
-		needScan = !VM_VMHelpers::isContinuationMountedOrConcurrentlyScanned(continuation);
+		needScan = !VM_VMHelpers::isContinuationMountedOrConcurrentlyScanned(continuation, isGlobalGC);
 	}
 #endif /* JAVA_SPEC_VERSION >= 19 */
 	return needScan;
diff --git a/runtime/gc_base/GCExtensions.hpp b/runtime/gc_base/GCExtensions.hpp
@@ -303,11 +303,13 @@ class MM_GCExtensions : public MM_GCExtensionsBase {
 	 * Check if we need to scan the java stack for the Continuation Object
 	 * Used during main scan phase of GC (object graph traversal) or heap object iteration (in sliding compact).
 	 * Not meant to be used during root scanning (neither strong roots nor weak roots)!
+	 *
 	 * @param[in] vmThread the current J9VMThread
 	 * @param[in] continuationObject the continuation object
+	 * @param[in] isGlobalGC
 	 * @return true if we need to scan the java stack
 	 */
-	static bool needScanStacksForContinuationObject(J9VMThread *vmThread, j9object_t objectPtr);
+	static bool needScanStacksForContinuationObject(J9VMThread *vmThread, j9object_t objectPtr, bool isGlobalGC);
 
 	/**
 	 * Create a GCExtensions object
diff --git a/runtime/gc_glue_java/CompactSchemeFixupObject.cpp b/runtime/gc_glue_java/CompactSchemeFixupObject.cpp
@@ -75,13 +75,15 @@ MM_CompactSchemeFixupObject::fixupContinuationNativeSlots(MM_EnvironmentStandard
 	 * mounted Virtual threads later during root fixup, we will skip it during this heap fixup pass
 	 * (hence passing true for scanOnlyUnmounted parameter).
 	 */
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = true;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4CompactSchemeFixupObject localData;
 		localData.compactSchemeFixupObject = this;
 		localData.env = env;
 		localData.fromObject = objectPtr;
+		const bool isConcurrentGC = false;
 
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForCompactScheme, false, false);
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForCompactScheme, false, false, isConcurrentGC, isGlobalGC);
 	}
 }
 
diff --git a/runtime/gc_glue_java/HeapWalkerDelegate.cpp b/runtime/gc_glue_java/HeapWalkerDelegate.cpp
@@ -60,14 +60,17 @@ MM_HeapWalkerDelegate::doContinuationNativeSlots(MM_EnvironmentBase *env, omrobj
 {
 	J9VMThread *currentThread = (J9VMThread *)env->getLanguageVMThread();
 
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = true;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4HeapWalker localData;
 		localData.heapWalker = _heapWalker;
 		localData.env = env;
 		localData.fromObject = objectPtr;
 		localData.function = function;
 		localData.userData = userData;
 		/* so far there is no case we need ClassWalk for heapwalker, so we set stackFrameClassWalkNeeded = false */
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForHeapWalker, false, false);
+		const bool isConcurrentGC = false;
+
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForHeapWalker, false, false, isConcurrentGC, isGlobalGC);
 	}
 }
diff --git a/runtime/gc_glue_java/MarkingDelegate.cpp b/runtime/gc_glue_java/MarkingDelegate.cpp
@@ -261,7 +261,8 @@ void
 MM_MarkingDelegate::scanContinuationNativeSlots(MM_EnvironmentBase *env, omrobjectptr_t objectPtr)
 {
 	J9VMThread *currentThread = (J9VMThread *)env->getLanguageVMThread();
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = true;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4MarkingDelegate localData;
 		localData.markingDelegate = this;
 		localData.env = env;
@@ -271,10 +272,10 @@ MM_MarkingDelegate::scanContinuationNativeSlots(MM_EnvironmentBase *env, omrobje
 #if defined(J9VM_GC_DYNAMIC_CLASS_UNLOADING)
 		stackFrameClassWalkNeeded = isDynamicClassUnloadingEnabled();
 #endif /* J9VM_GC_DYNAMIC_CLASS_UNLOADING */
-
 		/* In STW GC there are no racing carrier threads doing mount and no need for the synchronization. */
-		bool syncWithContinuationMounting = J9_ARE_ANY_BITS_SET(currentThread->privateFlags, J9_PRIVATE_FLAGS_CONCURRENT_MARK_ACTIVE);
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForMarkingDelegate, stackFrameClassWalkNeeded, false, syncWithContinuationMounting);
+		bool isConcurrentGC = J9_ARE_ANY_BITS_SET(currentThread->privateFlags, J9_PRIVATE_FLAGS_CONCURRENT_MARK_ACTIVE);
+
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForMarkingDelegate, stackFrameClassWalkNeeded, false, isConcurrentGC, isGlobalGC);
 	}
 }
 
diff --git a/runtime/gc_glue_java/MetronomeDelegate.cpp b/runtime/gc_glue_java/MetronomeDelegate.cpp
@@ -1647,7 +1647,8 @@ void
 MM_MetronomeDelegate::scanContinuationNativeSlots(MM_EnvironmentRealtime *env, J9Object *objectPtr)
 {
 	J9VMThread *currentThread = (J9VMThread *)env->getLanguageVMThread();
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = true;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4RealtimeMarkingScheme localData;
 		localData.realtimeMarkingScheme = _markingScheme;
 		localData.env = env;
@@ -1657,11 +1658,10 @@ MM_MetronomeDelegate::scanContinuationNativeSlots(MM_EnvironmentRealtime *env, J
 #if defined(J9VM_GC_DYNAMIC_CLASS_UNLOADING)
 		stackFrameClassWalkNeeded = isDynamicClassUnloadingEnabled();
 #endif /* J9VM_GC_DYNAMIC_CLASS_UNLOADING */
-
 		/* In STW GC there are no racing carrier threads doing mount and no need for the synchronization. */
-		bool syncWithContinuationMounting = _realtimeGC->isCollectorConcurrentTracing();
+		bool isConcurrentGC = _realtimeGC->isCollectorConcurrentTracing();
 
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForRealtimeGC, stackFrameClassWalkNeeded, false, syncWithContinuationMounting);
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForRealtimeGC, stackFrameClassWalkNeeded, false, isConcurrentGC, isGlobalGC);
 	}
 }
 
diff --git a/runtime/gc_glue_java/ScavengerDelegate.cpp b/runtime/gc_glue_java/ScavengerDelegate.cpp
@@ -345,16 +345,17 @@ MM_ScavengerDelegate::scanContinuationNativeSlots(MM_EnvironmentStandard *env, o
 	bool shouldRemember = false;
 
 	J9VMThread *currentThread = (J9VMThread *)env->getLanguageVMThread();
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = false;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4Scavenge localData;
 		localData.scavengerDelegate = this;
 		localData.env = env;
 		localData.reason = reason;
 		localData.shouldRemember = &shouldRemember;
 		/* In STW GC there are no racing carrier threads doing mount and no need for the synchronization. */
-		bool  syncWithContinuationMounting = _extensions->isConcurrentScavengerInProgress();
+		bool isConcurrentGC = _extensions->isConcurrentScavengerInProgress();
 
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForScavenge, false, false, syncWithContinuationMounting);
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForScavenge, false, false, isConcurrentGC, isGlobalGC);
 	}
 	return 	shouldRemember;
 }
diff --git a/runtime/gc_structs/VMThreadStackSlotIterator.cpp b/runtime/gc_structs/VMThreadStackSlotIterator.cpp
@@ -1,6 +1,6 @@
 
 /*******************************************************************************
- * Copyright (c) 1991, 2022 IBM Corp. and others
+ * Copyright (c) 1991, 2023 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -137,13 +137,14 @@ GC_VMThreadStackSlotIterator::scanSlots(
 			J9MODRON_OSLOTITERATOR *oSlotIterator,
 			bool includeStackFrameClassReferences,
 			bool trackVisibleFrameDepth,
-			bool syncWithContinuationMounting
+			bool isConcurrentGC,
+			bool isGlobalGC
 		)
 {
 	J9StackWalkState stackWalkState;
 
 	initializeStackWalkState(&stackWalkState, vmThread, userData, oSlotIterator, includeStackFrameClassReferences, trackVisibleFrameDepth);
-	VM_VMHelpers::walkContinuationStackFramesWrapper(vmThread, continuationObjectPtr, &stackWalkState, syncWithContinuationMounting);
+	VM_VMHelpers::walkContinuationStackFramesWrapper(vmThread, continuationObjectPtr, &stackWalkState, isConcurrentGC, isGlobalGC);
 }
 
 #if JAVA_SPEC_VERSION >= 19
diff --git a/runtime/gc_structs/VMThreadStackSlotIterator.hpp b/runtime/gc_structs/VMThreadStackSlotIterator.hpp
@@ -1,6 +1,6 @@
 
 /*******************************************************************************
- * Copyright (c) 1991, 2022 IBM Corp. and others
+ * Copyright (c) 1991, 2023 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -67,7 +67,8 @@ class GC_VMThreadStackSlotIterator
 			J9MODRON_OSLOTITERATOR *oSlotIterator,
 			bool includeStackFrameClassReferences,
 			bool trackVisibleFrameDepth,
-			bool syncWithContinuationMounting = false);
+			bool isConcurrentGC,
+			bool isGlobalGC);
 
 #if JAVA_SPEC_VERSION >= 19
 	static void scanSlots(
diff --git a/runtime/gc_vlhgc/CopyForwardScheme.cpp b/runtime/gc_vlhgc/CopyForwardScheme.cpp
@@ -2322,7 +2322,8 @@ MMINLINE void
 MM_CopyForwardScheme::scanContinuationNativeSlots(MM_EnvironmentVLHGC *env, MM_AllocationContextTarok *reservingContext, J9Object *objectPtr, ScanReason reason)
 {
 	J9VMThread *currentThread = (J9VMThread *)env->getLanguageVMThread();
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = false;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4CopyForward localData;
 		localData.copyForwardScheme = this;
 		localData.env = env;
@@ -2332,7 +2333,9 @@ MM_CopyForwardScheme::scanContinuationNativeSlots(MM_EnvironmentVLHGC *env, MM_A
 #if defined(J9VM_GC_DYNAMIC_CLASS_UNLOADING)
 		stackFrameClassWalkNeeded = isDynamicClassUnloadingEnabled();
 #endif /* J9VM_GC_DYNAMIC_CLASS_UNLOADING */
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForCopyForwardScheme, stackFrameClassWalkNeeded, false);
+		const bool isConcurrentGC = false;
+
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForCopyForwardScheme, stackFrameClassWalkNeeded, false, isConcurrentGC, isGlobalGC);
 	}
 }
 
diff --git a/runtime/gc_vlhgc/GlobalMarkCardScrubber.cpp b/runtime/gc_vlhgc/GlobalMarkCardScrubber.cpp
@@ -192,14 +192,16 @@ bool MM_GlobalMarkCardScrubber::scrubContinuationNativeSlots(MM_EnvironmentVLHGC
 {
 	bool doScrub = true;
 	J9VMThread *currentThread = (J9VMThread *)env->getLanguageVMThread();
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = true;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4GlobalMarkCardScrubber localData;
 		localData.globalMarkCardScrubber = this;
 		localData.env = env;
 		localData.doScrub = &doScrub;
 		localData.fromObject = objectPtr;
+		const bool isConcurrentGC = false;
 
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForGlobalMarkCardScrubber, false, false);
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForGlobalMarkCardScrubber, false, false, isConcurrentGC, isGlobalGC);
 	}
 	return doScrub;
 }
diff --git a/runtime/gc_vlhgc/GlobalMarkingScheme.cpp b/runtime/gc_vlhgc/GlobalMarkingScheme.cpp
@@ -792,7 +792,8 @@ void
 MM_GlobalMarkingScheme::scanContinuationNativeSlots(MM_EnvironmentVLHGC *env, J9Object *objectPtr, ScanReason reason)
 {
 	J9VMThread *currentThread = (J9VMThread *)env->getLanguageVMThread();
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = true;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4GlobalMarkingScheme localData;
 		localData.globalMarkingScheme = this;
 		localData.env = env;
@@ -801,11 +802,10 @@ MM_GlobalMarkingScheme::scanContinuationNativeSlots(MM_EnvironmentVLHGC *env, J9
 #if defined(J9VM_GC_DYNAMIC_CLASS_UNLOADING)
 		stackFrameClassWalkNeeded = isDynamicClassUnloadingEnabled();
 #endif /* J9VM_GC_DYNAMIC_CLASS_UNLOADING */
-
 		/* In STW GC there are no racing carrier threads doing mount and no need for the synchronization. */
-		bool syncWithContinuationMounting = (MM_VLHGCIncrementStats::mark_concurrent == static_cast<MM_CycleStateVLHGC*>(env->_cycleState)->_vlhgcIncrementStats._globalMarkIncrementType);
+		bool isConcurrentGC = (MM_VLHGCIncrementStats::mark_concurrent == static_cast<MM_CycleStateVLHGC*>(env->_cycleState)->_vlhgcIncrementStats._globalMarkIncrementType);
 
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForGlobalMarkingScheme, stackFrameClassWalkNeeded, false, syncWithContinuationMounting);
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForGlobalMarkingScheme, stackFrameClassWalkNeeded, false, isConcurrentGC, isGlobalGC);
 	}
 }
 
diff --git a/runtime/gc_vlhgc/WriteOnceCompactor.cpp b/runtime/gc_vlhgc/WriteOnceCompactor.cpp
@@ -1240,13 +1240,15 @@ MM_WriteOnceCompactor::fixupContinuationNativeSlots(MM_EnvironmentVLHGC* env, J9
 	 * mounted Virtual threads later during root fixup, we will skip it during this heap fixup pass
 	 * (hence passing true for scanOnlyUnmounted parameter).
 	 */
-	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {
+	const bool isGlobalGC = MM_CycleState::CT_GLOBAL_GARBAGE_COLLECTION == env->_cycleState->_collectionType;
+	if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {
 		StackIteratorData4WriteOnceCompactor localData;
 		localData.writeOnceCompactor = this;
 		localData.env = env;
 		localData.fromObject = objectPtr;
+		const bool isConcurrentGC = false;
 
-		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForWriteOnceCompactor, false, false);
+		GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForWriteOnceCompactor, false, false, isConcurrentGC, isGlobalGC);
 	}
 }
 
diff --git a/runtime/oti/VMHelpers.hpp b/runtime/oti/VMHelpers.hpp
diff --git a/runtime/oti/j9consts.h b/runtime/oti/j9consts.h
diff --git a/runtime/oti/j9nonbuilder.h b/runtime/oti/j9nonbuilder.h
diff --git a/runtime/vm/ContinuationHelpers.cpp b/runtime/vm/ContinuationHelpers.cpp

Original file line number	Diff line number	Diff line change
`@@ -320,7 +320,7 @@ MM_GCExtensions::releaseNativesForContinuationObject(MM_EnvironmentBase* env, j9`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`bool`
`323`		`-MM_GCExtensions::needScanStacksForContinuationObject(J9VMThread *vmThread, j9object_t objectPtr)`
	`323`	`+MM_GCExtensions::needScanStacksForContinuationObject(J9VMThread *vmThread, j9object_t objectPtr, bool isGlobalGC)`
`324`	`324`	`{`
`325`	`325`	`bool needScan = false;`
`326`	`326`	`#if JAVA_SPEC_VERSION >= 19`
`@@ -335,12 +335,14 @@ MM_GCExtensions::needScanStacksForContinuationObject(J9VMThread *vmThread, j9obj`
`335`	`335`	`*`
`336`	`336`	`* For fully STW GCs, there is no harm to scan them, but it's a waste of time since they are scanned during root scanning already.`
`337`	`337`	`*`
`338`		`- * We don't scan currently scanned either - one scan is enough.`
	`338`	`+ * We don't scan currently scanned for the same collector either - one scan is enough for the same collector, but there could be concurrent scavenger(local collector) and concurrent marking(global collector) overlapping,`
	`339`	`+ * they are irrelevant and both are concurrent, we handle them independently and separately, they are not blocked or ignored each other.`
	`340`	`+ *`
`339`	`341`	`* we don't scan the continuation object before started and after finished - java stack does not exist.`
`340`	`342`	`*/`
`341`	`343`	`if (started && !finished) {`
`342`	`344`	`Assert_MM_true(NULL != continuation);`
`343`		`- needScan = !VM_VMHelpers::isContinuationMountedOrConcurrentlyScanned(continuation);`
	`345`	`+ needScan = !VM_VMHelpers::isContinuationMountedOrConcurrentlyScanned(continuation, isGlobalGC);`
`344`	`346`	`}`
`345`	`347`	`#endif /* JAVA_SPEC_VERSION >= 19 */`
`346`	`348`	`return needScan;`
Original file line number	Diff line number	Diff line change
`@@ -60,14 +60,17 @@ MM_HeapWalkerDelegate::doContinuationNativeSlots(MM_EnvironmentBase *env, omrobj`
`60`	`60`	`{`
`61`	`61`	`J9VMThread currentThread = (J9VMThread )env->getLanguageVMThread();`
`62`	`62`
`63`		`- if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {`
	`63`	`+ const bool isGlobalGC = true;`
	`64`	`+ if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {`
`64`	`65`	`StackIteratorData4HeapWalker localData;`
`65`	`66`	`localData.heapWalker = _heapWalker;`
`66`	`67`	`localData.env = env;`
`67`	`68`	`localData.fromObject = objectPtr;`
`68`	`69`	`localData.function = function;`
`69`	`70`	`localData.userData = userData;`
`70`	`71`	`/* so far there is no case we need ClassWalk for heapwalker, so we set stackFrameClassWalkNeeded = false */`
`71`		`- GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForHeapWalker, false, false);`
	`72`	`+ const bool isConcurrentGC = false;`
	`73`	`+`
	`74`	`+ GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForHeapWalker, false, false, isConcurrentGC, isGlobalGC);`
`72`	`75`	`}`
`73`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`
`2`	`2`	`/*******************************************************************************`
`3`		`- * Copyright (c) 1991, 2022 IBM Corp. and others`
	`3`	`+ * Copyright (c) 1991, 2023 IBM Corp. and others`
`4`	`4`	`*`
`5`	`5`	`* This program and the accompanying materials are made available under`
`6`	`6`	`* the terms of the Eclipse Public License 2.0 which accompanies this`
`@@ -137,13 +137,14 @@ GC_VMThreadStackSlotIterator::scanSlots(`
`137`	`137`	`J9MODRON_OSLOTITERATOR *oSlotIterator,`
`138`	`138`	`bool includeStackFrameClassReferences,`
`139`	`139`	`bool trackVisibleFrameDepth,`
`140`		`- bool syncWithContinuationMounting`
	`140`	`+ bool isConcurrentGC,`
	`141`	`+ bool isGlobalGC`
`141`	`142`	`)`
`142`	`143`	`{`
`143`	`144`	`J9StackWalkState stackWalkState;`
`144`	`145`
`145`	`146`	`initializeStackWalkState(&stackWalkState, vmThread, userData, oSlotIterator, includeStackFrameClassReferences, trackVisibleFrameDepth);`
`146`		`- VM_VMHelpers::walkContinuationStackFramesWrapper(vmThread, continuationObjectPtr, &stackWalkState, syncWithContinuationMounting);`
	`147`	`+ VM_VMHelpers::walkContinuationStackFramesWrapper(vmThread, continuationObjectPtr, &stackWalkState, isConcurrentGC, isGlobalGC);`
`147`	`148`	`}`
`148`	`149`
`149`	`150`	`#if JAVA_SPEC_VERSION >= 19`
Original file line number	Diff line number	Diff line change
`@@ -2322,7 +2322,8 @@ MMINLINE void`
`2322`	`2322`	`MM_CopyForwardScheme::scanContinuationNativeSlots(MM_EnvironmentVLHGC env, MM_AllocationContextTarok reservingContext, J9Object *objectPtr, ScanReason reason)`
`2323`	`2323`	`{`
`2324`	`2324`	`J9VMThread currentThread = (J9VMThread )env->getLanguageVMThread();`
`2325`		`- if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {`
	`2325`	`+ const bool isGlobalGC = false;`
	`2326`	`+ if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {`
`2326`	`2327`	`StackIteratorData4CopyForward localData;`
`2327`	`2328`	`localData.copyForwardScheme = this;`
`2328`	`2329`	`localData.env = env;`
`@@ -2332,7 +2333,9 @@ MM_CopyForwardScheme::scanContinuationNativeSlots(MM_EnvironmentVLHGC *env, MM_A`
`2332`	`2333`	`#if defined(J9VM_GC_DYNAMIC_CLASS_UNLOADING)`
`2333`	`2334`	`stackFrameClassWalkNeeded = isDynamicClassUnloadingEnabled();`
`2334`	`2335`	`#endif /* J9VM_GC_DYNAMIC_CLASS_UNLOADING */`
`2335`		`- GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForCopyForwardScheme, stackFrameClassWalkNeeded, false);`
	`2336`	`+ const bool isConcurrentGC = false;`
	`2337`	`+`
	`2338`	`+ GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForCopyForwardScheme, stackFrameClassWalkNeeded, false, isConcurrentGC, isGlobalGC);`
`2336`	`2339`	`}`
`2337`	`2340`	`}`
`2338`	`2341`
Original file line number	Diff line number	Diff line change
`@@ -192,14 +192,16 @@ bool MM_GlobalMarkCardScrubber::scrubContinuationNativeSlots(MM_EnvironmentVLHGC`
`192`	`192`	`{`
`193`	`193`	`bool doScrub = true;`
`194`	`194`	`J9VMThread currentThread = (J9VMThread )env->getLanguageVMThread();`
`195`		`- if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr)) {`
	`195`	`+ const bool isGlobalGC = true;`
	`196`	`+ if (MM_GCExtensions::needScanStacksForContinuationObject(currentThread, objectPtr, isGlobalGC)) {`
`196`	`197`	`StackIteratorData4GlobalMarkCardScrubber localData;`
`197`	`198`	`localData.globalMarkCardScrubber = this;`
`198`	`199`	`localData.env = env;`
`199`	`200`	`localData.doScrub = &doScrub;`
`200`	`201`	`localData.fromObject = objectPtr;`
	`202`	`+ const bool isConcurrentGC = false;`
`201`	`203`
`202`		`- GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForGlobalMarkCardScrubber, false, false);`
	`204`	`+ GC_VMThreadStackSlotIterator::scanSlots(currentThread, objectPtr, (void *)&localData, stackSlotIteratorForGlobalMarkCardScrubber, false, false, isConcurrentGC, isGlobalGC);`
`203`	`205`	`}`
`204`	`206`	`return doScrub;`
`205`	`207`	`}`