add test

Author: zhengyu123

ddprof-test/src/test/java/com/datadoghq/profiler/cpu/ClinitResolutionTest.java

@@ -0,0 +1,107 @@
+package com.datadoghq.profiler.cpu;
+
+import com.datadoghq.profiler.AbstractProfilerTest;
+import com.datadoghq.profiler.Platform;
+import org.junit.jupiter.api.Assumptions;
+import org.junitpioneer.jupiter.RetryingTest;
+import org.openjdk.jmc.common.item.IItem;
+import org.openjdk.jmc.common.item.IItemCollection;
+import org.openjdk.jmc.common.item.IItemIterable;
+import org.openjdk.jmc.common.item.IMemberAccessor;
+import org.openjdk.jmc.flightrecorder.jdk.JdkAttributes;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Verifies that cstack=vm recordings correctly resolve {@code <clinit>} frames instead of
+ * reporting them as "unknown".
+ *
+ * <p>With cstack=vm, jmethodID preloading is disabled for all classes. walkVM stores
+ * method frames as raw VMMethod* pointers when no jmethodID has been allocated.
+ * At dump time, HotspotSupport::resolve() tries JNI GetMethodID / GetStaticMethodID to
+ * obtain the jmethodID, but JNI intentionally hides class initializers from callers.
+ * Without the fix both calls return null and the frame is serialised as "unknown".
+ * With the fix, a JVMTI GetClassMethods fallback forces jmethodID-slot allocation for
+ * all methods in the class (including {@code <clinit>}), and re-reading from VM metadata
+ * returns the correct identifier.
+ */
+public class ClinitResolutionTest extends AbstractProfilerTest {
+
+    // SpinningClinit must NOT be referenced anywhere except inside the test body so that
+    // the class is not loaded (and therefore not initialised) until the profiler is active.
+    // It is a named static inner class rather than ASM-generated bytes so that FindClass
+    // can locate it via the system/application class loader, which is the exact code path
+    // exercised by the fix (system-loader classes skip jmethodID preloading but ARE
+    // reachable via FindClass at dump time).
+    static class SpinningClinit {
+        // Spin for ~2 s in the static initialiser so the cpu=1ms profiler gets
+        // thousands of sample opportunities inside this <clinit>.
+        // System.nanoTime() calls prevent the JIT from eliminating the loop body,
+        // and the loop count is high enough that HotSpot's C1/C2 compilation kicks in
+        // — but crucially, HotSpot's JIT does NOT allocate jmethodID slots; only JNI
+        // or JVMTI callers do that.  The jmethodID slot therefore stays null until
+        // HotspotSupport::resolve() runs at dump time, which is exactly the scenario
+        // that requires the JVMTI fallback for <clinit>.
+        static {
+            long deadline = System.nanoTime() + 2_000_000_000L;
+            while (System.nanoTime() < deadline) {
+                // intentionally empty
+            }
+        }
+
+        // Static method whose invocation triggers class initialization.
+        static void touch() {}
+    }
+
+    @Override
+    protected String getProfilerCommand() {
+        // cstack=vm routes all Java-frame collection through HotspotSupport::walkVM and
+        // disables jmethodID preloading, producing raw VMMethod* frames that are resolved
+        // by HotspotSupport::resolve() at dump time.
+        return "cpu=1ms,cstack=vm";
+    }
+
+    @RetryingTest(5)
+    public void testClinitFrameIsResolvedNotUnknown() throws Exception {
+        // HotspotSupport::walkVM and the raw-pointer resolve path are Hotspot-only.
+        Assumptions.assumeFalse(Platform.isZing() || Platform.isJ9() || Platform.isGraal());
+
+        waitForProfilerReady(2000);
+
+        // Trigger class loading + initialisation on this thread.
+        // SpinningClinit.<clinit> spins for ~2 seconds; during that time the profiler
+        // collects cpu samples whose top Java frame is the class initialiser.
+        SpinningClinit.touch();
+
+        stopProfiler();
+
+        // Assert that at least one CPU sample contains a resolved <clinit> frame for
+        // SpinningClinit — i.e. both the class name and the method name are present,
+        // not replaced by "unknown".
+        //
+        // JMC's STACK_TRACE_STRING HTML-escapes angle brackets, so <clinit> appears as
+        // "&lt;clinit&gt;".  Matching on "clinit" catches both representations.
+        IItemCollection events = verifyEvents("datadog.ExecutionSample");
+        boolean foundClinit = false;
+        outer:
+        for (IItemIterable cpuSamples : events) {
+            IMemberAccessor<String, IItem> frameAccessor =
+                    JdkAttributes.STACK_TRACE_STRING.getAccessor(cpuSamples.getType());
+            if (frameAccessor == null) continue;
+            for (IItem sample : cpuSamples) {
+                String stackTrace = frameAccessor.getMember(sample);
+                if (stackTrace != null
+                        && stackTrace.contains("SpinningClinit")
+                        && stackTrace.contains("clinit")) {
+                    System.err.println("=CLINIT TRACE=\n" + stackTrace + "\n=END=");
+                    foundClinit = true;
+                    break outer;
+                }
+            }
+        }
+        assertTrue(foundClinit,
+                "No CPU sample contained a resolved <clinit> frame for SpinningClinit. "
+                + "HotspotSupport::resolve() must fall back to JVMTI GetClassMethods for "
+                + "<clinit> because JNI GetMethodID/GetStaticMethodID cannot look it up.");
+    }
+}