Merge pull request #16157 from LinHu2016/supportConcurrentScavenger2

Handle Continuation scan during Concurrent Scavenger and Metronome
eclipse-openj9 · Oct 24, 2022 · 1a8e36d · 1a8e36d
2 parents ca9e8b4 + c7a0338
commit 1a8e36d
Show file tree

Hide file tree

Showing 16 changed files with 119 additions and 44 deletions.
diff --git a/runtime/gc/gctable.c b/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,

diff --git a/runtime/gc_base/GCExtensions.cpp b/runtime/gc_base/GCExtensions.cpp
@@ -37,6 +37,7 @@
 #endif /* defined(OMR_GC_IDLE_HEAP_MANAGER) */
 #include "MemorySpace.hpp"
 #include "MemorySubSpace.hpp"
+#include "StandardAccessBarrier.hpp"
 #include "ObjectModel.hpp"
 #include "ReferenceChainWalkerMarkMap.hpp"
 #include "SublistPool.hpp"
@@ -284,3 +285,13 @@ MM_GCExtensions::getContinuationObjectListsExternal(J9VMThread *vmThread)
 {
 	return continuationObjectLists;
 }
+
+
+void
+MM_GCExtensions::registerScavenger(MM_Scavenger *scavenger)
+{
+	MM_GCExtensionsBase::registerScavenger(scavenger);
+	Assert_MM_true(isStandardGC());
+	Assert_MM_true(isScavengerEnabled());
+	((MM_StandardAccessBarrier *)accessBarrier)->registerScavenger(scavenger);
+}
diff --git a/runtime/gc_base/GCExtensions.hpp b/runtime/gc_base/GCExtensions.hpp
@@ -209,6 +209,8 @@ class MM_GCExtensions : public MM_GCExtensionsBase {
 
 	void computeDefaultMaxHeapForJava(bool enableOriginalJDK8HeapSizeCompatibilityOption);
 
+	virtual void registerScavenger(MM_Scavenger *scavenger);
+
 	MMINLINE J9HookInterface** getHookInterface() { return J9_HOOK_INTERFACE(hookInterface); };
 
 	/**

diff --git a/runtime/gc_base/ObjectAccessBarrier.hpp b/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

diff --git a/runtime/gc_base/accessBarrier.cpp b/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" */
 
diff --git a/runtime/gc_base/gc_internal.h b/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 */

diff --git a/runtime/gc_base/modronapi.cpp b/runtime/gc_base/modronapi.cpp
@@ -52,20 +52,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)
 {

diff --git a/runtime/gc_base/module.xml b/runtime/gc_base/module.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <!--
-Copyright (c) 2006, 2019 IBM Corp. and others
+Copyright (c) 2006, 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
@@ -53,6 +53,8 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-excepti
 			<include path="j9gcstats"/>
 			<include path="$(OMR_DIR)/gc/stats" type="relativepath"/>
 			<include path="j9gcgluejava"/>
+			<include path="$(OMR_DIR)/gc/base/standard" type="relativepath"/>
+			<include path="j9modronstandard"/>
 			<include path="j9gcvlhgc"/>
 			<include path="$(OMR_DIR)/include_core" type="relativepath"/>
 		</includes>

diff --git a/runtime/gc_glue_java/ScavengerDelegate.hpp b/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; }

diff --git a/runtime/gc_modron_standard/StandardAccessBarrier.cpp b/runtime/gc_modron_standard/StandardAccessBarrier.cpp
@@ -265,10 +265,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 +759,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 +789,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 +814,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 +827,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 +858,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 +883,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 +1037,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);
+}
diff --git a/runtime/gc_modron_standard/StandardAccessBarrier.hpp b/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,11 +71,21 @@ 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__;
 	}
 
+	void registerScavenger(MM_Scavenger *scavenger)
+	{
+#if defined(J9VM_GC_GENERATIONAL)
+		_scavenger = scavenger;
+#endif /* J9VM_GC_GENERATIONAL */
+	}
+
 	virtual J9Object* asConstantPoolObject(J9VMThread *vmThread, J9Object* toConvert, UDATA allocationFlags);
 
 	virtual void rememberObjectImpl(MM_EnvironmentBase *env, J9Object* object);
@@ -88,6 +99,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);

diff --git a/runtime/gc_realtime/RealtimeAccessBarrier.cpp b/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 */
 
diff --git a/runtime/gc_realtime/RealtimeAccessBarrier.hpp b/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);
 

diff --git a/runtime/gc_vlhgc/VLHGCAccessBarrier.cpp b/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);
+}
diff --git a/runtime/gc_vlhgc/VLHGCAccessBarrier.hpp b/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);