/**
* Stats gathering for synchronizing threads during sweep.
*/
void
MM_ParallelSweepTask::synchronizeGCThreads(MM_EnvironmentBase *env, const char *id)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
uint64_t startTime = omrtime_hires_clock();
MM_ParallelTask::synchronizeGCThreads(env, id);
uint64_t endTime = omrtime_hires_clock();
env->_sweepStats.addToIdleTime(startTime, endTime);
}
bool
MM_ParallelSweepTask::synchronizeGCThreadsAndReleaseSingleThread(MM_EnvironmentBase *env, const char *id)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
uint64_t startTime = omrtime_hires_clock();
bool result = MM_ParallelTask::synchronizeGCThreadsAndReleaseSingleThread(env, id);
uint64_t endTime = omrtime_hires_clock();
env->_sweepStats.addToIdleTime(startTime, endTime);
return result;
}
bool
MM_ParallelMarkTask::synchronizeGCThreadsAndReleaseMaster(MM_EnvironmentBase *env, const char *id)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
uint64_t startTime = omrtime_hires_clock();
bool result = MM_ParallelTask::synchronizeGCThreadsAndReleaseMaster(env, id);
uint64_t endTime = omrtime_hires_clock();
env->_markStats.addToSyncStallTime(startTime, endTime);
return result;
}
void
MM_EnvironmentBase::allocationFailureEndReportIfRequired(MM_AllocateDescription *allocDescription)
{
if (_allocationFailureReported) {
MM_GCExtensionsBase *extensions = getExtensions();
OMRPORT_ACCESS_FROM_OMRPORT(_portLibrary);
TRIGGER_J9HOOK_MM_PRIVATE_FAILED_ALLOCATION_COMPLETED(
extensions->privateHookInterface,
getOmrVMThread(),
omrtime_hires_clock(),
J9HOOK_MM_PRIVATE_FAILED_ALLOCATION_COMPLETED,
allocDescription->getAllocationSucceeded() ? TRUE : FALSE,
allocDescription->getBytesRequested());
Trc_MM_AllocationFailureEnd(getLanguageVMThread(),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_OLD),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_OLD),
(extensions->largeObjectArea ? extensions->heap->getApproximateActiveFreeLOAMemorySize(MEMORY_TYPE_OLD) : 0),
(extensions->largeObjectArea ? extensions->heap->getActiveLOAMemorySize(MEMORY_TYPE_OLD) : 0));
Trc_OMRMM_AllocationFailureEnd(getOmrVMThread(),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_OLD),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_OLD),
(extensions->largeObjectArea ? extensions->heap->getApproximateActiveFreeLOAMemorySize(MEMORY_TYPE_OLD) : 0),
(extensions->largeObjectArea ? extensions->heap->getActiveLOAMemorySize(MEMORY_TYPE_OLD) : 0));
if (J9_EVENT_IS_HOOKED(extensions->privateHookInterface, J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_END)) {
MM_CommonGCEndData commonData;
extensions->heap->initializeCommonGCEndData(this, &commonData);
ALWAYS_TRIGGER_J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_END(
extensions->privateHookInterface,
getOmrVMThread(),
omrtime_hires_clock(),
J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_END,
getExclusiveAccessTime(),
&commonData,
allocDescription);
}
_allocationFailureReported = false;
}
}
void
MM_EnvironmentBase::reportExclusiveAccessAcquire()
{
OMRPORT_ACCESS_FROM_OMRPORT(_portLibrary);
/* record statistics */
U_64 meanResponseTime = _omrVM->exclusiveVMAccessStats.totalResponseTime / (_omrVM->exclusiveVMAccessStats.haltedThreads + 1); /* +1 for the requester */
_exclusiveAccessTime = _omrVM->exclusiveVMAccessStats.endTime - _omrVM->exclusiveVMAccessStats.startTime;
_meanExclusiveAccessIdleTime = _exclusiveAccessTime - meanResponseTime;
_lastExclusiveAccessResponder = _omrVM->exclusiveVMAccessStats.lastResponder;
_exclusiveAccessHaltedThreads = _omrVM->exclusiveVMAccessStats.haltedThreads;
/* report hook */
/* first the deprecated trigger */
TRIGGER_J9HOOK_MM_PRIVATE_EXCLUSIVE_ACCESS(this->getExtensions()->privateHookInterface, _omrVMThread);
/* now the new trigger */
TRIGGER_J9HOOK_MM_PRIVATE_EXCLUSIVE_ACCESS_ACQUIRE(
this->getExtensions()->privateHookInterface,
_omrVMThread,
omrtime_hires_clock(),
J9HOOK_MM_PRIVATE_EXCLUSIVE_ACCESS_ACQUIRE,
_exclusiveAccessTime,
_meanExclusiveAccessIdleTime,
_lastExclusiveAccessResponder,
_exclusiveAccessHaltedThreads);
}
void
MM_EnvironmentBase::reportExclusiveAccessRelease()
{
OMRPORT_ACCESS_FROM_OMRPORT(_portLibrary);
TRIGGER_J9HOOK_MM_PRIVATE_EXCLUSIVE_ACCESS_RELEASE(
this->getExtensions()->privateHookInterface,
_omrVMThread,
omrtime_hires_clock(),
J9HOOK_MM_PRIVATE_EXCLUSIVE_ACCESS_RELEASE);
}
/**
* Perform a basic sweep operation.
* Called by all work threads from a task, performs a full sweep on all memory subspaces.
*
* @note Do not call directly - used by the dispatcher for work threads.
*/
void
MM_ParallelSweepScheme::internalSweep(MM_EnvironmentBase *env)
{
/* master thread does initialization */
if (env->_currentTask->synchronizeGCThreadsAndReleaseMaster(env, UNIQUE_ID)) {
/* Reset largestFreeEntry of all subSpaces at beginning of sweep */
_extensions->heap->resetLargestFreeEntry();
_chunksPrepared = prepareAllChunks(env);
env->_currentTask->releaseSynchronizedGCThreads(env);
}
/* ..all threads now join in to do actual sweep */
sweepAllChunks(env, _chunksPrepared);
/* ..and then master thread finishes off by connecting all the chunks */
if (env->_currentTask->synchronizeGCThreadsAndReleaseMaster(env, UNIQUE_ID)) {
#if defined(J9MODRON_TGC_PARALLEL_STATISTICS)
uint64_t mergeStartTime, mergeEndTime;
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
mergeStartTime = omrtime_hires_clock();
#endif /* J9MODRON_TGC_PARALLEL_STATISTICS */
connectAllChunks(env, _chunksPrepared);
_extensions->splitFreeListNumberChunksPrepared = _chunksPrepared;
allPoolsPostProcess(env);
#if defined(J9MODRON_TGC_PARALLEL_STATISTICS)
mergeEndTime = omrtime_hires_clock();
env->_sweepStats.addToMergeTime(mergeStartTime, mergeEndTime);
#endif /* J9MODRON_TGC_PARALLEL_STATISTICS */
env->_currentTask->releaseSynchronizedGCThreads(env);
}
}
void
MM_EnvironmentBase::allocationFailureStartReportIfRequired(MM_AllocateDescription *allocDescription, uintptr_t flags)
{
if (!_allocationFailureReported) {
MM_GCExtensionsBase *extensions = getExtensions();
OMRPORT_ACCESS_FROM_OMRPORT(_portLibrary);
Trc_MM_AllocationFailureStart(getLanguageVMThread(),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_OLD),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_OLD),
(extensions->largeObjectArea ? extensions->heap->getApproximateActiveFreeLOAMemorySize(MEMORY_TYPE_OLD) : 0),
(extensions->largeObjectArea ? extensions->heap->getActiveLOAMemorySize(MEMORY_TYPE_OLD) : 0),
allocDescription->getBytesRequested());
Trc_OMRMM_AllocationFailureStart(getOmrVMThread(),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_OLD),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_OLD),
(extensions->largeObjectArea ? extensions->heap->getApproximateActiveFreeLOAMemorySize(MEMORY_TYPE_OLD) : 0),
(extensions->largeObjectArea ? extensions->heap->getActiveLOAMemorySize(MEMORY_TYPE_OLD) : 0),
allocDescription->getBytesRequested());
if (J9_EVENT_IS_HOOKED(extensions->privateHookInterface, J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_START)) {
MM_CommonGCStartData commonData;
extensions->heap->initializeCommonGCStartData(this, &commonData);
ALWAYS_TRIGGER_J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_START(
extensions->privateHookInterface,
getOmrVMThread(),
omrtime_hires_clock(),
J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_START,
allocDescription->getBytesRequested(),
&commonData,
flags,
allocDescription->getTenuredFlag());
}
_allocationFailureReported = true;
}
}
/**
* Initializes the MM_VerboseManager instance.
*/
bool
MM_VerboseManager::initialize(MM_EnvironmentBase *env)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
MM_GCExtensionsBase *extensions = MM_GCExtensionsBase::getExtensions(env->getOmrVM());
_mmPrivateHooks = J9_HOOK_INTERFACE(extensions->privateHookInterface);
_omrHooks = J9_HOOK_INTERFACE(extensions->omrHookInterface);
_writerChain = MM_VerboseWriterChain::newInstance(env);
if (NULL == _writerChain) {
return false;
}
if(NULL == (_verboseHandlerOutput = createVerboseHandlerOutputObject(env))) {
return false;
}
_lastOutputTime = omrtime_hires_clock();
return true;
}
void
GCConfigTest::SetUp()
{
OMRPORT_ACCESS_FROM_OMRPORT(gcTestEnv->portLib);
printMemUsed("Setup()", gcTestEnv->portLib);
/* Initialize heap and collector */
MM_StartupManagerTestExample startupManager(exampleVM->_omrVM, GetParam());
omr_error_t rc = OMR_GC_IntializeHeapAndCollector(exampleVM->_omrVM, &startupManager);
ASSERT_EQ(OMR_ERROR_NONE, rc) << "Setup(): OMR_GC_IntializeHeapAndCollector failed, rc=" << rc;
/* Attach calling thread to the VM */
exampleVM->_omrVMThread = NULL;
rc = OMR_Thread_Init(exampleVM->_omrVM, NULL, &exampleVM->_omrVMThread, "OMRTestThread");
ASSERT_EQ(OMR_ERROR_NONE, rc) << "Setup(): OMR_Thread_Init failed, rc=" << rc;
/* Kick off the dispatcher threads */
rc = OMR_GC_InitializeDispatcherThreads(exampleVM->_omrVMThread);
ASSERT_EQ(OMR_ERROR_NONE, rc) << "Setup(): OMR_GC_InitializeDispatcherThreads failed, rc=" << rc;
env = MM_EnvironmentBase::getEnvironment(exampleVM->_omrVMThread);
/* load config file */
omrtty_printf("Configuration File: %s\n", GetParam());
#if defined(OMRGCTEST_PRINTFILE)
printFile(GetParam());
#endif
pugi::xml_parse_result result = doc.load_file(GetParam());
if (!result) {
FAIL() << "Failed to load test configuration file (" << GetParam() << ") with error description: " << result.description() << ".";
}
/* parse verbose information and initialize verbose manager */
pugi::xml_node optionNode = doc.select_node("/gc-config/option").node();
const char *verboseFileNamePrefix = optionNode.attribute("verboseLog").value();
numOfFiles = (uintptr_t)optionNode.attribute("numOfFiles").as_int();
uintptr_t numOfCycles = (uintptr_t)optionNode.attribute("numOfCycles").as_int();
if (0 == strcmp(verboseFileNamePrefix, "")) {
verboseFileNamePrefix = "VerboseGCOutput";
}
verboseFile = (char *)omrmem_allocate_memory(MAX_NAME_LENGTH, OMRMEM_CATEGORY_MM);
if (NULL == verboseFile) {
FAIL() << "Failed to allocate native memory.";
}
omrstr_printf(verboseFile, MAX_NAME_LENGTH, "%s_%d_%lld.xml", verboseFileNamePrefix, omrsysinfo_get_pid(), omrtime_current_time_millis());
verboseManager = MM_VerboseManager::newInstance(env, exampleVM->_omrVM);
verboseManager->configureVerboseGC(exampleVM->_omrVM, verboseFile, numOfFiles, numOfCycles);
omrtty_printf("Verbose File: %s\n", verboseFile);
#if defined(OMRGCTEST_DEBUG)
omrtty_printf("Verbose GC log name: %s; numOfFiles: %d; numOfCycles: %d.\n", verboseFile, numOfFiles, numOfCycles);
#endif
verboseManager->enableVerboseGC();
verboseManager->setInitializedTime(omrtime_hires_clock());
/* create object table */
objectTable.create();
/* create root table */
exampleVM->rootTable = hashTableNew(
gcTestEnv->portLib, OMR_GET_CALLSITE(), 0, sizeof(RootEntry), 0, 0, OMRMEM_CATEGORY_MM,
rootTableHashFn, rootTableHashEqualFn, NULL, NULL);
}
