Merge pull request #23155 from thallium/jfr

Add JFR ThreadAllocationStatistics event support

Author: tajila

runtime/oti/j9consts.h

@@ -1011,6 +1011,7 @@ extern "C" {
 #define J9JFR_EVENT_TYPE_CLASS_LOADER_STATISTICS 31
 #define J9JFR_EVENT_TYPE_NATIVE_LIBRARY 32
 #define J9JFR_EVENT_TYPE_THREAD_DUMP 33
+#define J9JFR_EVENT_TYPE_THREAD_ALLOCATION_STATISTICS 34
 
 /* JFR thread states. */
 

runtime/oti/j9nonbuilder.h

@@ -585,6 +585,11 @@ typedef struct J9JFRThreadDump {
 	UDATA bufferSize;
 } J9JFRThreadDump;
 
+typedef struct J9JFRThreadAllocationStatistics {
+	J9JFR_EVENT_COMMON_FIELDS
+	U_64 allocated;
+} J9JFRThreadAllocationStatistics;
+
 #endif /* defined(J9VM_OPT_JFR) */
 
 /* @ddr_namespace: map_to_type=J9CfrError */
@@ -6764,6 +6769,9 @@ typedef struct J9JavaVM {
 	IDATA jfrAsyncKey;
 	IDATA jfrThreadCPULoadAsyncKey;
 	UDATA isJFRExcludedOffset;
+#if JAVA_SPEC_VERSION >= 17
+	IDATA jfrThreadAllocationStatisticsAsyncKey;
+#endif /* JAVA_SPEC_VERSION >= 17 */
 #endif /* defined(J9VM_OPT_JFR) */
 	UDATA unsafeIndexableHeaderSize;
 #if defined(J9VM_OPT_SNAPSHOTS)

runtime/oti/vm_api.h

@@ -6031,6 +6031,9 @@ requestJFREvent(J9VMThread *currentThread, jlong id);
 UDATA
 getThreadDump(J9VMThread *currentThread, U_8 *buffer, UDATA bufferSize);
 
+I_64
+getThreadTID(J9VMThread *currentThread, J9VMThread *vmThread);
+
 #endif /* defined(J9VM_OPT_JFR) */
 
 #ifdef __cplusplus

runtime/vm/JFRChunkWriter.cpp

@@ -1157,6 +1157,31 @@ VM_JFRChunkWriter::writeClassLoaderStatisticsEvent(void *anElement, void *userDa
 	writeEventSize(_bufferWriter, dataStart);
 }
 
+void
+VM_JFRChunkWriter::writeThreadAllocationStatisticsEvent(void *anElement, void *userData)
+{
+	ThreadAllocationStatisticsEntry *entry = (ThreadAllocationStatisticsEntry *)anElement;
+	VM_BufferWriter *_bufferWriter = (VM_BufferWriter *)userData;
+
+	/* reserve size field */
+	U_8 *dataStart = reserveEventSize(_bufferWriter);
+
+	/* write event type */
+	_bufferWriter->writeLEB128(ThreadAllocationStatisticsID);
+
+	/* write start time */
+	_bufferWriter->writeLEB128(entry->ticks);
+
+	/* write allocated bytes */
+	_bufferWriter->writeLEB128(entry->allocated);
+
+	/* write thread */
+	_bufferWriter->writeLEB128(entry->threadIndex);
+
+	/* write size */
+	writeEventSize(_bufferWriter, dataStart);
+}
+
 void
 VM_JFRChunkWriter::writeThreadContextSwitchRateEvent(void *anElement, void *userData)
 {

runtime/vm/JFRChunkWriter.hpp

@@ -115,6 +115,7 @@ enum MetadataTypeID {
 	DataLossID = 86,
 	ClassLoadingStatisticsID = 100,
 	ClassLoaderStatisticsID = 101,
+	ThreadAllocationStatisticsID = 107,
 	PhysicalMemoryID = 108,
 	ExecutionSampleID = 109,
 	ThreadDumpID = 111,
@@ -240,6 +241,7 @@ class VM_JFRChunkWriter {
 	static constexpr int GC_HEAP_SUMMARY_EVENT_SIZE = sizeof(U_8) + (7 * LEB128_64_SIZE) + (3 * LEB128_32_SIZE);
 	static constexpr int NETWORK_UTILIZATION_EVENT_SIZE = (4 * sizeof(U_64)) + sizeof(U_32);
 	static constexpr int DATA_LOSS_EVENT_SIZE = sizeof(U_8) + LEB128_32_SIZE + (3 * LEB128_64_SIZE);
+	static constexpr int THREAD_ALLOCATION_STATISTICS_EVENT_SIZE = sizeof(U_8) + LEB128_32_SIZE + (3 * LEB128_64_SIZE);
 
 	static constexpr int METADATA_ID = 1;
 
@@ -459,6 +461,8 @@ class VM_JFRChunkWriter {
 
 			pool_do(_constantPoolTypes.getClassLoaderStatisticsTable(), &writeClassLoaderStatisticsEvent, _bufferWriter);
 
+			pool_do(_constantPoolTypes.getThreadAllocationStatisticsTable(), &writeThreadAllocationStatisticsEvent, _bufferWriter);
+
 			pool_do(_constantPoolTypes.getThreadContextSwitchRateTable(), &writeThreadContextSwitchRateEvent, _bufferWriter);
 
 			pool_do(_constantPoolTypes.getThreadStatisticsTable(), &writeThreadStatisticsEvent, _bufferWriter);
@@ -957,6 +961,8 @@ class VM_JFRChunkWriter {
 
 	static void writeClassLoaderStatisticsEvent(void *anElement, void *userData);
 
+	static void writeThreadAllocationStatisticsEvent(void *anElement, void *userData);
+
 	static void writeThreadContextSwitchRateEvent(void *anElement, void *userData);
 
 	static void writeThreadStatisticsEvent(void *anElement, void *userData);
@@ -1059,6 +1065,8 @@ class VM_JFRChunkWriter {
 
 		requiredBufferSize += _constantPoolTypes.getClassLoaderStatisticsCount() * CLASS_LOADER_STATISTICS_EVENT_SIZE;
 
+		requiredBufferSize += _constantPoolTypes.getThreadAllocationStatisticsCount() * THREAD_ALLOCATION_STATISTICS_EVENT_SIZE;
+
 		requiredBufferSize += _constantPoolTypes.getThreadContextSwitchRateCount() * THREAD_CONTEXT_SWITCH_RATE_SIZE;
 
 		requiredBufferSize += _constantPoolTypes.getThreadStatisticsCount() * THREAD_STATISTICS_EVENT_SIZE;

runtime/vm/JFRConstantPoolTypes.cpp

@@ -1547,6 +1547,24 @@ VM_JFRConstantPoolTypes::addThreadDumpEntry(J9JFRThreadDump *threadDumpData)
 	return;
 }
 
+void
+VM_JFRConstantPoolTypes::addThreadAllocationStatistics(J9JFRThreadAllocationStatistics *threadAlocationData)
+{
+	ThreadAllocationStatisticsEntry *entry = (ThreadAllocationStatisticsEntry *)pool_newElement(_threadAllocationStatisticsTable);
+
+	if (NULL == entry) {
+		_buildResult = OutOfMemory;
+		goto done;
+	}
+
+	entry->ticks = threadAlocationData->startTicks;
+	entry->threadIndex = threadAlocationData->currentThreadTID;
+	entry->allocated = threadAlocationData->allocated;
+
+done:
+	return;
+}
+
 void
 VM_JFRConstantPoolTypes::printTables()
 {

runtime/vm/JFRConstantPoolTypes.hpp

@@ -315,6 +315,12 @@ struct ClassLoaderStatisticsEntry {
 	U_64 hiddenBlockSize;
 };
 
+struct ThreadAllocationStatisticsEntry {
+	I_64 ticks;
+	U_64 threadIndex;
+	U_64 allocated;
+};
+
 struct ThreadContextSwitchRateEntry {
 	I_64 ticks;
 	float switchRate;
@@ -555,6 +561,8 @@ class VM_JFRConstantPoolTypes {
 	UDATA _dataLossCount;
 	J9Pool *_threadDumpTable;
 	UDATA _threadDumpCount;
+	J9Pool *_threadAllocationStatisticsTable;
+	UDATA _threadAllocationStatisticsCount;
 
 	/* Periodic events. */
 	bool _shouldWriteJVMInformation;
@@ -727,8 +735,6 @@ class VM_JFRConstantPoolTypes {
 
 	U_32 addStringUTF8Entry(J9UTF8 *string, bool free);
 
-	U_32 addThreadEntry(J9VMThread *vmThread);
-
 	U_32 addNetworkInterfaceNameEntry(const char *networkInterfaceName);
 
 	U_32 addThreadGroupEntry(j9object_t threadGroup);
@@ -879,6 +885,8 @@ class VM_JFRConstantPoolTypes {
 
 	void addThreadDumpEntry(J9JFRThreadDump *threadDumpData);
 
+	void addThreadAllocationStatistics(J9JFRThreadAllocationStatistics *threadAlocationData);
+
 	void addThreadObjectEntry(J9JFRThreadObject *tableEntry);
 
 	J9Pool *getExecutionSampleTable()
@@ -936,6 +944,11 @@ class VM_JFRConstantPoolTypes {
 		return _classLoaderStatisticsTable;
 	}
 
+	J9Pool *getThreadAllocationStatisticsTable()
+	{
+		return _threadAllocationStatisticsTable;
+	}
+
 	J9Pool *getThreadContextSwitchRateTable()
 	{
 		return _threadContextSwitchRateTable;
@@ -1101,6 +1114,11 @@ class VM_JFRConstantPoolTypes {
 		return _classLoaderStatisticsCount;
 	}
 
+	UDATA getThreadAllocationStatisticsCount()
+	{
+		return _threadAllocationStatisticsCount;
+	}
+
 	UDATA getThreadContextSwitchRateCount()
 	{
 		return _threadContextSwitchRateCount;
@@ -1453,6 +1471,9 @@ class VM_JFRConstantPoolTypes {
 			case J9JFR_EVENT_TYPE_DATA_LOSS:
 				addDataLossEntry((J9JFRDataLoss *)event);
 				break;
+			case J9JFR_EVENT_TYPE_THREAD_ALLOCATION_STATISTICS:
+				addThreadAllocationStatistics((J9JFRThreadAllocationStatistics *)event);
+				break;
 			default:
 				Assert_VM_unreachable();
 				break;
@@ -1464,15 +1485,14 @@ class VM_JFRConstantPoolTypes {
 			goto done;
 		}
 
-		addAllThreads();
-
 		if (J9_ARE_NO_BITS_SET(_vm->extendedRuntimeFlags3, J9_EXTENDED_RUNTIME3_JFR_V2_SUPPORT)) {
 			if (dumpCalled) {
 				loadSystemProcesses(_currentThread);
 				loadNativeLibraries(_currentThread);
 				loadModuleRequireAndModuleExportEvents();
 				loadClassLoaderStatisticsEvents(_currentThread);
 				loadThreadDumpEvents(_currentThread);
+				loadThreadAllocationStatisticsEvents();
 			}
 		} else {
 			if (_shouldWriteSystemProcess) {
@@ -1489,6 +1509,8 @@ class VM_JFRConstantPoolTypes {
 			}
 		}
 
+		addAllThreads();
+
 		shallowEntries = pool_new(sizeof(ClassEntry **), 0, sizeof(U_64), 0, J9_GET_CALLSITE(), OMRMEM_CATEGORY_VM, POOL_FOR_PORT(privatePortLibrary));
 		if (NULL == shallowEntries) {
 			_buildResult = OutOfMemory;
@@ -2092,6 +2114,44 @@ class VM_JFRConstantPoolTypes {
 		return;
 	}
 
+   /**
+	* @brief Generate and add ThreadAllocationStatistics events to _threadAllocationStatisticsTable.
+	*/
+	void loadThreadAllocationStatisticsEvents()
+	{
+		int64_t time = j9time_nano_time();
+		J9InternalVMFunctions *vmFuncs = _vm->internalVMFunctions;
+		J9MemoryManagerFunctions *mmfns = _vm->memoryManagerFunctions;
+
+		Assert_VM_mustHaveVMAccess(_currentThread);
+		vmFuncs->acquireExclusiveVMAccess(_currentThread);
+
+		J9VMThread *walkThread = J9_LINKED_LIST_START_DO(_vm->mainThread);
+
+		while (NULL != walkThread) {
+			ThreadAllocationStatisticsEntry *entry = (ThreadAllocationStatisticsEntry *)pool_newElement(_threadAllocationStatisticsTable);
+			if (NULL == entry) {
+				_buildResult = OutOfMemory;
+				break;
+			}
+			memset(entry, 0, sizeof(*entry));
+
+			entry->ticks = time;
+			entry->threadIndex = getThreadTID(_currentThread, walkThread);
+			if (isResultNotOKay()) {
+				goto done;
+			}
+			UDATA allocated = 0;
+			mmfns->j9gc_get_cumulative_bytes_allocated_by_thread(walkThread, &allocated);
+			entry->allocated = (U_64)allocated;
+
+			_threadAllocationStatisticsCount += 1;
+			walkThread = J9_LINKED_LIST_NEXT_DO(_vm->mainThread, walkThread);
+		}
+done:
+		vmFuncs->releaseExclusiveVMAccess(_currentThread);
+	}
+
 	VM_JFRConstantPoolTypes(J9VMThread *currentThread)
 		: _currentThread(currentThread)
 		, _vm(currentThread->javaVM)
@@ -2170,6 +2230,8 @@ class VM_JFRConstantPoolTypes {
 		, _dataLossCount(0)
 		, _threadDumpTable(NULL)
 		, _threadDumpCount(0)
+		, _threadAllocationStatisticsTable(NULL)
+		, _threadAllocationStatisticsCount(0)
 		, _shouldWriteJVMInformation(false)
 		, _shouldWriteCPUInformationEvent(false)
 		, _shouldWriteVirtualizationInformationEvent(false)
@@ -2326,6 +2388,12 @@ class VM_JFRConstantPoolTypes {
 			goto done;
 		}
 
+		_threadAllocationStatisticsTable = pool_new(sizeof(ThreadAllocationStatisticsEntry), 0, sizeof(U_64), 0, J9_GET_CALLSITE(), OMRMEM_CATEGORY_VM, POOL_FOR_PORT(privatePortLibrary));
+		if (NULL == _threadAllocationStatisticsTable) {
+			_buildResult = OutOfMemory;
+			goto done;
+		}
+
 		_threadContextSwitchRateTable = pool_new(sizeof(ThreadContextSwitchRateEntry), 0, sizeof(U_64), 0, J9_GET_CALLSITE(), OMRMEM_CATEGORY_VM, POOL_FOR_PORT(privatePortLibrary));
 		if (NULL == _threadContextSwitchRateTable) {
 			_buildResult = OutOfMemory;
@@ -2516,6 +2584,7 @@ class VM_JFRConstantPoolTypes {
 		pool_kill(_networkUtilizationTable);
 		pool_kill(_dataLossTable);
 		pool_kill(_threadDumpTable);
+		pool_kill(_threadAllocationStatisticsTable);
 		freeNetworkInterfaceNames();
 		j9mem_free_memory(_globalStringTable);
 	}

runtime/vm/JFRPeriodic.hpp

@@ -47,6 +47,7 @@ class JfrPeriodicEventSet {
 	static void requestOSInformation(J9VMThread *currentThread);
 	static void requestPhysicalMemory(J9VMThread *currentThread);
 	static void requestSystemProcess(J9VMThread *currentThread);
+	static void requestThreadAllocation(J9VMThread *currentThread);
 	static void requestThreadContextSwitchRate(J9VMThread *currentThread);
 	static void requestThreadCPULoad(J9VMThread *currentThread);
 	static void requestThreadDump(J9VMThread *currentThread);