Handle Continuation scan during Concurrent Scavenger and Metronome

For CS and Metronome, due to synchronous nature of their barriers (they
read the value of the slot and act on it immediately, for example they
may evacuate object for CS and mark object for Metronome), We fully
scan java stacks of related continuation during the virtual thread
mount.

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

runtime/gc/gctable.c

@@ -33,6 +33,8 @@ J9MemoryManagerFunctions MemoryManagerFunctions = {
 	J9WriteBarrierBatch,
 	J9WriteBarrierPostClass,
 	J9WriteBarrierClassBatch,
+	preMountContinuation,
+	postUnmountContinuation,
 	allocateMemoryForSublistFragment,
 	j9gc_heap_free_memory,
 	j9gc_heap_total_memory,
@@ -251,8 +253,6 @@ J9MemoryManagerFunctions MemoryManagerFunctions = {
 	j9mm_iterate_all_continuation_objects,
 	ownableSynchronizerObjectCreated,
 	continuationObjectCreated,
-	preMountContinuation,
-	postUnmountContinuation,
 	j9gc_notifyGCOfClassReplacement,
 	j9gc_get_jit_string_dedup_policy,
 	j9gc_stringHashFn,

runtime/gc_base/ObjectAccessBarrier.hpp

@@ -267,6 +267,8 @@ class MM_ObjectAccessBarrier : public MM_BaseVirtual
 	virtual bool postObjectRead(J9VMThread *vmThread, J9Object *srcObject, fj9object_t *srcAddress);
 	virtual bool postObjectRead(J9VMThread *vmThread, J9Class *srcClass, J9Object **srcAddress);
 
+	virtual void preMountContinuation(J9VMThread *vmThread, j9object_t contObject) {}
+	virtual void postUnmountContinuation(J9VMThread *vmThread, j9object_t contObject) {}
 	/**
 	 * Return back true if object references are compressed
 	 * @return true, if object references are compressed

runtime/gc_base/accessBarrier.cpp

@@ -835,5 +835,19 @@ j9gc_objaccess_jniDeleteGlobalReference(J9VMThread *vmThread, J9Object *referenc
 	barrier->jniDeleteGlobalReference(vmThread, reference);
 }
 
+void
+preMountContinuation(J9VMThread *vmThread, j9object_t object)
+{
+	MM_ObjectAccessBarrier *barrier = MM_GCExtensions::getExtensions(vmThread->javaVM)->accessBarrier;
+	barrier->preMountContinuation(vmThread, object);
+}
+
+void
+postUnmountContinuation(J9VMThread *vmThread, j9object_t object)
+{
+	MM_ObjectAccessBarrier *barrier = MM_GCExtensions::getExtensions(vmThread->javaVM)->accessBarrier;
+	barrier->postUnmountContinuation(vmThread, object);
+}
+
 } /* extern "C" */
 

runtime/gc_base/gc_internal.h

@@ -67,6 +67,8 @@ extern J9_CFUNC UDATA alwaysCallReferenceArrayCopyHelper(J9JavaVM *javaVM);
 extern J9_CFUNC void J9WriteBarrierBatch(J9VMThread *vmThread, j9object_t destinationObject);
 extern J9_CFUNC IDATA j9gc_objaccess_indexableReadI16(J9VMThread *vmThread, J9IndexableObject *srcObject, I_32 index, UDATA isVolatile);
 extern J9_CFUNC void J9WriteBarrierPost(J9VMThread *vmThread, j9object_t destinationObject, j9object_t storedObject);
+extern J9_CFUNC void preMountContinuation(J9VMThread *vmThread, j9object_t object);
+extern J9_CFUNC void postUnmountContinuation(J9VMThread *vmThread, j9object_t object);
 extern J9_CFUNC UDATA j9gc_heap_total_memory(J9JavaVM *javaVM);
 extern J9_CFUNC UDATA j9gc_is_garbagecollection_disabled(J9JavaVM *javaVM);
 extern J9_CFUNC UDATA j9gc_allsupported_memorypools(J9JavaVM* javaVM);
@@ -268,9 +270,6 @@ extern J9_CFUNC void* finalizeForcedClassLoaderUnload(J9VMThread *vmThread);
 extern J9_CFUNC UDATA ownableSynchronizerObjectCreated(J9VMThread *vmThread, j9object_t object);
 extern J9_CFUNC UDATA continuationObjectCreated(J9VMThread *vmThread, j9object_t object);
 
-extern J9_CFUNC void preMountContinuation(J9VMThread *vmThread, j9object_t object);
-extern J9_CFUNC void postUnmountContinuation(J9VMThread *vmThread, j9object_t object);
-
 extern J9_CFUNC void j9gc_notifyGCOfClassReplacement(J9VMThread *vmThread, J9Class *originalClass, J9Class *replacementClass, UDATA isFastHCR);
 
 /* GuaranteedNurseryRange.cpp */

runtime/gc_base/modronapi.cpp

@@ -38,6 +38,7 @@
 #include "HeapRegionIterator.hpp"
 #include "HeapRegionManager.hpp"
 #include "GlobalCollector.hpp"
+#include "ObjectAccessBarrier.hpp"
 #include "ObjectAllocationInterface.hpp"
 #include "ObjectModel.hpp"
 #include "OwnableSynchronizerObjectBuffer.hpp"
@@ -52,20 +53,6 @@
 
 extern "C" {
 
-void
-preMountContinuation(J9VMThread *vmThread, j9object_t object)
-{
-	/* need read barrier to handle concurrent scavenger and gcpolicy:metronome case */
-}
-
-void
-postUnmountContinuation(J9VMThread *vmThread, j9object_t object)
-{
-	/* Conservatively assume that via mutations of stack slots (which are not subject to access barriers),
-	 * all post-write barriers have been triggered on this Continuation object, since it's been mounted. */
-	vmThread->javaVM->memoryManagerFunctions->J9WriteBarrierBatch(vmThread, object);
-}
-
 UDATA
 j9gc_modron_global_collect(J9VMThread *vmThread)
 {

runtime/gc_glue_java/ScavengerDelegate.hpp

@@ -116,7 +116,6 @@ class MM_ScavengerDelegate : public MM_BaseNonVirtual {
 	 * prevents scavenging. Percolate collect instead.
 	 */
 	bool private_shouldPercolateGarbageCollect_activeJNICriticalRegions(MM_EnvironmentBase *envBase);
-	bool doContinuationObject(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr, MM_ScavengeScanReason reason);
 
 protected:
 public:
@@ -157,6 +156,7 @@ class MM_ScavengerDelegate : public MM_BaseNonVirtual {
 
 	void setShouldScavengeUnfinalizedObjects(bool shouldScavenge) { _shouldScavengeUnfinalizedObjects = shouldScavenge; }
 	void setShouldScavengeContinuationObjects(bool shouldScavenge) { _shouldScavengeContinuationObjects = shouldScavenge; }
+	bool doContinuationObject(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr, MM_ScavengeScanReason reason);
 
 	volatile bool getShouldScavengeFinalizableObjects() { return _shouldScavengeFinalizableObjects; }
 	volatile bool getShouldScavengeUnfinalizedObjects() { return _shouldScavengeUnfinalizedObjects; }

runtime/gc_modron_standard/StandardAccessBarrier.cpp

@@ -80,6 +80,7 @@ MM_StandardAccessBarrier::initialize(MM_EnvironmentBase *env)
 	if (!_generationalAccessBarrierComponent.initialize(env)) {
 		return false;
 	}
+	_scavenger = MM_GCExtensions::getExtensions(env)->scavenger;
 #endif /* J9VM_GC_GENERATIONAL */
 
 	return MM_ObjectAccessBarrier::initialize(env);
@@ -265,10 +266,12 @@ MM_StandardAccessBarrier::postObjectStoreImpl(J9VMThread *vmThread, J9Object *ds
 {
 	/* If the source object is NULL, there is no need for a write barrier. */
 	if(NULL != srcObject) {
+#if defined(OMR_GC_CONCURRENT_SCAVENGER)
 		if (_extensions->isConcurrentScavengerEnabled() && !_extensions->isScavengerBackOutFlagRaised()) {
-			Assert_MM_false(_extensions->scavenger->isObjectInEvacuateMemory(dstObject));
-			Assert_MM_false(_extensions->scavenger->isObjectInEvacuateMemory(srcObject));
+			Assert_MM_false(_scavenger->isObjectInEvacuateMemory(dstObject));
+			Assert_MM_false(_scavenger->isObjectInEvacuateMemory(srcObject));
 		}
+#endif /* OMR_GC_CONCURRENT_SCAVENGER */
 
 #if defined(OMR_GC_MODRON_CONCURRENT_MARK)
 		/* Call the concurrent write barrier if required */
@@ -757,10 +760,10 @@ MM_StandardAccessBarrier::preWeakRootSlotRead(J9VMThread *vmThread, j9object_t *
 	omrobjectptr_t object = (omrobjectptr_t)*srcAddress;
 	bool const compressed = compressObjectReferences();
 
-	if ((NULL != _extensions->scavenger) && _extensions->scavenger->isObjectInEvacuateMemory(object)) {
+	if ((NULL != _scavenger) && _scavenger->isObjectInEvacuateMemory(object)) {
 		MM_EnvironmentStandard *env = MM_EnvironmentStandard::getEnvironment(vmThread->omrVMThread);
-		Assert_MM_true(_extensions->scavenger->isConcurrentCycleInProgress());
-		Assert_MM_true(_extensions->scavenger->isMutatorThreadInSyncWithCycle(env));
+		Assert_MM_true(_scavenger->isConcurrentCycleInProgress());
+		Assert_MM_true(_scavenger->isMutatorThreadInSyncWithCycle(env));
 
 		MM_ForwardedHeader forwardHeader(object, compressed);
 		omrobjectptr_t forwardPtr = forwardHeader.getForwardedObject();
@@ -787,8 +790,8 @@ MM_StandardAccessBarrier::preWeakRootSlotRead(J9JavaVM *vm, j9object_t *srcAddre
 	omrobjectptr_t object = (omrobjectptr_t)*srcAddress;
 	bool const compressed = compressObjectReferences();
 
-	if ((NULL != _extensions->scavenger) && _extensions->scavenger->isObjectInEvacuateMemory(object)) {
-		Assert_MM_true(_extensions->scavenger->isConcurrentCycleInProgress());
+	if ((NULL != _scavenger) && _scavenger->isObjectInEvacuateMemory(object)) {
+		Assert_MM_true(_scavenger->isConcurrentCycleInProgress());
 
 		MM_ForwardedHeader forwardHeader(object, compressed);
 		omrobjectptr_t forwardPtr = forwardHeader.getForwardedObject();
@@ -812,10 +815,10 @@ MM_StandardAccessBarrier::preObjectRead(J9VMThread *vmThread, J9Class *srcClass,
 	omrobjectptr_t object = *(volatile omrobjectptr_t *)srcAddress;
 	bool const compressed = compressObjectReferences();
 
-	if ((NULL != _extensions->scavenger) && _extensions->scavenger->isObjectInEvacuateMemory(object)) {
+	if ((NULL != _scavenger) && _scavenger->isObjectInEvacuateMemory(object)) {
 		MM_EnvironmentStandard *env = MM_EnvironmentStandard::getEnvironment(vmThread->omrVMThread);
-		Assert_MM_true(_extensions->scavenger->isConcurrentCycleInProgress());
-		Assert_MM_true(_extensions->scavenger->isMutatorThreadInSyncWithCycle(env));
+		Assert_MM_true(_scavenger->isConcurrentCycleInProgress());
+		Assert_MM_true(_scavenger->isMutatorThreadInSyncWithCycle(env));
 
 		MM_ForwardedHeader forwardHeader(object, compressed);
 		omrobjectptr_t forwardPtr = forwardHeader.getForwardedObject();
@@ -825,7 +828,7 @@ MM_StandardAccessBarrier::preObjectRead(J9VMThread *vmThread, J9Class *srcClass,
 			forwardHeader.copyOrWait(forwardPtr);
 			MM_AtomicOperations::lockCompareExchange((uintptr_t *)srcAddress, (uintptr_t)object, (uintptr_t)forwardPtr);
 		} else {
-			omrobjectptr_t destinationObjectPtr = _extensions->scavenger->copyObject(env, &forwardHeader);
+			omrobjectptr_t destinationObjectPtr = _scavenger->copyObject(env, &forwardHeader);
 			if (NULL == destinationObjectPtr) {
 				/* Failure - the scavenger must back out the work it has done. Attempt to return the original object. */
 				forwardPtr = forwardHeader.setSelfForwardedObject();
@@ -856,13 +859,13 @@ MM_StandardAccessBarrier::preObjectRead(J9VMThread *vmThread, J9Object *srcObjec
 	fomrobject_t objectToken = (fomrobject_t)(compressed ? (uintptr_t)*(volatile uint32_t *)srcAddress: *(volatile uintptr_t *)srcAddress);
 	omrobjectptr_t object = convertPointerFromToken(objectToken);
 
-	if (NULL != _extensions->scavenger) {
+	if (NULL != _scavenger) {
 		MM_EnvironmentStandard *env = MM_EnvironmentStandard::getEnvironment(vmThread->omrVMThread);
-		Assert_GC_true_with_message(env, !_extensions->scavenger->isObjectInEvacuateMemory((omrobjectptr_t)srcAddress) || _extensions->isScavengerBackOutFlagRaised(), "readObject %llx in Evacuate\n", srcAddress);
-		if (_extensions->scavenger->isObjectInEvacuateMemory(object)) {
-			Assert_GC_true_with_message2(env, _extensions->scavenger->isConcurrentCycleInProgress(),
+		Assert_GC_true_with_message(env, !_scavenger->isObjectInEvacuateMemory((omrobjectptr_t)srcAddress) || _extensions->isScavengerBackOutFlagRaised(), "readObject %llx in Evacuate\n", srcAddress);
+		if (_scavenger->isObjectInEvacuateMemory(object)) {
+			Assert_GC_true_with_message2(env, _scavenger->isConcurrentCycleInProgress(),
 					"CS not in progress, found a object in Survivor: slot %llx object %llx\n", srcAddress, object);
-			Assert_MM_true(_extensions->scavenger->isMutatorThreadInSyncWithCycle(env));
+			Assert_MM_true(_scavenger->isMutatorThreadInSyncWithCycle(env));
 			/* since object is still in evacuate, srcObject has not been scanned yet => we cannot assert
 			 * if srcObject should (already) be remembered (even if it's old)
 			 */
@@ -881,7 +884,7 @@ MM_StandardAccessBarrier::preObjectRead(J9VMThread *vmThread, J9Object *srcObjec
 				forwardHeader.copyOrWait(forwardPtr);
 				slotObject.atomicWriteReferenceToSlot(object, forwardPtr);
 			} else {
-				omrobjectptr_t destinationObjectPtr = _extensions->scavenger->copyObject(env, &forwardHeader);
+				omrobjectptr_t destinationObjectPtr = _scavenger->copyObject(env, &forwardHeader);
 				if (NULL == destinationObjectPtr) {
 					/* We have no place to copy (or less likely, we lost to another thread forwarding it).
 					 * We are forced to return the original location of the object.
@@ -1035,3 +1038,24 @@ MM_StandardAccessBarrier::checkClassLive(J9JavaVM *javaVM, J9Class *classPtr)
 }
 #endif /* defined(J9VM_GC_DYNAMIC_CLASS_UNLOADING) */
 
+void
+MM_StandardAccessBarrier::preMountContinuation(J9VMThread *vmThread, j9object_t contObject)
+{
+#if defined(OMR_GC_CONCURRENT_SCAVENGER)
+	if (_extensions->isConcurrentScavengerInProgress()) {
+		/* concurrent scavenger in progress */
+		MM_EnvironmentStandard *env = (MM_EnvironmentStandard *) MM_EnvironmentBase::getEnvironment(vmThread->omrVMThread);
+		MM_ScavengeScanReason reason = SCAN_REASON_SCAVENGE;
+		_scavenger->getDelegate()->doContinuationObject(env, contObject, reason);
+	}
+#endif /* OMR_GC_CONCURRENT_SCAVENGER */
+}
+
+void
+MM_StandardAccessBarrier::postUnmountContinuation(J9VMThread *vmThread, j9object_t contObject)
+{
+	/* Conservatively assume that via mutations of stack slots (which are not subject to access barriers),
+	 * all post-write barriers have been triggered on this Continuation object, since it's been mounted.
+	 */
+	postBatchObjectStore(vmThread, contObject);
+}

runtime/gc_modron_standard/StandardAccessBarrier.hpp

@@ -1,6 +1,6 @@
 
 /*******************************************************************************
- * Copyright (c) 1991, 2021 IBM Corp. and others
+ * Copyright (c) 1991, 2022 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
@@ -49,8 +49,9 @@ class MM_StandardAccessBarrier : public MM_ObjectAccessBarrier
 private:
 #if defined(J9VM_GC_GENERATIONAL)
 	MM_GenerationalAccessBarrierComponent _generationalAccessBarrierComponent;	/**< Generational Component of Access Barrier */
+	MM_Scavenger *_scavenger;	/**< caching MM_GCExtensions::scavenger */
 #endif /* J9VM_GC_GENERATIONAL */
-	MM_MarkingScheme *_markingScheme;
+	MM_MarkingScheme *_markingScheme;	/**< caching MM_MarkingScheme instance */
 
 	void postObjectStoreImpl(J9VMThread *vmThread, J9Object *dstObject, J9Object *srcObject);
 	void postBatchObjectStoreImpl(J9VMThread *vmThread, J9Object *dstObject);
@@ -70,6 +71,9 @@ class MM_StandardAccessBarrier : public MM_ObjectAccessBarrier
 
 	MM_StandardAccessBarrier(MM_EnvironmentBase *env, MM_MarkingScheme *markingScheme) :
 		MM_ObjectAccessBarrier(env)
+#if defined(J9VM_GC_GENERATIONAL)
+		, _scavenger(NULL)
+#endif /* J9VM_GC_GENERATIONAL */
 		, _markingScheme(markingScheme)
 	{
 		_typeId = __FUNCTION__;
@@ -88,6 +92,9 @@ class MM_StandardAccessBarrier : public MM_ObjectAccessBarrier
 	virtual bool postBatchObjectStore(J9VMThread *vmThread, J9Class *destClass, bool isVolatile=false);
 	virtual void recentlyAllocatedObject(J9VMThread *vmThread, J9Object *object); 
 
+	virtual void preMountContinuation(J9VMThread *vmThread, j9object_t contObject);
+	virtual void postUnmountContinuation(J9VMThread *vmThread, j9object_t contObject);
+
 	virtual void* jniGetPrimitiveArrayCritical(J9VMThread* vmThread, jarray array, jboolean *isCopy);
 	virtual void jniReleasePrimitiveArrayCritical(J9VMThread* vmThread, jarray array, void * elems, jint mode);
 	virtual const jchar* jniGetStringCritical(J9VMThread* vmThread, jstring str, jboolean *isCopy);

runtime/gc_modron_startup/mmparseXXgc.cpp

@@ -1515,7 +1515,6 @@ gcParseXXgcArguments(J9JavaVM *vm, char *optArg)
 			continue;
 		}
 
-
 		/* Couldn't find a match for arguments */
 		j9nls_printf(PORTLIB, J9NLS_ERROR, J9NLS_GC_OPTION_UNKNOWN, error_scan);
 		returnValue = JNI_EINVAL;

runtime/gc_realtime/RealtimeAccessBarrier.cpp

@@ -950,5 +950,14 @@ MM_RealtimeAccessBarrier::forwardReferenceArrayCopyIndex(J9VMThread *vmThread, J
 	return -2;
 }
 
+void
+MM_RealtimeAccessBarrier::preMountContinuation(J9VMThread *vmThread, j9object_t contObject)
+{
+	MM_EnvironmentRealtime *env = (MM_EnvironmentRealtime *) MM_EnvironmentBase::getEnvironment(vmThread->omrVMThread);
+	if (isBarrierActive(env)) {
+		_realtimeGC->getRealtimeDelegate()->scanContinuationObject(env, contObject);
+	}
+}
+
 #endif /* J9VM_GC_REALTIME */
 

runtime/gc_realtime/RealtimeAccessBarrier.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 1991, 2021 IBM Corp. and others
+ * Copyright (c) 1991, 2022 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
@@ -151,6 +151,8 @@ class MM_RealtimeAccessBarrier : public MM_ObjectAccessBarrier
 	virtual bool preObjectStore(J9VMThread *vmThread, J9Object *destClass, J9Object **destAddress, J9Object *value, bool isVolatile=false);
 	virtual bool preObjectStore(J9VMThread *vmThread, J9Object **destAddress, J9Object *value, bool isVolatile=false);
 
+	virtual void preMountContinuation(J9VMThread *vmThread, j9object_t contObject);
+
 	virtual I_32 backwardReferenceArrayCopyIndex(J9VMThread *vmThread, J9IndexableObject *srcObject, J9IndexableObject *destObject, I_32 srcIndex, I_32 destIndex, I_32 lengthInSlots);
 	virtual I_32 forwardReferenceArrayCopyIndex(J9VMThread *vmThread, J9IndexableObject *srcObject, J9IndexableObject *destObject, I_32 srcIndex, I_32 destIndex, I_32 lengthInSlots);
 

runtime/gc_vlhgc/VLHGCAccessBarrier.cpp

@@ -634,3 +634,12 @@ MM_VLHGCAccessBarrier::preWeakRootSlotRead(J9JavaVM *vm, j9object_t *srcAddress)
 
 	return true;
 }
+
+void
+MM_VLHGCAccessBarrier::postUnmountContinuation(J9VMThread *vmThread, j9object_t contObject)
+{
+	/* Conservatively assume that via mutations of stack slots (which are not subject to access barriers),
+	 * all post-write barriers have been triggered on this Continuation object, since it's been mounted.
+	 */
+	postBatchObjectStore(vmThread, contObject);
+}

runtime/gc_vlhgc/VLHGCAccessBarrier.hpp

@@ -1,6 +1,6 @@
 
 /*******************************************************************************
- * Copyright (c) 1991, 2021 IBM Corp. and others
+ * Copyright (c) 1991, 2022 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
@@ -82,6 +82,8 @@ class MM_VLHGCAccessBarrier : public MM_ObjectAccessBarrier
 	virtual bool preWeakRootSlotRead(J9VMThread *vmThread, j9object_t *srcAddress);
 	virtual bool preWeakRootSlotRead(J9JavaVM *vm, j9object_t *srcAddress);
 
+	virtual void postUnmountContinuation(J9VMThread *vmThread, j9object_t contObject);
+
 	virtual I_32 backwardReferenceArrayCopyIndex(J9VMThread *vmThread, J9IndexableObject *srcObject, J9IndexableObject *destObject, I_32 srcIndex, I_32 destIndex, I_32 lengthInSlots);
 	virtual I_32 forwardReferenceArrayCopyIndex(J9VMThread *vmThread, J9IndexableObject *srcObject, J9IndexableObject *destObject, I_32 srcIndex, I_32 destIndex, I_32 lengthInSlots);
 

runtime/oti/j9nonbuilder.h

@@ -4280,6 +4280,8 @@ typedef struct J9MemoryManagerFunctions {
 	void  ( *J9WriteBarrierBatch)(struct J9VMThread *vmThread, j9object_t destinationObject) ;
 	void  ( *J9WriteBarrierPostClass)(struct J9VMThread *vmThread, J9Class *destinationClazz, j9object_t storedObject) ;
 	void  ( *J9WriteBarrierClassBatch)(struct J9VMThread *vmThread, J9Class *destinationClazz) ;
+	void ( *preMountContinuation)(struct J9VMThread *vmThread, j9object_t object) ;
+	void ( *postUnmountContinuation)(struct J9VMThread *vmThread, j9object_t object) ;
 	UDATA  ( *allocateMemoryForSublistFragment)(void *vmThread, J9VMGC_SublistFragment *fragmentPrimitive) ;
 	UDATA  ( *j9gc_heap_free_memory)(struct J9JavaVM *javaVM) ;
 	UDATA  ( *j9gc_heap_total_memory)(struct J9JavaVM *javaVM) ;
@@ -4499,8 +4501,6 @@ typedef struct J9MemoryManagerFunctions {
 	jvmtiIterationControl  ( *j9mm_iterate_all_continuation_objects)(struct J9VMThread *vmThread, J9PortLibrary *portLibrary, UDATA flags, jvmtiIterationControl (*func)(struct J9VMThread *vmThread, struct J9MM_IterateObjectDescriptor *object, void *userData), void *userData) ;
 	UDATA ( *ownableSynchronizerObjectCreated)(struct J9VMThread *vmThread, j9object_t object) ;
 	UDATA ( *continuationObjectCreated)(struct J9VMThread *vmThread, j9object_t object) ;
-	void ( *preMountContinuation)(struct J9VMThread *vmThread, j9object_t object) ;
-	void ( *postUnmountContinuation)(struct J9VMThread *vmThread, j9object_t object) ;
 
 	void  ( *j9gc_notifyGCOfClassReplacement)(struct J9VMThread *vmThread, J9Class *originalClass, J9Class *replacementClass, UDATA isFastHCR) ;
 	I_32  ( *j9gc_get_jit_string_dedup_policy)(struct J9JavaVM *javaVM) ;