More JFR events support

Add support for: - PhysicalMemory - CPUInformation - OSInformation - VirtualizationInformation Signed-off-by: Gengchen Tuo <gengchen.tuo@ibm.com>
eclipse-openj9 · Sep 5, 2024 · 80e619d · 80e619d
1 parent 91b5703
commit 80e619d
Show file tree

Hide file tree

Showing 5 changed files with 393 additions and 70 deletions.
diff --git a/runtime/vm/JFRChunkWriter.cpp b/runtime/vm/JFRChunkWriter.cpp
@@ -19,11 +19,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
  *******************************************************************************/
+#include "JFRUtils.hpp"
 #include "vm_internal.h"
 
 #if defined(J9VM_OPT_JFR)
 
 #include "JFRChunkWriter.hpp"
+#include "JFRConstantPoolTypes.hpp"
 
 void
 VM_JFRChunkWriter::writeJFRHeader()
@@ -638,7 +640,7 @@ VM_JFRChunkWriter::writeStacktraceCheckpointEvent()
 U_8 *
 VM_JFRChunkWriter::writeJVMInformationEvent()
 {
-	JVMInformationEntry *jvmInfo= &(((JFRConstantEvents *)(_vm->jfrState.constantEvents))->JVMInfoEntry);
+	JVMInformationEntry *jvmInfo= &(VM_JFRConstantPoolTypes::getJFRConstantEvents(_vm)->JVMInfoEntry);
 
 	/* reserve size field */
 	U_8 *dataStart = _bufferWriter->getAndIncCursor(sizeof(U_32));
@@ -647,7 +649,7 @@ VM_JFRChunkWriter::writeJVMInformationEvent()
 	_bufferWriter->writeLEB128(JVMInformationID);
 
 	/* write start time */
-	_bufferWriter->writeLEB128(jvmInfo->jvmStartTime);
+	_bufferWriter->writeLEB128(j9time_current_time_millis());
 
 	/* write JVM name */
 	writeStringLiteral(jvmInfo->jvmName);
@@ -676,5 +678,112 @@ VM_JFRChunkWriter::writeJVMInformationEvent()
 	return dataStart;
 }
 
+U_8 *
+VM_JFRChunkWriter::writePhysicalMemoryEvent()
+{
+	/* reserve size field */
+	U_8 *dataStart = _bufferWriter->getAndIncCursor(sizeof(U_32));
+
+	_bufferWriter->writeLEB128(PhysicalMemoryID);
+
+	/* write start time */
+	_bufferWriter->writeLEB128(j9time_current_time_millis());
+
+	J9MemoryInfo memInfo = {0};
+	I_32 rc = j9sysinfo_get_memory_info(&memInfo);
+	if (0 == rc) {
+		/* write total size */
+		_bufferWriter->writeLEB128(memInfo.totalPhysical);
+		/* write used size */
+		_bufferWriter->writeLEB128(memInfo.totalPhysical - memInfo.availPhysical);
+	} else {
+		_buildResult = InternalVMError;
+	}
+	/* write size */
+	_bufferWriter->writeLEB128PaddedU32(dataStart, _bufferWriter->getCursor() - dataStart);
+
+	return dataStart;
+}
+
+U_8 *
+VM_JFRChunkWriter::writeCPUInformationEvent()
+{
+	CPUInformationEntry *cpuInfo= &(VM_JFRConstantPoolTypes::getJFRConstantEvents(_vm)->CPUInfoEntry);
+
+	/* reserve size field */
+	U_8 *dataStart = _bufferWriter->getAndIncCursor(sizeof(U_32));
+
+	/* write event type */
+	_bufferWriter->writeLEB128(CPUInformationID);
+
+	/* write start time */
+	_bufferWriter->writeLEB128(j9time_current_time_millis());
+
+	/* write CPU type */
+	writeStringLiteral(cpuInfo->cpu);
+
+	/* write CPU description */
+	writeStringLiteral(cpuInfo->description);
+
+	/* write CPU sockets */
+	_bufferWriter->writeLEB128(cpuInfo->sockets);
+
+	/* write CPU cores */
+	_bufferWriter->writeLEB128(cpuInfo->cores);
+
+	/* write CPU hardware threads */
+	_bufferWriter->writeLEB128(cpuInfo->hwThreads);
+
+	/* write size */
+	_bufferWriter->writeLEB128PaddedU32(dataStart, _bufferWriter->getCursor() - dataStart);
+
+	return dataStart;
+}
+
+U_8 *
+VM_JFRChunkWriter::writeVirtualizationInformationEvent()
+{
+	VirtualizationInformationEntry *virtualizationInfo= &(VM_JFRConstantPoolTypes::getJFRConstantEvents(_vm)->VirtualizationInfoEntry);
+
+	/* reserve size field */
+	U_8 *dataStart = _bufferWriter->getAndIncCursor(sizeof(U_32));
+
+	/* write event type */
+	_bufferWriter->writeLEB128(VirtualizationInformationID);
+
+	/* write start time */
+	_bufferWriter->writeLEB128(j9time_current_time_millis());
+
+	/* write virtualization name */
+	writeStringLiteral(virtualizationInfo->name);
+
+	/* write size */
+	_bufferWriter->writeLEB128PaddedU32(dataStart, _bufferWriter->getCursor() - dataStart);
+
+	return dataStart;
+}
+
+U_8 *
+VM_JFRChunkWriter::writeOSInformationEvent()
+{
+	OSInformationEntry *osInfo = &(VM_JFRConstantPoolTypes::getJFRConstantEvents(_vm)->OSInfoEntry);
+
+	/* reserve size field */
+	U_8 *dataStart = _bufferWriter->getAndIncCursor(sizeof(U_32));
+
+	/* write event type */
+	_bufferWriter->writeLEB128(OSInformationID);
+
+	/* write start time */
+	_bufferWriter->writeLEB128(j9time_current_time_millis());
+
+	/* write OS version */
+	writeStringLiteral(osInfo->osVersion);
+
+	/* write size */
+	_bufferWriter->writeLEB128PaddedU32(dataStart, _bufferWriter->getCursor() - dataStart);
+
+	return dataStart;
+}
 
 #endif /* defined(J9VM_OPT_JFR) */
diff --git a/runtime/vm/JFRChunkWriter.hpp b/runtime/vm/JFRChunkWriter.hpp
@@ -66,6 +66,10 @@ enum MetadataTypeID {
 	ThreadEndID = 3,
 	ThreadSleepID = 4,
 	JVMInformationID = 86,
+	OSInformationID = 87,
+	VirtualizationInformationID = 88,
+	CPUInformationID = 92,
+	PhysicalMemoryID = 107,
 	ExecutionSampleID = 108,
 	ThreadID = 163,
 	ThreadGroupID = 164,
@@ -145,6 +149,10 @@ class VM_JFRChunkWriter {
 	static constexpr int THREAD_END_EVENT_SIZE = (4 * sizeof(U_64)) + sizeof(U_32);
 	static constexpr int THREAD_SLEEP_EVENT_SIZE = (7 * sizeof(U_64)) + sizeof(U_32);
 	static constexpr int JVM_INFORMATION_EVENT_SIZE = 3000;
+	static constexpr int PHYSICAL_MEMORY_EVENT_SIZE = (4 * sizeof(U_64)) + sizeof(U_32);
+	static constexpr int VIRTUALIZATION_INFORMATION_EVENT_SIZE = 50;
+	static constexpr int CPU_INFORMATION_EVENT_SIZE = 600;
+	static constexpr int OS_INFORMATION_EVENT_SIZE = 30;
 
 	static constexpr int METADATA_ID = 1;
 
@@ -249,6 +257,21 @@ class VM_JFRChunkWriter {
 			_constantPoolTypes.printTables();
 		}
 
+		if (FALSE == _vm->jfrState.isConstantEventsInitialized) {
+			omrthread_monitor_enter(_vm->jfrState.isConstantEventsInitializedMutex);
+			if (FALSE == _vm->jfrState.isConstantEventsInitialized) {
+				VM_JFRConstantPoolTypes::initializeJFRConstantEvents(_vm, _currentThread, &_buildResult);
+				if (isResultNotOKay()) {
+					VM_JFRConstantPoolTypes::freeJFRConstantEvents(_vm);
+					goto done;
+				}
+				/* Ensure that initialization is complete when the initialized variable is set to true */
+				VM_AtomicSupport::writeBarrier();
+				_vm->jfrState.isConstantEventsInitialized = TRUE;
+			}
+			omrthread_monitor_exit(_vm->jfrState.isConstantEventsInitializedMutex);
+		}
+
 		requiredBufferSize = calculateRequiredBufferSize();
 		if (isResultNotOKay()) {
 			goto done;
@@ -300,14 +323,29 @@ class VM_JFRChunkWriter {
 
 			writeJVMInformationEvent();
 
+			writePhysicalMemoryEvent();
+
+			writeCPUInformationEvent();
+
+			writeVirtualizationInformationEvent();
+
+			writeOSInformationEvent();
+
 			writeJFRHeader();
 
+			if (isResultNotOKay()) {
+				Trc_VM_jfr_ErrorWritingChunk(_currentThread, _buildResult);
+				goto freeBuffer;
+			}
+
 			writeJFRChunkToFile();
 
+			_vm->jfrState.jfrChunkCount += 1;
+
+freeBuffer:
 			_bufferWriter = NULL;
 			j9mem_free_memory(buffer);
 
-			_vm->jfrState.jfrChunkCount += 1;
 		}
 done:
 		return;
@@ -482,6 +520,14 @@ class VM_JFRChunkWriter {
 
 	U_8 *writeJVMInformationEvent();
 
+	U_8 *writePhysicalMemoryEvent();
+
+	U_8 *writeCPUInformationEvent();
+
+	U_8 *writeVirtualizationInformationEvent();
+
+	U_8 *writeOSInformationEvent();
+
 	UDATA
 	calculateRequiredBufferSize()
 	{
@@ -522,6 +568,14 @@ class VM_JFRChunkWriter {
 
 		requireBufferSize += JVM_INFORMATION_EVENT_SIZE;
 
+		requireBufferSize += OS_INFORMATION_EVENT_SIZE;
+
+		requireBufferSize += PHYSICAL_MEMORY_EVENT_SIZE;
+
+		requireBufferSize += VIRTUALIZATION_INFORMATION_EVENT_SIZE;
+
+		requireBufferSize += CPU_INFORMATION_EVENT_SIZE;
+
 		return requireBufferSize;
 	}