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