Add eventually visible benchmark

Author: trask

sdk/logs/build.gradle.kts

@@ -9,6 +9,33 @@ plugins {
 description = "OpenTelemetry Log SDK"
 otelJava.moduleName.set("io.opentelemetry.sdk.logs")
 
+sourceSets {
+  create("jmhJava9") {
+    java {
+      srcDirs("src/jmh/java9")
+    }
+    compileClasspath += sourceSets.jmh.get().compileClasspath
+    compileClasspath += sourceSets.jmh.get().output
+  }
+}
+
+tasks {
+  named<JavaCompile>("compileJmhJava9Java") {
+    options.release = 9
+    dependsOn("compileJmhJava")
+  }
+
+  // Configure JMH jar as multi-release jar
+  named<Jar>("jmhJar") {
+    into("META-INF/versions/9") {
+      from(sourceSets["jmhJava9"].output)
+    }
+    manifest.attributes(
+      "Multi-Release" to "true"
+    )
+  }
+}
+
 dependencies {
   api(project(":api:all"))
   api(project(":sdk:common"))

sdk/logs/src/jmh/java/io/opentelemetry/sdk/logs/booleanstate/BooleanState.java

@@ -0,0 +1,13 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs.booleanstate;
+
+public interface BooleanState {
+
+  boolean get();
+
+  void set(boolean state);
+}

sdk/logs/src/jmh/java/io/opentelemetry/sdk/logs/booleanstate/BooleanStateBenchmark.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs.booleanstate;
+
+import java.util.concurrent.TimeUnit;
+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.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Threads;
+import org.openjdk.jmh.annotations.Warmup;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Warmup(iterations = 5, time = 1)
+@Measurement(iterations = 10, time = 1)
+@Fork(1)
+@State(Scope.Benchmark)
+public class BooleanStateBenchmark {
+
+  @Param({
+    "NonVolatileBooleanState",
+    "ImmediateBooleanState",
+    "EventualBooleanState",
+    "VarHandleImmediateBooleanState", // available with -PjmhJavaVersion=11 and higher
+    "VarHandleEventualBooleanState" // available with -PjmhJavaVersion=11 and higher
+  })
+  private String implementation;
+
+  private BooleanState state;
+
+  @Setup(Level.Trial)
+  public void setup() {
+    switch (implementation) {
+      case "NonVolatileBooleanState":
+        state = new NonVolatileBooleanState();
+        break;
+      case "ImmediateBooleanState":
+        state = new ImmediateBooleanState();
+        break;
+      case "EventualBooleanState":
+        state = new EventualBooleanState();
+        break;
+      case "VarHandleImmediateBooleanState":
+        state = createVarHandleImmediateBooleanState();
+        break;
+      case "VarHandleEventualBooleanState":
+        state = createVarHandleEventualBooleanState();
+        break;
+      default:
+        throw new IllegalArgumentException("Unknown implementation: " + implementation);
+    }
+  }
+
+  private static BooleanState createVarHandleEventualBooleanState() {
+    try {
+      Class<?> clazz =
+          Class.forName("io.opentelemetry.sdk.logs.booleanstate.VarHandleEventualBooleanState");
+      return (BooleanState) clazz.getConstructor().newInstance();
+    } catch (Exception e) {
+      throw new IllegalStateException(
+          "VarHandleEventualBooleanState not available on this Java version", e);
+    }
+  }
+
+  private static BooleanState createVarHandleImmediateBooleanState() {
+    try {
+      Class<?> clazz =
+          Class.forName("io.opentelemetry.sdk.logs.booleanstate.VarHandleImmediateBooleanState");
+      return (BooleanState) clazz.getConstructor().newInstance();
+    } catch (Exception e) {
+      throw new IllegalStateException(
+          "VarHandleImmediateBooleanState not available on this Java version", e);
+    }
+  }
+
+  @Benchmark
+  @Threads(1)
+  public int read_singleThread() {
+    int count = 0;
+    for (int i = 0; i < 100; i++) {
+      if (state.get()) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  @Benchmark
+  @Threads(2) // not expecting significant concurrent access
+  public int read_twoThreads() {
+    int count = 0;
+    for (int i = 0; i < 100; i++) {
+      if (state.get()) {
+        count++;
+      }
+    }
+    return count;
+  }
+}

sdk/logs/src/jmh/java/io/opentelemetry/sdk/logs/booleanstate/EventualBooleanState.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs.booleanstate;
+
+public class EventualBooleanState implements BooleanState {
+
+  private volatile boolean state;
+  private boolean cached;
+
+  private int counter;
+
+  @Override
+  public boolean get() {
+    if (counter++ > 1000) {
+      counter = 0;
+      cached = state; // Update cached value for visibility in this thread
+    }
+    return cached;
+  }
+
+  @Override
+  public void set(boolean state) {
+    this.state = state;
+    this.cached = state; // Update cached value for immediate visibility in this thread
+  }
+}

sdk/logs/src/jmh/java/io/opentelemetry/sdk/logs/booleanstate/ImmediateBooleanState.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs.booleanstate;
+
+public class ImmediateBooleanState implements BooleanState {
+
+  private volatile boolean state;
+
+  @Override
+  public boolean get() {
+    return state;
+  }
+
+  @Override
+  public void set(boolean state) {
+    this.state = state;
+  }
+}

sdk/logs/src/jmh/java/io/opentelemetry/sdk/logs/booleanstate/NonVolatileBooleanState.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs.booleanstate;
+
+public class NonVolatileBooleanState implements BooleanState {
+
+  private boolean state;
+
+  @Override
+  public boolean get() {
+    return state;
+  }
+
+  @Override
+  public void set(boolean state) {
+    this.state = state;
+  }
+}

sdk/logs/src/jmh/java9/io/opentelemetry/sdk/logs/booleanstate/VarHandleEventualBooleanState.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs.booleanstate;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+
+public class VarHandleEventualBooleanState implements BooleanState {
+
+  private static final VarHandle STATE_HANDLE;
+
+  static {
+    try {
+      MethodHandles.Lookup lookup = MethodHandles.lookup();
+      STATE_HANDLE =
+          lookup.findVarHandle(VarHandleEventualBooleanState.class, "state", boolean.class);
+    } catch (ReflectiveOperationException e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+
+  @SuppressWarnings("UnusedVariable") // Used by VarHandle
+  private boolean state;
+
+  private int counter = 0;
+
+  public VarHandleEventualBooleanState() {
+    STATE_HANDLE.setRelease(this, false);
+  }
+
+  @Override
+  public boolean get() {
+    if (counter++ > 1000) {
+      counter = 0;
+      return (boolean) STATE_HANDLE.getAcquire(this);
+    }
+
+    return (boolean) STATE_HANDLE.getOpaque(this);
+  }
+
+  @Override
+  public void set(boolean state) {
+    STATE_HANDLE.setRelease(this, state);
+  }
+}

sdk/logs/src/jmh/java9/io/opentelemetry/sdk/logs/booleanstate/VarHandleImmediateBooleanState.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs.booleanstate;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+
+public class VarHandleImmediateBooleanState implements BooleanState {
+
+  private static final VarHandle STATE_HANDLE;
+
+  static {
+    try {
+      MethodHandles.Lookup lookup = MethodHandles.lookup();
+      STATE_HANDLE =
+          lookup.findVarHandle(VarHandleImmediateBooleanState.class, "state", boolean.class);
+    } catch (ReflectiveOperationException e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+
+  @SuppressWarnings("UnusedVariable") // Used by VarHandle
+  private boolean state;
+
+  public VarHandleImmediateBooleanState() {
+    STATE_HANDLE.setRelease(this, false);
+  }
+
+  @Override
+  public boolean get() {
+    return (boolean) STATE_HANDLE.getAcquire(this);
+  }
+
+  @Override
+  public void set(boolean state) {
+    STATE_HANDLE.setRelease(this, state);
+  }
+}