Replace FixedSizeStripedLongAdder with LongAdder (#9571)

* Replace StripedLongCounter with LongAdder

* Add microbench

* spotless - convert to normal comment

Author: amarziali

dd-java-agent/instrumentation/graal/native-image/src/main/java/datadog/trace/instrumentation/graal/nativeimage/AnnotationSubstitutionProcessorInstrumentation.java

@@ -36,7 +36,6 @@ public void methodAdvice(MethodTransformer transformer) {
   @Override
   public String[] helperClassNames() {
     return new String[] {
-      packageName + ".Target_datadog_jctools_counters_FixedSizeStripedLongCounterFields",
       packageName + ".Target_datadog_jctools_util_UnsafeRefArrayAccess",
       packageName + ".Target_org_datadog_jmxfetch_App",
       packageName + ".Target_org_datadog_jmxfetch_Status",
@@ -51,7 +50,6 @@ public String[] muzzleIgnoredClassNames() {
       "jdk.vm.ci.meta.ResolvedJavaType",
       "jdk.vm.ci.meta.ResolvedJavaField",
       // ignore helper class names as usual
-      packageName + ".Target_datadog_jctools_counters_FixedSizeStripedLongCounterFields",
       packageName + ".Target_datadog_jctools_util_UnsafeRefArrayAccess",
       packageName + ".Target_org_datadog_jmxfetch_App",
       packageName + ".Target_org_datadog_jmxfetch_Status",
@@ -62,7 +60,6 @@ public String[] muzzleIgnoredClassNames() {
   public static class FindTargetClassesAdvice {
     @Advice.OnMethodExit(suppress = Throwable.class)
     public static void onExit(@Advice.Return(readOnly = false) List<Class<?>> result) {
-      result.add(Target_datadog_jctools_counters_FixedSizeStripedLongCounterFields.class);
       result.add(Target_datadog_jctools_util_UnsafeRefArrayAccess.class);
       result.add(Target_org_datadog_jmxfetch_App.class);
       result.add(Target_org_datadog_jmxfetch_Status.class);

dd-java-agent/instrumentation/graal/native-image/src/main/java/datadog/trace/instrumentation/graal/nativeimage/Target_datadog_jctools_counters_FixedSizeStripedLongCounterFields.java

@@ -0,0 +1,66 @@
+package datadog.trace.common;
+
+import static java.util.concurrent.TimeUnit.MICROSECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import de.thetaphi.forbiddenapis.SuppressForbidden;
+import java.util.concurrent.atomic.LongAdder;
+import org.jctools.counters.CountersFactory;
+import org.jctools.counters.FixedSizeStripedLongCounter;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+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.State;
+import org.openjdk.jmh.annotations.Threads;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+/*
+ * Benchmark Mode Cnt Score Error Units
+ * LongAdderBenchmark.benchLongAdderIncrement avgt 0.009 us/op
+ * LongAdderBenchmark.benchLongAdderSum avgt 0.297 us/op
+ * LongAdderBenchmark.benchStripedCounterIncrement avgt 0.071 us/op
+ * LongAdderBenchmark.benchStripedCounterSum avgt 0.425 us/op
+ */
+@State(Scope.Benchmark)
+@Warmup(iterations = 1, time = 30, timeUnit = SECONDS)
+@Measurement(iterations = 1, time = 30, timeUnit = SECONDS)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(MICROSECONDS)
+@Fork(value = 1)
+@SuppressForbidden
+public class LongAdderBenchmark {
+  public final LongAdder adder = new LongAdder();
+  public final FixedSizeStripedLongCounter counter =
+      CountersFactory.createFixedSizeStripedCounter(8);
+
+  @Benchmark
+  @Threads(Threads.MAX)
+  public void benchLongAdderIncrement(Blackhole blackhole) {
+    adder.increment();
+  }
+
+  @Benchmark
+  @Threads(Threads.MAX)
+  public void benchStripedCounterIncrement(Blackhole blackhole) {
+    counter.inc();
+  }
+
+  @Benchmark
+  @Threads(Threads.MAX)
+  public void benchLongAdderSum(Blackhole blackhole) {
+    adder.increment();
+    blackhole.consume(adder.sum());
+  }
+
+  @Benchmark
+  @Threads(Threads.MAX)
+  public void benchStripedCounterSum(Blackhole blackhole) {
+    counter.inc();
+    blackhole.consume(counter.get());
+  }
+}

dd-trace-core/src/jmh/java/datadog/trace/common/LongAdderBenchmark.java

@@ -12,8 +12,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
-import org.jctools.counters.CountersFactory;
-import org.jctools.counters.FixedSizeStripedLongCounter;
+import java.util.concurrent.atomic.LongAdder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -30,10 +29,8 @@ public class PayloadDispatcherImpl implements ByteBufferConsumer, PayloadDispatc
   private RemoteMapper mapper;
   private WritableFormatter packer;
 
-  private final FixedSizeStripedLongCounter droppedSpanCount =
-      CountersFactory.createFixedSizeStripedCounter(8);
-  private final FixedSizeStripedLongCounter droppedTraceCount =
-      CountersFactory.createFixedSizeStripedCounter(8);
+  private final LongAdder droppedSpanCount = new LongAdder();
+  private final LongAdder droppedTraceCount = new LongAdder();
 
   public PayloadDispatcherImpl(
       RemoteMapperDiscovery mapperDiscovery,
@@ -60,8 +57,8 @@ public Collection<RemoteApi> getApis() {
 
   @Override
   public void onDroppedTrace(int spanCount) {
-    droppedSpanCount.inc(spanCount);
-    droppedTraceCount.inc();
+    droppedSpanCount.add(spanCount);
+    droppedTraceCount.increment();
   }
 
   @Override
@@ -97,8 +94,8 @@ Payload newPayload(int messageCount, ByteBuffer buffer) {
     return mapper
         .newPayload()
         .withBody(messageCount, buffer)
-        .withDroppedSpans(droppedSpanCount.getAndReset())
-        .withDroppedTraces(droppedTraceCount.getAndReset());
+        .withDroppedSpans(droppedSpanCount.sumThenReset())
+        .withDroppedTraces(droppedTraceCount.sumThenReset());
   }
 
   @Override