Support jdk.CPUTimeSample event in ProfileResults for Java 25+ (JEP 509)

build-tools/build-infra/src/main/java/org/apache/lucene/gradle/plugins/java/ProfileResults.java

@@ -101,10 +101,16 @@ public static void main(String[] args) throws IOException {
   }
 
   /** true if we care about this event */
-  static boolean isInteresting(String mode, RecordedEvent event) {
+  static boolean isInteresting(String mode, RecordedEvent event, boolean hasCPUTimeSamples) {
     String name = event.getEventType().getName();
     switch (mode) {
       case "cpu":
+        if (hasCPUTimeSamples) {
+          // Prefer jdk.CPUTimeSample (Java 25+, JEP 509): samples by CPU time, not wall-clock
+          // time, so idle threads (like gradle epoll) are inherently excluded — no filtering
+          // needed. When available, we skip legacy execution samples to avoid double-counting.
+          return name.equals("jdk.CPUTimeSample");
+        }
         return (name.equals("jdk.ExecutionSample") || name.equals("jdk.NativeMethodSample"))
             && !isGradlePollThread(event.getThread("sampledThread"));
       case "heap":
@@ -121,6 +127,24 @@ static boolean isGradlePollThread(RecordedThread thread) {
     return (thread != null && thread.getJavaName().startsWith("/127.0.0.1"));
   }
 
+  /**
+   * Pre-scan recording files to detect if any jdk.CPUTimeSample events are present. When they are,
+   * we prefer them over legacy jdk.ExecutionSample/jdk.NativeMethodSample to avoid double-counting.
+   */
+  static boolean detectCPUTimeSamples(List<String> files) throws IOException {
+    for (String file : files) {
+      try (RecordingFile recording = new RecordingFile(Paths.get(file))) {
+        while (recording.hasMoreEvents()) {
+          RecordedEvent event = recording.readEvent();
+          if (event.getEventType().getName().equals("jdk.CPUTimeSample")) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
   /** value we accumulate for this event */
   static long getValue(RecordedEvent event) {
     switch (event.getEventType().getName()) {
@@ -132,6 +156,8 @@ static long getValue(RecordedEvent event) {
         return 1L;
       case "jdk.NativeMethodSample":
         return 1L;
+      case "jdk.CPUTimeSample":
+        return 1L;
       default:
         throw new UnsupportedOperationException(event.toString());
     }
@@ -173,6 +199,11 @@ public static void printReport(
     if (count < 1) {
       throw new IllegalArgumentException("tests.profile.count must be positive");
     }
+
+    // Pre-scan to detect if CPU-time samples (Java 25+, JEP 509) are available.
+    // If so, prefer them over legacy execution samples to avoid double-counting.
+    boolean hasCPUTimeSamples = "cpu".equals(mode) && detectCPUTimeSamples(files);
+
     Map<String, SimpleEntry<String, Long>> histogram = new HashMap<>();
     int totalEvents = 0;
     long sumValues = 0;
@@ -181,7 +212,7 @@ public static void printReport(
       try (RecordingFile recording = new RecordingFile(Paths.get(file))) {
         while (recording.hasMoreEvents()) {
           RecordedEvent event = recording.readEvent();
-          if (!isInteresting(mode, event)) {
+          if (!isInteresting(mode, event, hasCPUTimeSamples)) {
             continue;
           }
           RecordedStackTrace trace = event.getStackTrace();

gradle/testing/profiling.jfc

@@ -29,6 +29,11 @@ Collects only execution and method samples at a low interval
     <setting name="period">1 ms</setting>
   </event>
 
+  <event name="jdk.CPUTimeSample">
+    <setting name="enabled">true</setting>
+    <setting name="throttle">10 ms</setting>
+  </event>
+
   <event name="jdk.ObjectAllocationInNewTLAB">
     <setting name="enabled">true</setting>
     <setting name="stackTrace">true</setting>

lucene/CHANGES.txt

@@ -185,6 +185,11 @@ Changes in Runtime Behavior
 
 Build
 ---------------------
+* GITHUB#15926: Support jdk.CPUTimeSample event (Java 25+, JEP 509) in ProfileResults.
+  CPU-time profiling produces more accurate profiles by sampling CPU instructions instead
+  of wall-clock time. When CPUTimeSample events are present, they are preferred over legacy
+  ExecutionSample events to avoid double-counting. (Prithvi S)
+
 * GITHUB#15327: New low-level build options to detect abuse of LuceneTestCase.random():
   tests.random.maxacquires and tests.random.maxcalls (Robert Muir, Dawid Weiss)