Merge pull request #21382 from adpopescu/jfr-gc-heap-event

Add JFR GCHeapConfiguration Event

Author: tajila

runtime/vm/JFRChunkWriter.cpp

@@ -809,6 +809,70 @@ VM_JFRChunkWriter::writeOSInformationEvent()
 	return dataStart;
 }
 
+void
+VM_JFRChunkWriter::writeNarrowOOPModeTypesEvent()
+{
+	U_8 *dataStart = writeCheckpointEventHeader(Generic, 1);
+
+	/* class ID */
+	_bufferWriter->writeLEB128(NarrowOopModesID);
+
+	/* number of states */
+	_bufferWriter->writeLEB128(OOPModeTypeCount);
+
+	for (int i = 0; i < OOPModeTypeCount; i++) {
+		/* constant index */
+		_bufferWriter->writeLEB128(i);
+
+		/* write string */
+		writeStringLiteral(oopModeTypeNames[i]);
+	}
+
+	/* write size */
+	writeEventSize(dataStart);
+
+}
+
+void
+VM_JFRChunkWriter::writeGCHeapConfigurationEvent()
+{
+	GCHeapConfigurationEntry *gcConfig = &(VM_JFRConstantPoolTypes::getJFRConstantEvents(_vm)->GCHeapConfigEntry);
+
+	/* reserve size field */
+	U_8 *dataStart = reserveEventSize();
+
+	/* write event type */
+	_bufferWriter->writeLEB128(GCHeapConfigID);
+
+	/* write event start time */
+	_bufferWriter->writeLEB128(j9time_nano_time());
+
+	/* write heap min size */
+	_bufferWriter->writeLEB128(gcConfig->minSize);
+
+	/* write heap max size */
+	_bufferWriter->writeLEB128(gcConfig->maxSize);
+
+	/* write heap initial size */
+	_bufferWriter->writeLEB128(gcConfig->initialSize);
+
+	/* write whether oops are used or not */
+	_bufferWriter->writeBoolean(gcConfig->usesCompressedOops);
+
+	/* write oops type being used */
+	_bufferWriter->writeLEB128(gcConfig->compressedOopsMode);
+
+	/* write how object alignment is on the heap */
+	_bufferWriter->writeLEB128(gcConfig->objectAlignment);
+
+	/* write how many bits head addresses are */
+	_bufferWriter->writeLEB128(gcConfig->heapAddressBits);
+
+	/* write event size */
+	writeEventSize(dataStart);
+
+}
+
 void
 VM_JFRChunkWriter::writeInitialSystemPropertyEvents(J9JavaVM *vm)
 {

runtime/vm/JFRChunkWriter.hpp

@@ -52,6 +52,10 @@ static constexpr const char * const threadStateNames[] = {
 	"STATE_BLOCKED_ON_MONITOR_ENTER"
 };
 
+static constexpr const char * const oopModeTypeNames[] = {
+	"Zero based"
+};
+
 enum StringEnconding {
 	NullString = 0,
 	EmptyString,
@@ -82,13 +86,15 @@ enum MetadataTypeID {
 	PhysicalMemoryID = 108,
 	ExecutionSampleID = 109,
 	ThreadDumpID = 111,
+	GCHeapConfigID = 133,
 	ThreadID = 164,
 	ThreadGroupID = 165,
 	ClassID = 166,
 	ClassLoaderID = 167,
 	MethodID = 168,
 	SymbolID = 169,
 	ThreadStateID = 170,
+	NarrowOopModesID = 180,
 	ModuleID = 186,
 	PackageID = 187,
 	StackTraceID = 188,
@@ -148,6 +154,7 @@ class VM_JFRChunkWriter {
 	static constexpr int CHECKPOINT_EVENT_HEADER_AND_FOOTER = 68;
 	static constexpr int STRING_CONSTANT_SIZE = 128;
 	static constexpr int THREADSTATE_ENTRY_LENGTH = CHECKPOINT_EVENT_HEADER_AND_FOOTER + sizeof(threadStateNames) + (THREADSTATE_COUNT * STRING_HEADER_LENGTH);
+	static constexpr int OOP_MODES_ENTRY_SIZE = CHECKPOINT_EVENT_HEADER_AND_FOOTER + sizeof(oopModeTypeNames) + (OOPModeTypeCount * STRING_HEADER_LENGTH);
 	static constexpr int CLASS_ENTRY_ENTRY_SIZE = (5 * sizeof(U_64)) + sizeof(U_8);
 	static constexpr int CLASSLOADER_ENTRY_SIZE = 3 * sizeof(U_64);
 	static constexpr int PACKAGE_ENTRY_SIZE = (3 * sizeof(U_64)) + sizeof(U_8);
@@ -344,6 +351,10 @@ class VM_JFRChunkWriter {
 
 			writeFrameTypeCheckpointEvent();
 
+			if (0 == _vm->jfrState.jfrChunkCount) {
+				writeNarrowOOPModeTypesEvent();
+			}
+
 			writeThreadCheckpointEvent();
 
 			writeThreadGroupCheckpointEvent();
@@ -399,6 +410,8 @@ class VM_JFRChunkWriter {
 				writeInitialSystemPropertyEvents(_vm);
 
 				writeInitialEnvironmentVariableEvents();
+
+				writeGCHeapConfigurationEvent();
 			}
 
 			writePhysicalMemoryEvent();
@@ -800,6 +813,10 @@ class VM_JFRChunkWriter {
 
 	U_8 *writeThreadDumpEvent();
 
+	void writeNarrowOOPModeTypesEvent();
+
+	void writeGCHeapConfigurationEvent();
+
 	void writeInitialSystemPropertyEvents(J9JavaVM *vm);
 
 	void writeInitialEnvironmentVariableEvents();

runtime/vm/JFRConstantPoolTypes.hpp

@@ -63,6 +63,11 @@ enum FrameType {
 	FrameTypeCount,
 };
 
+enum OOPModeType {
+	ZeroBased = 0,
+	OOPModeTypeCount,
+};
+
 enum ThreadState {
 	NEW = 0,
 	TERMINATED,
@@ -288,6 +293,16 @@ struct CPUInformationEntry {
 	U_32 hwThreads;
 };
 
+struct GCHeapConfigurationEntry {
+	U_64 minSize;
+	U_64 maxSize;
+	U_64 initialSize;
+	BOOLEAN usesCompressedOops;
+	OOPModeType compressedOopsMode;
+	U_64 objectAlignment;
+	UDATA heapAddressBits;
+};
+
 struct VirtualizationInformationEntry {
 	const char *name;
 };
@@ -301,6 +316,7 @@ struct JFRConstantEvents {
 	CPUInformationEntry CPUInfoEntry;
 	VirtualizationInformationEntry VirtualizationInfoEntry;
 	OSInformationEntry OSInfoEntry;
+	GCHeapConfigurationEntry GCHeapConfigEntry;
 };
 
 class VM_JFRConstantPoolTypes {
@@ -989,6 +1005,7 @@ class VM_JFRConstantPoolTypes {
 		initializeCPUInformationEvent(vm, currentThread, result);
 		initializeVirtualizationInformation(vm);
 		initializeOSInformation(vm, result);
+		initializeGCHeapConfigurationEvent(vm, result);
 	}
 
 	/**
@@ -1209,6 +1226,26 @@ class VM_JFRConstantPoolTypes {
 		}
 	}
 
+	/**
+	 * Initialize GCHeapConfigurationEntry
+	 *
+	 * @param vm[in] the J9JavaVM
+	 */
+	static void initializeGCHeapConfigurationEvent(J9JavaVM *vm, BuildResult *result)
+	{
+		J9MemoryManagerFunctions *mmFuncs = vm->memoryManagerFunctions;
+		GCHeapConfigurationEntry *gcConfiguration = &(getJFRConstantEvents(vm)->GCHeapConfigEntry);
+
+		gcConfiguration->minSize = mmFuncs->j9gc_get_initial_heap_size(vm);
+		gcConfiguration->maxSize = mmFuncs->j9gc_get_maximum_heap_size(vm);
+		gcConfiguration->initialSize = gcConfiguration->minSize;
+		uintptr_t value;
+		gcConfiguration->usesCompressedOops = mmFuncs->j9gc_modron_getConfigurationValueForKey(vm, j9gc_modron_configuration_compressObjectReferences, &value) ? value : 0;
+		gcConfiguration->compressedOopsMode = ZeroBased;
+		gcConfiguration->objectAlignment = vm->objectAlignmentInBytes;
+		gcConfiguration->heapAddressBits = J9JAVAVM_REFERENCE_SIZE(vm) * 8;
+	}
+
 	VM_JFRConstantPoolTypes(J9VMThread *currentThread)
 		: _currentThread(currentThread)
 		, _vm(currentThread->javaVM)

test/functional/cmdLineTests/jfr/jfrevents.xml

@@ -75,4 +75,10 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-ex
 		<output type="success" caseSensitive="yes" regex="no">stackTrace</output>
 		<output type="failure" caseSensitive="yes" regex="no">jfr print: could not read recording</output>
 	</test>
+	<test id="test jfr gc heap configuration - approx 30seconds">
+		<command>$JFR_EXE$ print --xml --events "GCHeapConfiguration" defaultJ9recording.jfr</command>
+		<output type="required" caseSensitive="yes" regex="no">http://www.w3.org/2001/XMLSchema-instance</output>
+		<output type="success" caseSensitive="yes" regex="no">jdk.GCHeapConfiguration</output>
+		<output type="failure" caseSensitive="yes" regex="no">jfr print: could not read recording</output>
+	</test>
 </suite>