Add benchmark

Author: JackPGreen

.github/workflows/validate.yml

@@ -0,0 +1,12 @@
+name: Validate
+
+on:
+  push:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - run: mvn --no-transfer-progress test-compile

.gitignore

@@ -0,0 +1,4 @@
+/target/
+/.settings
+.project
+.classpath

README.md

@@ -0,0 +1 @@
+# Benchmarks to support ["Turbocharging Java Reflection Performance with MethodHandle" blog post](https://hazelcast.com/?p=40392).

pom.xml

@@ -0,0 +1,44 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>com.hazelcast</groupId>
+	<artifactId>reflective-blog-benchmark</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<maven.compiler.source>17</maven.compiler.source>
+		<maven.compiler.target>${maven.compiler.source}</maven.compiler.target>
+        <version.jmh>1.37</version.jmh>
+	</properties>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.11.0</version>
+			</plugin>
+			<plugin>
+				<groupId>pw.krejci</groupId>
+				<artifactId>jmh-maven-plugin</artifactId>
+				<version>0.2.2</version>
+			</plugin>
+		</plugins>
+	</build>
+
+	<dependencies>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${version.jmh}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${version.jmh}</version>
+            <scope>provided</scope>
+        </dependency>
+	</dependencies>
+</project>

src/test/java/benchmark/AbstractReflectiveAccessBenchmark.java

@@ -0,0 +1,16 @@
+package benchmark;
+
+import org.openjdk.jmh.annotations.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+// For graphs, we want throughput results instead
+//@BenchmarkMode(Mode.Throughput)
+//@OutputTimeUnit(TimeUnit.SECONDS)
+@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
+@Measurement(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
+@State(Scope.Benchmark)
+public abstract class AbstractReflectiveAccessBenchmark {
+    protected SomeSource source = new SomeSource();
+}

src/test/java/benchmark/PrimitiveReflectiveAccessBenchmark.java

@@ -0,0 +1,40 @@
+package benchmark;
+
+import org.openjdk.jmh.annotations.*;
+import java.lang.invoke.*;
+import java.lang.reflect.Method;
+
+public class PrimitiveReflectiveAccessBenchmark extends AbstractReflectiveAccessBenchmark {
+    private Method method;
+    private MethodHandle methodHandle;
+
+    @Setup
+    public void setup() {
+        try {
+            method = source.getClass().getDeclaredMethod("getPrimitive");
+            methodHandle = MethodHandles.lookup().unreflect(method);
+        } catch (final ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Benchmark
+    public long direct() throws Throwable {
+        return source.getPrimitive();
+    }
+
+    @Benchmark
+    public long reflection() throws ReflectiveOperationException {
+        return ((Long) method.invoke(source)).longValue();
+    }
+
+    @Benchmark
+    public long methodHandleInvoke() throws Throwable {
+        return ((Long) methodHandle.invoke(source)).longValue();
+    }
+
+    @Benchmark
+    public long methodHandleInvokeExact() throws Throwable {
+        return (long) methodHandle.invokeExact(source);
+    }
+}

src/test/java/benchmark/ReferenceReflectiveAccessBenchmark.java

@@ -0,0 +1,50 @@
+package benchmark;
+
+import org.openjdk.jmh.annotations.*;
+import java.lang.invoke.*;
+import java.lang.reflect.Method;
+import java.util.function.Function;
+
+public class ReferenceReflectiveAccessBenchmark extends AbstractReflectiveAccessBenchmark {
+    private Method method;
+    private MethodHandle methodHandle;
+    private Function<SomeSource, ?> lambdaMetafactoryFunction;
+
+    @Setup
+    public void setup() {
+        try {
+            final MethodHandles.Lookup lookup = MethodHandles.lookup();
+
+            method = source.getClass().getDeclaredMethod("getObject");
+
+            methodHandle = lookup.unreflect(method);
+
+            lambdaMetafactoryFunction = (Function<SomeSource, ?>) LambdaMetafactory
+                    .metafactory(lookup, "apply", MethodType.methodType(Function.class),
+                            MethodType.methodType(Object.class, Object.class), methodHandle, methodHandle.type())
+                    .getTarget().invokeExact();
+        } catch (final Throwable t) {
+            throw new ExceptionInInitializerError(t);
+        }
+    }
+
+    @Benchmark
+    public Object direct() throws Throwable {
+        return source.getObject();
+    }
+
+    @Benchmark
+    public Object reflection() throws ReflectiveOperationException {
+        return method.invoke(source);
+    }
+
+    @Benchmark
+    public Object methodHandle() throws Throwable {
+        return methodHandle.invoke(source);
+    }
+
+    @Benchmark
+    public Object lambdaMetafactory() {
+        return lambdaMetafactoryFunction.apply(source);
+    }
+}

src/test/java/benchmark/SomeSource.java

@@ -0,0 +1,15 @@
+package benchmark;
+
+/** Some dummy class to query metrics for using reflection */
+class SomeSource {
+    private static long counter = Long.MAX_VALUE;
+
+    long getPrimitive() {
+        // Not thread-safe but not relevant for our purposes
+        return counter--;
+    }
+
+    Object getObject() {
+        return getPrimitive();
+    }
+}