Merge pull request #16106 from LinHu2016/supportConcurrentScavenger

Handle Continuation scan during Concurrent Scavenger and Metronome

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) ;