cli-scavenger-delegate.diff

--- upstream-master-cli-cpp	2019-02-13 10:27:27.112689338 -0500
+++ /Users/rwyoung/wsp/openj9-openjdk-jdk11/openj9/runtime/gc_glue_java/ScavengerDelegate.cpp	2019-02-06 16:52:43.493697694 -0500
@@ -1,6 +1,6 @@

 /*******************************************************************************
- * Copyright (c) 1991, 2018 IBM Corp. and others
+ * Copyright (c) 2019, 2019 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
@@ -21,9 +21,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
  *******************************************************************************/

-#include "CollectorLanguageInterfaceImpl.hpp"
+#include "omrcfg.h"
+
+#if defined(OMR_GC_MODRON_SCAVENGER)
+
+#include "ScavengerDelegate.hpp"

 #include "j9nongenerated.h"
+#include "j9consts.h"
 #include "mmhook.h"
 #include "mmomrhook_internal.h"
 #include "mmprivatehook.h"
@@ -110,38 +115,11 @@
 class MM_AllocationContext;

 /**
- * Initialization
- */
-MM_CollectorLanguageInterfaceImpl *
-MM_CollectorLanguageInterfaceImpl::newInstance(MM_EnvironmentBase *env)
-{
-	MM_CollectorLanguageInterfaceImpl *cliJava = NULL;
-
-	cliJava = (MM_CollectorLanguageInterfaceImpl *)env->getForge()->allocate(sizeof(MM_CollectorLanguageInterfaceImpl), MM_AllocationCategory::FIXED, J9_GET_CALLSITE());
-	if (NULL != cliJava) {
-		new(cliJava) MM_CollectorLanguageInterfaceImpl((J9JavaVM*)env->getLanguageVM());
-		if (!cliJava->initialize(env)) {
-			cliJava->kill(env);
-			cliJava = NULL;
-		}
-	}
-
-	return cliJava;
-}
-
-void
-MM_CollectorLanguageInterfaceImpl::kill(MM_EnvironmentBase *env)
-{
-	tearDown(env);
-	env->getForge()->free(this);
-}
-
-/**
  * Initialize the collector's internal structures and values.
  * @return true if initialization completed, false otherwise
  */
 bool
-MM_CollectorLanguageInterfaceImpl::initialize(MM_EnvironmentBase *env)
+MM_ScavengerDelegate::initialize(MM_EnvironmentBase *env)
 {
 	return true;
 }
@@ -150,13 +128,12 @@
  * Free any internal structures associated to the receiver.
  */
 void
-MM_CollectorLanguageInterfaceImpl::tearDown(MM_EnvironmentBase *env)
+MM_ScavengerDelegate::tearDown(MM_EnvironmentBase *env)
 {
 }

-#if defined(OMR_GC_MODRON_SCAVENGER)
 void
-MM_CollectorLanguageInterfaceImpl::scavenger_masterSetupForGC(MM_EnvironmentBase * envBase)
+MM_ScavengerDelegate::masterSetupForGC(MM_EnvironmentBase * envBase)
 {
 	/* Remember the candidates of OwnableSynchronizerObject before
 	 * clearing scavenger statistics
@@ -175,31 +152,31 @@
 	_extensions->scavengerJavaStats._ownableSynchronizerCandidates = ownableSynchronizerCandidates;

 	/* correspondent lists will be build this scavenge */
-	_scavenger_shouldScavengeSoftReferenceObjects = false;
-	_scavenger_shouldScavengeWeakReferenceObjects = false;
-	_scavenger_shouldScavengePhantomReferenceObjects = false;
+	_shouldScavengeSoftReferenceObjects = false;
+	_shouldScavengeWeakReferenceObjects = false;
+	_shouldScavengePhantomReferenceObjects = false;

 	/* Record whether finalizable processing is required in this scavenge */
-	_scavenger_shouldScavengeFinalizableObjects = _extensions->finalizeListManager->isFinalizableObjectProcessingRequired();
-	_scavenger_shouldScavengeUnfinalizedObjects = false;
+	_shouldScavengeFinalizableObjects = _extensions->finalizeListManager->isFinalizableObjectProcessingRequired();
+	_shouldScavengeUnfinalizedObjects = false;

-	private_scavenger_setupForOwnableSynchronizerProcessing(MM_EnvironmentStandard::getEnvironment(envBase));
+	private_setupForOwnableSynchronizerProcessing(MM_EnvironmentStandard::getEnvironment(envBase));

 	return;
 }

 void
-MM_CollectorLanguageInterfaceImpl::scavenger_workerSetupForGC_clearEnvironmentLangStats(MM_EnvironmentBase *envBase)
+MM_ScavengerDelegate::workerSetupForGC_clearEnvironmentLangStats(MM_EnvironmentBase *envBase)
 {
 	/* clear thread-local java-only gc stats */
 	envBase->getGCEnvironment()->_scavengerJavaStats.clear();
 }

 void
-MM_CollectorLanguageInterfaceImpl::scavenger_reportScavengeEnd(MM_EnvironmentBase * envBase, bool scavengeSuccessful)
+MM_ScavengerDelegate::reportScavengeEnd(MM_EnvironmentBase * envBase, bool scavengeSuccessful)
 {
 	Assert_GC_true_with_message2(envBase, _extensions->scavengerJavaStats._ownableSynchronizerCandidates >= _extensions->scavengerJavaStats._ownableSynchronizerTotalSurvived,
-			"[MM_CollectorLanguageInterfaceImpl::scavenger_reportScavengeEnd]: _extensions->scavengerJavaStats: _ownableSynchronizerCandidates=%zu < _ownableSynchronizerTotalSurvived=%zu\n", _extensions->scavengerJavaStats._ownableSynchronizerCandidates, _extensions->scavengerJavaStats._ownableSynchronizerTotalSurvived);
+			"[MM_ScavengerDelegate::reportScavengeEnd]: _extensions->scavengerJavaStats: _ownableSynchronizerCandidates=%zu < _ownableSynchronizerTotalSurvived=%zu\n", _extensions->scavengerJavaStats._ownableSynchronizerCandidates, _extensions->scavengerJavaStats._ownableSynchronizerTotalSurvived);

 	if (!scavengeSuccessful) {
 		/* for backout case, the ownableSynchronizerObject lists is restored before scavenge, so all of candidates are survived */
@@ -210,7 +187,7 @@
 }

 void
-MM_CollectorLanguageInterfaceImpl::scavenger_mergeGCStats_mergeLangStats(MM_EnvironmentBase * envBase)
+MM_ScavengerDelegate::mergeGCStats_mergeLangStats(MM_EnvironmentBase * envBase)
 {
 	MM_EnvironmentStandard* env = MM_EnvironmentStandard::getEnvironment(envBase);

@@ -230,11 +207,11 @@
 }

 void
-MM_CollectorLanguageInterfaceImpl::scavenger_masterThreadGarbageCollect_scavengeComplete(MM_EnvironmentBase * envBase)
+MM_ScavengerDelegate::masterThreadGarbageCollect_scavengeComplete(MM_EnvironmentBase * envBase)
 {
 #if defined(J9VM_GC_FINALIZATION)
 	/* Alert the finalizer if work needs to be done */
-	if(this->scavenger_getFinalizationRequired()) {
+	if(this->getFinalizationRequired()) {
 		omrthread_monitor_enter(_javaVM->finalizeMasterMonitor);
 		_javaVM->finalizeMasterFlags |= J9_FINALIZE_FLAGS_MASTER_WAKE_UP;
 		omrthread_monitor_notify_all(_javaVM->finalizeMasterMonitor);
@@ -244,7 +221,7 @@
 }

 void
-MM_CollectorLanguageInterfaceImpl::scavenger_masterThreadGarbageCollect_scavengeSuccess(MM_EnvironmentBase *envBase)
+MM_ScavengerDelegate::masterThreadGarbageCollect_scavengeSuccess(MM_EnvironmentBase *envBase)
 {
 	/* Once a scavenge has been completed successfully ensure that
 	 * identity hash salt for the nursery gets updated
@@ -263,15 +240,15 @@
  *   2. JNI critical sections require that objects cannot be moved.
  */
 bool
-MM_CollectorLanguageInterfaceImpl::scavenger_internalGarbageCollect_shouldPercolateGarbageCollect(MM_EnvironmentBase *envBase, PercolateReason * percolateReason, U_32 * percolateType)
+MM_ScavengerDelegate::internalGarbageCollect_shouldPercolateGarbageCollect(MM_EnvironmentBase *envBase, PercolateReason * percolateReason, U_32 * percolateType)
 {
 	bool shouldPercolate = false;

-	if (private_scavenger_shouldPercolateGarbageCollect_classUnloading(envBase)) {
+	if (private_shouldPercolateGarbageCollect_classUnloading(envBase)) {
 		*percolateReason = UNLOADING_CLASSES;
 		*percolateType = J9MMCONSTANT_IMPLICIT_GC_PERCOLATE_UNLOADING_CLASSES;
 		shouldPercolate = true;
-	} else if (private_scavenger_shouldPercolateGarbageCollect_activeJNICriticalRegions(envBase)) {
+	} else if (private_shouldPercolateGarbageCollect_activeJNICriticalRegions(envBase)) {
 		Trc_MM_Scavenger_percolate_activeJNICritical(envBase->getLanguageVMThread());
 		*percolateReason = CRITICAL_REGIONS;
 		*percolateType = J9MMCONSTANT_IMPLICIT_GC_PERCOLATE_CRITICAL_REGIONS;
@@ -282,11 +259,11 @@
 }

 GC_ObjectScanner *
-MM_CollectorLanguageInterfaceImpl::scavenger_getObjectScanner(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr, void *allocSpace, uintptr_t flags)
+MM_ScavengerDelegate::getObjectScanner(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr, void *allocSpace, uintptr_t flags)
 {
-#if defined(OMR_GC_MODRON_SCAVENGER_STRICT)
+#if defined(OMR_GC_MODRON_STRICT)
 	Assert_MM_true((GC_ObjectScanner::scanHeap == flags) ^ (GC_ObjectScanner::scanRoots == flags));
-#endif /* defined(OMR_GC_MODRON_SCAVENGER_STRICT) */
+#endif /* defined(OMR_GC_MODRON_STRICT) */

 	GC_ObjectScanner *objectScanner = NULL;
 	switch(_extensions->objectModel.getScanType(objectPtr)) {
@@ -311,8 +288,8 @@
 			switch (referenceObjectType) {
 			case J9_JAVA_CLASS_REFERENCE_WEAK:
 				referentMustBeCleared = (0 != (referenceObjectOptions & MM_CycleState::references_clear_weak));
-				if (!referentMustBeCleared && shouldScavengeReferenceObject && !_scavenger_shouldScavengeWeakReferenceObjects) {
-					_scavenger_shouldScavengeWeakReferenceObjects = true;
+				if (!referentMustBeCleared && shouldScavengeReferenceObject && !_shouldScavengeWeakReferenceObjects) {
+					_shouldScavengeWeakReferenceObjects = true;
 				}
 				break;
 			case J9_JAVA_CLASS_REFERENCE_SOFT:
@@ -320,14 +297,14 @@
 				referentMustBeMarked = referentMustBeMarked || ((0 == (referenceObjectOptions & MM_CycleState::references_soft_as_weak))
 					&& ((UDATA)J9GC_J9VMJAVALANGSOFTREFERENCE_AGE(env, objectPtr) < _extensions->getDynamicMaxSoftReferenceAge())
 				);
-				if (!referentMustBeCleared && shouldScavengeReferenceObject && !_scavenger_shouldScavengeSoftReferenceObjects) {
-					_scavenger_shouldScavengeSoftReferenceObjects = true;
+				if (!referentMustBeCleared && shouldScavengeReferenceObject && !_shouldScavengeSoftReferenceObjects) {
+					_shouldScavengeSoftReferenceObjects = true;
 				}
 				break;
 			case J9_JAVA_CLASS_REFERENCE_PHANTOM:
 				referentMustBeCleared = (0 != (referenceObjectOptions & MM_CycleState::references_clear_phantom));
-				if (!referentMustBeCleared && shouldScavengeReferenceObject && !_scavenger_shouldScavengePhantomReferenceObjects) {
-					_scavenger_shouldScavengePhantomReferenceObjects = true;
+				if (!referentMustBeCleared && shouldScavengeReferenceObject && !_shouldScavengePhantomReferenceObjects) {
+					_shouldScavengePhantomReferenceObjects = true;
 				}
 				break;
 			default:
@@ -355,7 +332,7 @@
 	case GC_ObjectModel::SCAN_OWNABLESYNCHRONIZER_OBJECT:
 		if (!_extensions->isConcurrentScavengerEnabled()) {
 			if (GC_ObjectScanner::isHeapScan(flags)) {
-				private_scavenger_addOwnableSynchronizerObjectInList(env, objectPtr);
+				private_addOwnableSynchronizerObjectInList(env, objectPtr);
 			}
 		}
 		objectScanner = GC_MixedObjectScanner::newInstance(env, objectPtr, allocSpace, flags);
@@ -378,13 +355,13 @@
 	return objectScanner;
 }

-void MM_CollectorLanguageInterfaceImpl::scavenger_flushReferenceObjects(MM_EnvironmentStandard *env)
+void MM_ScavengerDelegate::flushReferenceObjects(MM_EnvironmentStandard *env)
 {
 	env->getGCEnvironment()->_referenceObjectBuffer->flush(env);
 }

 bool
-MM_CollectorLanguageInterfaceImpl::scavenger_scavengeIndirectObjectSlots(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr)
+MM_ScavengerDelegate::scavengeIndirectObjectSlots(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr)
 {
 	bool shouldBeRemembered = false;

@@ -410,7 +387,7 @@
 }

 bool
-MM_CollectorLanguageInterfaceImpl::scavenger_hasIndirectReferentsInNewSpace(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr)
+MM_ScavengerDelegate::hasIndirectReferentsInNewSpace(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr)
 {
 	J9Class *classToScan = J9VM_J9CLASS_FROM_HEAPCLASS((J9VMThread*)env->getLanguageVMThread(), objectPtr);
 	Assert_MM_true(NULL != classToScan);
@@ -453,7 +430,7 @@

 #if defined(OMR_GC_CONCURRENT_SCAVENGER)
 void
-MM_CollectorLanguageInterfaceImpl::scavenger_fixupIndirectObjectSlots(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr)
+MM_ScavengerDelegate::fixupIndirectObjectSlots(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr)
 {
 	J9Class *clazz = J9VM_J9CLASS_FROM_HEAPCLASS((J9VMThread*)env->getLanguageVMThread(), objectPtr);
 	Assert_MM_true(NULL != clazz);
@@ -475,7 +452,7 @@
 #endif /* OMR_GC_CONCURRENT_SCAVENGER */

 void
-MM_CollectorLanguageInterfaceImpl::scavenger_backOutIndirectObjectSlots(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr)
+MM_ScavengerDelegate::backOutIndirectObjectSlots(MM_EnvironmentStandard *env, omrobjectptr_t objectPtr)
 {
 	J9Class *clazz = J9VM_J9CLASS_FROM_HEAPCLASS((J9VMThread*)env->getLanguageVMThread(), objectPtr);
 	Assert_MM_true(NULL != clazz);
@@ -496,7 +473,7 @@
 }

 void
-MM_CollectorLanguageInterfaceImpl:: scavenger_backOutIndirectObjects(MM_EnvironmentStandard *env)
+MM_ScavengerDelegate::backOutIndirectObjects(MM_EnvironmentStandard *env)
 {
 	GC_SegmentIterator classSegmentIterator(((J9JavaVM*)_omrVM->_language_vm)->classMemorySegments, MEMORY_TYPE_RAM_CLASS);
 	J9MemorySegment *classMemorySegment;
@@ -522,7 +499,7 @@
  * @param[in] env the environment for the current thread
  */
 void
-MM_CollectorLanguageInterfaceImpl::scavenger_reverseForwardedObject(MM_EnvironmentBase *env, MM_ForwardedHeader *originalForwardedHeader)
+MM_ScavengerDelegate::reverseForwardedObject(MM_EnvironmentBase *env, MM_ForwardedHeader *originalForwardedHeader)
 {
 	if (originalForwardedHeader->isForwardedPointer()) {
 		omrobjectptr_t objectPtr = originalForwardedHeader->getObject();
@@ -572,7 +549,7 @@

 #if defined (J9VM_INTERP_COMPRESSED_OBJECT_HEADER)
 void
-MM_CollectorLanguageInterfaceImpl::scavenger_fixupDestroyedSlot(MM_EnvironmentBase *env, MM_ForwardedHeader *originalForwardedHeader, MM_MemorySubSpaceSemiSpace *subSpaceNew)
+MM_ScavengerDelegate::fixupDestroyedSlot(MM_EnvironmentBase *env, MM_ForwardedHeader *originalForwardedHeader, MM_MemorySubSpaceSemiSpace *subSpaceNew)
 {
 	/* Nothing to do if overlap slot is not an object reference, and the destroyed slot for indexable objects is the size */
 	if ((0 != originalForwardedHeader->getPreservedOverlap())
@@ -611,7 +588,7 @@
 #endif /* defined (J9VM_INTERP_COMPRESSED_OBJECT_HEADER) */

 void
-MM_CollectorLanguageInterfaceImpl::private_scavenger_addOwnableSynchronizerObjectInList(MM_EnvironmentStandard *env, omrobjectptr_t object)
+MM_ScavengerDelegate::private_addOwnableSynchronizerObjectInList(MM_EnvironmentStandard *env, omrobjectptr_t object)
 {
 	omrobjectptr_t link = MM_GCExtensions::getExtensions(_extensions)->accessBarrier->isObjectInOwnableSynchronizerList(object);
 	/* if isObjectInOwnableSynchronizerList() return NULL, it means the object isn't in OwanbleSynchronizerList,
@@ -629,7 +606,7 @@
 }

 void
-MM_CollectorLanguageInterfaceImpl::private_scavenger_setupForOwnableSynchronizerProcessing(MM_EnvironmentStandard *env)
+MM_ScavengerDelegate::private_setupForOwnableSynchronizerProcessing(MM_EnvironmentStandard *env)
 {
 	MM_HeapRegionDescriptorStandard *region = NULL;
 	GC_HeapRegionIteratorStandard regionIterator(_extensions->heapRegionManager);
@@ -647,7 +624,7 @@
 }

 bool
-MM_CollectorLanguageInterfaceImpl::private_scavenger_shouldPercolateGarbageCollect_classUnloading(MM_EnvironmentBase *envBase)
+MM_ScavengerDelegate::private_shouldPercolateGarbageCollect_classUnloading(MM_EnvironmentBase *envBase)
 {
 	bool shouldGCPercolate = false;

@@ -660,7 +637,7 @@
 }

 bool
-MM_CollectorLanguageInterfaceImpl::private_scavenger_shouldPercolateGarbageCollect_activeJNICriticalRegions(MM_EnvironmentBase *envBase)
+MM_ScavengerDelegate::private_shouldPercolateGarbageCollect_activeJNICriticalRegions(MM_EnvironmentBase *envBase)
 {
 	bool shouldGCPercolate = false;

@@ -673,12 +650,12 @@

 #if defined(OMR_GC_CONCURRENT_SCAVENGER)
 bool
-MM_CollectorLanguageInterfaceImpl::scavenger_shouldYield() {
+MM_ScavengerDelegate::shouldYield() {
 	return (J9_XACCESS_PENDING == ((J9JavaVM*)_omrVM->_language_vm)->exclusiveAccessState);
 }

 void
-MM_CollectorLanguageInterfaceImpl::scavenger_switchConcurrentForThread(MM_EnvironmentBase *env)
+MM_ScavengerDelegate::switchConcurrentForThread(MM_EnvironmentBase *env)
 {
 	PORT_ACCESS_FROM_ENVIRONMENT(env);
 	J9VMThread *vmThread = (J9VMThread *)env->getOmrVMThread()->_language_vmthread;
@@ -744,18 +721,35 @@
     }
 }
 #endif /* OMR_GC_CONCURRENT_SCAVENGER */
-#endif /* OMR_GC_MODRON_SCAVENGER */

 #if defined(OMR_ENV_DATA64) && !defined(OMR_GC_COMPRESSED_POINTERS)
 void
-MM_CollectorLanguageInterfaceImpl::scavenger_poisonSlots(MM_EnvironmentBase *env)
+MM_ScavengerDelegate::poisonSlots(MM_EnvironmentBase *env)
 {
 	((MM_ReadBarrierVerifier *)_extensions->accessBarrier)->poisonSlots(env);
 }

 void
-MM_CollectorLanguageInterfaceImpl::scavenger_healSlots(MM_EnvironmentBase *env)
+MM_ScavengerDelegate::healSlots(MM_EnvironmentBase *env)
 {
 	((MM_ReadBarrierVerifier *)_extensions->accessBarrier)->healSlots(env);
 }
 #endif /* defined(OMR_ENV_DATA64) && !defined(OMR_GC_COMPRESSED_POINTERS) */
+
+MM_ScavengerDelegate::MM_ScavengerDelegate(MM_EnvironmentBase* env)
+	: _omrVM(MM_GCExtensions::getExtensions(env)->getOmrVM())
+	, _javaVM(MM_GCExtensions::getExtensions(env)->getJavaVM())
+	, _extensions(MM_GCExtensions::getExtensions(env))
+	, _shouldScavengeFinalizableObjects(false)
+	, _shouldScavengeUnfinalizedObjects(false)
+	, _shouldScavengeSoftReferenceObjects(false)
+	, _shouldScavengeWeakReferenceObjects(false)
+	, _shouldScavengePhantomReferenceObjects(false)
+#if defined(J9VM_GC_FINALIZATION)
+	, _finalizationRequired(false)
+#endif /* J9VM_GC_FINALIZATION */
+{
+	_typeId = __FUNCTION__;
+}
+
+#endif /* defined(OMR_GC_MODRON_SCAVENGER) */