Add JFR CPULoad and ThreadCPU event support

Depends on: eclipse/omr#7491

Signed-off-by: Gengchen Tuo <[email protected]>

runtime/oti/j9consts.h

@@ -931,6 +931,8 @@ extern "C" {
 #define J9JFR_EVENT_TYPE_THREAD_START 1
 #define J9JFR_EVENT_TYPE_THREAD_END 2
 #define J9JFR_EVENT_TYPE_THREAD_SLEEP 3
+#define J9JFR_EVENT_TYPE_CPU_LOAD 4
+#define J9JFR_EVENT_TYPE_THREAD_CPU_LOAD 5
 
 /* JFR thread states */
 

runtime/oti/j9nonbuilder.h

@@ -345,6 +345,12 @@ struct J9VMContinuation;
 
 #if defined(J9VM_OPT_JFR)
 
+typedef struct J9VMThreadJFRState {
+ U_64 prevUserTime;
+ U_64 prevSysTime;
+ I_64 prevTimestamp;
+} ThreadJFRState;
+
 typedef struct J9JFRBufferWalkState {
  U_8 *current;
  U_8 *end;
@@ -402,6 +408,19 @@ typedef struct J9JFRThreadSlept {
 
 #define J9JFRTHREADSLEPT_STACKTRACE(jfrEvent) ((UDATA*)(((J9JFRThreadSlept*)(jfrEvent)) + 1))
 
+typedef struct J9JFRCPULoad {
+ J9JFR_EVENT_COMMON_FIELDS
+ float jvmUser;
+ float jvmSystem;
+ float machineTotal;
+} J9JFRCPULoad;
+
+typedef struct J9JFRThreadCPULoad {
+ J9JFR_EVENT_COMMON_FIELDS
+ float user;
+ float system;
+} J9JFRThreadCPULoad;
+
 #endif /* defined(J9VM_OPT_JFR) */
 
 /* @ddr_namespace: map_to_type=J9CfrError */
@@ -5563,6 +5582,9 @@ typedef struct J9VMThread {
  j9object_t closeScopeObj;
 #endif /* JAVA_SPEC_VERSION >= 22 */
  UDATA unsafeIndexableHeaderSize;
+#if defined(J9VM_OPT_JFR)
+ ThreadJFRState threadJfrState;
+#endif /* defined(J9VM_OPT_JFR) */
 } J9VMThread;
 
 #define J9VMTHREAD_ALIGNMENT 0x100
@@ -5640,6 +5662,9 @@ typedef struct JFRState {
  void *constantEvents;
  BOOLEAN isConstantEventsInitialized;
  omrthread_monitor_t isConstantEventsInitializedMutex;
+ J9SysinfoCPUTime prevSysCPUTime;
+ omrthread_process_time_t prevProcCPUTime;
+ I_64 prevProcTimestamp;
 } JFRState;
 
 typedef struct J9ReflectFunctionTable {
@@ -6179,6 +6204,7 @@ typedef struct J9JavaVM {
  omrthread_t jfrSamplerThread;
  UDATA jfrSamplerState;
  IDATA jfrAsyncKey;
+ IDATA jfrThreadCPULoadAsyncKey;
 #endif /* defined(J9VM_OPT_JFR) */
 #if JAVA_SPEC_VERSION >= 22
  omrthread_monitor_t closeScopeMutex;

runtime/vm/BufferWriter.hpp

@@ -293,6 +293,16 @@ class VM_BufferWriter {
  writeU8(((newVal >> 21) & 0x7F));
  }
 
+ void
+ writeFloat(float val)
+ {
+ U_32 newVal = *(U_32 *)&val;
+ if (_isLE) {
+ newVal = byteSwap(newVal);
+ }
+ writeData((U_8 *)&newVal, 4);
+ }
+
  static U_32
  convertFromLEB128ToU32(U_8 *start)
  {

runtime/vm/JFRChunkWriter.hpp

@@ -70,6 +70,8 @@ enum MetadataTypeID {
  VirtualizationInformationID = 88,
  InitialSystemPropertyID = 89,
  CPUInformationID = 92,
+ CPULoadID = 94,
+ ThreadCPULoadID = 95,
  PhysicalMemoryID = 107,
  ExecutionSampleID = 108,
  ThreadID = 163,
@@ -155,6 +157,8 @@ class VM_JFRChunkWriter {
  static constexpr int CPU_INFORMATION_EVENT_SIZE = 600;
  static constexpr int OS_INFORMATION_EVENT_SIZE = 100;
  static constexpr int INITIAL_SYSTEM_PROPERTY_EVENT_SIZE = 6000;
+ static constexpr int CPU_LOAD_EVENT_SIZE = 3 * sizeof(float) + 3 * sizeof(I_64);
+ static constexpr int THREAD_CPU_LOAD_EVENT_SIZE = 2 * sizeof(float) + 4 * sizeof(I_64);
 
  static constexpr int METADATA_ID = 1;
 
@@ -323,6 +327,10 @@ class VM_JFRChunkWriter {
 
  pool_do(_constantPoolTypes.getThreadSleepTable(), &writeThreadSleepEvent, _bufferWriter);
 
+ pool_do(_constantPoolTypes.getCPULoadTable(), &writeCPULoadEvent, _bufferWriter);
+
+ pool_do(_constantPoolTypes.getThreadCPULoadTable(), &writeThreadCPULoadEvent, _bufferWriter);
+
  /* Only write constant events in first chunk */
  if (0 == _vm->jfrState.jfrChunkCount) {
  writeJVMInformationEvent();
@@ -477,6 +485,62 @@ class VM_JFRChunkWriter {
  _bufferWriter->writeLEB128PaddedU32(dataStart, _bufferWriter->getCursor() - dataStart);
  }
 
+ static void
+ writeCPULoadEvent(void *anElement, void *userData)
+ {
+ CPULoadEntry *entry = (CPULoadEntry *)anElement;
+ VM_BufferWriter *_bufferWriter = (VM_BufferWriter *)userData;
+
+ /* reserve size field */
+ U_8 *dataStart = _bufferWriter->getAndIncCursor(sizeof(U_32));
+
+ /* write event type */
+ _bufferWriter->writeLEB128(CPULoadID);
+
+ /* write start time */
+ _bufferWriter->writeLEB128(entry->ticks);
+
+ /* write user CPU load */
+ _bufferWriter->writeFloat(entry->jvmUser);
+
+ /* write system CPU load */
+ _bufferWriter->writeFloat(entry->jvmSystem);
+
+ /* write machine total CPU load */
+ _bufferWriter->writeFloat(entry->machineTotal);
+
+ /* write size */
+ _bufferWriter->writeLEB128PaddedU32(dataStart, _bufferWriter->getCursor() - dataStart);
+ }
+
+ static void
+ writeThreadCPULoadEvent(void *anElement, void *userData)
+ {
+ ThreadCPULoadEntry *entry = (ThreadCPULoadEntry *)anElement;
+ VM_BufferWriter *_bufferWriter = (VM_BufferWriter *)userData;
+
+ /* reserve size field */
+ U_8 *dataStart = _bufferWriter->getAndIncCursor(sizeof(U_32));
+
+ /* write event type */
+ _bufferWriter->writeLEB128(ThreadCPULoadID);
+
+ /* write start time */
+ _bufferWriter->writeLEB128(entry->ticks);
+
+ /* write thread index */
+ _bufferWriter->writeLEB128(entry->threadIndex);
+
+ /* write user thread CPU load */
+ _bufferWriter->writeFloat(entry->user);
+
+ /* write system thread CPU load */
+ _bufferWriter->writeFloat(entry->system);
+
+ /* write size */
+ _bufferWriter->writeLEB128PaddedU32(dataStart, _bufferWriter->getCursor() - dataStart);
+ }
+
  void
  writeJFRChunkToFile()
  {
@@ -590,6 +654,11 @@ class VM_JFRChunkWriter {
  requireBufferSize += CPU_INFORMATION_EVENT_SIZE;
 
  requireBufferSize += INITIAL_SYSTEM_PROPERTY_EVENT_SIZE;
+
+ requireBufferSize += _constantPoolTypes.getCPULoadCount() * CPU_LOAD_EVENT_SIZE;
+
+ requireBufferSize += _constantPoolTypes.getThreadCPULoadCount() * THREAD_CPU_LOAD_EVENT_SIZE;
+
  return requireBufferSize;
  }
 

runtime/vm/JFRConstantPoolTypes.cpp

@@ -1031,6 +1031,51 @@ VM_JFRConstantPoolTypes::addThreadSleepEntry(J9JFRThreadSlept *threadSleepData)
  return index;
 }
 
+U_32
+VM_JFRConstantPoolTypes::addCPULoadEntry(J9JFRCPULoad *cpuLoadData)
+{
+ CPULoadEntry *entry = (CPULoadEntry *)pool_newElement(_cpuLoadTable);
+ U_32 index = U_32_MAX;
+
+ if (NULL == entry) {
+ _buildResult = OutOfMemory;
+ goto done;
+ }
+
+ entry->ticks = cpuLoadData->startTicks;
+ entry->jvmUser = cpuLoadData->jvmUser;
+ entry->jvmSystem = cpuLoadData->jvmSystem;
+ entry->machineTotal = cpuLoadData->machineTotal;
+
+ index = _cpuLoadCount++;
+
+done:
+ return index;
+}
+
+U_32
+VM_JFRConstantPoolTypes::addThreadCPULoadEntry(J9JFRThreadCPULoad *threadCPULoadData)
+{
+ ThreadCPULoadEntry *entry = (ThreadCPULoadEntry *)pool_newElement(_threadCPULoadTable);
+ U_32 index = U_32_MAX;
+
+ if (NULL == entry) {
+ _buildResult = OutOfMemory;
+ goto done;
+ }
+
+ entry->ticks = threadCPULoadData->startTicks;
+ entry->user = threadCPULoadData->user;
+ entry->system = threadCPULoadData->system;
+
+ entry->threadIndex = addThreadEntry(threadCPULoadData->vmThread);
+ if (isResultNotOKay()) goto done;
+
+ index = _threadCPULoadCount++;
+
+done:
+ return index;
+}
 
 void
 VM_JFRConstantPoolTypes::printTables()

runtime/vm/JFRConstantPoolTypes.hpp

@@ -199,6 +199,20 @@ struct StackTraceEntry {
  StackTraceEntry *next;
 };
 
+struct CPULoadEntry {
+ I_64 ticks;
+ float jvmUser;
+ float jvmSystem;
+ float machineTotal;
+};
+
+struct ThreadCPULoadEntry {
+ I_64 ticks;
+ U_32 threadIndex;
+ float user;
+ float system;
+};
+
 struct JVMInformationEntry {
  const char *jvmName;
  const char *jvmVersion;
@@ -274,6 +288,10 @@ class VM_JFRConstantPoolTypes {
  UDATA _threadEndCount;
  J9Pool *_threadSleepTable;
  UDATA _threadSleepCount;
+ J9Pool *_cpuLoadTable;
+ UDATA _cpuLoadCount;
+ J9Pool *_threadCPULoadTable;
+ UDATA _threadCPULoadCount;
 
  /* Processing buffers */
  StackFrame *_currentStackFrameBuffer;
@@ -515,6 +533,10 @@ class VM_JFRConstantPoolTypes {
 
  U_32 addThreadSleepEntry(J9JFRThreadSlept *threadSleepData);
 
+ U_32 addCPULoadEntry(J9JFRCPULoad *cpuLoadData);
+
+ U_32 addThreadCPULoadEntry(J9JFRThreadCPULoad *threadCPULoadData);
+
  J9Pool *getExecutionSampleTable()
  {
  return _executionSampleTable;
@@ -535,6 +557,16 @@ class VM_JFRConstantPoolTypes {
  return _threadSleepTable;
  }
 
+ J9Pool *getCPULoadTable()
+ {
+ return _cpuLoadTable;
+ }
+
+ J9Pool *getThreadCPULoadTable()
+ {
+ return _threadCPULoadTable;
+ }
+
  UDATA getExecutionSampleCount()
  {
  return _executionSampleCount;
@@ -555,6 +587,16 @@ class VM_JFRConstantPoolTypes {
  return _threadSleepCount;
  }
 
+ UDATA getCPULoadCount()
+ {
+ return _cpuLoadCount;
+ }
+
+ UDATA getThreadCPULoadCount()
+ {
+ return _threadCPULoadCount;
+ }
+
  ClassloaderEntry *getClassloaderEntry()
  {
  return _firstClassloaderEntry;
@@ -694,6 +736,12 @@ class VM_JFRConstantPoolTypes {
  case J9JFR_EVENT_TYPE_THREAD_SLEEP:
  addThreadSleepEntry((J9JFRThreadSlept*) event);
  break;
+ case J9JFR_EVENT_TYPE_CPU_LOAD:
+ addCPULoadEntry((J9JFRCPULoad *)event);
+ break;
+ case J9JFR_EVENT_TYPE_THREAD_CPU_LOAD:
+ addThreadCPULoadEntry((J9JFRThreadCPULoad *)event);
+ break;
  default:
  Assert_VM_unreachable();
  break;
@@ -986,6 +1034,10 @@ class VM_JFRConstantPoolTypes {
  , _threadEndCount(0)
  , _threadSleepTable(NULL)
  , _threadSleepCount(0)
+ , _cpuLoadTable(NULL)
+ , _cpuLoadCount(0)
+ , _threadCPULoadTable(NULL)
+ , _threadCPULoadCount(0)
  , _previousStackTraceEntry(NULL)
  , _firstStackTraceEntry(NULL)
  , _previousThreadEntry(NULL)
@@ -1082,6 +1134,18 @@ class VM_JFRConstantPoolTypes {
  goto done;
  }
 
+ _cpuLoadTable = pool_new(sizeof(CPULoadEntry), 0, sizeof(U_64), 0, J9_GET_CALLSITE(), OMRMEM_CATEGORY_VM, POOL_FOR_PORT(privatePortLibrary));
+ if (NULL == _cpuLoadTable) {
+ _buildResult = OutOfMemory;
+ goto done;
+ }
+
+ _threadCPULoadTable = pool_new(sizeof(ThreadCPULoadEntry), 0, sizeof(U_64), 0, J9_GET_CALLSITE(), OMRMEM_CATEGORY_VM, POOL_FOR_PORT(privatePortLibrary));
+ if (NULL == _threadCPULoadTable) {
+ _buildResult = OutOfMemory;
+ goto done;
+ }
+
  /* Add reserved index for default entries. For strings zero is the empty or NUll string.
  * For package zero is the deafult package, for Module zero is the unnamed module. ThreadGroup
  * zero is NULL threadGroup.
@@ -1161,6 +1225,8 @@ class VM_JFRConstantPoolTypes {
  pool_kill(_threadStartTable);
  pool_kill(_threadEndTable);
  pool_kill(_threadSleepTable);
+ pool_kill(_cpuLoadTable);
+ pool_kill(_threadCPULoadTable);
  j9mem_free_memory(_globalStringTable);
  }