static void
removeDump(OMRPortLibrary *portLib, const char *filename, const char *testName)
{
OMRPORT_ACCESS_FROM_OMRPORT(portLib);
bool removeDumpSucceeded = true;
portTestEnv->changeIndent(1);
/* Delete the file if possible. */
#if defined(J9ZOS390)
char deleteCore[EsMaxPath] = {0};
sprintf(deleteCore, "tso delete %s", (strstr(filename, ".") + 1));
char *ending = strstr(deleteCore, ".X&DS");
if (NULL != ending) {
strncpy(ending, ".X001", 5);
}
if (-1 == system(deleteCore)) {
removeDumpSucceeded = false;
}
#else /* defined(J9ZOS390) */
if (0 != remove(filename)) {
removeDumpSucceeded = false;
}
#endif /* defined(J9ZOS390) */
if (removeDumpSucceeded) {
portTestEnv->log("removed: %s\n", filename);
} else {
outputErrorMessage(PORTTEST_ERROR_ARGS, "\tfailed to remove %s\n", filename);
}
portTestEnv->changeIndent(-1);
}
static uintptr_t
simpleHandlerFunction(struct OMRPortLibrary *portLibrary, uint32_t gpType, void *gpInfo, void *handler_arg)
{
OMRPORT_ACCESS_FROM_OMRPORT(portLibrary);
simpleHandlerInfo *info = (simpleHandlerInfo *)handler_arg;
const char *testName = info->testName;
uintptr_t rc;
portTestEnv->log("calling omrdump_create with filename: %s\n", info->coreFileName);
#if defined(J9ZOS390)
rc = omrdump_create(info->coreFileName, "IEATDUMP", NULL);
#else
rc = omrdump_create(info->coreFileName, NULL, NULL);
#endif
if (rc == 0) {
uintptr_t verifyFileRC = 99;
portTestEnv->log("omrdump_create claims to have written a core file to: %s\n", info->coreFileName);
verifyFileRC = verifyFileExists(PORTTEST_ERROR_ARGS, info->coreFileName);
if (verifyFileRC == 0) {
removeDump(OMRPORTLIB, info->coreFileName, testName);
}
} else {
outputErrorMessage(PORTTEST_ERROR_ARGS, "omrdump_create returned: %u, with filename: %s", rc, info->coreFileName);
}
return OMRPORT_SIG_EXCEPTION_RETURN;
}
/**
* Probe the file system for existing files. Determine
* the first number which is unused, or the number of the oldest
* file if all numbers are used.
* @return the first file number to use (starting at 0), or -1 on failure
*/
intptr_t
MM_VerboseWriterFileLogging::findInitialFile(MM_EnvironmentBase *env)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
MM_GCExtensionsBase *extensions = MM_GCExtensionsBase::getExtensions(env->getOmrVM());
int64_t oldestTime = J9CONST64(0x7FFFFFFFFFFFFFFF); /* the highest possible time. */
intptr_t oldestFile = 0;
if (_mode != rotating_files) {
/* nothing to do */
return 0;
}
for (uintptr_t currentFile = 0; currentFile < _numFiles; currentFile++) {
char *filenameToOpen = expandFilename(env, currentFile);
if (NULL == filenameToOpen) {
return -1;
}
int64_t thisTime = omrfile_lastmod(filenameToOpen);
extensions->getForge()->free(filenameToOpen);
if (thisTime < 0) {
/* file doesn't exist, or some other problem reading the file */
oldestFile = currentFile;
break;
} else if (thisTime < oldestTime) {
oldestTime = thisTime;
oldestFile = currentFile;
}
}
return oldestFile;
}
/**
* Call omrdump_create() without passing in core file name. This does not actually test that a core file was actually created.
*/
TEST(PortDumpTest, dump_test_create_dump_with_NO_name)
{
OMRPORT_ACCESS_FROM_OMRPORT(portTestEnv->getPortLibrary());
const char *testName = "omrdump_test_create_dump_with_NO_name";
uintptr_t rc = 99;
char coreFileName[EsMaxPath];
BOOLEAN doFileVerification = FALSE;
#if defined(AIXPPC)
struct vario myvar;
int sys_parmRC;
#endif
reportTestEntry(OMRPORTLIB, testName);
coreFileName[0] = '\0';
#if 0
/* try out a NULL test (turns out this crashes) */
rc = omrdump_create(NULL, NULL, NULL); /* this crashes */
#endif
/* try out a more sane NULL test */
portTestEnv->log("calling omrdump_create with empty filename\n");
#if defined(J9ZOS390)
rc = omrdump_create(coreFileName, "IEATDUMP", NULL);
#else
rc = omrdump_create(coreFileName, NULL, NULL);
#endif
if (rc == 0) {
uintptr_t verifyFileRC = 99;
portTestEnv->log("omrdump_create claims to have written a core file to: %s\n", coreFileName);
#if defined(AIXPPC)
/* We defer to fork abort on AIX machines that don't have "Enable full CORE dump" enabled in smit,
* in which case omrdump_create will not return the filename.
* So, only check for a specific filename if we are getting full core dumps */
sys_parmRC = sys_parm(SYSP_GET, SYSP_V_FULLCORE, &myvar);
if ((sys_parmRC == 0) && (myvar.v.v_fullcore.value == 1)) {
doFileVerification = TRUE;
}
#else /* defined(AIXPPC) */
doFileVerification = TRUE;
#endif /* defined(AIXPPC) */
if (doFileVerification) {
verifyFileRC = verifyFileExists(PORTTEST_ERROR_ARGS, coreFileName);
if (verifyFileRC == 0) {
removeDump(OMRPORTLIB, coreFileName, testName);
}
}
} else {
outputErrorMessage(PORTTEST_ERROR_ARGS, "omrdump_create returned: %u, with filename: %s", rc, coreFileName);
}
reportTestExit(OMRPORTLIB, testName);
}
/**
* Removes a directory by recursively removing sub-directory and files.
*
* @param[in] portLibrary The port library
* @param[in] directory to clean up
*
* @return void
*/
void
deleteControlDirectory(struct OMRPortLibrary *portLibrary, char *baseDir)
{
OMRPORT_ACCESS_FROM_OMRPORT(portLibrary);
struct J9FileStat buf;
omrfile_stat(baseDir, (uint32_t)0, &buf);
if (buf.isDir != 1) {
omrfile_unlink(baseDir);
} else {
char mybaseFilePath[EsMaxPath];
char resultBuffer[EsMaxPath];
uintptr_t rc, handle;
omrstr_printf(mybaseFilePath, EsMaxPath, "%s", baseDir);
rc = handle = omrfile_findfirst(mybaseFilePath, resultBuffer);
while ((uintptr_t)-1 != rc) {
char nextEntry[EsMaxPath];
/* skip current and parent dir */
if (resultBuffer[0] == '.') {
rc = omrfile_findnext(handle, resultBuffer);
continue;
}
omrstr_printf(nextEntry, EsMaxPath, "%s/%s", mybaseFilePath, resultBuffer);
deleteControlDirectory(OMRPORTLIB, nextEntry);
rc = omrfile_findnext(handle, resultBuffer);
}
if (handle != (uintptr_t)-1) {
omrfile_findclose(handle);
}
omrfile_unlinkdir(mybaseFilePath);
}
}
bool
MM_VerboseWriter::initialize(MM_EnvironmentBase* env)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
MM_GCExtensionsBase* ext = env->getExtensions();
/* Initialize _header */
const char* version = omrgc_get_version(env->getOmrVM());
/* The length is -2 for the "%s" in VERBOSEGC_HEADER and +1 for '\0' */
uintptr_t headerLength = strlen(version) + strlen(VERBOSEGC_HEADER) - 1;
_header = (char*)ext->getForge()->allocate(sizeof(char) * headerLength, OMR::GC::AllocationCategory::DIAGNOSTIC, OMR_GET_CALLSITE());
if (NULL == _header) {
return false;
}
omrstr_printf(_header, headerLength, VERBOSEGC_HEADER, version);
/* Initialize _footer */
uintptr_t footerLength = strlen(VERBOSEGC_FOOTER) + 1;
_footer = (char*)ext->getForge()->allocate(sizeof(char) * footerLength, OMR::GC::AllocationCategory::DIAGNOSTIC, OMR_GET_CALLSITE());
if (NULL == _footer) {
ext->getForge()->free(_header);
return false;
}
omrstr_printf(_footer, footerLength, VERBOSEGC_FOOTER);
return true;
}
wchar_t *
convertFromUTF8(OMRPortLibrary *portLibrary, const char *string, wchar_t *unicodeBuffer, uintptr_t unicodeBufferSize)
{
wchar_t *unicodeString;
uintptr_t length;
OMRPORT_ACCESS_FROM_OMRPORT(portLibrary);
if (NULL == string) {
return NULL;
}
length = (uintptr_t)strlen(string);
if (length < unicodeBufferSize) {
unicodeString = unicodeBuffer;
} else {
unicodeString = (wchar_t *)omrmem_allocate_memory((length + 1) * 2, OMRMEM_CATEGORY_PORT_LIBRARY);
if (NULL == unicodeString) {
return NULL;
}
}
if (0 == MultiByteToWideChar(OS_ENCODING_CODE_PAGE, OS_ENCODING_MB_FLAGS, string, -1, unicodeString, (int)length + 1)) {
omrerror_set_last_error(GetLastError(), OMRPORT_ERROR_OPFAILED);
if (unicodeString != unicodeBuffer) {
omrmem_free_memory(unicodeString);
}
return NULL;
}
return unicodeString;
}
TEST(TraceLifecycleTest, deregisterSubscriberAfterShutdown)
{
/* OMR VM data structures */
OMRTestVM testVM;
OMR_VMThread *vmthread = NULL;
UtSubscription *subscriptionID = NULL;
const OMR_TI *ti = omr_agent_getTI();
OMRPORT_ACCESS_FROM_OMRPORT(rasTestEnv->getPortLibrary());
char *datDir = getTraceDatDir(rasTestEnv->_argc, (const char **)rasTestEnv->_argv);
OMRTEST_ASSERT_ERROR_NONE(omrTestVMInit(&testVM, OMRPORTLIB));
/* use small buffers to exercise buffer wrapping */
OMRTEST_ASSERT_ERROR_NONE(omr_ras_initTraceEngine(&testVM.omrVM, "buffers=1k:maximal=all:print=omr_test", datDir));
/* Attach the thread to the trace engine */
OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "registerSubscriberAfterShutdown"));
/* Register the subscriber */
OMRTEST_ASSERT_ERROR_NONE(
ti->RegisterRecordSubscriber(vmthread, "registerSubscriberAfterShutdown", subscribeFunc, NULL, NULL, &subscriptionID));
/* Shut down the trace engine */
OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread));
/* Attempt to deregister using external agent API. This succeeds because this thread is still attached to the trace engine. */
OMRTEST_ASSERT_ERROR_NONE(ti->DeregisterRecordSubscriber(vmthread, subscriptionID));
/* Now clear up the VM we started for this test case. */
OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread));
OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM));
ASSERT_TRUE(NULL == (void *)omr_test_UtModuleInfo.intf);
}
static void
testDispatch(OMRPortLibrary *portLib, uintptr_t *passCount, uintptr_t *failCount, uintptr_t event, uintptr_t expectedResult)
{
OMRPORT_ACCESS_FROM_OMRPORT(portLib);
uintptr_t count = 0;
switch (event) {
case TESTHOOK_EVENT1:
TRIGGER_TESTHOOK_EVENT1(sampleHookInterface, count, -1);
break;
case TESTHOOK_EVENT2:
TRIGGER_TESTHOOK_EVENT2(sampleHookInterface, 1, count, -1);
break;
case TESTHOOK_EVENT3:
TRIGGER_TESTHOOK_EVENT3(sampleHookInterface, 2, 3, count, -1);
break;
case TESTHOOK_EVENT4:
TRIGGER_TESTHOOK_EVENT4(sampleHookInterface, 4, 5, 6, count, -1);
break;
}
if (count == expectedResult) {
(*passCount)++;
} else {
omrtty_printf("Incorrect number of listeners responded for 0x%zx. Got %d, expected %d\n", event, count, expectedResult);
(*failCount)++;
}
}
bool
MM_MemoryManager::isLargePage(MM_EnvironmentBase* env, uintptr_t pageSize)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
uintptr_t* pageSizes = omrvmem_supported_page_sizes();
return pageSize > pageSizes[0];
}
bool
MM_ConcurrentGCIncrementalUpdate::createCardTable(MM_EnvironmentBase *env)
{
bool result = false;
Assert_MM_true(NULL == _cardTable);
Assert_MM_true(NULL == _extensions->cardTable);
#if defined(AIXPPC) || defined(LINUXPPC)
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
if ((uintptr_t)omrsysinfo_get_number_CPUs_by_type(OMRPORT_CPU_ONLINE) > 1 ) {
_cardTable = MM_ConcurrentCardTableForWC::newInstance(env, _extensions->getHeap(), _markingScheme, this);
} else
#endif /* AIXPPC || LINUXPPC */
{
_cardTable = MM_ConcurrentCardTable::newInstance(env, _extensions->getHeap(), _markingScheme, this);
}
if(NULL != _cardTable) {
result = true;
/* Set card table address in GC Extensions */
_extensions->cardTable = _cardTable;
}
return result;
}
static int J9THREAD_PROC
moduleUnloadAfterThreadDetachHelper(void *entryArg)
{
omr_error_t rc = OMR_ERROR_NONE;
ChildThreadData *childData = (ChildThreadData *)entryArg;
OMRTestVM *testVM = childData->testVM;
OMR_VMThread *vmthread = NULL;
OMRPORT_ACCESS_FROM_OMRPORT(testVM->portLibrary);
rc = OMRTEST_PRINT_ERROR(OMR_Thread_Init(&testVM->omrVM, NULL, &vmthread, "moduleUnloadAfterThreadDetachHelper"));
if (OMR_ERROR_NONE != rc) {
childData->childRc = rc;
return -1;
}
UT_OMR_TEST_MODULE_LOADED(testVM->omrVM._trcEngine->utIntf);
Trc_OMR_Test_String(vmthread, "This tracepoint should appear.");
rc = OMRTEST_PRINT_ERROR(OMR_Thread_Free(vmthread));
if (OMR_ERROR_NONE != rc) {
childData->childRc = rc;
return -1;
}
/* This should fail silently without crashing */
UT_OMR_TEST_MODULE_UNLOADED(testVM->omrVM._trcEngine->utIntf);
return 0;
}
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);
}
ObjectEntry *
GCConfigTest::createObject(const char *namePrefix, OMRGCObjectType objType, int32_t depth, int32_t nthInRow, uintptr_t size)
{
OMRPORT_ACCESS_FROM_OMRPORT(gcTestEnv->portLib);
ObjectEntry *objEntry = NULL;
char *objName = (char *)omrmem_allocate_memory(MAX_NAME_LENGTH, OMRMEM_CATEGORY_MM);
if (NULL == objName) {
omrtty_printf("%s:%d Failed to allocate native memory.\n", __FILE__, __LINE__);
goto done;
}
omrstr_printf(objName, MAX_NAME_LENGTH, "%s_%d_%d", namePrefix, depth, nthInRow);
objEntry = find(objName);
if (NULL != objEntry) {
#if defined(OMRGCTEST_DEBUG)
omrtty_printf("Found object %s in object table.\n", objEntry->name);
#endif
omrmem_free_memory(objName);
} else {
objEntry = allocateHelper(objName, size);
if (NULL != objEntry) {
/* Keep count of the new allocated non-garbage object size for garbage insertion. If the object exists in objectTable, its size is ignored. */
if ((ROOT == objType) || (NORMAL == objType)) {
gp.accumulatedSize += env->getExtensions()->objectModel.getSizeInBytesWithHeader(objEntry->objPtr);
}
} else {
omrmem_free_memory(objName);
}
}
done:
return objEntry;
}
/**
* Wait for expected event and optionally bring event related data back.
*
* @param testName The name of the waiting thread
* @param info The pointer to SigMaskTestInfo object
* @param event The expected event
* @param result The event related data
* @param size The size of the event data
* @return TRUE upon success; FALSE if expected event did not occur before timeout.
*/
static BOOLEAN
waitForEvent(const char *testName, SigMaskTestInfo *info, SignalEvent event, void *result, size_t size)
{
OMRPORT_ACCESS_FROM_OMRPORT(info->portLibrary);
BOOLEAN ret = FALSE;
intptr_t waitRC = J9THREAD_WOULD_BLOCK;
omrthread_monitor_enter(info->monitor);
while (info->bulletinBoard.event != event) {
waitRC = omrthread_monitor_wait_timed(info->monitor, 60000, 0);
if (J9THREAD_TIMED_OUT == waitRC) {
break;
}
}
ret = (info->bulletinBoard.event == event);
if (TRUE == ret) {
if ((NULL != result) && (size > 0)) {
memcpy(result, &info->bulletinBoard.data, size);
}
} else {
if (J9THREAD_TIMED_OUT == waitRC) {
outputErrorMessage(PORTTEST_ERROR_ARGS, "timed out without being notified. expected (%d), received (%d)\n", event, info->bulletinBoard.event);
} else {
outputErrorMessage(PORTTEST_ERROR_ARGS, "expected event(%d) was not received. bulletinBoard(%d)\n", event, info->bulletinBoard.event);
}
}
info->bulletinBoard.event = INVALID;
omrthread_monitor_exit(info->monitor);
return ret;
}
uint64_t
incrementTraceCounter(UtModuleInfo *moduleInfo, UtComponentList *componentList, int32_t tracepoint)
{
UtComponentData *compData;
OMRPORT_ACCESS_FROM_OMRPORT(OMR_TRACEGLOBAL(portLibrary));
if (moduleInfo == NULL) {
/* this is an internal tracepoint */
UT_DBGOUT(2, ("<UT> incrementTraceCounter short circuit returning due to NULL compName\n"));
return 0;
}
compData = getComponentDataForModule(moduleInfo, componentList);
if (compData == NULL) {
UT_DBGOUT(1, ("<UT> Unable to increment trace counter %s.%d - no component\n", moduleInfo->name, tracepoint));
return 0;
}
if (compData->moduleInfo == NULL) {
UT_DBGOUT(1, ("<UT> Unable to increment trace counter %s.%d - no such loaded component\n", moduleInfo->name, tracepoint));
return 0;
}
if (compData->tracepointcounters == NULL) {
/* first time anything in this component has been counted */
compData->tracepointcounters = (uint64_t *) omrmem_allocate_memory(sizeof(uint64_t) * compData->moduleInfo->count, OMRMEM_CATEGORY_TRACE);
if (compData->tracepointcounters == NULL) {
UT_DBGOUT(1, ("<UT> Unable to allocate trace counter buffers for %s\n", moduleInfo->name));
return 0;
}
memset(compData->tracepointcounters, 0, sizeof(uint64_t) * compData->moduleInfo->count);
}
return ++compData->tracepointcounters[tracepoint];
}
void
MM_VerboseManagerImpl::tearDown(MM_EnvironmentBase *env)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
MM_VerboseManager::tearDown(env);
omrmem_free_memory(this->filename);
}
TEST(TraceLifecycleTest, moduleUnloadAfterThreadDetach)
{
/* OMR VM data structures */
OMRTestVM testVM;
OMR_VMThread *vmthread = NULL;
omrthread_t childThread = NULL;
ChildThreadData *childData = NULL;
OMRPORT_ACCESS_FROM_OMRPORT(rasTestEnv->getPortLibrary());
char *datDir = getTraceDatDir(rasTestEnv->_argc, (const char **)rasTestEnv->_argv);
OMRTEST_ASSERT_ERROR_NONE(omrTestVMInit(&testVM, OMRPORTLIB));
/* use small buffers to exercise buffer wrapping */
OMRTEST_ASSERT_ERROR_NONE(omr_ras_initTraceEngine(&testVM.omrVM, "buffers=1k:maximal=all:print=omr_test", datDir));
OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Init(&testVM.omrVM, NULL, &vmthread, "moduleLoadBeforeThreadAttach"));
ASSERT_NO_FATAL_FAILURE(startChildThread(&testVM, &childThread, moduleUnloadAfterThreadDetachHelper, &childData));
ASSERT_EQ(1, omrthread_resume(childThread));
OMRTEST_ASSERT_ERROR_NONE(waitForChildThread(&testVM, childThread, childData));
/* Unload the module that was left loaded by the child thread */
UT_OMR_TEST_MODULE_UNLOADED(testVM.omrVM._trcEngine->utIntf);
/* Now clear up the VM we started for this test case. */
OMRTEST_ASSERT_ERROR_NONE(omr_ras_cleanupTraceEngine(vmthread));
OMRTEST_ASSERT_ERROR_NONE(OMR_Thread_Free(vmthread));
OMRTEST_ASSERT_ERROR_NONE(omrTestVMFini(&testVM));
ASSERT_TRUE(NULL == (void *)omr_test_UtModuleInfo.intf);
}
DDR_RC
readFileList(OMRPortLibrary *portLibrary, const char *debugFileList, vector<string> *debugFiles)
{
OMRPORT_ACCESS_FROM_OMRPORT(portLibrary);
DDR_RC rc = DDR_RC_OK;
/* Read list of debug files to scan from the input file. */
intptr_t fd = omrfile_open(debugFileList, EsOpenRead, 0660);
if (0 > fd) {
ERRMSG("Failure attempting to open %s\nExiting...\n", debugFileList);
rc = DDR_RC_ERROR;
} else {
char *buff = NULL;
int64_t offset = omrfile_seek(fd, 0, SEEK_END);
if (-1 != offset) {
buff = (char *)malloc(offset + 1);
memset(buff, 0, offset + 1);
omrfile_seek(fd, 0, SEEK_SET);
if (0 < omrfile_read(fd, buff, offset)) {
char *fileName = strtok(buff, "\n");
while (NULL != fileName) {
debugFiles->push_back(string(fileName));
fileName = strtok(NULL, "\n");
}
}
free(buff);
}
}
return rc;
}
static int J9THREAD_PROC
shutdownTraceHelper(void *entryArg)
{
omr_error_t rc = OMR_ERROR_NONE;
ChildThreadData *childData = (ChildThreadData *)entryArg;
OMRTestVM *testVM = childData->testVM;
OMR_VMThread *vmthread = NULL;
OMRPORT_ACCESS_FROM_OMRPORT(testVM->portLibrary);
rc = OMRTEST_PRINT_ERROR(OMR_Thread_Init(&testVM->omrVM, NULL, &vmthread, "shutdownTraceHelper"));
if (OMR_ERROR_NONE != rc) {
childData->childRc = rc;
return -1;
}
rc = OMRTEST_PRINT_ERROR(omr_ras_cleanupTraceEngine(vmthread));
if (OMR_ERROR_NONE != rc) {
childData->childRc = rc;
return -1;
}
rc = OMRTEST_PRINT_ERROR(OMR_Thread_Free(vmthread));
if (OMR_ERROR_NONE != rc) {
childData->childRc = rc;
return -1;
}
return 0;
}
void
MM_ParallelMarkTask::cleanup(MM_EnvironmentBase *env)
{
_markingScheme->workerCleanupAfterGC(env);
if (env->isMasterThread()) {
Assert_MM_true(_cycleState == env->_cycleState);
} else {
env->_cycleState = NULL;
}
/* record the thread-specific parallelism stats in the trace buffer. This partially duplicates info in -Xtgc:parallel */
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
Trc_MM_ParallelMarkTask_parallelStats(
env->getLanguageVMThread(),
(uint32_t)env->getSlaveID(),
(uint32_t)omrtime_hires_delta(0, env->_workPacketStats._workStallTime, OMRPORT_TIME_DELTA_IN_MILLISECONDS),
(uint32_t)omrtime_hires_delta(0, env->_workPacketStats._completeStallTime, OMRPORT_TIME_DELTA_IN_MILLISECONDS),
(uint32_t)omrtime_hires_delta(0, env->_markStats._syncStallTime, OMRPORT_TIME_DELTA_IN_MILLISECONDS),
(uint32_t)env->_workPacketStats._workStallCount,
(uint32_t)env->_workPacketStats._completeStallCount,
(uint32_t)env->_markStats._syncStallCount,
env->_workPacketStats.workPacketsAcquired,
env->_workPacketStats.workPacketsReleased,
env->_workPacketStats.workPacketsExchanged,
0/* TODO CRG figure out to get the array split size*/);
}
int32_t
GCConfigTest::triggerOperation(pugi::xml_node node)
{
OMRPORT_ACCESS_FROM_OMRPORT(gcTestEnv->portLib);
int32_t rt = 0;
for (; node; node = node.next_sibling()) {
if (0 == strcmp(node.name(), "systemCollect")) {
const char *gcCodeStr = node.attribute("gcCode").value();
if (0 == strcmp(gcCodeStr, "")) {
/* gcCode defaults to J9MMCONSTANT_IMPLICIT_GC_DEFAULT */
gcCodeStr = "0";
}
uint32_t gcCode = (uint32_t)atoi(gcCodeStr);
omrtty_printf("Invoking gc system collect with gcCode %d...\n", gcCode);
rt = (int32_t)OMR_GC_SystemCollect(exampleVM->_omrVMThread, gcCode);
if (OMR_ERROR_NONE != rt) {
omrtty_printf("%s:%d Failed to perform OMR_GC_SystemCollect with error code %d.\n", __FILE__, __LINE__, rt);
goto done;
}
OMRGCTEST_CHECK_RT(rt);
verboseManager->getWriterChain()->endOfCycle(env);
}
}
done:
return rt;
}
/**
* Initialize a new lock object.
* A lock must be initialized before it may be used.
*
* @param env
* @param options
* @param name Lock name
* @return TRUE on success
* @note Creates a store barrier.
*/
bool
MM_LightweightNonReentrantLock::initialize(MM_EnvironmentBase *env, ModronLnrlOptions *options, const char * name)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
/* initialize variables in case constructor was not called */
_initialized = false;
_tracing = NULL;
_extensions = env->getExtensions();
if (NULL != _extensions) {
J9Pool* tracingPool = _extensions->_lightweightNonReentrantLockPool;
if (NULL != tracingPool) {
omrthread_monitor_enter(_extensions->_lightweightNonReentrantLockPoolMutex);
_tracing = (J9ThreadMonitorTracing *)pool_newElement(tracingPool);
omrthread_monitor_exit(_extensions->_lightweightNonReentrantLockPoolMutex);
if (NULL == _tracing) {
goto error_no_memory;
}
_tracing->monitor_name = NULL;
if (NULL != name) {
uintptr_t length = omrstr_printf(NULL, 0, "[%p] %s", this, name) + 1;
if (length > MAX_LWNR_LOCK_NAME_SIZE) {
goto error_no_memory;
}
_tracing->monitor_name = _nameBuf;
if (NULL == _tracing->monitor_name) {
goto error_no_memory;
}
omrstr_printf(_tracing->monitor_name, length, "[%p] %s", this, name);
}
}
}
#if defined(OMR_ENV_DATA64)
if(0 != (((uintptr_t)this) % sizeof(uintptr_t))) {
omrtty_printf("GC FATAL: LWNRL misaligned.\n");
abort();
}
#endif
#if defined(J9MODRON_USE_CUSTOM_SPINLOCKS)
_initialized = omrgc_spinlock_init(&_spinlock) ? false : true;
_spinlock.spinCount1 = options->spinCount1;
_spinlock.spinCount2 = options->spinCount2;
_spinlock.spinCount3 = options->spinCount3;
#else /* J9MODRON_USE_CUSTOM_SPINLOCKS */
_initialized = MUTEX_INIT(_mutex) ? true : false;
#endif /* J9MODRON_USE_CUSTOM_SPINLOCKS */
return _initialized;
error_no_memory:
return false;
}
void
MM_VerboseHandlerOutputStandard::handleScavengeEnd(J9HookInterface** hook, uintptr_t eventNum, void* eventData)
{
MM_ScavengeEndEvent* event = (MM_ScavengeEndEvent*)eventData;
MM_EnvironmentBase* env = MM_EnvironmentBase::getEnvironment(event->currentThread);
MM_GCExtensionsBase *extensions = MM_GCExtensionsBase::getExtensions(env->getOmrVM());
MM_VerboseManager* manager = getManager();
MM_VerboseWriterChain* writer = manager->getWriterChain();
MM_ScavengerStats *scavengerStats = &extensions->scavengerStats;
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
uint64_t duration = 0;
bool deltaTimeSuccess = getTimeDeltaInMicroSeconds(&duration, scavengerStats->_startTime, scavengerStats->_endTime);
enterAtomicReportingBlock();
handleGCOPOuterStanzaStart(env, "scavenge", env->_cycleState->_verboseContextID, duration, deltaTimeSuccess);
writer->formatAndOutput(env, 1, "<scavenger-info tenureage=\"%zu\" tenuremask=\"%4zx\" tiltratio=\"%zu\" />", scavengerStats->_tenureAge, scavengerStats->getFlipHistory(0)->_tenureMask, scavengerStats->_tiltRatio);
if (0 != scavengerStats->_flipCount) {
writer->formatAndOutput(env, 1, "<memory-copied type=\"nursery\" objects=\"%zu\" bytes=\"%zu\" bytesdiscarded=\"%zu\" />",
scavengerStats->_flipCount, scavengerStats->_flipBytes, scavengerStats->_flipDiscardBytes);
}
if (0 != scavengerStats->_tenureAggregateCount) {
writer->formatAndOutput(env, 1, "<memory-copied type=\"tenure\" objects=\"%zu\" bytes=\"%zu\" bytesdiscarded=\"%zu\" />",
scavengerStats->_tenureAggregateCount, scavengerStats->_tenureAggregateBytes, scavengerStats->_tenureDiscardBytes);
}
if (0 != scavengerStats->_failedFlipCount) {
writer->formatAndOutput(env, 1, "<copy-failed type=\"nursery\" objects=\"%zu\" bytes=\"%zu\" />",
scavengerStats->_failedFlipCount, scavengerStats->_failedFlipBytes);
}
if (0 != scavengerStats->_failedTenureCount) {
writer->formatAndOutput(env, 1, "<copy-failed type=\"tenure\" objects=\"%zu\" bytes=\"%zu\" />",
scavengerStats->_failedTenureCount, scavengerStats->_failedTenureBytes);
}
handleScavengeEndInternal(env, eventData);
if(0 != scavengerStats->_tenureExpandedCount) {
uint64_t expansionMicros = omrtime_hires_delta(0, scavengerStats->_tenureExpandedTime, OMRPORT_TIME_DELTA_IN_MICROSECONDS);
outputCollectorHeapResizeInfo(env, 1, HEAP_EXPAND, scavengerStats->_tenureExpandedBytes, scavengerStats->_tenureExpandedCount, MEMORY_TYPE_OLD, SATISFY_COLLECTOR, expansionMicros);
}
if(scavengerStats->_rememberedSetOverflow) {
writer->formatAndOutput(env, 1, "<warning details=\"remembered set overflow detected\" />");
if(scavengerStats->_causedRememberedSetOverflow) {
writer->formatAndOutput(env, 1, "<warning details=\"remembered set overflow triggered\" />");
}
}
if(scavengerStats->_scanCacheOverflow) {
writer->formatAndOutput(env, 1, "<warning details=\"scan cache overflow (storage acquired from heap)\" />");
}
if(scavengerStats->_backout) {
writer->formatAndOutput(env, 1, "<warning details=\"aborted collection due to insufficient free space\" />");
}
handleGCOPOuterStanzaEnd(env);
writer->flush(env);
exitAtomicReportingBlock();
}
/* Utility function for parsing command line options */
static void
freeSubString(char *buffer)
{
OMRPORT_ACCESS_FROM_OMRPORT(OMR_TRACEGLOBAL(portLibrary));
UT_DBGOUT(2, ("<UT> freeSubString: buffer %p\n", buffer));
omrmem_free_memory(buffer);
return;
}
void
spaceSavingFree(OMRSpaceSaving *spaceSaving)
{
OMRPORT_ACCESS_FROM_OMRPORT(spaceSaving->portLib);
rankingFree(spaceSaving->ranking);
omrmem_free_memory(spaceSaving);
return;
}
/**
* 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);
}
J9Pool *
MM_ConfigurationSegregated::createEnvironmentPool(MM_EnvironmentBase *env)
{
OMRPORT_ACCESS_FROM_OMRPORT(env->getPortLibrary());
uintptr_t numberOfElements = getConfigurationDelegate()->getInitialNumberOfPooledEnvironments(env);
/* number of elements, pool flags = 0, 0 selects default pool configuration (at least 1 element, puddle size rounded to OS page size) */
return pool_new(sizeof(MM_EnvironmentBase), numberOfElements, sizeof(uint64_t), 0, OMR_GET_CALLSITE(), OMRMEM_CATEGORY_MM, POOL_FOR_PORT(OMRPORTLIB));
}
static omr_error_t
addDeferredConfigToList(const char *componentName, int32_t all, int32_t first, int32_t last,
unsigned char value, int level, const char *groupName,
UtDeferredConfigInfo **configList, int32_t setActive)
{
UtDeferredConfigInfo *dconfiginfo;
UtDeferredConfigInfo *temp;
OMRPORT_ACCESS_FROM_OMRPORT(OMR_TRACEGLOBAL(portLibrary));
/* 1) add to deferred options for components that register */
UT_DBGOUT(2, ("<UT> setTracePointsTo: component %s applying to all and adding to global deferred", componentName));
dconfiginfo = (UtDeferredConfigInfo *)omrmem_allocate_memory(sizeof(UtDeferredConfigInfo), OMRMEM_CATEGORY_TRACE);
if (dconfiginfo == NULL) {
UT_DBGOUT(1, ("<UT> Unable to set tracepoints in %s - can't allocate config info\n", componentName));
return OMR_ERROR_OUT_OF_NATIVE_MEMORY;
}
dconfiginfo->componentName = (char *)omrmem_allocate_memory(strlen(componentName) + 1, OMRMEM_CATEGORY_TRACE);
if (dconfiginfo->componentName == NULL) {
UT_DBGOUT(1, ("<UT> Unable to set tracepoints in %s - can't allocate config info componentName\n", componentName));
return OMR_ERROR_OUT_OF_NATIVE_MEMORY;
}
strcpy(dconfiginfo->componentName, componentName);
dconfiginfo->all = all;
dconfiginfo->firstTracePoint = first;
dconfiginfo->lastTracePoint = last;
dconfiginfo->value = value;
dconfiginfo->level = level;
dconfiginfo->setActive = setActive;
if (groupName == NULL) {
dconfiginfo->groupName = NULL;
} else {
dconfiginfo->groupName = (char *)omrmem_allocate_memory(strlen(groupName) + 1, OMRMEM_CATEGORY_TRACE);
if (dconfiginfo->groupName == NULL) {
UT_DBGOUT(1, ("<UT> Unable to set tracepoints in %s - can't allocate config info groupName\n", componentName));
return OMR_ERROR_OUT_OF_NATIVE_MEMORY;
}
strcpy(dconfiginfo->groupName, groupName);
}
dconfiginfo->next = NULL;
if (*configList == NULL) {
*configList = dconfiginfo;
} else {
temp = *configList;
while (temp->next != NULL) {
temp = temp->next;
}
temp->next = dconfiginfo;
}
return OMR_ERROR_NONE;
}
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);
}
