version 3

Signed-off-by: lhu <linhu@ca.ibm.com>

runtime/gc_base/ReferenceChainWalker.cpp

@@ -427,7 +427,7 @@ MM_ReferenceChainWalker::scanContinuationNativeSlots(J9Object *objectPtr)
 		GC_ContinuationSlotIterator continuationSlotIterator(currentThread, continuation);
 
 		while (J9Object **slotPtr = continuationSlotIterator.nextSlot()) {
-			doSlot(slotPtr, J9GC_ROOT_TYPE_UNKNOWN, -1, NULL);
+			doContinuationSlot(slotPtr, &continuationSlotIterator);
 		}
 #endif /* JAVA_SPEC_VERSION >= 24 */
 
@@ -664,6 +664,31 @@ MM_ReferenceChainWalker::doVMClassSlot(J9Class *classPtr)
 	doClassSlot(classPtr, J9GC_ROOT_TYPE_VM_CLASS_SLOT, -1, NULL);
 }
 
+#if JAVA_SPEC_VERSION >= 24
+/**
+ * @todo Provide function documentation
+ */
+void
+MM_ReferenceChainWalker::doContinuationSlot(J9Object **slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator)
+{
+	J9Object *slotValue = *slotPtr;
+	/* Only report heap objects */
+	if (isHeapObject(slotValue) && !_heap->objectIsInGap(slotValue)) {
+		switch(continuationSlotIterator->getState()) {
+		case continuationslotiterator_state_monitor_records:
+			doSlot(slotPtr, J9GC_ROOT_TYPE_CONTINUATION_MONITOR, -1, NULL);
+			break;
+		case continuationslotiterator_state_vthread:
+			doSlot(slotPtr, J9GC_ROOT_TYPE_CONTINUATION_SLOT, -1, NULL);
+			break;
+		default:
+			doSlot(slotPtr, J9GC_ROOT_TYPE_UNKNOWN, -1, NULL);
+			break;
+		}
+	}
+}
+#endif /* JAVA_SPEC_VERSION >= 24 */
+
 /**
  * @todo Provide function documentation
  */

runtime/gc_base/ReferenceChainWalker.hpp

@@ -127,6 +127,9 @@ class MM_ReferenceChainWalker : public MM_RootScanner
 	virtual void doStringTableSlot(J9Object **slotPtr, GC_StringTableIterator *stringTableIterator);
 	virtual void doVMClassSlot(J9Class *classPtr);
 	virtual void doVMThreadSlot(J9Object **slotPtr, GC_VMThreadIterator *vmThreadIterator);
+#if JAVA_SPEC_VERSION >= 24
+	virtual void doContinuationSlot(J9Object **slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator);
+#endif /* JAVA_SPEC_VERSION >= 24 */
 	virtual void doStackSlot(J9Object **slotPtr, void *walkState, const void* stackLocation);
 	virtual void doSlot(J9Object **slotPtr);
 	virtual void doClassSlot(J9Class *classPtr);

runtime/gc_base/RootScanner.cpp

@@ -36,9 +36,6 @@
 #include "ClassIterator.hpp"
 #include "ClassHeapIterator.hpp"
 #include "ClassLoaderIterator.hpp"
-#if JAVA_SPEC_VERSION >= 24
-#include "ContinuationSlotIterator.hpp"
-#endif /* JAVA_SPEC_VERSION >= 24 */
 #include "Debug.hpp"
 #include "EnvironmentBase.hpp"
 #if defined(J9VM_GC_FINALIZATION)
@@ -359,6 +356,20 @@ MM_RootScanner::doClassSlot(J9Class *classPtr)
 	/* ignore class slots by default */
 }
 
+#if JAVA_SPEC_VERSION >= 24
+/**
+ * @todo Provide function documentation
+ */
+void
+MM_RootScanner::doContinuationSlot(J9Object **slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator)
+{
+	/* ensure that this isn't a slot pointing into the gap (only matters for split heap VMs) */
+	if (!_extensions->heap->objectIsInGap(*slotPtr)) {
+		doSlot(slotPtr);
+	}
+}
+#endif /* JAVA_SPEC_VERSION >= 24 */
+
 /**
  * @todo Provide function documentation
  */
@@ -560,7 +571,7 @@ MM_RootScanner::scanOneThread(MM_EnvironmentBase *env, J9VMThread *walkThread, v
 
 		while (J9Object **slot = continuationSlotIterator.nextSlot()) {
 			/* do current continuation slot (mounted vthread case, the slot for saved carrier thread) */
-			doVMThreadSlot(slot, &vmThreadIterator);
+			doContinuationSlot(slot, &continuationSlotIterator);
 		}
 #endif /* JAVA_SPEC_VERSION >= 24 */
 	}

runtime/gc_base/RootScanner.hpp

@@ -35,6 +35,9 @@
 
 #include "BaseVirtual.hpp"
 
+#if JAVA_SPEC_VERSION >= 24
+#include "ContinuationSlotIterator.hpp"
+#endif /* JAVA_SPEC_VERSION >= 24 */
 #include "EnvironmentBase.hpp"
 #include "GCExtensions.hpp"
 #include "JVMTIObjectTagTableIterator.hpp"
@@ -605,6 +608,9 @@ class MM_RootScanner : public MM_BaseVirtual
 	virtual void doDoubleMappedObjectSlot(J9Object *objectPtr, struct J9PortVmemIdentifier *identifier);
 #endif /* J9VM_GC_ENABLE_DOUBLE_MAP */
 
+#if JAVA_SPEC_VERSION >= 24
+	virtual void doContinuationSlot(J9Object **slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator);
+#endif /* JAVA_SPEC_VERSION >= 24 */
 	/**
 	 * Called for each object stack slot. Subclasses may override.
 	 * 

runtime/gc_glue_java/CompactSchemeFixupObject.cpp

@@ -53,15 +53,15 @@ MM_CompactSchemeFixupObject::fixupMixedObject(omrobjectptr_t objectPtr)
 }
 
 void
-MM_CompactSchemeFixupObject::doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t fromObject, omrobjectptr_t *slot)
+MM_CompactSchemeFixupObject::doSlot(MM_EnvironmentBase *env, omrobjectptr_t fromObject, omrobjectptr_t *slot)
 {
 	*slot = _compactScheme->getForwardingPtr(*slot);
 }
 
 void
 MM_CompactSchemeFixupObject::doStackSlot(MM_EnvironmentBase *env, omrobjectptr_t fromObject, omrobjectptr_t *slot)
 {
-	doContinuationSlot(env, fromObject, slot);
+	doSlot(env, fromObject, slot);
 }
 /**
  * @todo Provide function documentation
@@ -99,7 +99,7 @@ MM_CompactSchemeFixupObject::fixupContinuationNativeSlots(MM_EnvironmentStandard
 		GC_ContinuationSlotIterator continuationSlotIterator(currentThread, continuation);
 
 		while (J9Object **slotPtr = continuationSlotIterator.nextSlot()) {
-			doContinuationSlot(env, objectPtr, slotPtr);
+			doSlot(env, objectPtr, slotPtr);
 		}
 #endif /* JAVA_SPEC_VERSION >= 24 */
 

runtime/gc_glue_java/CompactSchemeFixupObject.hpp

@@ -38,7 +38,7 @@ class MM_CompactSchemeFixupObject {
 	MM_CompactScheme *_compactScheme;
 public:
 
-	MMINLINE void doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t fromObject, omrobjectptr_t *slot);
+	MMINLINE void doSlot(MM_EnvironmentBase *env, omrobjectptr_t fromObject, omrobjectptr_t *slot);
 	void doStackSlot(MM_EnvironmentBase *env, omrobjectptr_t fromObject, omrobjectptr_t *slot);
 	/**
 	 * Perform fixup for a single object

runtime/gc_glue_java/ConcurrentMarkingDelegate.cpp

@@ -39,12 +39,22 @@
 #include "VMThreadListIterator.hpp"
 
 void
-MM_ConcurrentMarkingDelegate::doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t *slotPtr)
+MM_ConcurrentMarkingDelegate::doSlot(MM_EnvironmentBase *env, omrobjectptr_t *slotPtr)
+{
+	_markingScheme->markObject(env, *slotPtr);
+}
+
+#if JAVA_SPEC_VERSION >= 24
+void
+MM_ConcurrentMarkingDelegate::doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t *slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator)
 {
 	if (_markingScheme->isHeapObject(*slotPtr) && !env->getExtensions()->heap->objectIsInGap(*slotPtr)) {
-		_markingScheme->markObject(env, *slotPtr);
+		doSlot(env, slotPtr);
+	} else if (NULL != *slotPtr) {
+		Assert_MM_true(continuationslotiterator_state_monitor_records == continuationSlotIterator->getState());
 	}
 }
+#endif /* JAVA_SPEC_VERSION >= 24 */
 
 void
 MM_ConcurrentMarkingDelegate::doStackSlot(MM_EnvironmentBase *env, omrobjectptr_t *slotPtr, J9StackWalkState *walkState, const void *stackLocation)
@@ -56,7 +66,7 @@ MM_ConcurrentMarkingDelegate::doStackSlot(MM_EnvironmentBase *env, omrobjectptr_
 	} else if (_markingScheme->isHeapObject(object)) {
 		/* heap object - validate and mark */
 		Assert_MM_validStackSlot(MM_StackSlotValidator(0, object, stackLocation, walkState).validate(env));
-		_markingScheme->markObject(env, object);
+		doSlot(env, slotPtr);
 	} else if (NULL != object) {
 		/* stack object - just validate */
 		Assert_MM_validStackSlot(MM_StackSlotValidator(MM_StackSlotValidator::NOT_ON_HEAP, object, stackLocation, walkState).validate(env));
@@ -177,7 +187,7 @@ MM_ConcurrentMarkingDelegate::scanThreadRoots(MM_EnvironmentBase *env)
 		GC_ContinuationSlotIterator continuationSlotIterator(vmThread, vmThread->currentContinuation);
 
 		while (J9Object **slot = continuationSlotIterator.nextSlot()) {
-			doContinuationSlot(env, slot);
+			doContinuationSlot(env, slot, &continuationSlotIterator);
 		}
 #endif /* JAVA_SPEC_VERSION >= 24 */
 	}

runtime/gc_glue_java/ConcurrentMarkingDelegate.hpp

@@ -46,6 +46,9 @@
 #include "ScanClassesMode.hpp"
 #endif /* J9VM_GC_DYNAMIC_CLASS_UNLOADING */
 
+#if JAVA_SPEC_VERSION >= 24
+class GC_ContinuationSlotIterator;
+#endif /* JAVA_SPEC_VERSION >= 24 */
 class GC_VMThreadIterator;
 class MM_ConcurrentGC;
 class MM_MarkingScheme;
@@ -114,7 +117,10 @@ class MM_ConcurrentMarkingDelegate
 	 */
 	bool initialize(MM_EnvironmentBase *env, MM_ConcurrentGC *collector);
 
-	MMINLINE void doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t *slotPtr);
+	MMINLINE void doSlot(MM_EnvironmentBase *env, omrobjectptr_t *slotPtr);
+#if JAVA_SPEC_VERSION >= 24
+	void doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t *slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator);
+#endif /* JAVA_SPEC_VERSION >= 24 */
 	void doStackSlot(MM_EnvironmentBase *env, omrobjectptr_t *slotPtr, J9StackWalkState *walkState, const void *stackLocation);
 	/**
 	 * In the case of Weak Consistency platforms we require this method to bring mutator threads to a safe point. A safe

runtime/gc_glue_java/MarkingDelegate.cpp

@@ -242,21 +242,32 @@ MM_MarkingDelegate::startRootListProcessing(MM_EnvironmentBase *env)
 }
 
 void
-MM_MarkingDelegate::doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t objectPtr, omrobjectptr_t *slotPtr)
+MM_MarkingDelegate::doSlot(MM_EnvironmentBase *env, omrobjectptr_t objectPtr, omrobjectptr_t *slotPtr)
 {
-	omrobjectptr_t object = *slotPtr;
-	if (_markingScheme->isHeapObject(object) && !_extensions->heap->objectIsInGap(object)) {
-		if (_extensions->isConcurrentScavengerEnabled() && _extensions->isScavengerBackOutFlagRaised()) {
-			_markingScheme->fixupForwardedSlot(slotPtr);
-		}
-		_markingScheme->inlineMarkObject(env, *slotPtr);
+	if (_extensions->isConcurrentScavengerEnabled() && _extensions->isScavengerBackOutFlagRaised()) {
+		_markingScheme->fixupForwardedSlot(slotPtr);
 	}
+	_markingScheme->inlineMarkObject(env, *slotPtr);
 }
 
+#if JAVA_SPEC_VERSION >= 24
+void
+MM_MarkingDelegate::doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t objectPtr, omrobjectptr_t *slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator)
+{
+	if (_markingScheme->isHeapObject(*slotPtr) && !_extensions->heap->objectIsInGap(*slotPtr)) {
+		doSlot(env, objectPtr, slotPtr);
+	} else if (NULL != *slotPtr) {
+		Assert_MM_true(continuationslotiterator_state_monitor_records == continuationSlotIterator->getState());
+	}
+}
+#endif /* JAVA_SPEC_VERSION >= 24 */
+
 void
 MM_MarkingDelegate::doStackSlot(MM_EnvironmentBase *env, omrobjectptr_t objectPtr, omrobjectptr_t *slotPtr)
 {
-	doContinuationSlot(env, objectPtr, slotPtr);
+	if (_markingScheme->isHeapObject(*slotPtr) && !_extensions->heap->objectIsInGap(*slotPtr)) {
+		doSlot(env, objectPtr, slotPtr);
+	}
 }
 
 /**
@@ -296,7 +307,7 @@ MM_MarkingDelegate::scanContinuationNativeSlots(MM_EnvironmentBase *env, omrobje
 		GC_ContinuationSlotIterator continuationSlotIterator(currentThread, continuation);
 
 		while (J9Object **slotPtr = continuationSlotIterator.nextSlot()) {
-			doContinuationSlot(env, objectPtr, slotPtr);
+			doContinuationSlot(env, objectPtr, slotPtr, &continuationSlotIterator);
 		}
 #endif /* JAVA_SPEC_VERSION >= 24 */
 

runtime/gc_glue_java/MarkingDelegate.hpp

@@ -36,6 +36,9 @@
 #include "ReferenceObjectScanner.hpp"
 #include "PointerArrayObjectScanner.hpp"
 
+#if JAVA_SPEC_VERSION >= 24
+class GC_ContinuationSlotIterator;
+#endif /* JAVA_SPEC_VERSION >= 24 */
 class GC_ObjectScanner;
 class MM_EnvironmentBase;
 class MM_HeapRegionDescriptorStandard;
@@ -128,7 +131,10 @@ class MM_MarkingDelegate
 		return 0;
 	}
 
-	MMINLINE void doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t objectPtr, omrobjectptr_t *slotPtr);
+	MMINLINE void doSlot(MM_EnvironmentBase *env, omrobjectptr_t objectPtr, omrobjectptr_t *slotPtr);
+#if JAVA_SPEC_VERSION >= 24
+	void doContinuationSlot(MM_EnvironmentBase *env, omrobjectptr_t objectPtr, omrobjectptr_t *slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator);
+#endif /* JAVA_SPEC_VERSION >= 24 */
 	void doStackSlot(MM_EnvironmentBase *env, omrobjectptr_t objectPtr, omrobjectptr_t *slotPtr);
 	void scanContinuationNativeSlots(MM_EnvironmentBase *env, omrobjectptr_t objectPtr);
 

runtime/gc_glue_java/MarkingSchemeRootMarker.cpp

@@ -46,24 +46,35 @@ MM_MarkingSchemeRootMarker::doStackSlot(omrobjectptr_t *slotPtr, void *walkState
 	if (_markingScheme->isHeapObject(object) && !_extensions->heap->objectIsInGap(object)) {
 		/* heap object - validate and mark */
 		Assert_MM_validStackSlot(MM_StackSlotValidator(0, object, stackLocation, walkState).validate(_env));
-		_markingScheme->inlineMarkObject(_env, object);
-
+		doSlot(slotPtr);
 	} else if (NULL != object) {
 		/* stack object - just validate */
 		Assert_MM_validStackSlot(MM_StackSlotValidator(MM_StackSlotValidator::NOT_ON_HEAP, object, stackLocation, walkState).validate(_env));
 	}
 }
 
+#if JAVA_SPEC_VERSION >= 24
+void
+MM_MarkingSchemeRootMarker::doContinuationSlot(J9Object **slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator)
+{
+	omrobjectptr_t object = *slotPtr;
+	if (_markingScheme->isHeapObject(object) && !_extensions->heap->objectIsInGap(object)) {
+		doSlot(slotPtr);
+	} else if (NULL != object) {
+		Assert_MM_true(continuationslotiterator_state_monitor_records == continuationSlotIterator->getState());
+	}
+}
+#endif /* JAVA_SPEC_VERSION >= 24 */
+
 void
 MM_MarkingSchemeRootMarker::doVMThreadSlot(omrobjectptr_t *slotPtr, GC_VMThreadIterator *vmThreadIterator)
 {
 	omrobjectptr_t object = *slotPtr;
 	if (_markingScheme->isHeapObject(object) && !_extensions->heap->objectIsInGap(object)) {
-		_markingScheme->inlineMarkObject(_env, object);
+		doSlot(slotPtr);
+	} else if (NULL != object) {
+		Assert_MM_true(vmthreaditerator_state_monitor_records == vmThreadIterator->getState());
 	}
-//	else if (NULL != object) {
-//		Assert_MM_true(vmthreaditerator_state_monitor_records == vmThreadIterator->getState());
-//	}
 }
 
 void

runtime/gc_glue_java/MarkingSchemeRootMarker.hpp

@@ -52,6 +52,9 @@ class MM_MarkingSchemeRootMarker : public MM_RootScanner
 
 	virtual void doSlot(omrobjectptr_t *slotPtr);
 	virtual void doStackSlot(omrobjectptr_t *slotPtr, void *walkState, const void* stackLocation);
+#if JAVA_SPEC_VERSION >= 24
+	virtual void doContinuationSlot(J9Object **slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator);
+#endif /* JAVA_SPEC_VERSION >= 24 */
 	virtual void doVMThreadSlot(omrobjectptr_t *slotPtr, GC_VMThreadIterator *vmThreadIterator);
 	virtual void doClass(J9Class *clazz);
 	virtual void doClassLoader(J9ClassLoader *classLoader);

runtime/gc_glue_java/MetronomeDelegate.cpp

@@ -1636,20 +1636,30 @@ MM_MetronomeDelegate::unsetUnmarkedImpliesCleared()
 }
 
 void
-MM_MetronomeDelegate::doContinuationSlot(MM_EnvironmentRealtime *env, J9Object **slotPtr)
+MM_MetronomeDelegate::doSlot(MM_EnvironmentRealtime *env, J9Object **slotPtr)
 {
 	J9Object *object = *slotPtr;
-	if (_markingScheme->isHeapObject(object)) {
-		if (MUTATOR_THREAD == env->getThreadType()) {
-			/* special handle by mutator thread for preMountContinuation case */
-			MM_GCExtensions *extensions = MM_GCExtensions::getExtensions(env);
-			((MM_RealtimeAccessBarrier *)extensions->accessBarrier)->rememberObject(env, object);
-		} else {
-			/* scan object by the GC Thread */
-			_markingScheme->markObject(env, object);
-		}
+	if (MUTATOR_THREAD == env->getThreadType()) {
+		/* special handle by mutator thread for preMountContinuation case */
+		MM_GCExtensions *extensions = MM_GCExtensions::getExtensions(env);
+		((MM_RealtimeAccessBarrier *)extensions->accessBarrier)->rememberObject(env, object);
+	} else {
+		/* scan object by the GC Thread */
+		_markingScheme->markObject(env, object);
+	}
+}
+
+#if JAVA_SPEC_VERSION >= 24
+void
+MM_MetronomeDelegate::doContinuationSlot(MM_EnvironmentRealtime *env, J9Object **slotPtr, GC_ContinuationSlotIterator *continuationSlotIterator)
+{
+	if (_markingScheme->isHeapObject(*slotPtr)) {
+		doSlot(env, slotPtr);
+	} else if (NULL != *slotPtr) {
+		Assert_MM_true(continuationslotiterator_state_monitor_records == continuationSlotIterator->getState());
 	}
 }
+#endif /* JAVA_SPEC_VERSION >= 24 */
 
 void
 MM_MetronomeDelegate::doStackSlot(MM_EnvironmentRealtime *env, J9Object **slotPtr, J9StackWalkState *walkState, const void *stackLocation)
@@ -1658,7 +1668,7 @@ MM_MetronomeDelegate::doStackSlot(MM_EnvironmentRealtime *env, J9Object **slotPt
 	if (_markingScheme->isHeapObject(object)) {
 		/* heap object - validate and mark */
 		Assert_MM_validStackSlot(MM_StackSlotValidator(0, object, stackLocation, walkState).validate(env));
-		doContinuationSlot(env, slotPtr);
+		doSlot(env, slotPtr);
 	} else if (NULL != object) {
 		/* stack object - just validate */
 		Assert_MM_validStackSlot(MM_StackSlotValidator(MM_StackSlotValidator::NOT_ON_HEAP, object, stackLocation, walkState).validate(env));
@@ -1697,7 +1707,7 @@ MM_MetronomeDelegate::scanContinuationNativeSlots(MM_EnvironmentRealtime *env, J
 		GC_ContinuationSlotIterator continuationSlotIterator(currentThread, continuation);
 
 		while (J9Object **slotPtr = continuationSlotIterator.nextSlot()) {
-			doContinuationSlot(env, slotPtr);
+			doContinuationSlot(env, slotPtr, &continuationSlotIterator);
 		}
 #endif /* JAVA_SPEC_VERSION >= 24 */