perf(profiling): eliminate allocations in OTLP encoder hot paths

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

Author: jbachorik

.gitignore

@@ -93,3 +93,4 @@ mise*.local.toml
 
 # Exclude kotlin build files
 .kotlin
+.claude/state/

dd-java-agent/agent-profiling/profiling-otel/build.gradle.kts

@@ -27,6 +27,18 @@ jmh {
       "-XX:+DebugNonSafepoints"
     )
   }
+
+  // async-profiler CPU flamegraph
+  // Usage: ./gradlew jmh -PjmhAsyncProfiler=/path/to/libasyncProfiler.dylib
+  // Output: /tmp/jmh-async-profile.html
+  if (project.hasProperty("jmhAsyncProfiler")) {
+    val lib = project.property("jmhAsyncProfiler") as String
+    jvmArgs = listOf(
+      "-XX:+UnlockDiagnosticVMOptions",
+      "-XX:+DebugNonSafepoints",
+      "-agentpath:$lib=start,event=cpu,file=/tmp/jmh-async-profile.html,flamegraph"
+    )
+  }
 }
 
 // OTLP validation tests removed - use profcheck validation instead (see validateOtlp task below)

dd-java-agent/agent-profiling/profiling-otel/src/jmh/java/com/datadog/profiling/otel/benchmark/RealFileConversionBenchmark.java

@@ -0,0 +1,55 @@
+package com.datadog.profiling.otel.benchmark;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.openjdk.jmh.annotations.Mode.Throughput;
+
+import com.datadog.profiling.otel.JfrToOtlpConverter;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.Instant;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+/** Benchmarks JFR-to-OTLP conversion on real production JFR recordings. */
+@State(Scope.Benchmark)
+@BenchmarkMode(Throughput)
+@OutputTimeUnit(SECONDS)
+@Fork(value = 1)
+@Warmup(iterations = 3, time = 5)
+@Measurement(iterations = 5, time = 10)
+public class RealFileConversionBenchmark {
+
+  @Param({"/tmp/inventory-cache.jfr", "/tmp/sbom.jfr", "/tmp/otelp.jfr"})
+  String jfrFilePath;
+
+  private Path jfrFile;
+  private JfrToOtlpConverter converter;
+  private Instant start;
+  private Instant end;
+
+  @Setup(Level.Trial)
+  public void setup() throws IOException {
+    jfrFile = Paths.get(jfrFilePath);
+    converter = new JfrToOtlpConverter();
+    start = Instant.EPOCH;
+    end = Instant.now();
+  }
+
+  @Benchmark
+  public void convertJfrToOtlp(Blackhole bh) throws IOException {
+    byte[] result = converter.addFile(jfrFile, start, end).convert();
+    bh.consume(result);
+    converter.reset();
+  }
+}

dd-java-agent/agent-profiling/profiling-otel/src/main/java/com/datadog/profiling/otel/JfrToOtlpConverter.java

@@ -67,6 +67,73 @@ public enum Kind {
     JSON_PRETTY
   }
 
+  /**
+   * Open-addressing long→int hash map. Eliminates boxing overhead of {@code HashMap<Long,Integer>}
+   * for the stack-trace and frame caches.
+   */
+  private static final class LongIntMap {
+    private static final long EMPTY = Long.MIN_VALUE;
+    private static final int INITIAL_CAPACITY = 1024; // power of 2
+
+    private long[] keys;
+    private int[] values;
+    private int mask;
+
+    LongIntMap() {
+      keys = new long[INITIAL_CAPACITY];
+      values = new int[INITIAL_CAPACITY];
+      mask = INITIAL_CAPACITY - 1;
+      java.util.Arrays.fill(keys, EMPTY);
+    }
+
+    int get(long key) {
+      int slot = (int) (mix(key) & mask);
+      while (keys[slot] != EMPTY) {
+        if (keys[slot] == key) return values[slot];
+        slot = (slot + 1) & mask;
+      }
+      return -1;
+    }
+
+    void put(long key, int value) {
+      if (size * 2 >= keys.length) rehash();
+      int slot = (int) (mix(key) & mask);
+      while (keys[slot] != EMPTY && keys[slot] != key) {
+        slot = (slot + 1) & mask;
+      }
+      if (keys[slot] == EMPTY) size++;
+      keys[slot] = key;
+      values[slot] = value;
+    }
+
+    void clear() {
+      java.util.Arrays.fill(keys, EMPTY);
+      size = 0;
+    }
+
+    private int size;
+
+    private void rehash() {
+      long[] oldKeys = keys;
+      int[] oldValues = values;
+      keys = new long[oldKeys.length * 2];
+      values = new int[oldKeys.length * 2];
+      mask = keys.length - 1;
+      java.util.Arrays.fill(keys, EMPTY);
+      size = 0;
+      for (int i = 0; i < oldKeys.length; i++) {
+        if (oldKeys[i] != EMPTY) put(oldKeys[i], oldValues[i]);
+      }
+    }
+
+    private static long mix(long key) {
+      key ^= key >>> 33;
+      key *= 0xff51afd7ed558ccdL;
+      key ^= key >>> 33;
+      return key;
+    }
+  }
+
   private static final class PathEntry {
     final Path path;
     final boolean ephemeral;
@@ -109,8 +176,16 @@ public int hashCode() {
   private final AttributeTable attributeTable = new AttributeTable();
 
   // Stack trace cache: maps (stackTraceId + chunkId) → stack index
-  // This avoids redundant frame processing for duplicate stack traces
-  private final java.util.Map<Long, Integer> stackTraceCache = new java.util.HashMap<>();
+  private final LongIntMap stackTraceCache = new LongIntMap();
+
+  // Frame cache: maps (methodId + chunkId + lineNumber) → locationIndex
+  private final LongIntMap frameCache = new LongIntMap();
+
+  // Per-type attribute index arrays, lazily initialized once per conversion session and shared
+  // across all samples of the same type to avoid per-sample allocation.
+  private int[] cpuAttrIndices;
+  private int[] wallAttrIndices;
+  private int[] lockAttrIndices;
 
   // Sample collectors by profile type
   private final List<SampleData> cpuSamples = new ArrayList<>();
@@ -287,6 +362,10 @@ public void reset() {
     linkTable.reset();
     attributeTable.reset();
     stackTraceCache.clear();
+    frameCache.clear();
+    cpuAttrIndices = null;
+    wallAttrIndices = null;
+    lockAttrIndices = null;
     cpuSamples.clear();
     wallSamples.clear();
     allocSamples.clear();
@@ -372,8 +451,8 @@ private void handleExecutionSample(ExecutionSample event, Control ctl) {
     int linkIndex = extractLinkIndex(event.spanId(), event.localRootSpanId());
     long timestamp = convertTimestamp(event.startTime(), ctl);
 
-    int[] attributeIndices = new int[] {getSampleTypeAttributeIndex("cpu")};
-    cpuSamples.add(new SampleData(stackIndex, linkIndex, 1, timestamp, attributeIndices));
+    if (cpuAttrIndices == null) cpuAttrIndices = new int[] {getSampleTypeAttributeIndex("cpu")};
+    cpuSamples.add(new SampleData(stackIndex, linkIndex, 1, timestamp, cpuAttrIndices));
   }
 
   private void handleMethodSample(MethodSample event, Control ctl) {
@@ -384,8 +463,8 @@ private void handleMethodSample(MethodSample event, Control ctl) {
     int linkIndex = extractLinkIndex(event.spanId(), event.localRootSpanId());
     long timestamp = convertTimestamp(event.startTime(), ctl);
 
-    int[] attributeIndices = new int[] {getSampleTypeAttributeIndex("wall")};
-    wallSamples.add(new SampleData(stackIndex, linkIndex, 1, timestamp, attributeIndices));
+    if (wallAttrIndices == null) wallAttrIndices = new int[] {getSampleTypeAttributeIndex("wall")};
+    wallSamples.add(new SampleData(stackIndex, linkIndex, 1, timestamp, wallAttrIndices));
   }
 
   private void handleObjectSample(ObjectSample event, Control ctl) {
@@ -446,8 +525,8 @@ private void handleMonitorEnter(JavaMonitorEnter event, Control ctl) {
     long timestamp = convertTimestamp(event.startTime(), ctl);
     long durationNanos = ctl.chunkInfo().asDuration(event.duration()).toNanos();
 
-    int[] attributeIndices = new int[] {getSampleTypeAttributeIndex("lock-contention")};
-    lockSamples.add(new SampleData(stackIndex, 0, durationNanos, timestamp, attributeIndices));
+    if (lockAttrIndices == null) lockAttrIndices = new int[] {getSampleTypeAttributeIndex("lock-contention")};
+    lockSamples.add(new SampleData(stackIndex, 0, durationNanos, timestamp, lockAttrIndices));
   }
 
   private void handleMonitorWait(JavaMonitorWait event, Control ctl) {
@@ -458,8 +537,8 @@ private void handleMonitorWait(JavaMonitorWait event, Control ctl) {
     long timestamp = convertTimestamp(event.startTime(), ctl);
     long durationNanos = ctl.chunkInfo().asDuration(event.duration()).toNanos();
 
-    int[] attributeIndices = new int[] {getSampleTypeAttributeIndex("lock-contention")};
-    lockSamples.add(new SampleData(stackIndex, 0, durationNanos, timestamp, attributeIndices));
+    if (lockAttrIndices == null) lockAttrIndices = new int[] {getSampleTypeAttributeIndex("lock-contention")};
+    lockSamples.add(new SampleData(stackIndex, 0, durationNanos, timestamp, lockAttrIndices));
   }
 
   private JfrStackTrace safeGetStackTrace(java.util.function.Supplier<JfrStackTrace> supplier) {
@@ -479,8 +558,8 @@ private int convertStackTrace(
     long cacheKey = stackTraceId ^ ((long) System.identityHashCode(ctl.chunkInfo()) << 32);
 
     // Check cache first - avoid resolving stack trace if cached
-    Integer cachedIndex = stackTraceCache.get(cacheKey);
-    if (cachedIndex != null) {
+    int cachedIndex = stackTraceCache.get(cacheKey);
+    if (cachedIndex != -1) {
       return cachedIndex;
     }
 
@@ -499,15 +578,15 @@ private int convertStackTrace(
 
     int[] locationIndices = new int[frames.length];
     for (int i = 0; i < frames.length; i++) {
-      locationIndices[i] = convertFrame(frames[i]);
+      locationIndices[i] = convertFrame(frames[i], ctl);
     }
 
     int stackIndex = stackTable.intern(locationIndices);
     stackTraceCache.put(cacheKey, stackIndex);
     return stackIndex;
   }
 
-  private int convertFrame(JfrStackFrame frame) {
+  private int convertFrame(JfrStackFrame frame, Control ctl) {
     if (frame == null) {
       return 0;
     }
@@ -517,33 +596,40 @@ private int convertFrame(JfrStackFrame frame) {
       return 0;
     }
 
-    // Get class and method names
+    int lineNumber = frame.lineNumber();
+    long methodId = frame.methodId();
+
+    // Cache key mirrors the stackTraceCache pattern: tag methodId with chunk identity
+    // so per-chunk CP indices don't collide across chunks.
+    long cacheKey =
+        methodId ^ ((long) System.identityHashCode(ctl.chunkInfo()) << 32) ^ (lineNumber * 1000003L);
+    int cached = frameCache.get(cacheKey);
+    if (cached != -1) {
+      return cached;
+    }
+
+    // Cache miss — full processing
     String methodName = method.name();
     JfrClass type = method.type();
     String className = type != null ? type.name() : null;
 
-    // Get line number
-    int lineNumber = frame.lineNumber();
     long line = Math.max(lineNumber, 0);
 
-    // Build full name
     String fullName;
     if (className != null && !className.isEmpty()) {
       fullName = className + "." + (methodName != null ? methodName : "");
     } else {
       fullName = methodName != null ? methodName : "";
     }
 
-    // Intern strings
     int nameIndex = stringTable.intern(fullName);
     int classNameIndex = stringTable.intern(className);
     int methodNameIndex = stringTable.intern(methodName);
-
-    // Intern function
     int functionIndex = functionTable.intern(nameIndex, methodNameIndex, classNameIndex, 0);
+    int locationIndex = locationTable.intern(0, 0, functionIndex, line, 0);
 
-    // Create location entry
-    return locationTable.intern(0, 0, functionIndex, line, 0);
+    frameCache.put(cacheKey, locationIndex);
+    return locationIndex;
   }
 
   private int extractLinkIndex(long spanId, long localRootSpanId) {
@@ -725,12 +811,11 @@ private void encodeSample(ProtobufEncoder encoder, SampleData sample) {
     encoder.writeVarintField(OtlpProtoFields.Sample.LINK_INDEX, sample.linkIndex);
 
     // Field 4: values (packed)
-    encoder.writePackedVarintField(OtlpProtoFields.Sample.VALUES, new long[] {sample.value});
+    encoder.writePackedVarintField(OtlpProtoFields.Sample.VALUES, sample.value);
 
     // Field 5: timestamps_unix_nano (packed)
     if (sample.timestampNanos > 0) {
-      encoder.writePackedFixed64Field(
-          OtlpProtoFields.Sample.TIMESTAMPS_UNIX_NANO, new long[] {sample.timestampNanos});
+      encoder.writePackedFixed64Field(OtlpProtoFields.Sample.TIMESTAMPS_UNIX_NANO, sample.timestampNanos);
     }
   }
 

dd-java-agent/agent-profiling/profiling-otel/src/main/java/com/datadog/profiling/otel/jfr/JfrStackFrame.java

@@ -1,11 +1,15 @@
 package com.datadog.profiling.otel.jfr;
 
+import io.jafar.parser.api.JfrField;
 import io.jafar.parser.api.JfrType;
 
 /** Represents a JFR stack frame. */
 @JfrType("jdk.types.StackFrame")
 public interface JfrStackFrame {
   JfrMethod method();
 
+  @JfrField(value = "method", raw = true)
+  long methodId();
+
   int lineNumber();
 }