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

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

@@ -20,6 +20,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.util.List;
+import java.util.Locale;
 import org.apache.lucene.gradle.plugins.LuceneGradlePlugin;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.GradleException;
@@ -91,6 +92,8 @@ public void run() {
             getCount().get(),
             getLineNumbers().get(),
             getFrametypes().get());
+      } catch (IllegalStateException e) {
+        throw new GradleException(e.getMessage(), e);
       } catch (IOException e) {
         throw new GradleException("Error when generating jfr profile summaries.", e);
       }
@@ -189,7 +192,7 @@ public void apply(Project project) {
             task.jvmArgs(
                 List.of(
                     "-XX:StartFlightRecording=dumponexit=true,maxsize=250M,settings="
-                        + gradlePluginResource(project, "testing/profiling.jfc"),
+                        + gradlePluginResource(project, profilingSettingsPath()),
                     "-XX:+UnlockDiagnosticVMOptions",
                     "-XX:+DebugNonSafepoints"));
             task.dependsOn(cleanPreviousProfiles);
@@ -254,4 +257,14 @@ private record ProfilingOptions(
       Provider<Integer> countOption,
       Provider<Boolean> lineNumbersOption,
       Provider<Boolean> frametypesOption) {}
+
+  /**
+   * JEP 509 CPU-time sampling ({@code jdk.CPUTimeSample}) is implemented on Linux. Use a Linux-only
+   * JFR template with CPU-time sampling only; other hosts keep wall-clock execution sampling for
+   * short tests.
+   */
+  private static String profilingSettingsPath() {
+    String os = System.getProperty("os.name", "").toLowerCase(Locale.ROOT);
+    return os.contains("linux") ? "testing/profiling.linux.jfc" : "testing/profiling.jfc";
+  }
 }

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

@@ -101,10 +101,17 @@ 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 present, we ignore jdk.ExecutionSample and jdk.NativeMethodSample
+          // (wall-clock / JNI execution sampling) so the same hot code is not double-counted.
+          return name.equals("jdk.CPUTimeSample");
+        }
         return (name.equals("jdk.ExecutionSample") || name.equals("jdk.NativeMethodSample"))
             && !isGradlePollThread(event.getThread("sampledThread"));
       case "heap":
@@ -121,6 +128,37 @@ static boolean isGradlePollThread(RecordedThread thread) {
     return (thread != null && thread.getJavaName().startsWith("/127.0.0.1"));
   }
 
+  /**
+   * Pre-scan recording files for CPU sampling strategy. Returns whether any {@code
+   * jdk.CPUTimeSample} events appear in the inputs. Throws if recordings mix those with legacy
+   * wall-clock samples ({@code jdk.ExecutionSample} / {@code jdk.NativeMethodSample}); only one
+   * CPU sampler should be enabled in JFR settings.
+   */
+  static boolean resolveCpuTimeSampling(List<String> files) throws IOException {
+    boolean hasCpuTime = false;
+    boolean hasLegacy = false;
+    for (String file : files) {
+      try (RecordingFile recording = new RecordingFile(Paths.get(file))) {
+        while (recording.hasMoreEvents()) {
+          RecordedEvent event = recording.readEvent();
+          String n = event.getEventType().getName();
+          if (n.equals("jdk.CPUTimeSample")) {
+            hasCpuTime = true;
+          } else if (n.equals("jdk.ExecutionSample") || n.equals("jdk.NativeMethodSample")) {
+            hasLegacy = true;
+          }
+          if (hasCpuTime && hasLegacy) {
+            throw new IllegalStateException(
+                "Mixed CPU profiling events: found both jdk.CPUTimeSample and legacy wall-clock "
+                    + "samples (jdk.ExecutionSample / jdk.NativeMethodSample). Use a single sampler "
+                    + "in JFR settings (see gradle/testing/profiling*.jfc).");
+          }
+        }
+      }
+    }
+    return hasCpuTime;
+  }
+
   /** value we accumulate for this event */
   static long getValue(RecordedEvent event) {
     switch (event.getEventType().getName()) {
@@ -132,6 +170,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 +213,10 @@ public static void printReport(
     if (count < 1) {
       throw new IllegalArgumentException("tests.profile.count must be positive");
     }
+
+    // Pre-scan recordings: decide CPU-time vs legacy sampling and reject mixed configurations.
+    boolean hasCPUTimeSamples = "cpu".equals(mode) && resolveCpuTimeSampling(files);
+
     Map<String, SimpleEntry<String, Long>> histogram = new HashMap<>();
     int totalEvents = 0;
     long sumValues = 0;
@@ -181,7 +225,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

@@ -16,7 +16,9 @@
     limitations under the License.
 -->
 <!--
-Collects only execution and method samples at a low interval
+  Wall-clock execution samples for CPU profiling on platforms where JEP 509 CPU-time sampling
+  is unavailable (non-Linux). On Linux, CodeProfilingPlugin uses profiling.linux.jfc instead.
+  Heap allocation events are enabled on all platforms.
 -->
 <configuration version="2.0" label="TestProfiling" description="Sampling for unit tests" provider="Apache">
   <event name="jdk.ExecutionSample">

lucene/CHANGES.txt

@@ -185,6 +185,11 @@ Changes in Runtime Behavior
 
 Build
 ---------------------
+* GITHUB#15926: Support jdk.CPUTimeSample event (Java 25+, JEP 509) in ProfileResults.
+  Linux test JVMs use gradle/testing/profiling.linux.jfc (CPU-time sampling only); other hosts
+  keep wall-clock jdk.ExecutionSample/jdk.NativeMethodSample. ProfileResults rejects recordings
+  that mix CPU-time and legacy execution samples. (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)