Remove stop/restart test, enable NMT by default

- Removed testGetLineNumberTableNoLeak (stop/restart not production usage)
- Updated test docs to focus on continuous profiling scenario
- Enabled NMT automatically with IgnoreUnrecognizedVMOptions fallback
- No longer requires -PenableNMT flag

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: jbachorik

ddprof-test/build.gradle

@@ -293,10 +293,10 @@ tasks.withType(Test).configureEach {
     "-Djava.library.path=${outputLibDir.absolutePath}"
   ]
 
-  // Enable Native Memory Tracking for leak detection tests if requested
-  if (project.hasProperty('enableNMT') || Boolean.parseBoolean(System.getenv("ENABLE_NMT"))) {
-    jvmArgsList.add('-XX:NativeMemoryTracking=detail')
-  }
+  // Enable Native Memory Tracking for leak detection tests
+  // Use IgnoreUnrecognizedVMOptions to silently ignore on JVMs that don't support NMT
+  jvmArgsList.add('-XX:+IgnoreUnrecognizedVMOptions')
+  jvmArgsList.add('-XX:NativeMemoryTracking=detail')
 
   jvmArgs jvmArgsList
 

ddprof-test/src/test/java/com/datadoghq/profiler/memleak/GetLineNumberTableLeakTest.java

@@ -35,23 +35,28 @@
 import java.util.List;
 
 /**
- * Test to detect native memory leaks in GetLineNumberTable JVMTI calls.
+ * Test to validate that method_map cleanup prevents unbounded memory growth in continuous profiling.
  *
- * <p>This test verifies that repeated flush() operations during profiling sessions
- * do not cause memory leaks from line number table allocations.
+ * <p>This test focuses on the production scenario where the profiler runs continuously for
+ * extended periods without stop/restart cycles. In production, Recording objects live for the
+ * entire application lifetime (days/weeks), and without cleanup, _method_map would accumulate
+ * ALL methods encountered, causing unbounded growth (observed: 3.8M methods × ~300 bytes = 1.2 GB).
  *
- * <p><b>Test Limitations:</b>
+ * <p><b>What This Test Validates:</b>
  * <ul>
- *   <li>NMT (Native Memory Tracking) does not create a JVMTI category until allocations are
- *       significant (typically 1KB+)</li>
- *   <li>GetLineNumberTable allocations are small (~10-100 bytes per method), so short-running
- *       tests show 0 KB even with leaks present</li>
- *   <li>This test serves as <b>regression protection</b> rather than numerical leak validation</li>
- *   <li>It ensures the code path works without crashes and follows JVMTI spec</li>
- *   <li>Production leaks would manifest over days/weeks with millions of method encounters</li>
+ *   <li>Age-based cleanup removes methods unused for 3+ consecutive chunks</li>
+ *   <li>method_map size stays bounded (500-1000 methods vs 3000 without cleanup)</li>
+ *   <li>Cleanup runs during switchChunk() triggered by dump() operations</li>
+ *   <li>Memory growth plateaus after initial warmup (not linear growth)</li>
  * </ul>
  *
- * <p>Requires NMT: Run with -XX:NativeMemoryTracking=detail or -PenableNMT
+ * <p><b>Test Strategy:</b>
+ * <ul>
+ *   <li>Continuous profiling (NO stop/restart cycles)</li>
+ *   <li>Generate transient methods across multiple chunk boundaries</li>
+ *   <li>Hold strong references to prevent GC (isolate cleanup behavior)</li>
+ *   <li>Verify bounded growth via TEST_LOG output showing method_map size</li>
+ * </ul>
  */
 public class GetLineNumberTableLeakTest extends AbstractProfilerTest {
 
@@ -61,185 +66,6 @@ protected String getProfilerCommand() {
     return "cpu=1ms,alloc=512k";
   }
 
-  @Test
-  public void testGetLineNumberTableNoLeak() throws Exception {
-    // Verify NMT is enabled (test skipped if not available)
-    Assumptions.assumeTrue(
-        NativeMemoryTracking.isEnabled(), "Test requires -XX:NativeMemoryTracking=detail");
-
-    // Take NMT baseline
-    NativeMemoryTracking.NMTSnapshot baseline = NativeMemoryTracking.takeSnapshot();
-    System.out.println(
-        String.format(
-            "Baseline NMT: malloc=%d KB, Internal=%d KB",
-            baseline.mallocKB, baseline.internalReservedKB));
-
-    // Phase 1: Warmup - generate many unique classes with ASM to populate _method_map
-    System.out.println("Phase 1: Warmup - generating many unique classes via ASM...");
-    final int warmupClassGenerations = 20; // Generate classes in batches
-    final int totalRestarts = 25; // Need 25 restarts for 5 checkpoint intervals (5 restarts each)
-    final int checkpointInterval = 5; // Check every 5 restarts
-
-    // Track snapshots: baseline + afterWarmup + 5 checkpoint intervals = 7 total
-    NativeMemoryTracking.NMTSnapshot[] checkpoints = new NativeMemoryTracking.NMTSnapshot[7];
-    checkpoints[0] = baseline;
-    int checkpointIndex = 1;
-
-    // Cache many generated classes for reuse in steady state
-    // generateUniqueMethodCalls() returns 5 classes, each with 20 methods
-    // Total: 20 batches × 5 classes/batch = 100 classes with ~2,000 methods
-    Class<?>[] cachedClasses = new Class<?>[warmupClassGenerations * 5];
-    int cachedClassIndex = 0;
-
-    for (int i = 0; i < warmupClassGenerations; i++) {
-      // Generate 5 unique classes per batch via ASM (each with 20 methods with line tables)
-      Class<?>[] newClasses = generateUniqueMethodCalls();
-      System.arraycopy(newClasses, 0, cachedClasses, cachedClassIndex, newClasses.length);
-      cachedClassIndex += newClasses.length;
-
-      // Flush profiler to trigger method resolution and GetLineNumberTable calls
-      dump(tempFile("warmup-" + i));
-
-      if ((i + 1) % 20 == 0) {
-        System.out.println(
-            String.format("Generated %d classes so far (%d batches)...", cachedClassIndex, i + 1));
-      }
-    }
-
-    // Take snapshot after warmup
-    NativeMemoryTracking.NMTSnapshot afterWarmup = NativeMemoryTracking.takeSnapshot();
-    checkpoints[checkpointIndex++] = afterWarmup;
-    long warmupInternalGrowthKB = afterWarmup.internalReservedKB - baseline.internalReservedKB;
-    System.out.println(
-        String.format(
-            "After warmup: %d classes generated, Internal=%d KB (+%d KB)",
-            cachedClassIndex,
-            afterWarmup.internalReservedKB,
-            warmupInternalGrowthKB));
-
-    // Phase 2: Steady state - repeated restarts to accumulate leak if present
-    // Stop/start cycles trigger SharedLineNumberTable destructors
-    // With bug: each restart leaks ~16 KB; across many restarts this should accumulate into a detectable leak
-    System.out.println(
-        String.format(
-            "Phase 2: Performing %d profiler restarts to test for accumulated leaks...",
-            totalRestarts));
-
-    for (int restart = 0; restart < totalRestarts; restart++) {
-      // Stop profiler to destroy Recording and trigger all SharedLineNumberTable destructors
-      profiler.stop();
-      Thread.sleep(10); // Allow cleanup to complete
-
-      // Restart profiler (creates new Recording, repopulates _method_map from same classes)
-      profiler.execute(
-          "start," + getProfilerCommand() + ",jfr,file=" + tempFile("restart-" + restart));
-
-      // Reuse cached classes to trigger GetLineNumberTable again
-      invokeCachedClasses(cachedClasses, restart);
-
-      // Single flush per restart
-      dump(tempFile("steady-" + restart));
-
-      // Take checkpoint snapshots every checkpointInterval restarts
-      if ((restart + 1) % checkpointInterval == 0) {
-        NativeMemoryTracking.NMTSnapshot progress = NativeMemoryTracking.takeSnapshot();
-        checkpoints[checkpointIndex++] = progress;
-
-        long internalGrowthFromWarmupKB = progress.internalReservedKB - afterWarmup.internalReservedKB;
-        long internalGrowthKB = progress.internalReservedKB - baseline.internalReservedKB;
-        System.out.println(
-            String.format(
-                "After %d restarts: Internal=%d KB (+%d KB from warmup, +%d KB total)",
-                restart + 1,
-                progress.internalReservedKB,
-                internalGrowthFromWarmupKB,
-                internalGrowthKB));
-      }
-    }
-
-    // Take final snapshot
-    NativeMemoryTracking.NMTSnapshot afterRestarts = checkpoints[6];
-    long steadyStateInternalGrowthKB =
-        afterRestarts.internalReservedKB - afterWarmup.internalReservedKB;
-    long totalInternalGrowthKB = afterRestarts.internalReservedKB - baseline.internalReservedKB;
-
-    // Calculate Internal category growth rates for steady state intervals
-    // checkpoints[1] = after warmup
-    // checkpoints[2-6] = after 5, 10, 15, 20, 25 restarts (with checkpointInterval = 5)
-    long[] steadyStateInternalGrowths = new long[5];
-    for (int i = 0; i < 5; i++) {
-      steadyStateInternalGrowths[i] =
-          checkpoints[i + 2].internalReservedKB - checkpoints[i + 1].internalReservedKB;
-    }
-
-    // Assert that Internal category doesn't show super-linear growth
-    // With fix: Internal should plateau after warmup (< 10 KB per 5 restarts from minor JVM allocations)
-    // Without fix: each restart leaks ~1.6 KB → 5 restarts = ~8 KB per interval
-    long maxIntervalGrowth = 0;
-    for (int i = 0; i < steadyStateInternalGrowths.length; i++) {
-      maxIntervalGrowth = Math.max(maxIntervalGrowth, steadyStateInternalGrowths[i]);
-
-      System.out.println(
-          String.format(
-              "Interval %d (restarts %d-%d): Internal +%d KB",
-              i + 1,
-              i * checkpointInterval,
-              (i + 1) * checkpointInterval,
-              steadyStateInternalGrowths[i]));
-
-      // Assert individual intervals don't show excessive JVMTI leak growth
-      // Threshold: 10 KB per interval
-      // With fix: typically < 5 KB (minor allocations)
-      // Without fix: ~10-20 KB per interval (line table leaks accumulate)
-      if (steadyStateInternalGrowths[i] > 10) { // 10 KB per interval
-        fail(
-            String.format(
-                "Internal category growth indicates JVMTI leak!\n"
-                    + "Interval %d (restarts %d-%d): +%d KB\n"
-                    + "Expected: Internal should plateau; no significant growth across intervals\n"
-                    + "Actual: continued growth indicates leaked GetLineNumberTable allocations",
-                i + 1,
-                i * checkpointInterval,
-                (i + 1) * checkpointInterval,
-                steadyStateInternalGrowths[i]));
-      }
-    }
-
-    // Verify total steady state Internal growth is bounded
-    // With fix: should be < 20 KB total (minor JVM allocations over 25 restarts)
-    // Without fix: 25 restarts × ~1.6 KB/restart = ~40 KB JVMTI leak (based on observed leak rate)
-    NativeMemoryTracking.assertInternalMemoryBounded(
-        afterWarmup,
-        afterRestarts,
-        20 * 1024, // 20 KB - tight enough to catch 40 KB leak
-        "Internal category grew excessively - JVMTI leak detected!");
-
-    // Print summary
-    System.out.println(
-        String.format(
-            "\n=== Test Completed Successfully ===\n"
-                + "Phase 1 (Warmup):\n"
-                + "  Classes generated: %d (via ASM)\n"
-                + "  Internal growth: +%d KB\n"
-                + "Phase 2 (Leak Detection):\n"
-                + "  Profiler restarts: %d\n"
-                + "  Internal steady state growth: +%d KB (threshold: < 20 KB)\n"
-                + "  Max interval growth: %d KB per 5 restarts (threshold: < 10 KB)\n"
-                + "Total Internal: %d KB → %d KB (+%d KB)\n"
-                + "\n"
-                + "Result: No JVMTI memory leak detected\n"
-                + "Note: GetLineNumberTable allocations tracked in Internal NMT category\n"
-                + "Note: Each restart destroys Recording, triggering SharedLineNumberTable destructors",
-            cachedClassIndex,
-            warmupInternalGrowthKB,
-            totalRestarts,
-            steadyStateInternalGrowthKB,
-            maxIntervalGrowth,
-            baseline.internalReservedKB,
-            afterRestarts.internalReservedKB,
-            totalInternalGrowthKB));
-  }
-
   private int classCounter = 0;
 
   /**
@@ -279,24 +105,6 @@ private Class<?>[] generateUniqueMethodCalls() throws Exception {
     return generatedClasses;
   }
 
-  /**
-   * Invokes methods from cached classes to generate profiling samples without creating new
-   * jmethodIDs. This allows testing whether malloc plateaus once _method_map is populated.
-   *
-   * @param cachedClasses array of previously generated classes
-   * @param iteration current iteration number (used to cycle through classes)
-   */
-  private void invokeCachedClasses(Class<?>[] cachedClasses, int iteration) throws Exception {
-    // Cycle through cached classes to ensure we hit various methods
-    int startIndex = (iteration * 10) % cachedClasses.length;
-    for (int i = 0; i < Math.min(10, cachedClasses.length); i++) {
-      int index = (startIndex + i) % cachedClasses.length;
-      if (cachedClasses[index] != null) {
-        invokeClassMethods(cachedClasses[index]);
-      }
-    }
-  }
-
   /**
    * Invokes all int-returning no-arg methods in a class to trigger profiling samples.
    *