JFR PhysicalMemory event fix-up

In V2, respond to emit event request immediately instead of deferring to
chunk generation. This allows multiple such events to be generated in
one chunk.

Related: #24194

Signed-off-by: Gengchen Tuo <gengchen.tuo@ibm.com>

Author: thallium

runtime/oti/j9nonbuilder.h

@@ -585,6 +585,12 @@ typedef struct J9JFRThreadDump {
 	UDATA bufferSize;
 } J9JFRThreadDump;
 
+typedef struct J9JFRPhysicalMemory {
+	J9JFR_EVENT_COMMON_FIELDS
+	U_64 totalSize;
+	U_64 usedSize;
+} J9JFRPhysicalMemory;
+
 #endif /* defined(J9VM_OPT_JFR) */
 
 /* @ddr_namespace: map_to_type=J9CfrError */

runtime/vm/JFRChunkWriter.hpp

@@ -217,7 +217,7 @@ class VM_JFRChunkWriter {
 	static constexpr int MONITOR_ENTER_EVENT_SIZE = sizeof(U_32) + (3 * LEB128_64_SIZE) + (5 * LEB128_32_SIZE);
 	static constexpr int THREAD_PARK_EVENT_SIZE = (9 * 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 PHYSICAL_MEMORY_EVENT_SIZE = LEB128_32_SIZE + (4 * LEB128_64_SIZE);
 	static constexpr int VIRTUALIZATION_INFORMATION_EVENT_SIZE = 50;
 	static constexpr int CPU_INFORMATION_EVENT_SIZE = 600;
 	static constexpr int OS_INFORMATION_EVENT_SIZE = 100;
@@ -475,6 +475,8 @@ class VM_JFRChunkWriter {
 
 			pool_do(_constantPoolTypes.getGarbageCollectionTable(), &writeGarbageCollectionEvent, _bufferWriter);
 
+			pool_do(_constantPoolTypes.getPhysicalMemoryTable(), &writePhysicalMemoryEvent, _bufferWriter);
+
 			pool_do(_constantPoolTypes.getGCHeapSummaryTable(), &writeGCHeapSummaryEvent, _bufferWriter);
 
 			pool_do(_constantPoolTypes.getNetworkUtilizationTable(), &writeNetworkUtilizationEvent, this);
@@ -541,9 +543,7 @@ class VM_JFRChunkWriter {
 					writeYoungGenerationConfigurationEvent();
 				}
 
-				if (_constantPoolTypes.shouldWritePhysicalMemory()) {
-					writePhysicalMemoryEvent();
-				}
+
 			}
 
 			writeJFRHeader();
@@ -871,6 +871,32 @@ class VM_JFRChunkWriter {
 		writeEventSize(_bufferWriter, dataStart);
 	}
 
+	static void
+	writePhysicalMemoryEvent(void *anElement, void *userData)
+	{
+		PhysicalMemoryEntry *entry = (PhysicalMemoryEntry *)anElement;
+		VM_BufferWriter *_bufferWriter = (VM_BufferWriter *)userData;
+
+		/* reserve size field */
+		U_8 *dataStart = reserveEventSize(_bufferWriter);
+
+		/* write event type */
+		_bufferWriter->writeLEB128(PhysicalMemoryID);
+
+		/* write start time */
+		_bufferWriter->writeLEB128(entry->ticks);
+
+		/* write total size */
+		_bufferWriter->writeLEB128(entry->totalSize);
+
+		/* write used size */
+		_bufferWriter->writeLEB128(entry->usedSize);
+
+		/* write size */
+		writeEventSize(_bufferWriter, dataStart);
+	}
+
+
 	void
 	writeJFRChunkToFile()
 	{
@@ -1041,7 +1067,7 @@ class VM_JFRChunkWriter {
 
 		requiredBufferSize += OS_INFORMATION_EVENT_SIZE;
 
-		requiredBufferSize += PHYSICAL_MEMORY_EVENT_SIZE;
+		requiredBufferSize += (_constantPoolTypes.getPhysicalMemoryCount() * PHYSICAL_MEMORY_EVENT_SIZE);
 
 		requiredBufferSize += VIRTUALIZATION_INFORMATION_EVENT_SIZE;
 

runtime/vm/JFRConstantPoolTypes.cpp

@@ -1547,6 +1547,26 @@ VM_JFRConstantPoolTypes::addThreadDumpEntry(J9JFRThreadDump *threadDumpData)
 	return;
 }
 
+void
+VM_JFRConstantPoolTypes::addPhysicalMemoryEntry(J9JFRPhysicalMemory *physicalMemoryData)
+{
+	PhysicalMemoryEntry *entry = (PhysicalMemoryEntry *)pool_newElement(_physicalMemoryTable);
+
+	if (NULL == entry) {
+		_buildResult = OutOfMemory;
+		goto done;
+	}
+
+	entry->ticks = physicalMemoryData->startTicks;
+	entry->totalSize = physicalMemoryData->totalSize;
+	entry->usedSize = physicalMemoryData->usedSize;
+
+	_physicalMemoryCount += 1;
+
+done:
+	return;
+}
+
 void
 VM_JFRConstantPoolTypes::printTables()
 {

runtime/vm/JFRConstantPoolTypes.hpp

@@ -461,6 +461,12 @@ struct ThreadDumpEntry {
 	UDATA resultLength;
 };
 
+struct PhysicalMemoryEntry {
+	I_64 ticks;
+	U_64 totalSize;
+	U_64 usedSize;
+};
+
 struct JFRConstantEvents {
 	JVMInformationEntry JVMInfoEntry;
 	CPUInformationEntry CPUInfoEntry;
@@ -555,6 +561,8 @@ class VM_JFRConstantPoolTypes {
 	UDATA _dataLossCount;
 	J9Pool *_threadDumpTable;
 	UDATA _threadDumpCount;
+	J9Pool *_physicalMemoryTable;
+	UDATA _physicalMemoryCount;
 
 	/* Periodic events. */
 	bool _shouldWriteJVMInformation;
@@ -565,7 +573,6 @@ class VM_JFRConstantPoolTypes {
 	bool _shouldWriteInitialEnvironmentVariableEvents;
 	bool _shouldWritewriteGCHeapConfigurationEvent;
 	bool _shouldWriteYoungGenerationConfigurationEvent;
-	bool _shouldWritePhysicalMemory;
 	bool _shouldWriteSystemProcess;
 	bool _shouldWriteNativeLibrary;
 	bool _shouldWriteModuleRequire;
@@ -875,6 +882,9 @@ class VM_JFRConstantPoolTypes {
 	void addGCHeapSummaryEntry(J9JFRGCHeapSummary *gcHeapSummaryData);
 
 	void addNetworkUtilizationEntry(J9JFRNetworkUtilization *networkUtilizationData);
+
+	void addPhysicalMemoryEntry(J9JFRPhysicalMemory *physicalMemoryData);
+
 	void addDataLossEntry(J9JFRDataLoss *dataLossData);
 
 	void addThreadDumpEntry(J9JFRThreadDump *threadDumpData);
@@ -1256,6 +1266,16 @@ class VM_JFRConstantPoolTypes {
 		return _stackFrameCount;
 	}
 
+	UDATA getPhysicalMemoryCount()
+	{
+		return _physicalMemoryCount;
+	}
+
+	J9Pool *getPhysicalMemoryTable()
+	{
+		return _physicalMemoryTable;
+	}
+
 	bool shouldWriteJVMInformation()
 	{
 		return _shouldWriteJVMInformation;
@@ -1296,11 +1316,6 @@ class VM_JFRConstantPoolTypes {
 		return _shouldWriteYoungGenerationConfigurationEvent;
 	}
 
-	bool shouldWritePhysicalMemory()
-	{
-		return _shouldWritePhysicalMemory;
-	}
-
 	bool shouldWriteSystemProcess()
 	{
 		return _shouldWriteSystemProcess;
@@ -1430,7 +1445,7 @@ class VM_JFRConstantPoolTypes {
 				_shouldWriteYoungGenerationConfigurationEvent = true;
 				break;
 			case J9JFR_EVENT_TYPE_PHYSICAL_MEMORY:
-				_shouldWritePhysicalMemory = true;
+				addPhysicalMemoryEntry((J9JFRPhysicalMemory *)event);
 				break;
 			case J9JFR_EVENT_TYPE_SYSTEM_PROCESS:
 				_shouldWriteSystemProcess = true;
@@ -2170,6 +2185,8 @@ class VM_JFRConstantPoolTypes {
 		, _dataLossCount(0)
 		, _threadDumpTable(NULL)
 		, _threadDumpCount(0)
+		, _physicalMemoryTable(NULL)
+		, _physicalMemoryCount(0)
 		, _shouldWriteJVMInformation(false)
 		, _shouldWriteCPUInformationEvent(false)
 		, _shouldWriteVirtualizationInformationEvent(false)
@@ -2178,7 +2195,6 @@ class VM_JFRConstantPoolTypes {
 		, _shouldWriteInitialEnvironmentVariableEvents(false)
 		, _shouldWritewriteGCHeapConfigurationEvent(false)
 		, _shouldWriteYoungGenerationConfigurationEvent(false)
-		, _shouldWritePhysicalMemory(false)
 		, _shouldWriteSystemProcess(false)
 		, _shouldWriteNativeLibrary(false)
 		, _shouldWriteModuleRequire(false)
@@ -2338,6 +2354,13 @@ class VM_JFRConstantPoolTypes {
 			goto done;
 		}
 
+		_physicalMemoryTable = pool_new(sizeof(PhysicalMemoryEntry), 0, sizeof(U_64), 0, J9_GET_CALLSITE(), OMRMEM_CATEGORY_VM, POOL_FOR_PORT(privatePortLibrary));
+		if (NULL == _physicalMemoryTable) {
+			_buildResult = OutOfMemory;
+			goto done;
+		}
+
+
 		_systemProcessTable = pool_new(sizeof(SystemProcessEntry), 0, sizeof(U_64), 0, J9_GET_CALLSITE(), OMRMEM_CATEGORY_VM, POOL_FOR_PORT(privatePortLibrary));
 		if (NULL == _systemProcessTable) {
 			_buildResult = OutOfMemory;
@@ -2516,6 +2539,7 @@ class VM_JFRConstantPoolTypes {
 		pool_kill(_networkUtilizationTable);
 		pool_kill(_dataLossTable);
 		pool_kill(_threadDumpTable);
+		pool_kill(_physicalMemoryTable);
 		freeNetworkInterfaceNames();
 		j9mem_free_memory(_globalStringTable);
 	}

runtime/vm/jfr.cpp

@@ -193,14 +193,16 @@ jfrEventSize(J9JFREvent *jfrEvent)
 	case J9JFR_EVENT_TYPE_INITIAL_ENVIRONMENT_VARIABLE:
 	case J9JFR_EVENT_TYPE_GC_HEAP_CONFIGURATION:
 	case J9JFR_EVENT_TYPE_YOUNG_GENERATION_CONFIGURATION:
-	case J9JFR_EVENT_TYPE_PHYSICAL_MEMORY:
 	case J9JFR_EVENT_TYPE_SYSTEM_PROCESS:
 	case J9JFR_EVENT_TYPE_MODULE_REQUIRE:
 	case J9JFR_EVENT_TYPE_MODULE_EXPORT:
 	case J9JFR_EVENT_TYPE_CLASS_LOADER_STATISTICS:
 	case J9JFR_EVENT_TYPE_NATIVE_LIBRARY:
 		size = sizeof(J9JFREvent);
 		break;
+	case J9JFR_EVENT_TYPE_PHYSICAL_MEMORY:
+		size = sizeof(J9JFRPhysicalMemory);
+		break;
 	default:
 		Assert_VM_unreachable();
 		break;
@@ -1583,6 +1585,24 @@ jfrThreadStatistics(J9VMThread *currentThread)
 
 }
 
+static void
+jfrPhysicalMemory(J9VMThread *currentThread)
+{
+	PORT_ACCESS_FROM_VMC(currentThread);
+
+	J9MemoryInfo memInfo = {0};
+	I_32 rc = j9sysinfo_get_memory_info(&memInfo);
+
+	if (0 == rc) {
+		J9JFRPhysicalMemory *jfrEvent = (J9JFRPhysicalMemory *)reserveBuffer(currentThread, currentThread, sizeof(J9JFRPhysicalMemory));
+		if (NULL != jfrEvent) {
+			initializeEventFields(currentThread, currentThread, (J9JFREvent *)jfrEvent, J9JFR_EVENT_TYPE_PHYSICAL_MEMORY);
+			jfrEvent->totalSize = memInfo.totalPhysical;
+			jfrEvent->usedSize = memInfo.totalPhysical - memInfo.availPhysical;
+		}
+	}
+}
+
 static int J9THREAD_PROC
 jfrSamplingThreadProc(void *entryArg)
 {
@@ -2307,10 +2327,7 @@ JfrPeriodicEventSet::requestClassLoaderStatistics(J9VMThread *currentThread)
 void
 JfrPeriodicEventSet::requestPhysicalMemory(J9VMThread *currentThread)
 {
-	J9JFREvent *jfrEvent = (J9JFREvent *)reserveBuffer(currentThread, currentThread, sizeof(J9JFREvent));
-	if (NULL != jfrEvent) {
-		initializeEventFields(currentThread, currentThread, jfrEvent, J9JFR_EVENT_TYPE_PHYSICAL_MEMORY);
-	}
+	jfrPhysicalMemory(currentThread);
 }
 
 void