Optimize PendingTrace hot paths with lazySet and CAS guard

tag: no release note
tag: ai generated

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bm1549

dd-trace-core/src/jmh/java/datadog/trace/core/TimeSourceBenchmark.java

@@ -0,0 +1,63 @@
+package datadog.trace.core;
+
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import datadog.trace.api.DDTraceId;
+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.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.openjdk.jmh.annotations.Threads;
+import org.openjdk.jmh.annotations.Warmup;
+
+@State(Scope.Thread)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.Throughput)
+@Threads(8)
+@OutputTimeUnit(NANOSECONDS)
+@Fork(value = 1)
+public class TimeSourceBenchmark {
+
+  static final CoreTracer TRACER = CoreTracer.builder().build();
+
+  private PendingTrace pendingTrace;
+
+  @Setup(Level.Trial)
+  public void setup() {
+    TraceCollector collector = TRACER.createTraceCollector(DDTraceId.ONE);
+    pendingTrace = (PendingTrace) collector;
+  }
+
+  @TearDown(Level.Trial)
+  public void teardown() {
+    pendingTrace = null;
+  }
+
+  @Benchmark
+  public long getCurrentTimeNano() {
+    return pendingTrace.getCurrentTimeNano();
+  }
+
+  @Benchmark
+  public long systemNanoTime() {
+    return System.nanoTime();
+  }
+
+  @Benchmark
+  public long systemCurrentTimeMillis() {
+    return System.currentTimeMillis();
+  }
+
+  @Benchmark
+  public long traceGetTimeWithNanoTicks() {
+    return TRACER.getTimeWithNanoTicks(System.nanoTime());
+  }
+}

dd-trace-core/src/main/java/datadog/trace/core/PendingTrace.java

@@ -131,10 +131,14 @@ public PendingTrace create(@Nonnull DDTraceId traceId, ConfigSnapshot traceConfi
 
   /**
    * Updated with the latest nanoTicks each time getCurrentTimeNano is called (at the start and
-   * finish of each span).
+   * finish of each span). Uses lazySet for writes (release-store semantics) since the value is only
+   * read for approximate timeout detection by the PendingTraceBuffer background thread.
    */
   private volatile long lastReferenced = 0;
 
+  private static final AtomicLongFieldUpdater<PendingTrace> LAST_REFERENCED =
+      AtomicLongFieldUpdater.newUpdater(PendingTrace.class, "lastReferenced");
+
   private PendingTrace(
       @Nonnull CoreTracer tracer,
       @Nonnull DDTraceId traceId,
@@ -163,25 +167,27 @@ private PendingTrace(
   @Override
   public long getCurrentTimeNano() {
     long nanoTicks = timeSource.getNanoTicks();
-    lastReferenced = nanoTicks;
+    LAST_REFERENCED.lazySet(this, nanoTicks);
     return tracer.getTimeWithNanoTicks(nanoTicks);
   }
 
   @Override
   void touch() {
-    lastReferenced = timeSource.getNanoTicks();
+    LAST_REFERENCED.lazySet(this, timeSource.getNanoTicks());
   }
 
   @Override
   public boolean lastReferencedNanosAgo(long nanos) {
     long currentNanoTicks = timeSource.getNanoTicks();
-    long age = currentNanoTicks - lastReferenced;
+    long age = currentNanoTicks - LAST_REFERENCED.get(this);
     return nanos < age;
   }
 
   @Override
   void registerSpan(final DDSpan span) {
-    ROOT_SPAN.compareAndSet(this, null, span);
+    if (rootSpan == null) {
+      ROOT_SPAN.compareAndSet(this, null, span);
+    }
     PENDING_REFERENCE_COUNT.incrementAndGet(this);
     healthMetrics.onCreateSpan();
     if (pendingTraceBuffer.longRunningSpansEnabled()) {