diff --git a/research/issue-67/README.md b/research/issue-67/README.md new file mode 100644 index 0000000..7e2699f --- /dev/null +++ b/research/issue-67/README.md @@ -0,0 +1,122 @@ +# Issue #67: absolute-long-offset VarHandle adapter experiment + +Status: rejected as a production implementation. This directory records the +experiment from pull request #121; it is research evidence, not code proposed +for `develop`. + +## Scoped conclusion + +On the tested JDKs and payload sizes, adapting the existing absolute-`long`- +offset `Access` API to byte-array view VarHandles makes whole XXH3 hashes slower +than the existing Unsafe implementation. This adapter is therefore unsuitable +as a drop-in replacement. + +This result does not establish that VarHandle is inherently slower than Unsafe. +In particular, it does not evaluate a specialised relative-`int`-offset path, +XxHash, streaming or file input, heap or direct `ByteBuffer`, raw memory, or an +implementation designed independently of the existing Unsafe-shaped API. + +The adapter is not a fallback for denied Unsafe memory access. It obtains +`UnsafeAccess.BYTE_BASE`, which initialises `UnsafeAccess` and invokes Unsafe +memory-access methods. XXH3 also continues to read its secret through +`UnsafeAccess`. + +## Experiment identity + +- Repository base: `develop` at + `44f5e8cae1b862a731fbc7d469c8d87e159907dc`. +- Original pull-request head: + `15971be0c616447c0595a664ef76ffc38b8f2f9b`. +- `prototype.patch` contains the experimental adapter, differential test and + benchmark. Its Maven profile was made explicit and reproducible for this + archive; it is not activated by an ordinary build. +- JMH version: 1.37. + +## Equivalence evidence + +`VarHandleAccessTest` performs 2,730 comparisons per execution: + +- ten 64-bit hash-function configurations over lengths 0 through 264; and +- the same ten configurations at eight unaligned prefixes. + +Every comparison matched the existing Unsafe path. This is useful differential +evidence for the tested `byte[]` adapter. It is not an external specification, +an Unsafe-denial test, or coverage of every public input form. The retained +`raw/equivalence-test.log` records both Surefire executions and the complete +14,903-test build result. + +## Performance evidence + +The benchmark hashes the same repeatedly accessed `byte[]` with unseeded XXH3. +The methods receive the same absolute offset, but the VarHandle adapter performs +`(int) (offset - BYTE_BASE)` on each read. That coordinate conversion is part of +the implementation measured. + +The original matrix used AverageTime in ns/op, two forks, three 500 ms warm-up +iterations and five 500 ms measurement iterations. It covered lengths 8, 16, +64, 128, 1024 and 4096 at starting alignments 0 and 1. + +| Input | VarHandle cost over Unsafe across JDK 11/17/21/25 | +| --- | --- | +| 8 bytes | 6% to 20% | +| 16 bytes | 10% to 18% | +| 64 bytes | 22% to 27% | +| 128 bytes | 11% to 28% | +| 1024 bytes | 35% to 62% | +| 4096 bytes | 13% to 45% | + +`results-summary.txt` contains every aggregate score and confidence-interval +half-width. The `raw` directory contains the original JMH JSON and console logs. +An independent JDK 21 rerun on 2026-08-21 reproduced all 12 parameter pairs: +the adapter was 12% to 59% slower. Its output is retained as +`raw/reproduction-jdk21.{json,log}`. + +## Environment + +- Host: Intel Core Ultra 9 185H, x86-64, 22 online logical CPUs. +- OS: Ubuntu 24.04, Linux `7.0.0-28-generic`. +- JDKs: + - OpenJDK 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu; + - OpenJDK 17.0.19+10-1-24.04.2-Ubuntu; + - OpenJDK 21.0.11+10-1-24.04.2-Ubuntu; + - OpenJDK 25.0.3+9-2-24.04.2-Ubuntu. +- JVM arguments: none. +- The host was shared and CPU frequency was not pinned. Treat the direction as + credible, but do not treat the percentages as a cross-machine performance + guarantee. + +## Reproduction + +The exact original shell command was not retained. The following command +reconstructs the settings recorded by JMH and was used for the retained JDK 21 +reproduction: + +```bash +git switch develop +git apply research/issue-67/prototype.patch + +export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64 +export PATH="$JAVA_HOME/bin:$PATH" + +mvn -B -DvarhandlePrototype clean test \ + -Dtest=VarHandleAccessTest \ + dependency:build-classpath \ + -Dmdep.outputFile=target/test-classpath.txt \ + -DincludeScope=test + +JMH_CP=$(sed -n '1p' target/test-classpath.txt) +java -cp "target/test-classes:target/classes:$JMH_CP" \ + org.openjdk.jmh.Main \ + 'net.openhft.hashing.VarHandleVsUnsafeBenchmark.*' \ + -bm avgt -f 2 -wi 3 -w 500ms -i 5 -r 500ms \ + -rf json -rff results-jdk21.json -o run-jdk21.log +``` + +## Consequence + +Do not merge or ship this adapter. A successor investigation should design the +complete supported-memory-access architecture before selecting an +implementation. It should compare natural coordinate models and specialised +algorithm paths, cover every public input form, work without Unsafe memory +access on its modern path, preserve the Java 8 artefact, and retain complete +correctness and benchmark evidence. diff --git a/research/issue-67/prototype.patch b/research/issue-67/prototype.patch new file mode 100644 index 0000000..b1846bd --- /dev/null +++ b/research/issue-67/prototype.patch @@ -0,0 +1,326 @@ +diff --git a/pom.xml b/pom.xml +index 078bece..cc9c84d 100644 +--- a/pom.xml ++++ b/pom.xml +@@ -381,6 +381,46 @@ + + + ++ ++ ++ varhandle-prototype ++ ++ ++ varhandlePrototype ++ ++ ++ ++ 11 ++ ++ ++ ++ ++ maven-compiler-plugin ++ ++ full ++ ++ ++ ++ org.codehaus.mojo ++ build-helper-maven-plugin ++ ++ ++ add-varhandle-prototype-test-source ++ generate-test-sources ++ ++ add-test-source ++ ++ ++ ++ src/test/java9-prototype ++ ++ ++ ++ ++ ++ ++ ++ + + quality + +diff --git a/src/test/java9-prototype/net/openhft/hashing/VarHandleAccess.java b/src/test/java9-prototype/net/openhft/hashing/VarHandleAccess.java +new file mode 100644 +index 0000000..3022d43 +--- /dev/null ++++ b/src/test/java9-prototype/net/openhft/hashing/VarHandleAccess.java +@@ -0,0 +1,101 @@ ++/* ++ * Copyright 2013-2025 chronicle.software; SPDX-License-Identifier: Apache-2.0 ++ */ ++package net.openhft.hashing; ++ ++import java.lang.invoke.MethodHandles; ++import java.lang.invoke.VarHandle; ++import java.nio.ByteOrder; ++ ++import static net.openhft.hashing.Primitives.unsignedByte; ++import static net.openhft.hashing.Primitives.unsignedInt; ++import static net.openhft.hashing.Primitives.unsignedShort; ++ ++/** ++ * Prototype {@link Access} to {@code byte[]} backed by {@link VarHandle} rather than ++ * {@code sun.misc.Unsafe} (issue #67). This lives in the test tree because it needs ++ * Java 9+ APIs while the shipped library still compiles for Java 8. It exists only ++ * to record the bounded experiment performed for issue #67. ++ *

++ * Offsets follow the same convention as {@link UnsafeAccess} for {@code byte[]} inputs: ++ * they are absolute {@code UnsafeAccess.BYTE_BASE + arrayIndex} values, so this access ++ * can be dropped into {@link LongHashFunction#hash} in place of {@link Access#unsafe()}. ++ * ++ *

Scoped conclusion

++ * {@link VarHandleVsUnsafeBenchmark} measured whole XXH3 hashes over small, repeatedly accessed ++ * {@code byte[]} inputs on JDK 11/17/21/25. Adapting the current absolute-{@code long}-offset ++ * {@link Access} contract to byte-array view VarHandles was slower than {@link UnsafeAccess} in ++ * every measured case. This prototype is therefore unsuitable as a drop-in replacement. ++ * The experiment does not evaluate a specialised relative-{@code int}-offset implementation, ++ * XxHash, streaming input, {@code ByteBuffer}, or raw-memory access. ++ *

++ * This class is not an Unsafe-denial fallback: its {@link #BYTE_BASE} initialisation and the XXH3 ++ * implementation still depend on Unsafe memory-access methods. ++ */ ++final class VarHandleAccess extends Access { ++ ++ static final VarHandleAccess INSTANCE = new VarHandleAccess(); ++ ++ private static final long BYTE_BASE = UnsafeAccess.BYTE_BASE; ++ ++ private static final VarHandle LONG_VH = ++ MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.nativeOrder()); ++ private static final VarHandle INT_VH = ++ MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.nativeOrder()); ++ private static final VarHandle SHORT_VH = ++ MethodHandles.byteArrayViewVarHandle(short[].class, ByteOrder.nativeOrder()); ++ ++ private final Access reverse = Access.newDefaultReverseAccess(this); ++ ++ private VarHandleAccess() { ++ } ++ ++ private static int index(final long offset) { ++ return (int) (offset - BYTE_BASE); ++ } ++ ++ @Override ++ public long getLong(final byte[] input, final long offset) { ++ return (long) LONG_VH.get(input, index(offset)); ++ } ++ ++ @Override ++ public long getUnsignedInt(final byte[] input, final long offset) { ++ return unsignedInt(getInt(input, offset)); ++ } ++ ++ @Override ++ public int getInt(final byte[] input, final long offset) { ++ return (int) INT_VH.get(input, index(offset)); ++ } ++ ++ @Override ++ public int getUnsignedShort(final byte[] input, final long offset) { ++ return unsignedShort(getShort(input, offset)); ++ } ++ ++ @Override ++ public int getShort(final byte[] input, final long offset) { ++ return (short) SHORT_VH.get(input, index(offset)); ++ } ++ ++ @Override ++ public int getUnsignedByte(final byte[] input, final long offset) { ++ return unsignedByte(getByte(input, offset)); ++ } ++ ++ @Override ++ public int getByte(final byte[] input, final long offset) { ++ return input[index(offset)]; ++ } ++ ++ @Override ++ public ByteOrder byteOrder(final byte[] input) { ++ return ByteOrder.nativeOrder(); ++ } ++ ++ @Override ++ protected Access reverseAccess() { ++ return reverse; ++ } ++} +diff --git a/src/test/java9-prototype/net/openhft/hashing/VarHandleAccessTest.java b/src/test/java9-prototype/net/openhft/hashing/VarHandleAccessTest.java +new file mode 100644 +index 0000000..ebfa3f7 +--- /dev/null ++++ b/src/test/java9-prototype/net/openhft/hashing/VarHandleAccessTest.java +@@ -0,0 +1,66 @@ ++/* ++ * Copyright 2013-2025 chronicle.software; SPDX-License-Identifier: Apache-2.0 ++ */ ++package net.openhft.hashing; ++ ++import org.junit.Test; ++ ++import java.util.Random; ++ ++import static org.junit.Assert.assertEquals; ++ ++/** ++ * Validates the {@link VarHandleAccess} prototype for issue #67: a VarHandle-based ++ * byte[] read path must produce results bit-for-bit identical to the shipped ++ * {@code sun.misc.Unsafe} path across the hash functions and a range of lengths, ++ * including sub-word tails and unaligned offsets. This is a differential test against ++ * the current implementation, not an external specification or an Unsafe-denial test. ++ */ ++public class VarHandleAccessTest { ++ ++ private static final LongHashFunction[] FUNCTIONS = { ++ LongHashFunction.xx(), ++ LongHashFunction.xx(42L), ++ LongHashFunction.xx3(), ++ LongHashFunction.xx3(42L), ++ LongHashFunction.city_1_1(), ++ LongHashFunction.farmNa(), ++ LongHashFunction.farmUo(), ++ LongHashFunction.murmur_3(), ++ LongHashFunction.wy_3(), ++ LongHashFunction.metro(), ++ }; ++ ++ @Test ++ public void varHandleAccessMatchesUnsafeForByteArrays() { ++ final Random random = new Random(12345L); ++ for (int len = 0; len <= 264; len++) { ++ final byte[] bytes = new byte[len]; ++ random.nextBytes(bytes); ++ for (LongHashFunction fn : FUNCTIONS) { ++ final long viaUnsafe = fn.hashBytes(bytes); ++ final long viaVarHandle = ++ fn.hash(bytes, VarHandleAccess.INSTANCE, UnsafeAccess.BYTE_BASE, len); ++ assertEquals("mismatch for " + fn + " at length " + len, ++ viaUnsafe, viaVarHandle); ++ } ++ } ++ } ++ ++ @Test ++ public void varHandleAccessMatchesUnsafeAtUnalignedOffsets() { ++ final Random random = new Random(67890L); ++ final int len = 96; ++ for (int prefix = 0; prefix < 8; prefix++) { ++ final byte[] bytes = new byte[prefix + len]; ++ random.nextBytes(bytes); ++ for (LongHashFunction fn : FUNCTIONS) { ++ final long viaUnsafe = fn.hashBytes(bytes, prefix, len); ++ final long viaVarHandle = fn.hash( ++ bytes, VarHandleAccess.INSTANCE, UnsafeAccess.BYTE_BASE + prefix, len); ++ assertEquals("mismatch for " + fn + " at prefix " + prefix, ++ viaUnsafe, viaVarHandle); ++ } ++ } ++ } ++} +diff --git a/src/test/java9-prototype/net/openhft/hashing/VarHandleVsUnsafeBenchmark.java b/src/test/java9-prototype/net/openhft/hashing/VarHandleVsUnsafeBenchmark.java +new file mode 100644 +index 0000000..c8d53b1 +--- /dev/null ++++ b/src/test/java9-prototype/net/openhft/hashing/VarHandleVsUnsafeBenchmark.java +@@ -0,0 +1,90 @@ ++/* ++ * Copyright 2013-2025 chronicle.software; SPDX-License-Identifier: Apache-2.0 ++ */ ++package net.openhft.hashing; ++ ++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.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 java.io.IOException; ++import java.util.Random; ++import java.util.concurrent.TimeUnit; ++ ++/** ++ * Go/no-go benchmark for issue #67: is a {@link java.lang.invoke.VarHandle}-based ++ * {@link Access} to {@code byte[]} at least as fast as the shipped {@code sun.misc.Unsafe} ++ * path for whole hash operations (not isolated primitive loads)? ++ *

++ * The two benchmark methods run the identical hash algorithm over the identical input; ++ * they differ only in the {@link Access} implementation handed to ++ * {@link LongHashFunction#hash(Object, Access, long, long)}: ++ *

++ * Both accesses receive the same absolute offset. The VarHandle adapter converts that ++ * {@code long} value to a relative {@code int} index for every read; this conversion is part of ++ * the adapter cost measured here. Parameters sweep input length and start alignment because the ++ * JIT can treat aligned and unaligned access differently on some JDKs. ++ *

++ * Fork count, iteration counts and modes are intentionally left at conservative defaults and ++ * are meant to be overridden on the JMH command line per JDK under test so the same source ++ * produces comparable raw output on JDK 11, 17, 21 and 25. ++ *

++ * Run explicitly with {@code -DvarhandlePrototype} on JDK 11+; it lives in the test tree ++ * because {@link VarHandleAccess} needs newer APIs while the library still targets Java 8. ++ */ ++@State(Scope.Thread) ++@BenchmarkMode({Mode.AverageTime, Mode.Throughput}) ++@OutputTimeUnit(TimeUnit.NANOSECONDS) ++@Warmup(iterations = 5, time = 1) ++@Measurement(iterations = 5, time = 1) ++@Fork(3) ++public class VarHandleVsUnsafeBenchmark { ++ ++ private static final long BYTE_BASE = UnsafeAccess.BYTE_BASE; ++ ++ @Param({"8", "16", "64", "128", "1024", "4096"}) ++ private int length; ++ ++ /** 0 = aligned start, 1 = start one byte in so 8-byte reads straddle word boundaries. */ ++ @Param({"0", "1"}) ++ private int startAlign; ++ ++ private LongHashFunction xx3; ++ private byte[] input; ++ private long offset; ++ private long len; ++ ++ @Setup ++ public void setup() { ++ xx3 = LongHashFunction.xx3(); ++ input = new byte[length + 8]; ++ new Random(42).nextBytes(input); ++ offset = BYTE_BASE + startAlign; ++ len = length; ++ } ++ ++ @Benchmark ++ public long unsafe() { ++ return xx3.hash(input, UnsafeAccess.INSTANCE, offset, len); ++ } ++ ++ @Benchmark ++ public long varHandle() { ++ return xx3.hash(input, VarHandleAccess.INSTANCE, offset, len); ++ } ++ ++ public static void main(String[] args) throws IOException { ++ org.openjdk.jmh.Main.main(args); ++ } ++} diff --git a/research/issue-67/raw/equivalence-test.log b/research/issue-67/raw/equivalence-test.log new file mode 100644 index 0000000..6b070d4 --- /dev/null +++ b/research/issue-67/raw/equivalence-test.log @@ -0,0 +1,173 @@ +item=ZAH #67 +repo=Zero-Allocation-Hashing +branch=feat/Zero-Allocation-Hashing-67-prototype-java-9-mr-jar-varhandle +sha=15971be0c616447c0595a664ef76ffc38b8f2f9b +command=mvn -o -B clean test +started=2026-08-20T20:00:08+01:00 + +[INFO] Scanning for projects... +[INFO] +[INFO] ----------------< net.openhft:zero-allocation-hashing >----------------- +[INFO] Building Zero-allocation Hashing 2026.1-SNAPSHOT +[INFO] -------------------------------[ bundle ]------------------------------- +[INFO] +[INFO] --- maven-clean-plugin:3.5.0:clean (default-clean) @ zero-allocation-hashing --- +[INFO] Deleting /tmp/draft-pr-local-validation.ds07V8/Zero-Allocation-Hashing/target +[INFO] +[INFO] --- maven-enforcer-plugin:3.3.0:enforce (enforce-maven) @ zero-allocation-hashing --- +[INFO] Rule 0: org.apache.maven.enforcer.rules.version.RequireMavenVersion passed +[INFO] +[INFO] --- maven-enforcer-plugin:3.3.0:enforce (enforce-no-snapshots) @ zero-allocation-hashing --- +[INFO] Rule 0: org.apache.maven.enforcer.rules.dependency.RequireReleaseDeps passed +[INFO] +[INFO] --- maven-enforcer-plugin:3.3.0:enforce (enforce-versions) @ zero-allocation-hashing --- +[INFO] Rule 0: org.apache.maven.enforcer.rules.version.RequireMavenVersion passed +[INFO] Rule 1: org.apache.maven.enforcer.rules.version.RequireJavaVersion passed +[INFO] Rule 2: org.apache.maven.enforcer.rules.property.RequireProperty passed +[INFO] +[INFO] --- build-helper-maven-plugin:3.1.0:regex-properties (match-target-release) @ zero-allocation-hashing --- +[INFO] +[INFO] --- maven-checkstyle-plugin:3.3.0:check (validate) @ zero-allocation-hashing --- +[INFO] You have 0 Checkstyle violations. +[INFO] +[INFO] --- build-helper-maven-plugin:3.1.0:add-source (add-stub-source) @ zero-allocation-hashing --- +[INFO] Source directory: /tmp/draft-pr-local-validation.ds07V8/Zero-Allocation-Hashing/src/main/java-stub added. +[INFO] +[INFO] --- maven-resources-plugin:3.3.1:resources (default-resources) @ zero-allocation-hashing --- +[INFO] skip non existing resourceDirectory /tmp/draft-pr-local-validation.ds07V8/Zero-Allocation-Hashing/src/main/resources +[INFO] +[INFO] --- maven-compiler-plugin:3.14.0:compile (default-compile) @ zero-allocation-hashing --- +[INFO] Recompiling the module because of changed source code. +[INFO] Compiling 26 source files with javac [debug deprecation release 8] to target/classes +[WARNING] source value 8 is obsolete and will be removed in a future release +[WARNING] target value 8 is obsolete and will be removed in a future release +[WARNING] To suppress warnings about obsolete options, use -Xlint:-options. +[INFO] +[INFO] --- maven-bundle-plugin:5.1.9:manifest (default) @ zero-allocation-hashing --- +[INFO] No MANIFEST.MF file found, generating manifest. +[INFO] Writing manifest: /tmp/draft-pr-local-validation.ds07V8/Zero-Allocation-Hashing/target/classes/META-INF/MANIFEST.MF +[INFO] +[INFO] --- build-helper-maven-plugin:3.1.0:add-test-source (add-varhandle-prototype-test-source) @ zero-allocation-hashing --- +[INFO] Test Source directory: /tmp/draft-pr-local-validation.ds07V8/Zero-Allocation-Hashing/src/test/java9-prototype added. +[INFO] +[INFO] --- maven-resources-plugin:3.3.1:testResources (default-testResources) @ zero-allocation-hashing --- +[INFO] skip non existing resourceDirectory /tmp/draft-pr-local-validation.ds07V8/Zero-Allocation-Hashing/src/test/resources +[INFO] +[INFO] --- maven-compiler-plugin:3.14.0:testCompile (default-testCompile) @ zero-allocation-hashing --- +[INFO] Recompiling the module because of changed dependency. +[INFO] Compiling 25 source files with javac [debug deprecation release 11] to target/test-classes +[INFO] +[INFO] --- maven-surefire-plugin:3.1.2:test (default-test) @ zero-allocation-hashing --- +[INFO] Using auto detected provider org.apache.maven.surefire.junit4.JUnit4Provider +[INFO] +[INFO] ------------------------------------------------------- +[INFO] T E S T S +[INFO] ------------------------------------------------------- +[INFO] Running net.openhft.hashing.VarHandleAccessTest +[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.072 s -- in net.openhft.hashing.VarHandleAccessTest +[INFO] Running net.openhft.hashing.XxHashTest +[INFO] Tests run: 2050, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.258 s -- in net.openhft.hashing.XxHashTest +[INFO] Running net.openhft.hashing.XxHashCollisionTest +[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.032 s -- in net.openhft.hashing.XxHashCollisionTest +[INFO] Running net.openhft.hashing.XXH3Test +[INFO] Tests run: 4100, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.412 s -- in net.openhft.hashing.XXH3Test +[INFO] Running net.openhft.hashing.XXH128Test +[INFO] Tests run: 2562, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.364 s -- in net.openhft.hashing.XXH128Test +[INFO] Running net.openhft.hashing.WyHashTest +[INFO] Tests run: 2050, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.257 s -- in net.openhft.hashing.WyHashTest +[INFO] Running net.openhft.hashing.UtilTest +[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.037 s -- in net.openhft.hashing.UtilTest +[INFO] Running net.openhft.hashing.UnsafeAccessTest +[WARNING] Tests run: 8, Failures: 0, Errors: 0, Skipped: 2, Time elapsed: 0.066 s -- in net.openhft.hashing.UnsafeAccessTest +[INFO] Running net.openhft.hashing.PrimitivesTest +[WARNING] Tests run: 2, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.046 s -- in net.openhft.hashing.PrimitivesTest +[INFO] Running net.openhft.hashing.OriginalFarmHashTest +[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.220 s -- in net.openhft.hashing.OriginalFarmHashTest +[INFO] Running net.openhft.hashing.MurmurHash3Test +[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.151 s -- in net.openhft.hashing.MurmurHash3Test +[INFO] Running net.openhft.hashing.ModernCompactStringHashTest +[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.051 s -- in net.openhft.hashing.ModernCompactStringHashTest +[INFO] Running net.openhft.hashing.MetroHashTest +[INFO] Tests run: 2050, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.261 s -- in net.openhft.hashing.MetroHashTest +[INFO] Running net.openhft.hashing.MathsTest +[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.036 s -- in net.openhft.hashing.MathsTest +[INFO] Running net.openhft.hashing.FarmHashTest +[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.152 s -- in net.openhft.hashing.FarmHashTest +[INFO] Running net.openhft.hashing.DualHashFunctionTest +[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.033 s -- in net.openhft.hashing.DualHashFunctionTest +[INFO] Running net.openhft.hashing.CompactLatin1CharSequenceAccessTest +[WARNING] Tests run: 2, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.035 s -- in net.openhft.hashing.CompactLatin1CharSequenceAccessTest +[INFO] Running net.openhft.hashing.City64_1_1_Test +[INFO] Tests run: 2050, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.229 s -- in net.openhft.hashing.City64_1_1_Test +[INFO] Running net.openhft.hashing.CharSequenceAccessTest +[WARNING] Tests run: 5, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.032 s -- in net.openhft.hashing.CharSequenceAccessTest +[INFO] Running net.openhft.hashing.ByteBufferAccessTest +[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.030 s -- in net.openhft.hashing.ByteBufferAccessTest +[INFO] +[INFO] Results: +[INFO] +[WARNING] Tests run: 14903, Failures: 0, Errors: 0, Skipped: 5 +[INFO] +[INFO] +[INFO] --- maven-surefire-plugin:3.1.2:test (test-without-compact-string) @ zero-allocation-hashing --- +[INFO] Using auto detected provider org.apache.maven.surefire.junit4.JUnit4Provider +[INFO] +[INFO] ------------------------------------------------------- +[INFO] T E S T S +[INFO] ------------------------------------------------------- +[INFO] Running net.openhft.hashing.VarHandleAccessTest +[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.059 s -- in net.openhft.hashing.VarHandleAccessTest +[INFO] Running net.openhft.hashing.XxHashTest +[INFO] Tests run: 2050, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.208 s -- in net.openhft.hashing.XxHashTest +[INFO] Running net.openhft.hashing.XxHashCollisionTest +[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.042 s -- in net.openhft.hashing.XxHashCollisionTest +[INFO] Running net.openhft.hashing.XXH3Test +[INFO] Tests run: 4100, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.390 s -- in net.openhft.hashing.XXH3Test +[INFO] Running net.openhft.hashing.XXH128Test +[INFO] Tests run: 2562, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.405 s -- in net.openhft.hashing.XXH128Test +[INFO] Running net.openhft.hashing.WyHashTest +[INFO] Tests run: 2050, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.235 s -- in net.openhft.hashing.WyHashTest +[INFO] Running net.openhft.hashing.UtilTest +[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.037 s -- in net.openhft.hashing.UtilTest +[INFO] Running net.openhft.hashing.UnsafeAccessTest +[WARNING] Tests run: 8, Failures: 0, Errors: 0, Skipped: 2, Time elapsed: 0.043 s -- in net.openhft.hashing.UnsafeAccessTest +[INFO] Running net.openhft.hashing.PrimitivesTest +[WARNING] Tests run: 2, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.032 s -- in net.openhft.hashing.PrimitivesTest +[INFO] Running net.openhft.hashing.OriginalFarmHashTest +[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.214 s -- in net.openhft.hashing.OriginalFarmHashTest +[INFO] Running net.openhft.hashing.MurmurHash3Test +[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.127 s -- in net.openhft.hashing.MurmurHash3Test +[INFO] Running net.openhft.hashing.ModernCompactStringHashTest +[WARNING] Tests run: 7, Failures: 0, Errors: 0, Skipped: 3, Time elapsed: 0.037 s -- in net.openhft.hashing.ModernCompactStringHashTest +[INFO] Running net.openhft.hashing.MetroHashTest +[INFO] Tests run: 2050, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.210 s -- in net.openhft.hashing.MetroHashTest +[INFO] Running net.openhft.hashing.MathsTest +[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.034 s -- in net.openhft.hashing.MathsTest +[INFO] Running net.openhft.hashing.FarmHashTest +[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.114 s -- in net.openhft.hashing.FarmHashTest +[INFO] Running net.openhft.hashing.DualHashFunctionTest +[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.041 s -- in net.openhft.hashing.DualHashFunctionTest +[INFO] Running net.openhft.hashing.CompactLatin1CharSequenceAccessTest +[WARNING] Tests run: 2, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.045 s -- in net.openhft.hashing.CompactLatin1CharSequenceAccessTest +[INFO] Running net.openhft.hashing.City64_1_1_Test +[INFO] Tests run: 2050, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.191 s -- in net.openhft.hashing.City64_1_1_Test +[INFO] Running net.openhft.hashing.CharSequenceAccessTest +[WARNING] Tests run: 5, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.035 s -- in net.openhft.hashing.CharSequenceAccessTest +[INFO] Running net.openhft.hashing.ByteBufferAccessTest +[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.031 s -- in net.openhft.hashing.ByteBufferAccessTest +[INFO] +[INFO] Results: +[INFO] +[WARNING] Tests run: 14903, Failures: 0, Errors: 0, Skipped: 8 +[INFO] +[INFO] ------------------------------------------------------------------------ +[INFO] BUILD SUCCESS +[INFO] ------------------------------------------------------------------------ +[INFO] Total time: 18.960 s +[INFO] Finished at: 2026-08-20T20:00:28+01:00 +[INFO] ------------------------------------------------------------------------ + +finished=2026-08-20T20:00:28+01:00 +duration_seconds=20 +exit_code=0 +post_test_changes=0 diff --git a/research/issue-67/raw/reproduction-jdk21.json b/research/issue-67/raw/reproduction-jdk21.json new file mode 100644 index 0000000..3048dc8 --- /dev/null +++ b/research/issue-67/raw/reproduction-jdk21.json @@ -0,0 +1,1490 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.3390886672082907, + "scoreError" : 0.04700722506671816, + "scoreConfidence" : [ + 2.2920814421415727, + 2.3860958922750086 + ], + "scorePercentiles" : { + "0.0" : 2.309118943134112, + "50.0" : 2.3328173165978683, + "90.0" : 2.4127340697862767, + "95.0" : 2.4196098248214692, + "99.0" : 2.4196098248214692, + "99.9" : 2.4196098248214692, + "99.99" : 2.4196098248214692, + "99.999" : 2.4196098248214692, + "99.9999" : 2.4196098248214692, + "100.0" : 2.4196098248214692 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.339251244599259, + 2.319789383685213, + 2.3231592763580475, + 2.345284952416532, + 2.350852274469544 + ], + [ + 2.3325079487165485, + 2.309118943134112, + 2.3181861394029912, + 2.3331266844791885, + 2.4196098248214692 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.3293197363629594, + "scoreError" : 0.020877449926006444, + "scoreConfidence" : [ + 2.308442286436953, + 2.3501971862889657 + ], + "scorePercentiles" : { + "0.0" : 2.3082418525620674, + "50.0" : 2.324112175357784, + "90.0" : 2.3524884738919543, + "95.0" : 2.3533993853191384, + "99.0" : 2.3533993853191384, + "99.9" : 2.3533993853191384, + "99.99" : 2.3533993853191384, + "99.999" : 2.3533993853191384, + "99.9999" : 2.3533993853191384, + "100.0" : 2.3533993853191384 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.3429996462287943, + 2.3218749218281327, + 2.3213987365446545, + 2.324673852105756, + 2.323550498609811 + ], + [ + 2.3082418525620674, + 2.3196537225696696, + 2.333114476814272, + 2.3533993853191384, + 2.3442902710472975 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.5854335468131135, + "scoreError" : 0.30750257501441824, + "scoreConfidence" : [ + 2.2779309717986953, + 2.892936121827532 + ], + "scorePercentiles" : { + "0.0" : 2.5076647010398694, + "50.0" : 2.520623118480416, + "90.0" : 3.1015679081540695, + "95.0" : 3.1633026491432434, + "99.0" : 3.1633026491432434, + "99.9" : 3.1633026491432434, + "99.99" : 3.1633026491432434, + "99.999" : 3.1633026491432434, + "99.9999" : 3.1633026491432434, + "100.0" : 3.1633026491432434 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.5180796015079614, + 2.5353736569390044, + 2.5459552392514997, + 2.519452793445715, + 2.5108030577427742 + ], + [ + 2.521793443515117, + 3.1633026491432434, + 2.5076647010398694, + 2.508463231383344, + 2.5234470941626084 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.5155108934430035, + "scoreError" : 0.02259877767815901, + "scoreConfidence" : [ + 2.4929121157648444, + 2.5381096711211626 + ], + "scorePercentiles" : { + "0.0" : 2.4985240258575905, + "50.0" : 2.515368761440879, + "90.0" : 2.546295529941181, + "95.0" : 2.548283472939447, + "99.0" : 2.548283472939447, + "99.9" : 2.548283472939447, + "99.99" : 2.548283472939447, + "99.999" : 2.548283472939447, + "99.9999" : 2.548283472939447, + "100.0" : 2.548283472939447 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.548283472939447, + 2.5143948972486188, + 2.517243462230322, + 2.51243677165772, + 2.5284040429567876 + ], + [ + 2.5163426256331394, + 2.518572707517453, + 2.5020117127502806, + 2.4985240258575905, + 2.4988952156386763 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 5.407092404350676, + "scoreError" : 0.03460609761312209, + "scoreConfidence" : [ + 5.372486306737554, + 5.441698501963798 + ], + "scorePercentiles" : { + "0.0" : 5.370209035261819, + "50.0" : 5.402876883754082, + "90.0" : 5.440732102975457, + "95.0" : 5.440996132730764, + "99.0" : 5.440996132730764, + "99.9" : 5.440996132730764, + "99.99" : 5.440996132730764, + "99.999" : 5.440996132730764, + "99.9999" : 5.440996132730764, + "100.0" : 5.440996132730764 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.3985625229207, + 5.425931057511994, + 5.401258526199514, + 5.40449524130865, + 5.386195235197178 + ], + [ + 5.390623928039649, + 5.440996132730764, + 5.414296529158803, + 5.370209035261819, + 5.438355835177692 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 5.39497213860293, + "scoreError" : 0.11046313459792641, + "scoreConfidence" : [ + 5.284509004005003, + 5.505435273200857 + ], + "scorePercentiles" : { + "0.0" : 5.32679940981338, + "50.0" : 5.375483414432974, + "90.0" : 5.53699327344029, + "95.0" : 5.541200722346837, + "99.0" : 5.541200722346837, + "99.9" : 5.541200722346837, + "99.99" : 5.541200722346837, + "99.999" : 5.541200722346837, + "99.9999" : 5.541200722346837, + "100.0" : 5.541200722346837 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.4248132322545155, + 5.499126233281365, + 5.541200722346837, + 5.329069569350937, + 5.32679940981338 + ], + [ + 5.335627102845344, + 5.38674471325939, + 5.372602730957311, + 5.355373574011584, + 5.378364097908636 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 10.891532864400915, + "scoreError" : 0.07889398561251476, + "scoreConfidence" : [ + 10.8126388787884, + 10.97042685001343 + ], + "scorePercentiles" : { + "0.0" : 10.8235422771896, + "50.0" : 10.914145930564313, + "90.0" : 10.94901160685857, + "95.0" : 10.950443316445162, + "99.0" : 10.950443316445162, + "99.9" : 10.950443316445162, + "99.99" : 10.950443316445162, + "99.999" : 10.950443316445162, + "99.9999" : 10.950443316445162, + "100.0" : 10.950443316445162 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 10.950443316445162, + 10.935768666807622, + 10.936126220579236, + 10.933891334289543, + 10.907924311727806 + ], + [ + 10.829385987854913, + 10.920367549400822, + 10.8235422771896, + 10.829431791314528, + 10.848447188399913 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 11.028786573917259, + "scoreError" : 0.12088311794330728, + "scoreConfidence" : [ + 10.907903455973951, + 11.149669691860566 + ], + "scorePercentiles" : { + "0.0" : 10.936232163956104, + "50.0" : 11.01368395102638, + "90.0" : 11.20813245162811, + "95.0" : 11.223053581843942, + "99.0" : 11.223053581843942, + "99.9" : 11.223053581843942, + "99.99" : 11.223053581843942, + "99.999" : 11.223053581843942, + "99.9999" : 11.223053581843942, + "100.0" : 11.223053581843942 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 11.045772228830158, + 11.0020265168402, + 11.02276090740306, + 11.223053581843942, + 10.9888938972364 + ], + [ + 11.004606994649698, + 11.073842279685625, + 10.936232163956104, + 10.952053941767458, + 11.03862322695994 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 65.29759561774901, + "scoreError" : 1.2335093743572132, + "scoreConfidence" : [ + 64.0640862433918, + 66.53110499210622 + ], + "scorePercentiles" : { + "0.0" : 64.43708237665555, + "50.0" : 65.14124026370587, + "90.0" : 67.04664789490703, + "95.0" : 67.14664824927601, + "99.0" : 67.14664824927601, + "99.9" : 67.14664824927601, + "99.99" : 67.14664824927601, + "99.999" : 67.14664824927601, + "99.9999" : 67.14664824927601, + "100.0" : 67.14664824927601 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 67.14664824927601, + 64.59098295984582, + 65.37652682327948, + 64.43708237665555, + 66.14664470558608 + ], + [ + 64.61491132022562, + 65.21192355124535, + 65.0705569761664, + 65.02116048659107, + 65.35951872861887 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 67.11348597829748, + "scoreError" : 1.1700091153391194, + "scoreConfidence" : [ + 65.94347686295836, + 68.28349509363659 + ], + "scorePercentiles" : { + "0.0" : 65.84587692514648, + "50.0" : 67.02011154711029, + "90.0" : 68.07951280543983, + "95.0" : 68.08739685620841, + "99.0" : 68.08739685620841, + "99.9" : 68.08739685620841, + "99.99" : 68.08739685620841, + "99.999" : 68.08739685620841, + "99.9999" : 68.08739685620841, + "100.0" : 68.08739685620841 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 67.82843216145673, + 68.08739685620841, + 66.7183973426769, + 66.32948127817379, + 66.95854907992664 + ], + [ + 66.53596239057401, + 68.00855634852262, + 65.84587692514648, + 67.08167401429394, + 67.74053338599523 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 248.9477841795755, + "scoreError" : 2.4881231029612247, + "scoreConfidence" : [ + 246.45966107661428, + 251.43590728253673 + ], + "scorePercentiles" : { + "0.0" : 247.23822255967502, + "50.0" : 249.02274163636008, + "90.0" : 252.4651374550019, + "95.0" : 252.73457053376438, + "99.0" : 252.73457053376438, + "99.9" : 252.73457053376438, + "99.99" : 252.73457053376438, + "99.999" : 252.73457053376438, + "99.9999" : 252.73457053376438, + "100.0" : 252.73457053376438 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 248.89601665859584, + 247.23822255967502, + 247.51574707484332, + 247.55314000097016, + 247.6933810248087 + ], + [ + 252.73457053376438, + 250.04023974613938, + 249.4226918876327, + 249.14946661412435, + 249.234365695201 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 255.38686093379988, + "scoreError" : 3.2187719227350873, + "scoreConfidence" : [ + 252.16808901106478, + 258.60563285653495 + ], + "scorePercentiles" : { + "0.0" : 251.1417414576111, + "50.0" : 256.0842110644274, + "90.0" : 258.03933080755047, + "95.0" : 258.20282976493485, + "99.0" : 258.20282976493485, + "99.9" : 258.20282976493485, + "99.99" : 258.20282976493485, + "99.999" : 258.20282976493485, + "99.9999" : 258.20282976493485, + "100.0" : 258.20282976493485 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 255.40450582954145, + 256.17904187598515, + 255.6620947726535, + 252.11564182782223, + 251.1417414576111 + ], + [ + 255.98938025286964, + 256.25944562183076, + 256.34608774365904, + 256.567840191091, + 258.20282976493485 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.706270994762594, + "scoreError" : 0.031366362584461856, + "scoreConfidence" : [ + 2.6749046321781322, + 2.737637357347056 + ], + "scorePercentiles" : { + "0.0" : 2.6843984826523277, + "50.0" : 2.6998339388433514, + "90.0" : 2.753683459805392, + "95.0" : 2.7578390324647053, + "99.0" : 2.7578390324647053, + "99.9" : 2.7578390324647053, + "99.99" : 2.7578390324647053, + "99.999" : 2.7578390324647053, + "99.9999" : 2.7578390324647053, + "100.0" : 2.7578390324647053 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.694838267739976, + 2.6843984826523277, + 2.7161289079033883, + 2.6947881952597146, + 2.7063558624650783 + ], + [ + 2.7162833058715727, + 2.7578390324647053, + 2.6924100155824746, + 2.700623205632684, + 2.6990446720540184 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.700532059079114, + "scoreError" : 0.015622355259887135, + "scoreConfidence" : [ + 2.6849097038192267, + 2.7161544143390013 + ], + "scorePercentiles" : { + "0.0" : 2.6806513016882585, + "50.0" : 2.7003878734086557, + "90.0" : 2.7111458168743923, + "95.0" : 2.7111494773636236, + "99.0" : 2.7111494773636236, + "99.9" : 2.7111494773636236, + "99.99" : 2.7111494773636236, + "99.999" : 2.7111494773636236, + "99.9999" : 2.7111494773636236, + "100.0" : 2.7111494773636236 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.7021899170817485, + 2.693797707334879, + 2.698585829735563, + 2.7097913357559476, + 2.6972242221536833 + ], + [ + 2.7111494773636236, + 2.7102185830738055, + 2.690599344132319, + 2.711112872471311, + 2.6806513016882585 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.9787345894017534, + "scoreError" : 0.036012342446017, + "scoreConfidence" : [ + 2.9427222469557366, + 3.01474693184777 + ], + "scorePercentiles" : { + "0.0" : 2.947877413070175, + "50.0" : 2.9761522181913573, + "90.0" : 3.021371885758203, + "95.0" : 3.022361353938088, + "99.0" : 3.022361353938088, + "99.9" : 3.022361353938088, + "99.99" : 3.022361353938088, + "99.999" : 3.022361353938088, + "99.9999" : 3.022361353938088, + "100.0" : 3.022361353938088 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.9718295720583106, + 2.9768297457920956, + 2.9774161557946646, + 2.975474690590619, + 2.9517749536278277 + ], + [ + 2.987981640483795, + 2.9633336965227226, + 2.947877413070175, + 3.022361353938088, + 3.0124666721392397 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.9679180461194052, + "scoreError" : 0.03832477707321739, + "scoreConfidence" : [ + 2.9295932690461877, + 3.006242823192623 + ], + "scorePercentiles" : { + "0.0" : 2.917996698145769, + "50.0" : 2.971311853124326, + "90.0" : 3.011273641090177, + "95.0" : 3.014553043099456, + "99.0" : 3.014553043099456, + "99.9" : 3.014553043099456, + "99.99" : 3.014553043099456, + "99.999" : 3.014553043099456, + "99.9999" : 3.014553043099456, + "100.0" : 3.014553043099456 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.96589330185406, + 2.964095171584901, + 2.9788689408965894, + 2.981759023006666, + 3.014553043099456 + ], + [ + 2.9767304043945924, + 2.917996698145769, + 2.977132914629389, + 2.9457711761519927, + 2.956379787430633 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 6.591011511865384, + "scoreError" : 0.07730570021375381, + "scoreConfidence" : [ + 6.51370581165163, + 6.668317212079137 + ], + "scorePercentiles" : { + "0.0" : 6.535740533335076, + "50.0" : 6.585395448329676, + "90.0" : 6.708023721588769, + "95.0" : 6.718767612304245, + "99.0" : 6.718767612304245, + "99.9" : 6.718767612304245, + "99.99" : 6.718767612304245, + "99.999" : 6.718767612304245, + "99.9999" : 6.718767612304245, + "100.0" : 6.718767612304245 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 6.611328705149482, + 6.591045670094994, + 6.549975374879612, + 6.585056874600312, + 6.535740533335076 + ], + [ + 6.554922102934199, + 6.585734022059039, + 6.5703038756888015, + 6.607240347608071, + 6.718767612304245 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 6.644546237179087, + "scoreError" : 0.08278567188048748, + "scoreConfidence" : [ + 6.5617605652985995, + 6.727331909059575 + ], + "scorePercentiles" : { + "0.0" : 6.57009626587522, + "50.0" : 6.633009964461882, + "90.0" : 6.772752786887114, + "95.0" : 6.78521070546639, + "99.0" : 6.78521070546639, + "99.9" : 6.78521070546639, + "99.99" : 6.78521070546639, + "99.999" : 6.78521070546639, + "99.9999" : 6.78521070546639, + "100.0" : 6.78521070546639 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 6.628580122684086, + 6.630930798058693, + 6.630543249172293, + 6.647684819668711, + 6.620068987962543 + ], + [ + 6.635089130865071, + 6.78521070546639, + 6.660631519673625, + 6.636626772364248, + 6.57009626587522 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 12.147509451401755, + "scoreError" : 0.10836396549286073, + "scoreConfidence" : [ + 12.039145485908893, + 12.255873416894616 + ], + "scorePercentiles" : { + "0.0" : 12.03701757973887, + "50.0" : 12.141890333486614, + "90.0" : 12.2363354514138, + "95.0" : 12.236468492128996, + "99.0" : 12.236468492128996, + "99.9" : 12.236468492128996, + "99.99" : 12.236468492128996, + "99.999" : 12.236468492128996, + "99.9999" : 12.236468492128996, + "100.0" : 12.236468492128996 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 12.123252038510332, + 12.083967564458973, + 12.184645804661255, + 12.236468492128996, + 12.130147745182208 + ], + [ + 12.03701757973887, + 12.067683952537898, + 12.153632921791019, + 12.223140330030963, + 12.235138084977038 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 12.37118910711328, + "scoreError" : 0.09746156810471189, + "scoreConfidence" : [ + 12.273727539008567, + 12.468650675217992 + ], + "scorePercentiles" : { + "0.0" : 12.293997995295415, + "50.0" : 12.371029654528417, + "90.0" : 12.466127794799023, + "95.0" : 12.466578863951302, + "99.0" : 12.466578863951302, + "99.9" : 12.466578863951302, + "99.99" : 12.466578863951302, + "99.999" : 12.466578863951302, + "99.9999" : 12.466578863951302, + "100.0" : 12.466578863951302 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 12.351923533173727, + 12.406468021568752, + 12.329819271724773, + 12.303011873132412, + 12.46206817242852 + ], + [ + 12.30317190832694, + 12.390135775883106, + 12.466578863951302, + 12.404715655647852, + 12.293997995295415 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 103.8164405980012, + "scoreError" : 1.6016913779463557, + "scoreConfidence" : [ + 102.21474922005484, + 105.41813197594755 + ], + "scorePercentiles" : { + "0.0" : 102.16768235320315, + "50.0" : 103.57221892902263, + "90.0" : 105.6422921726341, + "95.0" : 105.73464477191534, + "99.0" : 105.73464477191534, + "99.9" : 105.73464477191534, + "99.99" : 105.73464477191534, + "99.999" : 105.73464477191534, + "99.9999" : 105.73464477191534, + "100.0" : 105.73464477191534 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 104.81111877910294, + 103.22560774619296, + 103.61551157098455, + 104.35189829414247, + 104.62726685990621 + ], + [ + 103.52892628706068, + 105.73464477191534, + 103.30145175822537, + 102.80029755927804, + 102.16768235320315 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 105.48989392288472, + "scoreError" : 2.9059817372027803, + "scoreConfidence" : [ + 102.58391218568194, + 108.3958756600875 + ], + "scorePercentiles" : { + "0.0" : 103.21807653833778, + "50.0" : 105.48679340838848, + "90.0" : 109.69482294566289, + "95.0" : 110.0464808389509, + "99.0" : 110.0464808389509, + "99.9" : 110.0464808389509, + "99.99" : 110.0464808389509, + "99.999" : 110.0464808389509, + "99.9999" : 110.0464808389509, + "100.0" : 110.0464808389509 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 105.78493010795778, + 106.52990190607078, + 105.65661394898025, + 110.0464808389509, + 105.10814821508883 + ], + [ + 103.21807653833778, + 103.61337341976832, + 103.94170079048402, + 105.31697286779671, + 105.68274059541189 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 358.0702593146385, + "scoreError" : 1.421306896574227, + "scoreConfidence" : [ + 356.6489524180643, + 359.4915662112127 + ], + "scorePercentiles" : { + "0.0" : 356.1323741365805, + "50.0" : 358.1385495089542, + "90.0" : 359.534542062633, + "95.0" : 359.5960200092468, + "99.0" : 359.5960200092468, + "99.9" : 359.5960200092468, + "99.99" : 359.5960200092468, + "99.999" : 359.5960200092468, + "99.9999" : 359.5960200092468, + "100.0" : 359.5960200092468 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 358.9812405431091, + 358.3896365601199, + 358.41540671070334, + 357.47368624191176, + 359.5960200092468 + ], + [ + 357.5566317035732, + 356.1323741365805, + 358.4164164888726, + 357.8537182944797, + 357.8874624577885 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 368.6392731168169, + "scoreError" : 23.94374219064639, + "scoreConfidence" : [ + 344.69553092617053, + 392.5830153074633 + ], + "scorePercentiles" : { + "0.0" : 353.1696729895605, + "50.0" : 366.3976507149763, + "90.0" : 400.66690375106475, + "95.0" : 402.95041900960484, + "99.0" : 402.95041900960484, + "99.9" : 402.95041900960484, + "99.99" : 402.95041900960484, + "99.999" : 402.95041900960484, + "99.9999" : 402.95041900960484, + "100.0" : 402.95041900960484 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 371.0586721293474, + 378.9480685983083, + 402.95041900960484, + 380.11526642420375, + 372.37871133233807 + ], + [ + 356.52846560499614, + 361.7366293006051, + 355.99019674140595, + 353.51662903779896, + 353.1696729895605 + ] + ] + }, + "secondaryMetrics" : { + } + } +] diff --git a/research/issue-67/raw/reproduction-jdk21.log b/research/issue-67/raw/reproduction-jdk21.log new file mode 100644 index 0000000..b9b0559 --- /dev/null +++ b/research/issue-67/raw/reproduction-jdk21.log @@ -0,0 +1,1049 @@ +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 0.00% complete, ETA 00:03:12 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.586 ns/op +# Warmup Iteration 2: 2.640 ns/op +# Warmup Iteration 3: 2.353 ns/op +Iteration 1: 2.339 ns/op +Iteration 2: 2.320 ns/op +Iteration 3: 2.323 ns/op +Iteration 4: 2.345 ns/op +Iteration 5: 2.351 ns/op + +# Run progress: 2.08% complete, ETA 00:03:17 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.640 ns/op +# Warmup Iteration 2: 2.555 ns/op +# Warmup Iteration 3: 2.339 ns/op +Iteration 1: 2.333 ns/op +Iteration 2: 2.309 ns/op +Iteration 3: 2.318 ns/op +Iteration 4: 2.333 ns/op +Iteration 5: 2.420 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.339 ±(99.9%) 0.047 ns/op [Average] + (min, avg, max) = (2.309, 2.339, 2.420), stdev = 0.031 + CI (99.9%): [2.292, 2.386] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 4.17% complete, ETA 00:03:11 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.581 ns/op +# Warmup Iteration 2: 2.555 ns/op +# Warmup Iteration 3: 2.341 ns/op +Iteration 1: 2.343 ns/op +Iteration 2: 2.322 ns/op +Iteration 3: 2.321 ns/op +Iteration 4: 2.325 ns/op +Iteration 5: 2.324 ns/op + +# Run progress: 6.25% complete, ETA 00:03:07 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.572 ns/op +# Warmup Iteration 2: 2.539 ns/op +# Warmup Iteration 3: 2.329 ns/op +Iteration 1: 2.308 ns/op +Iteration 2: 2.320 ns/op +Iteration 3: 2.333 ns/op +Iteration 4: 2.353 ns/op +Iteration 5: 2.344 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.329 ±(99.9%) 0.021 ns/op [Average] + (min, avg, max) = (2.308, 2.329, 2.353), stdev = 0.014 + CI (99.9%): [2.308, 2.350] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 8.33% complete, ETA 00:03:03 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.776 ns/op +# Warmup Iteration 2: 2.727 ns/op +# Warmup Iteration 3: 2.513 ns/op +Iteration 1: 2.518 ns/op +Iteration 2: 2.535 ns/op +Iteration 3: 2.546 ns/op +Iteration 4: 2.519 ns/op +Iteration 5: 2.511 ns/op + +# Run progress: 10.42% complete, ETA 00:02:58 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.780 ns/op +# Warmup Iteration 2: 2.755 ns/op +# Warmup Iteration 3: 2.534 ns/op +Iteration 1: 2.522 ns/op +Iteration 2: 3.163 ns/op +Iteration 3: 2.508 ns/op +Iteration 4: 2.508 ns/op +Iteration 5: 2.523 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.585 ±(99.9%) 0.308 ns/op [Average] + (min, avg, max) = (2.508, 2.585, 3.163), stdev = 0.203 + CI (99.9%): [2.278, 2.893] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 12.50% complete, ETA 00:02:54 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.815 ns/op +# Warmup Iteration 2: 2.758 ns/op +# Warmup Iteration 3: 2.558 ns/op +Iteration 1: 2.548 ns/op +Iteration 2: 2.514 ns/op +Iteration 3: 2.517 ns/op +Iteration 4: 2.512 ns/op +Iteration 5: 2.528 ns/op + +# Run progress: 14.58% complete, ETA 00:02:50 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.750 ns/op +# Warmup Iteration 2: 2.733 ns/op +# Warmup Iteration 3: 2.530 ns/op +Iteration 1: 2.516 ns/op +Iteration 2: 2.519 ns/op +Iteration 3: 2.502 ns/op +Iteration 4: 2.499 ns/op +Iteration 5: 2.499 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.516 ±(99.9%) 0.023 ns/op [Average] + (min, avg, max) = (2.499, 2.516, 2.548), stdev = 0.015 + CI (99.9%): [2.493, 2.538] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 16.67% complete, ETA 00:02:46 +# Fork: 1 of 2 +# Warmup Iteration 1: 5.703 ns/op +# Warmup Iteration 2: 5.671 ns/op +# Warmup Iteration 3: 5.416 ns/op +Iteration 1: 5.399 ns/op +Iteration 2: 5.426 ns/op +Iteration 3: 5.401 ns/op +Iteration 4: 5.404 ns/op +Iteration 5: 5.386 ns/op + +# Run progress: 18.75% complete, ETA 00:02:42 +# Fork: 2 of 2 +# Warmup Iteration 1: 5.658 ns/op +# Warmup Iteration 2: 5.615 ns/op +# Warmup Iteration 3: 5.451 ns/op +Iteration 1: 5.391 ns/op +Iteration 2: 5.441 ns/op +Iteration 3: 5.414 ns/op +Iteration 4: 5.370 ns/op +Iteration 5: 5.438 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.407 ±(99.9%) 0.035 ns/op [Average] + (min, avg, max) = (5.370, 5.407, 5.441), stdev = 0.023 + CI (99.9%): [5.372, 5.442] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 20.83% complete, ETA 00:02:37 +# Fork: 1 of 2 +# Warmup Iteration 1: 5.629 ns/op +# Warmup Iteration 2: 5.570 ns/op +# Warmup Iteration 3: 5.424 ns/op +Iteration 1: 5.425 ns/op +Iteration 2: 5.499 ns/op +Iteration 3: 5.541 ns/op +Iteration 4: 5.329 ns/op +Iteration 5: 5.327 ns/op + +# Run progress: 22.92% complete, ETA 00:02:33 +# Fork: 2 of 2 +# Warmup Iteration 1: 5.693 ns/op +# Warmup Iteration 2: 5.558 ns/op +# Warmup Iteration 3: 5.397 ns/op +Iteration 1: 5.336 ns/op +Iteration 2: 5.387 ns/op +Iteration 3: 5.373 ns/op +Iteration 4: 5.355 ns/op +Iteration 5: 5.378 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.395 ±(99.9%) 0.110 ns/op [Average] + (min, avg, max) = (5.327, 5.395, 5.541), stdev = 0.073 + CI (99.9%): [5.285, 5.505] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 25.00% complete, ETA 00:02:29 +# Fork: 1 of 2 +# Warmup Iteration 1: 11.408 ns/op +# Warmup Iteration 2: 11.189 ns/op +# Warmup Iteration 3: 10.760 ns/op +Iteration 1: 10.950 ns/op +Iteration 2: 10.936 ns/op +Iteration 3: 10.936 ns/op +Iteration 4: 10.934 ns/op +Iteration 5: 10.908 ns/op + +# Run progress: 27.08% complete, ETA 00:02:25 +# Fork: 2 of 2 +# Warmup Iteration 1: 11.467 ns/op +# Warmup Iteration 2: 11.249 ns/op +# Warmup Iteration 3: 11.013 ns/op +Iteration 1: 10.829 ns/op +Iteration 2: 10.920 ns/op +Iteration 3: 10.824 ns/op +Iteration 4: 10.829 ns/op +Iteration 5: 10.848 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 10.892 ±(99.9%) 0.079 ns/op [Average] + (min, avg, max) = (10.824, 10.892, 10.950), stdev = 0.052 + CI (99.9%): [10.813, 10.970] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 29.17% complete, ETA 00:02:21 +# Fork: 1 of 2 +# Warmup Iteration 1: 11.562 ns/op +# Warmup Iteration 2: 11.471 ns/op +# Warmup Iteration 3: 11.045 ns/op +Iteration 1: 11.046 ns/op +Iteration 2: 11.002 ns/op +Iteration 3: 11.023 ns/op +Iteration 4: 11.223 ns/op +Iteration 5: 10.989 ns/op + +# Run progress: 31.25% complete, ETA 00:02:17 +# Fork: 2 of 2 +# Warmup Iteration 1: 11.430 ns/op +# Warmup Iteration 2: 11.311 ns/op +# Warmup Iteration 3: 10.999 ns/op +Iteration 1: 11.005 ns/op +Iteration 2: 11.074 ns/op +Iteration 3: 10.936 ns/op +Iteration 4: 10.952 ns/op +Iteration 5: 11.039 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 11.029 ±(99.9%) 0.121 ns/op [Average] + (min, avg, max) = (10.936, 11.029, 11.223), stdev = 0.080 + CI (99.9%): [10.908, 11.150] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 33.33% complete, ETA 00:02:12 +# Fork: 1 of 2 +# Warmup Iteration 1: 68.141 ns/op +# Warmup Iteration 2: 66.093 ns/op +# Warmup Iteration 3: 65.259 ns/op +Iteration 1: 67.147 ns/op +Iteration 2: 64.591 ns/op +Iteration 3: 65.377 ns/op +Iteration 4: 64.437 ns/op +Iteration 5: 66.147 ns/op + +# Run progress: 35.42% complete, ETA 00:02:08 +# Fork: 2 of 2 +# Warmup Iteration 1: 67.562 ns/op +# Warmup Iteration 2: 65.993 ns/op +# Warmup Iteration 3: 65.066 ns/op +Iteration 1: 64.615 ns/op +Iteration 2: 65.212 ns/op +Iteration 3: 65.071 ns/op +Iteration 4: 65.021 ns/op +Iteration 5: 65.360 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 65.298 ±(99.9%) 1.234 ns/op [Average] + (min, avg, max) = (64.437, 65.298, 67.147), stdev = 0.816 + CI (99.9%): [64.064, 66.531] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 37.50% complete, ETA 00:02:04 +# Fork: 1 of 2 +# Warmup Iteration 1: 68.602 ns/op +# Warmup Iteration 2: 68.397 ns/op +# Warmup Iteration 3: 68.636 ns/op +Iteration 1: 67.828 ns/op +Iteration 2: 68.087 ns/op +Iteration 3: 66.718 ns/op +Iteration 4: 66.329 ns/op +Iteration 5: 66.959 ns/op + +# Run progress: 39.58% complete, ETA 00:02:00 +# Fork: 2 of 2 +# Warmup Iteration 1: 68.812 ns/op +# Warmup Iteration 2: 66.953 ns/op +# Warmup Iteration 3: 65.571 ns/op +Iteration 1: 66.536 ns/op +Iteration 2: 68.009 ns/op +Iteration 3: 65.846 ns/op +Iteration 4: 67.082 ns/op +Iteration 5: 67.741 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 67.113 ±(99.9%) 1.170 ns/op [Average] + (min, avg, max) = (65.846, 67.113, 68.087), stdev = 0.774 + CI (99.9%): [65.943, 68.283] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 41.67% complete, ETA 00:01:56 +# Fork: 1 of 2 +# Warmup Iteration 1: 263.146 ns/op +# Warmup Iteration 2: 249.364 ns/op +# Warmup Iteration 3: 247.592 ns/op +Iteration 1: 248.896 ns/op +Iteration 2: 247.238 ns/op +Iteration 3: 247.516 ns/op +Iteration 4: 247.553 ns/op +Iteration 5: 247.693 ns/op + +# Run progress: 43.75% complete, ETA 00:01:52 +# Fork: 2 of 2 +# Warmup Iteration 1: 263.720 ns/op +# Warmup Iteration 2: 249.284 ns/op +# Warmup Iteration 3: 249.386 ns/op +Iteration 1: 252.735 ns/op +Iteration 2: 250.040 ns/op +Iteration 3: 249.423 ns/op +Iteration 4: 249.149 ns/op +Iteration 5: 249.234 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 248.948 ±(99.9%) 2.488 ns/op [Average] + (min, avg, max) = (247.238, 248.948, 252.735), stdev = 1.646 + CI (99.9%): [246.460, 251.436] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 45.83% complete, ETA 00:01:47 +# Fork: 1 of 2 +# Warmup Iteration 1: 271.762 ns/op +# Warmup Iteration 2: 258.562 ns/op +# Warmup Iteration 3: 254.510 ns/op +Iteration 1: 255.405 ns/op +Iteration 2: 256.179 ns/op +Iteration 3: 255.662 ns/op +Iteration 4: 252.116 ns/op +Iteration 5: 251.142 ns/op + +# Run progress: 47.92% complete, ETA 00:01:43 +# Fork: 2 of 2 +# Warmup Iteration 1: 272.676 ns/op +# Warmup Iteration 2: 255.480 ns/op +# Warmup Iteration 3: 254.883 ns/op +Iteration 1: 255.989 ns/op +Iteration 2: 256.259 ns/op +Iteration 3: 256.346 ns/op +Iteration 4: 256.568 ns/op +Iteration 5: 258.203 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 255.387 ±(99.9%) 3.219 ns/op [Average] + (min, avg, max) = (251.142, 255.387, 258.203), stdev = 2.129 + CI (99.9%): [252.168, 258.606] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 50.00% complete, ETA 00:01:39 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.990 ns/op +# Warmup Iteration 2: 2.940 ns/op +# Warmup Iteration 3: 2.678 ns/op +Iteration 1: 2.695 ns/op +Iteration 2: 2.684 ns/op +Iteration 3: 2.716 ns/op +Iteration 4: 2.695 ns/op +Iteration 5: 2.706 ns/op + +# Run progress: 52.08% complete, ETA 00:01:35 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.976 ns/op +# Warmup Iteration 2: 3.004 ns/op +# Warmup Iteration 3: 2.689 ns/op +Iteration 1: 2.716 ns/op +Iteration 2: 2.758 ns/op +Iteration 3: 2.692 ns/op +Iteration 4: 2.701 ns/op +Iteration 5: 2.699 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.706 ±(99.9%) 0.031 ns/op [Average] + (min, avg, max) = (2.684, 2.706, 2.758), stdev = 0.021 + CI (99.9%): [2.675, 2.738] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 54.17% complete, ETA 00:01:31 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.954 ns/op +# Warmup Iteration 2: 2.935 ns/op +# Warmup Iteration 3: 2.690 ns/op +Iteration 1: 2.702 ns/op +Iteration 2: 2.694 ns/op +Iteration 3: 2.699 ns/op +Iteration 4: 2.710 ns/op +Iteration 5: 2.697 ns/op + +# Run progress: 56.25% complete, ETA 00:01:27 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.967 ns/op +# Warmup Iteration 2: 2.906 ns/op +# Warmup Iteration 3: 2.669 ns/op +Iteration 1: 2.711 ns/op +Iteration 2: 2.710 ns/op +Iteration 3: 2.691 ns/op +Iteration 4: 2.711 ns/op +Iteration 5: 2.681 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.701 ±(99.9%) 0.016 ns/op [Average] + (min, avg, max) = (2.681, 2.701, 2.711), stdev = 0.010 + CI (99.9%): [2.685, 2.716] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 58.33% complete, ETA 00:01:23 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.230 ns/op +# Warmup Iteration 2: 3.190 ns/op +# Warmup Iteration 3: 2.946 ns/op +Iteration 1: 2.972 ns/op +Iteration 2: 2.977 ns/op +Iteration 3: 2.977 ns/op +Iteration 4: 2.975 ns/op +Iteration 5: 2.952 ns/op + +# Run progress: 60.42% complete, ETA 00:01:18 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.201 ns/op +# Warmup Iteration 2: 3.214 ns/op +# Warmup Iteration 3: 2.961 ns/op +Iteration 1: 2.988 ns/op +Iteration 2: 2.963 ns/op +Iteration 3: 2.948 ns/op +Iteration 4: 3.022 ns/op +Iteration 5: 3.012 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.979 ±(99.9%) 0.036 ns/op [Average] + (min, avg, max) = (2.948, 2.979, 3.022), stdev = 0.024 + CI (99.9%): [2.943, 3.015] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 62.50% complete, ETA 00:01:14 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.243 ns/op +# Warmup Iteration 2: 3.222 ns/op +# Warmup Iteration 3: 3.008 ns/op +Iteration 1: 2.966 ns/op +Iteration 2: 2.964 ns/op +Iteration 3: 2.979 ns/op +Iteration 4: 2.982 ns/op +Iteration 5: 3.015 ns/op + +# Run progress: 64.58% complete, ETA 00:01:10 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.195 ns/op +# Warmup Iteration 2: 3.149 ns/op +# Warmup Iteration 3: 2.954 ns/op +Iteration 1: 2.977 ns/op +Iteration 2: 2.918 ns/op +Iteration 3: 2.977 ns/op +Iteration 4: 2.946 ns/op +Iteration 5: 2.956 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.968 ±(99.9%) 0.038 ns/op [Average] + (min, avg, max) = (2.918, 2.968, 3.015), stdev = 0.025 + CI (99.9%): [2.930, 3.006] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 66.67% complete, ETA 00:01:06 +# Fork: 1 of 2 +# Warmup Iteration 1: 6.709 ns/op +# Warmup Iteration 2: 6.795 ns/op +# Warmup Iteration 3: 6.531 ns/op +Iteration 1: 6.611 ns/op +Iteration 2: 6.591 ns/op +Iteration 3: 6.550 ns/op +Iteration 4: 6.585 ns/op +Iteration 5: 6.536 ns/op + +# Run progress: 68.75% complete, ETA 00:01:02 +# Fork: 2 of 2 +# Warmup Iteration 1: 6.779 ns/op +# Warmup Iteration 2: 6.610 ns/op +# Warmup Iteration 3: 6.556 ns/op +Iteration 1: 6.555 ns/op +Iteration 2: 6.586 ns/op +Iteration 3: 6.570 ns/op +Iteration 4: 6.607 ns/op +Iteration 5: 6.719 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 6.591 ±(99.9%) 0.077 ns/op [Average] + (min, avg, max) = (6.536, 6.591, 6.719), stdev = 0.051 + CI (99.9%): [6.514, 6.668] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 70.83% complete, ETA 00:00:58 +# Fork: 1 of 2 +# Warmup Iteration 1: 6.701 ns/op +# Warmup Iteration 2: 6.636 ns/op +# Warmup Iteration 3: 6.635 ns/op +Iteration 1: 6.629 ns/op +Iteration 2: 6.631 ns/op +Iteration 3: 6.631 ns/op +Iteration 4: 6.648 ns/op +Iteration 5: 6.620 ns/op + +# Run progress: 72.92% complete, ETA 00:00:53 +# Fork: 2 of 2 +# Warmup Iteration 1: 6.743 ns/op +# Warmup Iteration 2: 6.676 ns/op +# Warmup Iteration 3: 6.602 ns/op +Iteration 1: 6.635 ns/op +Iteration 2: 6.785 ns/op +Iteration 3: 6.661 ns/op +Iteration 4: 6.637 ns/op +Iteration 5: 6.570 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 6.645 ±(99.9%) 0.083 ns/op [Average] + (min, avg, max) = (6.570, 6.645, 6.785), stdev = 0.055 + CI (99.9%): [6.562, 6.727] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 75.00% complete, ETA 00:00:49 +# Fork: 1 of 2 +# Warmup Iteration 1: 12.276 ns/op +# Warmup Iteration 2: 12.311 ns/op +# Warmup Iteration 3: 12.112 ns/op +Iteration 1: 12.123 ns/op +Iteration 2: 12.084 ns/op +Iteration 3: 12.185 ns/op +Iteration 4: 12.236 ns/op +Iteration 5: 12.130 ns/op + +# Run progress: 77.08% complete, ETA 00:00:45 +# Fork: 2 of 2 +# Warmup Iteration 1: 12.261 ns/op +# Warmup Iteration 2: 12.018 ns/op +# Warmup Iteration 3: 12.159 ns/op +Iteration 1: 12.037 ns/op +Iteration 2: 12.068 ns/op +Iteration 3: 12.154 ns/op +Iteration 4: 12.223 ns/op +Iteration 5: 12.235 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 12.148 ±(99.9%) 0.108 ns/op [Average] + (min, avg, max) = (12.037, 12.148, 12.236), stdev = 0.072 + CI (99.9%): [12.039, 12.256] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 79.17% complete, ETA 00:00:41 +# Fork: 1 of 2 +# Warmup Iteration 1: 12.438 ns/op +# Warmup Iteration 2: 13.299 ns/op +# Warmup Iteration 3: 12.354 ns/op +Iteration 1: 12.352 ns/op +Iteration 2: 12.406 ns/op +Iteration 3: 12.330 ns/op +Iteration 4: 12.303 ns/op +Iteration 5: 12.462 ns/op + +# Run progress: 81.25% complete, ETA 00:00:37 +# Fork: 2 of 2 +# Warmup Iteration 1: 12.757 ns/op +# Warmup Iteration 2: 13.010 ns/op +# Warmup Iteration 3: 12.279 ns/op +Iteration 1: 12.303 ns/op +Iteration 2: 12.390 ns/op +Iteration 3: 12.467 ns/op +Iteration 4: 12.405 ns/op +Iteration 5: 12.294 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 12.371 ±(99.9%) 0.097 ns/op [Average] + (min, avg, max) = (12.294, 12.371, 12.467), stdev = 0.064 + CI (99.9%): [12.274, 12.469] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 83.33% complete, ETA 00:00:33 +# Fork: 1 of 2 +# Warmup Iteration 1: 108.881 ns/op +# Warmup Iteration 2: 106.116 ns/op +# Warmup Iteration 3: 105.946 ns/op +Iteration 1: 104.811 ns/op +Iteration 2: 103.226 ns/op +Iteration 3: 103.616 ns/op +Iteration 4: 104.352 ns/op +Iteration 5: 104.627 ns/op + +# Run progress: 85.42% complete, ETA 00:00:29 +# Fork: 2 of 2 +# Warmup Iteration 1: 108.973 ns/op +# Warmup Iteration 2: 105.756 ns/op +# Warmup Iteration 3: 104.164 ns/op +Iteration 1: 103.529 ns/op +Iteration 2: 105.735 ns/op +Iteration 3: 103.301 ns/op +Iteration 4: 102.800 ns/op +Iteration 5: 102.168 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 103.816 ±(99.9%) 1.602 ns/op [Average] + (min, avg, max) = (102.168, 103.816, 105.735), stdev = 1.059 + CI (99.9%): [102.215, 105.418] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 87.50% complete, ETA 00:00:24 +# Fork: 1 of 2 +# Warmup Iteration 1: 108.534 ns/op +# Warmup Iteration 2: 106.998 ns/op +# Warmup Iteration 3: 104.694 ns/op +Iteration 1: 105.785 ns/op +Iteration 2: 106.530 ns/op +Iteration 3: 105.657 ns/op +Iteration 4: 110.046 ns/op +Iteration 5: 105.108 ns/op + +# Run progress: 89.58% complete, ETA 00:00:20 +# Fork: 2 of 2 +# Warmup Iteration 1: 110.887 ns/op +# Warmup Iteration 2: 105.727 ns/op +# Warmup Iteration 3: 102.513 ns/op +Iteration 1: 103.218 ns/op +Iteration 2: 103.613 ns/op +Iteration 3: 103.942 ns/op +Iteration 4: 105.317 ns/op +Iteration 5: 105.683 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 105.490 ±(99.9%) 2.906 ns/op [Average] + (min, avg, max) = (103.218, 105.490, 110.046), stdev = 1.922 + CI (99.9%): [102.584, 108.396] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 91.67% complete, ETA 00:00:16 +# Fork: 1 of 2 +# Warmup Iteration 1: 392.461 ns/op +# Warmup Iteration 2: 364.828 ns/op +# Warmup Iteration 3: 362.226 ns/op +Iteration 1: 358.981 ns/op +Iteration 2: 358.390 ns/op +Iteration 3: 358.415 ns/op +Iteration 4: 357.474 ns/op +Iteration 5: 359.596 ns/op + +# Run progress: 93.75% complete, ETA 00:00:12 +# Fork: 2 of 2 +# Warmup Iteration 1: 389.924 ns/op +# Warmup Iteration 2: 359.087 ns/op +# Warmup Iteration 3: 356.741 ns/op +Iteration 1: 357.557 ns/op +Iteration 2: 356.132 ns/op +Iteration 3: 358.416 ns/op +Iteration 4: 357.854 ns/op +Iteration 5: 357.887 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 358.070 ±(99.9%) 1.421 ns/op [Average] + (min, avg, max) = (356.132, 358.070, 359.596), stdev = 0.940 + CI (99.9%): [356.649, 359.492] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 95.83% complete, ETA 00:00:08 +# Fork: 1 of 2 +# Warmup Iteration 1: 400.382 ns/op +# Warmup Iteration 2: 367.994 ns/op +# Warmup Iteration 3: 365.613 ns/op +Iteration 1: 371.059 ns/op +Iteration 2: 378.948 ns/op +Iteration 3: 402.950 ns/op +Iteration 4: 380.115 ns/op +Iteration 5: 372.379 ns/op + +# Run progress: 97.92% complete, ETA 00:00:04 +# Fork: 2 of 2 +# Warmup Iteration 1: 400.930 ns/op +# Warmup Iteration 2: 361.919 ns/op +# Warmup Iteration 3: 364.509 ns/op +Iteration 1: 356.528 ns/op +Iteration 2: 361.737 ns/op +Iteration 3: 355.990 ns/op +Iteration 4: 353.517 ns/op +Iteration 5: 353.170 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 368.639 ±(99.9%) 23.944 ns/op [Average] + (min, avg, max) = (353.170, 368.639, 402.950), stdev = 15.837 + CI (99.9%): [344.696, 392.583] (assumes normal distribution) + + +# Run complete. Total time: 00:03:19 + +REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on +why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial +experiments, perform baseline and negative tests that provide experimental control, make sure +the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts. +Do not assume the numbers tell you what you want them to tell. + +NOTE: Current JVM experimentally supports Compiler Blackholes, and they are in use. Please exercise +extra caution when trusting the results, look into the generated code to check the benchmark still +works, and factor in a small probability of new VM bugs. Additionally, while comparisons between +different JVMs are already problematic, the performance difference caused by different Blackhole +modes can be very significant. Please make sure you use the consistent Blackhole mode for comparisons. + +Benchmark (length) (startAlign) Mode Cnt Score Error Units +VarHandleVsUnsafeBenchmark.unsafe 8 0 avgt 10 2.339 ± 0.047 ns/op +VarHandleVsUnsafeBenchmark.unsafe 8 1 avgt 10 2.329 ± 0.021 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 0 avgt 10 2.585 ± 0.308 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 1 avgt 10 2.516 ± 0.023 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 0 avgt 10 5.407 ± 0.035 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 1 avgt 10 5.395 ± 0.110 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 0 avgt 10 10.892 ± 0.079 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 1 avgt 10 11.029 ± 0.121 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 0 avgt 10 65.298 ± 1.234 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 1 avgt 10 67.113 ± 1.170 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 0 avgt 10 248.948 ± 2.488 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 1 avgt 10 255.387 ± 3.219 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 0 avgt 10 2.706 ± 0.031 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 1 avgt 10 2.701 ± 0.016 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 0 avgt 10 2.979 ± 0.036 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 1 avgt 10 2.968 ± 0.038 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 0 avgt 10 6.591 ± 0.077 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 1 avgt 10 6.645 ± 0.083 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 0 avgt 10 12.148 ± 0.108 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 1 avgt 10 12.371 ± 0.097 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 0 avgt 10 103.816 ± 1.602 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 1 avgt 10 105.490 ± 2.906 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 0 avgt 10 358.070 ± 1.421 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 1 avgt 10 368.639 ± 23.944 ns/op + +Benchmark result is saved to /tmp/zah121-reproduction-jdk21.json diff --git a/research/issue-67/raw/results-jdk11.json b/research/issue-67/raw/results-jdk11.json new file mode 100644 index 0000000..ff9504e --- /dev/null +++ b/research/issue-67/raw/results-jdk11.json @@ -0,0 +1,1490 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.9154580159037993, + "scoreError" : 0.08042649104122147, + "scoreConfidence" : [ + 2.8350315248625777, + 2.995884506945021 + ], + "scorePercentiles" : { + "0.0" : 2.848091687842484, + "50.0" : 2.9062423021021067, + "90.0" : 3.0391060533240113, + "95.0" : 3.0507916576109055, + "99.0" : 3.0507916576109055, + "99.9" : 3.0507916576109055, + "99.99" : 3.0507916576109055, + "99.999" : 3.0507916576109055, + "99.9999" : 3.0507916576109055, + "100.0" : 3.0507916576109055 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.848091687842484, + 3.0507916576109055, + 2.897667594304454, + 2.914924385271921, + 2.911793171193486 + ], + [ + 2.923271226841244, + 2.933935614741961, + 2.900691433010728, + 2.8891558475070247, + 2.8842575407137905 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.88495270863136, + "scoreError" : 0.043292572126044634, + "scoreConfidence" : [ + 2.8416601365053156, + 2.9282452807574044 + ], + "scorePercentiles" : { + "0.0" : 2.850050072952148, + "50.0" : 2.88296115423767, + "90.0" : 2.926555363222541, + "95.0" : 2.927160014155942, + "99.0" : 2.927160014155942, + "99.9" : 2.927160014155942, + "99.99" : 2.927160014155942, + "99.999" : 2.927160014155942, + "99.9999" : 2.927160014155942, + "100.0" : 2.927160014155942 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.8755817223048035, + 2.8539372476294087, + 2.850050072952148, + 2.8508656237130925, + 2.912852444580978 + ], + [ + 2.8920441476799588, + 2.886445317111147, + 2.927160014155942, + 2.9211135048219306, + 2.8794769913641933 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 3.081162739570582, + "scoreError" : 0.08439078192520416, + "scoreConfidence" : [ + 2.996771957645378, + 3.165553521495786 + ], + "scorePercentiles" : { + "0.0" : 3.029948396260738, + "50.0" : 3.0684314711579814, + "90.0" : 3.2108566942626036, + "95.0" : 3.2230599525167816, + "99.0" : 3.2230599525167816, + "99.9" : 3.2230599525167816, + "99.99" : 3.2230599525167816, + "99.999" : 3.2230599525167816, + "99.9999" : 3.2230599525167816, + "100.0" : 3.2230599525167816 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 3.0805939464217396, + 3.0562689958942233, + 3.029948396260738, + 3.0543266703315397, + 3.043324384712511 + ], + [ + 3.090954437284645, + 3.1010273699750006, + 3.0940427854143175, + 3.0380804568943267, + 3.2230599525167816 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 3.056599156912169, + "scoreError" : 0.05477749476617573, + "scoreConfidence" : [ + 3.001821662145993, + 3.1113766516783445 + ], + "scorePercentiles" : { + "0.0" : 3.0101456674525253, + "50.0" : 3.0587891917200833, + "90.0" : 3.1135719739156196, + "95.0" : 3.115741658228519, + "99.0" : 3.115741658228519, + "99.9" : 3.115741658228519, + "99.99" : 3.115741658228519, + "99.999" : 3.115741658228519, + "99.9999" : 3.115741658228519, + "100.0" : 3.115741658228519 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 3.0776657627859705, + 3.0746703929314276, + 3.0787103240238953, + 3.115741658228519, + 3.0940448150995215 + ], + [ + 3.015444604215596, + 3.025318642357249, + 3.0101456674525253, + 3.0429079905087386, + 3.031341711518247 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 5.7994872695332385, + "scoreError" : 0.29650334982340876, + "scoreConfidence" : [ + 5.50298391970983, + 6.095990619356647 + ], + "scorePercentiles" : { + "0.0" : 5.624977230738593, + "50.0" : 5.7100433478336665, + "90.0" : 6.212074050669944, + "95.0" : 6.235050411441331, + "99.0" : 6.235050411441331, + "99.9" : 6.235050411441331, + "99.99" : 6.235050411441331, + "99.999" : 6.235050411441331, + "99.9999" : 6.235050411441331, + "100.0" : 6.235050411441331 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.684405256100704, + 5.686113644595632, + 5.644886901121318, + 5.733973051071702, + 5.624977230738593 + ], + [ + 5.654763906889126, + 6.005286803727458, + 6.235050411441331, + 5.877039136568457, + 5.848376353078066 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 5.727020810168589, + "scoreError" : 0.08398455314070029, + "scoreConfidence" : [ + 5.643036257027888, + 5.811005363309289 + ], + "scorePercentiles" : { + "0.0" : 5.638933942407081, + "50.0" : 5.738526931696472, + "90.0" : 5.800700980835752, + "95.0" : 5.801646345247409, + "99.0" : 5.801646345247409, + "99.9" : 5.801646345247409, + "99.99" : 5.801646345247409, + "99.999" : 5.801646345247409, + "99.9999" : 5.801646345247409, + "100.0" : 5.801646345247409 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.753360979992167, + 5.679176827943196, + 5.638933942407081, + 5.705534816923267, + 5.658256311305654 + ], + [ + 5.792192701130838, + 5.7602952412748945, + 5.7571180520606084, + 5.801646345247409, + 5.723692883400777 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 9.9564381330369, + "scoreError" : 0.14856126652255028, + "scoreConfidence" : [ + 9.807876866514349, + 10.10499939955945 + ], + "scorePercentiles" : { + "0.0" : 9.828469673415688, + "50.0" : 9.932811226050333, + "90.0" : 10.182035987025404, + "95.0" : 10.204158974675467, + "99.0" : 10.204158974675467, + "99.9" : 10.204158974675467, + "99.99" : 10.204158974675467, + "99.999" : 10.204158974675467, + "99.9999" : 10.204158974675467, + "100.0" : 10.204158974675467 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 9.933633567497207, + 9.982929098174836, + 9.828469673415688, + 10.204158974675467, + 9.925049539811548 + ], + [ + 9.93198888460346, + 9.920683258294243, + 9.978352532490929, + 9.889856848697672, + 9.969258952707932 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 9.980100197223077, + "scoreError" : 0.12026324298886727, + "scoreConfidence" : [ + 9.85983695423421, + 10.100363440211945 + ], + "scorePercentiles" : { + "0.0" : 9.882512969882065, + "50.0" : 9.977439094606815, + "90.0" : 10.150274992329624, + "95.0" : 10.162986254453834, + "99.0" : 10.162986254453834, + "99.9" : 10.162986254453834, + "99.99" : 10.162986254453834, + "99.999" : 10.162986254453834, + "99.9999" : 10.162986254453834, + "100.0" : 10.162986254453834 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 10.162986254453834, + 9.980152424574435, + 9.94664614590256, + 9.884248430409013, + 9.99298907127691 + ], + [ + 9.97902236814062, + 9.975855821073011, + 10.035873633211738, + 9.882512969882065, + 9.960714853306587 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 63.360988862673935, + "scoreError" : 0.9870574988117066, + "scoreConfidence" : [ + 62.373931363862226, + 64.34804636148564 + ], + "scorePercentiles" : { + "0.0" : 62.56352735761511, + "50.0" : 63.18672551875238, + "90.0" : 64.35796782718619, + "95.0" : 64.364370459103, + "99.0" : 64.364370459103, + "99.9" : 64.364370459103, + "99.99" : 64.364370459103, + "99.999" : 64.364370459103, + "99.9999" : 64.364370459103, + "100.0" : 64.364370459103 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 63.008960023657295, + 62.881696123290425, + 63.80291404373144, + 64.3003441399349, + 64.364370459103 + ], + [ + 62.56352735761511, + 63.06762918929441, + 63.70050586492438, + 63.305821848210364, + 62.61411957697803 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 71.46761800082272, + "scoreError" : 10.11483077892432, + "scoreConfidence" : [ + 61.3527872218984, + 81.58244877974704 + ], + "scorePercentiles" : { + "0.0" : 64.72415996252192, + "50.0" : 71.12776143311046, + "90.0" : 78.85448496406633, + "95.0" : 78.90090184719224, + "99.0" : 78.90090184719224, + "99.9" : 78.90090184719224, + "99.99" : 78.90090184719224, + "99.999" : 78.90090184719224, + "99.9999" : 78.90090184719224, + "100.0" : 78.90090184719224 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 64.73947111892866, + 65.3963489607086, + 64.72415996252192, + 65.43707136756252, + 65.45923701223064 + ], + [ + 76.7962858539903, + 78.43673301593304, + 77.80383481858357, + 78.90090184719224, + 76.98213605057575 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 253.7241827474176, + "scoreError" : 3.999865530757646, + "scoreConfidence" : [ + 249.72431721665993, + 257.72404827817525 + ], + "scorePercentiles" : { + "0.0" : 249.6410655428431, + "50.0" : 254.30527433923822, + "90.0" : 258.23142698979, + "95.0" : 258.53900241443887, + "99.0" : 258.53900241443887, + "99.9" : 258.53900241443887, + "99.99" : 258.53900241443887, + "99.999" : 258.53900241443887, + "99.9999" : 258.53900241443887, + "100.0" : 258.53900241443887 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 255.46324816795, + 258.53900241443887, + 254.41220127283307, + 255.0044545814182, + 254.72727119977392 + ], + [ + 252.53460891354752, + 252.80779987083093, + 254.19834740564335, + 249.91382810489682, + 249.6410655428431 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 256.7819950841123, + "scoreError" : 4.109094889734285, + "scoreConfidence" : [ + 252.672900194378, + 260.8910899738466 + ], + "scorePercentiles" : { + "0.0" : 254.14799964431347, + "50.0" : 256.1687871669948, + "90.0" : 262.3532943121964, + "95.0" : 262.7186359820944, + "99.0" : 262.7186359820944, + "99.9" : 262.7186359820944, + "99.99" : 262.7186359820944, + "99.999" : 262.7186359820944, + "99.9999" : 262.7186359820944, + "100.0" : 262.7186359820944 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 256.2109506398444, + 259.0652192831147, + 254.94240082773103, + 256.12662369414517, + 254.70852111761877 + ], + [ + 259.0249345986655, + 256.43799140586106, + 262.7186359820944, + 254.14799964431347, + 254.436673647734 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 3.0968451106772177, + "scoreError" : 0.045910995271706986, + "scoreConfidence" : [ + 3.0509341154055107, + 3.1427561059489246 + ], + "scorePercentiles" : { + "0.0" : 3.0600925067204625, + "50.0" : 3.0842803010916295, + "90.0" : 3.1530629268332504, + "95.0" : 3.154399701973551, + "99.0" : 3.154399701973551, + "99.9" : 3.154399701973551, + "99.99" : 3.154399701973551, + "99.999" : 3.154399701973551, + "99.9999" : 3.154399701973551, + "100.0" : 3.154399701973551 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 3.154399701973551, + 3.0757982817263696, + 3.0826406518803475, + 3.079763051907994, + 3.085919950302912 + ], + [ + 3.0600925067204625, + 3.076176994338883, + 3.103042820085193, + 3.1410319505705466, + 3.1095851972659174 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 3.0956446396510375, + "scoreError" : 0.11092159525321317, + "scoreConfidence" : [ + 2.9847230443978243, + 3.2065662349042507 + ], + "scorePercentiles" : { + "0.0" : 3.0425624151329917, + "50.0" : 3.0640629723868047, + "90.0" : 3.26928573006491, + "95.0" : 3.284605206117204, + "99.0" : 3.284605206117204, + "99.9" : 3.284605206117204, + "99.99" : 3.284605206117204, + "99.999" : 3.284605206117204, + "99.9999" : 3.284605206117204, + "100.0" : 3.284605206117204 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 3.056686610211905, + 3.064470598994545, + 3.0497437928976336, + 3.0425624151329917, + 3.0636553457790643 + ], + [ + 3.114049131582465, + 3.104638635436924, + 3.284605206117204, + 3.1314104455942617, + 3.0446242147633837 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 3.514888213361858, + "scoreError" : 0.12075471633619599, + "scoreConfidence" : [ + 3.394133497025662, + 3.635642929698054 + ], + "scorePercentiles" : { + "0.0" : 3.419895836553525, + "50.0" : 3.4860617513026275, + "90.0" : 3.6608861354758404, + "95.0" : 3.6613422661600405, + "99.0" : 3.6613422661600405, + "99.9" : 3.6613422661600405, + "99.99" : 3.6613422661600405, + "99.999" : 3.6613422661600405, + "99.9999" : 3.6613422661600405, + "100.0" : 3.6613422661600405 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 3.6613422661600405, + 3.504000053633742, + 3.478618519035239, + 3.6567809593180374, + 3.419895836553525 + ], + [ + 3.488537258613356, + 3.473960162158829, + 3.469954070364129, + 3.512206763789779, + 3.483586243991899 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 3.4930146605752563, + "scoreError" : 0.04285468312882998, + "scoreConfidence" : [ + 3.450159977446426, + 3.5358693437040865 + ], + "scorePercentiles" : { + "0.0" : 3.4448036293765876, + "50.0" : 3.498908820542547, + "90.0" : 3.530303225884965, + "95.0" : 3.5312911982236668, + "99.0" : 3.5312911982236668, + "99.9" : 3.5312911982236668, + "99.99" : 3.5312911982236668, + "99.999" : 3.5312911982236668, + "99.9999" : 3.5312911982236668, + "100.0" : 3.5312911982236668 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 3.4448036293765876, + 3.466922914466093, + 3.492178540508839, + 3.5070735248668337, + 3.478332531329429 + ], + [ + 3.465024520565306, + 3.5214114748366465, + 3.5174691710028974, + 3.5056391005762553, + 3.5312911982236668 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 7.323260503120975, + "scoreError" : 0.2451153146452783, + "scoreConfidence" : [ + 7.078145188475697, + 7.5683758177662535 + ], + "scorePercentiles" : { + "0.0" : 7.1782533221421785, + "50.0" : 7.313254037427615, + "90.0" : 7.67603506739433, + "95.0" : 7.70616739545065, + "99.0" : 7.70616739545065, + "99.9" : 7.70616739545065, + "99.99" : 7.70616739545065, + "99.999" : 7.70616739545065, + "99.9999" : 7.70616739545065, + "100.0" : 7.70616739545065 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 7.70616739545065, + 7.381500573787394, + 7.404844114887452, + 7.371672169229782, + 7.335386731359343 + ], + [ + 7.2036674443800335, + 7.1782533221421785, + 7.181217031335661, + 7.291121343495887, + 7.178774905141381 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 7.2763943654389704, + "scoreError" : 0.15608077232220877, + "scoreConfidence" : [ + 7.120313593116761, + 7.4324751377611795 + ], + "scorePercentiles" : { + "0.0" : 7.11874503774843, + "50.0" : 7.283468593194234, + "90.0" : 7.438529937874612, + "95.0" : 7.445456102823246, + "99.0" : 7.445456102823246, + "99.9" : 7.445456102823246, + "99.99" : 7.445456102823246, + "99.999" : 7.445456102823246, + "99.9999" : 7.445456102823246, + "100.0" : 7.445456102823246 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 7.208042692265457, + 7.360646178463551, + 7.319924552101817, + 7.376194453336905, + 7.445456102823246 + ], + [ + 7.11874503774843, + 7.277338437219002, + 7.212395360630525, + 7.289598749169466, + 7.155602090631307 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 12.23127744714868, + "scoreError" : 0.05712126807064047, + "scoreConfidence" : [ + 12.17415617907804, + 12.28839871521932 + ], + "scorePercentiles" : { + "0.0" : 12.166572714933043, + "50.0" : 12.23020487469368, + "90.0" : 12.298454774116017, + "95.0" : 12.301752459098529, + "99.0" : 12.301752459098529, + "99.9" : 12.301752459098529, + "99.99" : 12.301752459098529, + "99.999" : 12.301752459098529, + "99.9999" : 12.301752459098529, + "100.0" : 12.301752459098529 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 12.229204069697461, + 12.23942620283342, + 12.251997582196157, + 12.166572714933043, + 12.19791946253404 + ], + [ + 12.301752459098529, + 12.268775609273407, + 12.21438861416561, + 12.231205679689896, + 12.211532077065236 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 12.376110135963517, + "scoreError" : 0.18376437398480722, + "scoreConfidence" : [ + 12.192345761978709, + 12.559874509948324 + ], + "scorePercentiles" : { + "0.0" : 12.230853952720787, + "50.0" : 12.339567769678172, + "90.0" : 12.574789071631209, + "95.0" : 12.581506682707431, + "99.0" : 12.581506682707431, + "99.9" : 12.581506682707431, + "99.99" : 12.581506682707431, + "99.999" : 12.581506682707431, + "99.9999" : 12.581506682707431, + "100.0" : 12.581506682707431 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 12.514330571945203, + 12.506407091597282, + 12.267238498494056, + 12.408367863690382, + 12.30783050455806 + ], + [ + 12.230853952720787, + 12.288309895951182, + 12.284951263172482, + 12.581506682707431, + 12.371305034798283 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 95.94558084552935, + "scoreError" : 27.305759497065182, + "scoreConfidence" : [ + 68.63982134846417, + 123.25134034259453 + ], + "scorePercentiles" : { + "0.0" : 77.97536530626306, + "50.0" : 95.6067610893985, + "90.0" : 116.66865941675874, + "95.0" : 117.09371145000316, + "99.0" : 117.09371145000316, + "99.9" : 117.09371145000316, + "99.99" : 117.09371145000316, + "99.999" : 117.09371145000316, + "99.9999" : 117.09371145000316, + "100.0" : 117.09371145000316 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 112.843191117559, + 117.09371145000316, + 111.38428620678597, + 111.86779987658848, + 111.86173080135507 + ], + [ + 78.75484190009482, + 79.16523514618821, + 77.97536530626306, + 79.82923597201105, + 78.68041067844479 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 96.45415491594306, + "scoreError" : 26.41628978399258, + "scoreConfidence" : [ + 70.03786513195048, + 122.87044469993565 + ], + "scorePercentiles" : { + "0.0" : 79.4040643410865, + "50.0" : 95.69452504481404, + "90.0" : 116.04612830812147, + "95.0" : 116.35090211420003, + "99.0" : 116.35090211420003, + "99.9" : 116.35090211420003, + "99.99" : 116.35090211420003, + "99.999" : 116.35090211420003, + "99.9999" : 116.35090211420003, + "100.0" : 116.35090211420003 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 79.83763381284999, + 80.5874745608335, + 80.25451331625038, + 79.4040643410865, + 79.60251674924159 + ], + [ + 113.30316405341448, + 112.98270079921512, + 111.41700388354445, + 110.8015755287946, + 116.35090211420003 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 285.87791746620803, + "scoreError" : 4.280817265962943, + "scoreConfidence" : [ + 281.5971002002451, + 290.15873473217096 + ], + "scorePercentiles" : { + "0.0" : 282.9172752143441, + "50.0" : 285.20775975231385, + "90.0" : 292.4260520222768, + "95.0" : 292.96754726442185, + "99.0" : 292.96754726442185, + "99.9" : 292.96754726442185, + "99.99" : 292.96754726442185, + "99.999" : 292.96754726442185, + "99.9999" : 292.96754726442185, + "100.0" : 292.96754726442185 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 283.78579264107816, + 286.26318743948747, + 282.9172752143441, + 284.5530116684946, + 284.1533357868695 + ], + [ + 285.41326258372646, + 285.00225692090123, + 287.55259484297096, + 292.96754726442185, + 286.1709102997865 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "11.0.31", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 293.0195560097236, + "scoreError" : 8.11094615136958, + "scoreConfidence" : [ + 284.908609858354, + 301.1305021610932 + ], + "scorePercentiles" : { + "0.0" : 287.02131508839494, + "50.0" : 291.70077472779167, + "90.0" : 304.60456110491737, + "95.0" : 305.56717807375696, + "99.0" : 305.56717807375696, + "99.9" : 305.56717807375696, + "99.99" : 305.56717807375696, + "99.999" : 305.56717807375696, + "99.9999" : 305.56717807375696, + "100.0" : 305.56717807375696 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 288.6087089239263, + 295.6078273990885, + 305.56717807375696, + 290.16664278707856, + 290.50440318197633 + ], + [ + 292.89714627360706, + 289.2837068400631, + 287.02131508839494, + 294.5976231439831, + 295.94100838536093 + ] + ] + }, + "secondaryMetrics" : { + } + } +] diff --git a/research/issue-67/raw/results-jdk17.json b/research/issue-67/raw/results-jdk17.json new file mode 100644 index 0000000..6c35dab --- /dev/null +++ b/research/issue-67/raw/results-jdk17.json @@ -0,0 +1,1490 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.282598523188803, + "scoreError" : 0.07445847748513512, + "scoreConfidence" : [ + 2.2081400457036677, + 2.3570570006739384 + ], + "scorePercentiles" : { + "0.0" : 2.231408068821848, + "50.0" : 2.2702873488454216, + "90.0" : 2.3852391326270417, + "95.0" : 2.3914882443851924, + "99.0" : 2.3914882443851924, + "99.9" : 2.3914882443851924, + "99.99" : 2.3914882443851924, + "99.999" : 2.3914882443851924, + "99.9999" : 2.3914882443851924, + "100.0" : 2.3914882443851924 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.231408068821848, + 2.266503233167714, + 2.3914882443851924, + 2.295693773855634, + 2.302210843189272 + ], + [ + 2.3289971268036873, + 2.252224633055969, + 2.246312587687068, + 2.237075256398514, + 2.2740714645231286 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.2487321481577873, + "scoreError" : 0.04668417784757387, + "scoreConfidence" : [ + 2.2020479703102134, + 2.2954163260053613 + ], + "scorePercentiles" : { + "0.0" : 2.2112655268958696, + "50.0" : 2.2460623617329407, + "90.0" : 2.3082702950074223, + "95.0" : 2.3103186891560874, + "99.0" : 2.3103186891560874, + "99.9" : 2.3103186891560874, + "99.99" : 2.3103186891560874, + "99.999" : 2.3103186891560874, + "99.9999" : 2.3103186891560874, + "100.0" : 2.3103186891560874 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.2112655268958696, + 2.2245134185708237, + 2.250333770702368, + 2.241790952763514, + 2.252751360257654 + ], + [ + 2.2898347476694356, + 2.3103186891560874, + 2.237750056964079, + 2.250341331237631, + 2.2184216273604114 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.4063256514918456, + "scoreError" : 0.055334026666715684, + "scoreConfidence" : [ + 2.35099162482513, + 2.4616596781585613 + ], + "scorePercentiles" : { + "0.0" : 2.361023702070273, + "50.0" : 2.4046759584831205, + "90.0" : 2.4611682362440264, + "95.0" : 2.4627450938100885, + "99.0" : 2.4627450938100885, + "99.9" : 2.4627450938100885, + "99.99" : 2.4627450938100885, + "99.999" : 2.4627450938100885, + "99.9999" : 2.4627450938100885, + "100.0" : 2.4627450938100885 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.396559323558945, + 2.446976518149467, + 2.3628864515590204, + 2.361023702070273, + 2.3997620595514397 + ], + [ + 2.420587403571878, + 2.409589857414801, + 2.4627450938100885, + 2.4395321525947398, + 2.3635939526378014 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.458727902908914, + "scoreError" : 0.054851093346755385, + "scoreConfidence" : [ + 2.4038768095621585, + 2.5135789962556694 + ], + "scorePercentiles" : { + "0.0" : 2.425419589124302, + "50.0" : 2.4502679040940203, + "90.0" : 2.5466587211034657, + "95.0" : 2.5555415256206597, + "99.0" : 2.5555415256206597, + "99.9" : 2.5555415256206597, + "99.99" : 2.5555415256206597, + "99.999" : 2.5555415256206597, + "99.9999" : 2.5555415256206597, + "100.0" : 2.5555415256206597 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.43543945817, + 2.4490088313926863, + 2.4407755422221404, + 2.442109704623227, + 2.451526976795354 + ], + [ + 2.425419589124302, + 2.5555415256206597, + 2.462362571420703, + 2.4583813492713484, + 2.466713480448721 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 5.153135461111171, + "scoreError" : 0.06548520156101927, + "scoreConfidence" : [ + 5.087650259550152, + 5.2186206626721905 + ], + "scorePercentiles" : { + "0.0" : 5.083811456481263, + "50.0" : 5.150619500676022, + "90.0" : 5.219649915116967, + "95.0" : 5.221031968632653, + "99.0" : 5.221031968632653, + "99.9" : 5.221031968632653, + "99.99" : 5.221031968632653, + "99.999" : 5.221031968632653, + "99.9999" : 5.221031968632653, + "100.0" : 5.221031968632653 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.157244193853683, + 5.192779611736407, + 5.221031968632653, + 5.127904325779942, + 5.083811456481263 + ], + [ + 5.207211433475783, + 5.112458993171577, + 5.149105362370713, + 5.152133638981333, + 5.127673626628356 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 5.234075509786857, + "scoreError" : 0.14423375712325046, + "scoreConfidence" : [ + 5.089841752663607, + 5.378309266910107 + ], + "scorePercentiles" : { + "0.0" : 5.119799501747751, + "50.0" : 5.216729380702072, + "90.0" : 5.398393173560023, + "95.0" : 5.402027041697459, + "99.0" : 5.402027041697459, + "99.9" : 5.402027041697459, + "99.99" : 5.402027041697459, + "99.999" : 5.402027041697459, + "99.9999" : 5.402027041697459, + "100.0" : 5.402027041697459 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.19940772550562, + 5.135878388418648, + 5.119799501747751, + 5.145764717830072, + 5.194120987052142 + ], + [ + 5.234051035898524, + 5.365688360323097, + 5.402027041697459, + 5.261831389912215, + 5.282185949483037 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 10.714913888628189, + "scoreError" : 0.15816015972195588, + "scoreConfidence" : [ + 10.556753728906234, + 10.873074048350144 + ], + "scorePercentiles" : { + "0.0" : 10.54358584737612, + "50.0" : 10.738317288141396, + "90.0" : 10.885519360473301, + "95.0" : 10.892822425057881, + "99.0" : 10.892822425057881, + "99.9" : 10.892822425057881, + "99.99" : 10.892822425057881, + "99.999" : 10.892822425057881, + "99.9999" : 10.892822425057881, + "100.0" : 10.892822425057881 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 10.735777784971525, + 10.760632632737734, + 10.54358584737612, + 10.593258243137498, + 10.748617927513793 + ], + [ + 10.740856791311268, + 10.639223722924392, + 10.892822425057881, + 10.819791779212078, + 10.674571732039576 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 10.97614554262611, + "scoreError" : 0.3974369583604722, + "scoreConfidence" : [ + 10.578708584265637, + 11.373582500986583 + ], + "scorePercentiles" : { + "0.0" : 10.795444979791968, + "50.0" : 10.904486679554303, + "90.0" : 11.634391346992492, + "95.0" : 11.708621697378272, + "99.0" : 11.708621697378272, + "99.9" : 11.708621697378272, + "99.99" : 11.708621697378272, + "99.999" : 11.708621697378272, + "99.9999" : 11.708621697378272, + "100.0" : 11.708621697378272 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 10.837985470612736, + 10.795444979791968, + 10.956447621100143, + 10.883163802846664, + 10.887582580492447 + ], + [ + 10.92139077861616, + 10.939652165633301, + 10.864848136268929, + 10.96631819352047, + 11.708621697378272 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 68.61518686815012, + "scoreError" : 0.5270447915718972, + "scoreConfidence" : [ + 68.08814207657822, + 69.14223165972201 + ], + "scorePercentiles" : { + "0.0" : 68.11011062225289, + "50.0" : 68.58043447434649, + "90.0" : 69.07315671887413, + "95.0" : 69.08076726679711, + "99.0" : 69.08076726679711, + "99.9" : 69.08076726679711, + "99.99" : 69.08076726679711, + "99.999" : 69.08076726679711, + "99.9999" : 69.08076726679711, + "100.0" : 69.08076726679711 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 68.80692578684739, + 68.48886365320048, + 68.99722595111626, + 68.5467539023937, + 68.61411504629928 + ], + [ + 68.11011062225289, + 69.00466178756726, + 68.22050561069754, + 68.28193905432936, + 69.08076726679711 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 70.2944970468466, + "scoreError" : 1.0933869704128163, + "scoreConfidence" : [ + 69.20111007643378, + 71.38788401725942 + ], + "scorePercentiles" : { + "0.0" : 69.60766797219694, + "50.0" : 70.07080639317188, + "90.0" : 71.95808350340285, + "95.0" : 72.09565092180844, + "99.0" : 72.09565092180844, + "99.9" : 72.09565092180844, + "99.99" : 72.09565092180844, + "99.999" : 72.09565092180844, + "99.9999" : 72.09565092180844, + "100.0" : 72.09565092180844 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 70.22022030665462, + 69.60766797219694, + 69.88916026008043, + 70.1379926709601, + 69.89187728630286 + ], + [ + 70.60607494652456, + 70.7199767377525, + 69.77272925080194, + 72.09565092180844, + 70.00362011538365 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 263.91054218354793, + "scoreError" : 2.5520052182849926, + "scoreConfidence" : [ + 261.35853696526294, + 266.4625474018329 + ], + "scorePercentiles" : { + "0.0" : 261.86242730694136, + "50.0" : 263.6832580637299, + "90.0" : 266.4101046752881, + "95.0" : 266.4844295542275, + "99.0" : 266.4844295542275, + "99.9" : 266.4844295542275, + "99.99" : 266.4844295542275, + "99.999" : 266.4844295542275, + "99.9999" : 266.4844295542275, + "100.0" : 266.4844295542275 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 262.95031079408216, + 262.0494518361276, + 263.27094615432384, + 262.2536405673933, + 261.86242730694136 + ], + [ + 265.73714546044414, + 264.6603194239701, + 266.4844295542275, + 264.095569973136, + 265.74118076483313 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 268.01145560569387, + "scoreError" : 3.59425310535618, + "scoreConfidence" : [ + 264.4172025003377, + 271.60570871105006 + ], + "scorePercentiles" : { + "0.0" : 265.5767614169378, + "50.0" : 267.4228330844785, + "90.0" : 272.75793934191967, + "95.0" : 272.94715988473627, + "99.0" : 272.94715988473627, + "99.9" : 272.94715988473627, + "99.99" : 272.94715988473627, + "99.999" : 272.94715988473627, + "99.9999" : 272.94715988473627, + "100.0" : 272.94715988473627 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 268.9579319806329, + 267.45155880775445, + 266.24581098080677, + 271.05495445657, + 265.5767614169378 + ], + [ + 267.39410736120254, + 268.0537376356297, + 265.93313098506576, + 266.4994025476031, + 272.94715988473627 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.69617988935668, + "scoreError" : 0.14075535958765287, + "scoreConfidence" : [ + 2.5554245297690272, + 2.836935248944333 + ], + "scorePercentiles" : { + "0.0" : 2.588220871405596, + "50.0" : 2.6858645501562526, + "90.0" : 2.8297757100089784, + "95.0" : 2.832975023771288, + "99.0" : 2.832975023771288, + "99.9" : 2.832975023771288, + "99.99" : 2.832975023771288, + "99.999" : 2.832975023771288, + "99.9999" : 2.832975023771288, + "100.0" : 2.832975023771288 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.712285827420337, + 2.7711605152387158, + 2.8009818861481914, + 2.770950853399144, + 2.832975023771288 + ], + [ + 2.588220871405596, + 2.6594432728921684, + 2.608659816732718, + 2.6288421075889987, + 2.5882787189696423 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.691910238816942, + "scoreError" : 0.09748790229938087, + "scoreConfidence" : [ + 2.594422336517561, + 2.7893981411163224 + ], + "scorePercentiles" : { + "0.0" : 2.6207871039150534, + "50.0" : 2.6827954325402654, + "90.0" : 2.7851643115424887, + "95.0" : 2.7859035559636287, + "99.0" : 2.7859035559636287, + "99.9" : 2.7859035559636287, + "99.99" : 2.7859035559636287, + "99.999" : 2.7859035559636287, + "99.9999" : 2.7859035559636287, + "100.0" : 2.7859035559636287 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.6217133513358775, + 2.6278996116804536, + 2.6421305343063435, + 2.6779274403982116, + 2.6207871039150534 + ], + [ + 2.7359146889858965, + 2.7859035559636287, + 2.7785111117522274, + 2.740651565149407, + 2.6876634246823192 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.6383434607771354, + "scoreError" : 0.03504942830165384, + "scoreConfidence" : [ + 2.6032940324754814, + 2.6733928890787895 + ], + "scorePercentiles" : { + "0.0" : 2.613767692315972, + "50.0" : 2.6309574275764556, + "90.0" : 2.6804210929805463, + "95.0" : 2.6815375657991303, + "99.0" : 2.6815375657991303, + "99.9" : 2.6815375657991303, + "99.99" : 2.6815375657991303, + "99.999" : 2.6815375657991303, + "99.9999" : 2.6815375657991303, + "100.0" : 2.6815375657991303 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.617585457986474, + 2.634185730294634, + 2.648564865655711, + 2.6815375657991303, + 2.6277291248582775 + ], + [ + 2.6239934462291643, + 2.613767692315972, + 2.647164484931351, + 2.6185334020873428, + 2.670372837613292 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.7526871300800435, + "scoreError" : 0.08766712566667685, + "scoreConfidence" : [ + 2.6650200044133667, + 2.8403542557467203 + ], + "scorePercentiles" : { + "0.0" : 2.70166535988479, + "50.0" : 2.7335802266453744, + "90.0" : 2.870142630721828, + "95.0" : 2.8761517878497065, + "99.0" : 2.8761517878497065, + "99.9" : 2.8761517878497065, + "99.99" : 2.8761517878497065, + "99.999" : 2.8761517878497065, + "99.9999" : 2.8761517878497065, + "100.0" : 2.8761517878497065 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.8761517878497065, + 2.7021912360338316, + 2.7078313929346387, + 2.7407551266399994, + 2.70166535988479 + ], + [ + 2.736062772724452, + 2.7310976805662963, + 2.795641528061039, + 2.7194141995347563, + 2.8160602165709228 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 6.50114568073724, + "scoreError" : 0.12838776978703514, + "scoreConfidence" : [ + 6.372757910950205, + 6.629533450524275 + ], + "scorePercentiles" : { + "0.0" : 6.324130212605307, + "50.0" : 6.5092180795757635, + "90.0" : 6.646629550830973, + "95.0" : 6.656883577127951, + "99.0" : 6.656883577127951, + "99.9" : 6.656883577127951, + "99.99" : 6.656883577127951, + "99.999" : 6.656883577127951, + "99.9999" : 6.656883577127951, + "100.0" : 6.656883577127951 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 6.656883577127951, + 6.507700841916279, + 6.530257346304937, + 6.522011574667148, + 6.554343314158162 + ], + [ + 6.497770827413861, + 6.436862144869533, + 6.47076165107398, + 6.324130212605307, + 6.510735317235247 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 6.481855831006148, + "scoreError" : 0.08241194994676158, + "scoreConfidence" : [ + 6.399443881059386, + 6.5642677809529095 + ], + "scorePercentiles" : { + "0.0" : 6.390771028985293, + "50.0" : 6.497395650573193, + "90.0" : 6.539960855464016, + "95.0" : 6.540520356832565, + "99.0" : 6.540520356832565, + "99.9" : 6.540520356832565, + "99.99" : 6.540520356832565, + "99.999" : 6.540520356832565, + "99.9999" : 6.540520356832565, + "100.0" : 6.540520356832565 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 6.534925343147069, + 6.525265531318218, + 6.390771028985293, + 6.41043810386398, + 6.444022753798462 + ], + [ + 6.4535724463249196, + 6.5159909359264905, + 6.540520356832565, + 6.524251444644574, + 6.478800365219895 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 11.936376651505274, + "scoreError" : 0.21676121854670347, + "scoreConfidence" : [ + 11.71961543295857, + 12.153137870051978 + ], + "scorePercentiles" : { + "0.0" : 11.778209814050074, + "50.0" : 11.913445501260625, + "90.0" : 12.198903621335635, + "95.0" : 12.210381281424272, + "99.0" : 12.210381281424272, + "99.9" : 12.210381281424272, + "99.99" : 12.210381281424272, + "99.999" : 12.210381281424272, + "99.9999" : 12.210381281424272, + "100.0" : 12.210381281424272 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 11.913624560625694, + 11.778209814050074, + 11.850857631147143, + 11.796990059629861, + 11.816319047375245 + ], + [ + 11.921288833033758, + 11.913266441895557, + 12.210381281424272, + 12.067224165333222, + 12.095604680537896 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 12.18749886491086, + "scoreError" : 0.16242356524291943, + "scoreConfidence" : [ + 12.025075299667941, + 12.34992243015378 + ], + "scorePercentiles" : { + "0.0" : 12.015290563141653, + "50.0" : 12.167216930050408, + "90.0" : 12.357153470049077, + "95.0" : 12.359071001655552, + "99.0" : 12.359071001655552, + "99.9" : 12.359071001655552, + "99.99" : 12.359071001655552, + "99.999" : 12.359071001655552, + "99.9999" : 12.359071001655552, + "100.0" : 12.359071001655552 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 12.179916240343323, + 12.154517619757495, + 12.20778836431457, + 12.015290563141653, + 12.117723550883362 + ], + [ + 12.339895685590797, + 12.135371474333825, + 12.261354094991225, + 12.359071001655552, + 12.104060054096825 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 98.70472088538355, + "scoreError" : 2.428645541282232, + "scoreConfidence" : [ + 96.27607534410132, + 101.13336642666579 + ], + "scorePercentiles" : { + "0.0" : 96.92744906702485, + "50.0" : 98.37451201274385, + "90.0" : 101.95762503117662, + "95.0" : 102.11634813437895, + "99.0" : 102.11634813437895, + "99.9" : 102.11634813437895, + "99.99" : 102.11634813437895, + "99.999" : 102.11634813437895, + "99.9999" : 102.11634813437895, + "100.0" : 102.11634813437895 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 96.92963127118516, + 96.92744906702485, + 98.15983205996928, + 98.58919196551842, + 97.85315123025983 + ], + [ + 98.84879748382872, + 99.19544386502453, + 97.89824667429014, + 100.52911710235557, + 102.11634813437895 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 99.51299902217382, + "scoreError" : 0.9920511053047149, + "scoreConfidence" : [ + 98.5209479168691, + 100.50505012747853 + ], + "scorePercentiles" : { + "0.0" : 98.38617767614514, + "50.0" : 99.56123054261585, + "90.0" : 100.51729421350734, + "95.0" : 100.55683073092231, + "99.0" : 100.55683073092231, + "99.9" : 100.55683073092231, + "99.99" : 100.55683073092231, + "99.999" : 100.55683073092231, + "99.9999" : 100.55683073092231, + "100.0" : 100.55683073092231 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 99.81903528191344, + 99.67857368422206, + 98.61984376001143, + 99.41235787680557, + 99.24192273959338 + ], + [ + 99.44388740100963, + 99.80989551434259, + 98.38617767614514, + 100.55683073092231, + 100.1614655567726 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 379.0815512292448, + "scoreError" : 4.909183522574485, + "scoreConfidence" : [ + 374.1723677066703, + 383.9907347518193 + ], + "scorePercentiles" : { + "0.0" : 374.2735159267222, + "50.0" : 378.08590334877454, + "90.0" : 383.7439285544071, + "95.0" : 383.89616090810557, + "99.0" : 383.89616090810557, + "99.9" : 383.89616090810557, + "99.99" : 383.89616090810557, + "99.999" : 383.89616090810557, + "99.9999" : 383.89616090810557, + "100.0" : 383.89616090810557 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 377.4145233694217, + 376.8300160027485, + 374.2735159267222, + 377.98641919044195, + 382.3738373711206 + ], + [ + 381.80446975125903, + 375.8251249810293, + 378.1853875071072, + 383.89616090810557, + 382.2260572844917 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-17-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.19", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.19+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 379.9962316945449, + "scoreError" : 6.195211789975823, + "scoreConfidence" : [ + 373.8010199045691, + 386.19144348452073 + ], + "scorePercentiles" : { + "0.0" : 374.1014822570392, + "50.0" : 379.79744295436245, + "90.0" : 386.70234107695984, + "95.0" : 386.9955531938263, + "99.0" : 386.9955531938263, + "99.9" : 386.9955531938263, + "99.99" : 386.9955531938263, + "99.999" : 386.9955531938263, + "99.9999" : 386.9955531938263, + "100.0" : 386.9955531938263 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 383.419435693919, + 386.9955531938263, + 380.03745601186387, + 384.06343202516183, + 377.5345263485192 + ], + [ + 374.1014822570392, + 375.4723920947003, + 376.9746011890857, + 381.8060082344733, + 379.55742989686104 + ] + ] + }, + "secondaryMetrics" : { + } + } +] diff --git a/research/issue-67/raw/results-jdk21.json b/research/issue-67/raw/results-jdk21.json new file mode 100644 index 0000000..97a7470 --- /dev/null +++ b/research/issue-67/raw/results-jdk21.json @@ -0,0 +1,1490 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.2825236819683656, + "scoreError" : 0.05269693821310749, + "scoreConfidence" : [ + 2.2298267437552584, + 2.335220620181473 + ], + "scorePercentiles" : { + "0.0" : 2.239272117560138, + "50.0" : 2.27478967924357, + "90.0" : 2.3615815856383686, + "95.0" : 2.3674227687439897, + "99.0" : 2.3674227687439897, + "99.9" : 2.3674227687439897, + "99.99" : 2.3674227687439897, + "99.999" : 2.3674227687439897, + "99.9999" : 2.3674227687439897, + "100.0" : 2.3674227687439897 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.3674227687439897, + 2.3090109376877765, + 2.2638166395982893, + 2.2705512415761047, + 2.2841160595360805 + ], + [ + 2.2593991972355325, + 2.239272117560138, + 2.2734144129417775, + 2.2761649455453625, + 2.2820684992586098 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.2795839946798315, + "scoreError" : 0.02351137737488233, + "scoreConfidence" : [ + 2.256072617304949, + 2.303095372054714 + ], + "scorePercentiles" : { + "0.0" : 2.2535300624091197, + "50.0" : 2.281545220640285, + "90.0" : 2.301147279126415, + "95.0" : 2.3016028432434434, + "99.0" : 2.3016028432434434, + "99.9" : 2.3016028432434434, + "99.99" : 2.3016028432434434, + "99.999" : 2.3016028432434434, + "99.9999" : 2.3016028432434434, + "100.0" : 2.3016028432434434 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.286399917620354, + 2.297047202073159, + 2.3016028432434434, + 2.28868424845792, + 2.2825087523808465 + ], + [ + 2.258362031932951, + 2.278370976047783, + 2.268752223733016, + 2.280581688899724, + 2.2535300624091197 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.4760991414819156, + "scoreError" : 0.06197590619030959, + "scoreConfidence" : [ + 2.4141232352916058, + 2.5380750476722254 + ], + "scorePercentiles" : { + "0.0" : 2.425839062467025, + "50.0" : 2.4725122937519872, + "90.0" : 2.5700940844635523, + "95.0" : 2.5795495719782293, + "99.0" : 2.5795495719782293, + "99.9" : 2.5795495719782293, + "99.99" : 2.5795495719782293, + "99.999" : 2.5795495719782293, + "99.9999" : 2.5795495719782293, + "100.0" : 2.5795495719782293 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.4611298202168115, + 2.4827819903667727, + 2.440391183381249, + 2.5795495719782293, + 2.4849946968314596 + ], + [ + 2.478380102725055, + 2.466687247493615, + 2.425839062467025, + 2.478337340010359, + 2.462900399348583 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.514289461637791, + "scoreError" : 0.0782825994616952, + "scoreConfidence" : [ + 2.4360068621760957, + 2.592572061099486 + ], + "scorePercentiles" : { + "0.0" : 2.414208412469484, + "50.0" : 2.5305682669606613, + "90.0" : 2.581862398260174, + "95.0" : 2.5838771863362813, + "99.0" : 2.5838771863362813, + "99.9" : 2.5838771863362813, + "99.99" : 2.5838771863362813, + "99.999" : 2.5838771863362813, + "99.9999" : 2.5838771863362813, + "100.0" : 2.5838771863362813 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.5838771863362813, + 2.5417289352030594, + 2.527368227481016, + 2.5637293055752077, + 2.533768306440307 + ], + [ + 2.4806594454409026, + 2.4538744547170364, + 2.504115581647957, + 2.539564761066656, + 2.414208412469484 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 5.173878065890122, + "scoreError" : 0.06483750169916755, + "scoreConfidence" : [ + 5.109040564190955, + 5.238715567589289 + ], + "scorePercentiles" : { + "0.0" : 5.092702487084703, + "50.0" : 5.162834752943942, + "90.0" : 5.2259876282057345, + "95.0" : 5.2269503913695035, + "99.0" : 5.2269503913695035, + "99.9" : 5.2269503913695035, + "99.99" : 5.2269503913695035, + "99.999" : 5.2269503913695035, + "99.9999" : 5.2269503913695035, + "100.0" : 5.2269503913695035 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.149095922281882, + 5.212212910358857, + 5.158601715856786, + 5.147620784440479, + 5.167067790031098 + ], + [ + 5.215361684117281, + 5.092702487084703, + 5.2173227597318155, + 5.2269503913695035, + 5.15184421362881 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 5.206648729288174, + "scoreError" : 0.04709046721578051, + "scoreConfidence" : [ + 5.159558262072394, + 5.253739196503955 + ], + "scorePercentiles" : { + "0.0" : 5.159486257456582, + "50.0" : 5.210281699003145, + "90.0" : 5.266385437658074, + "95.0" : 5.2713854245628315, + "99.0" : 5.2713854245628315, + "99.9" : 5.2713854245628315, + "99.99" : 5.2713854245628315, + "99.999" : 5.2713854245628315, + "99.9999" : 5.2713854245628315, + "100.0" : 5.2713854245628315 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.16925227988678, + 5.203899428342247, + 5.186311374216773, + 5.211143638221323, + 5.2713854245628315 + ], + [ + 5.221385555515252, + 5.213035376623475, + 5.159486257456582, + 5.209419759784967, + 5.2211681982715135 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 10.470820370014014, + "scoreError" : 0.07105116089852528, + "scoreConfidence" : [ + 10.399769209115489, + 10.54187153091254 + ], + "scorePercentiles" : { + "0.0" : 10.422262034281276, + "50.0" : 10.463395746817465, + "90.0" : 10.552148563355715, + "95.0" : 10.555417213068727, + "99.0" : 10.555417213068727, + "99.9" : 10.555417213068727, + "99.99" : 10.555417213068727, + "99.999" : 10.555417213068727, + "99.9999" : 10.555417213068727, + "100.0" : 10.555417213068727 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 10.478107365653948, + 10.522730715938598, + 10.516016205786554, + 10.45749146616492, + 10.42322671203222 + ], + [ + 10.422262034281276, + 10.555417213068727, + 10.425255953249685, + 10.469300027470013, + 10.43839600649418 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 10.70545396572309, + "scoreError" : 0.1235631997453123, + "scoreConfidence" : [ + 10.581890765977777, + 10.829017165468402 + ], + "scorePercentiles" : { + "0.0" : 10.614460800545736, + "50.0" : 10.7049436871289, + "90.0" : 10.871199589621547, + "95.0" : 10.882527884146475, + "99.0" : 10.882527884146475, + "99.9" : 10.882527884146475, + "99.99" : 10.882527884146475, + "99.999" : 10.882527884146475, + "99.9999" : 10.882527884146475, + "100.0" : 10.882527884146475 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 10.769244938897193, + 10.633368485832973, + 10.719081610740654, + 10.691570172015266, + 10.882527884146475 + ], + [ + 10.616007962317425, + 10.614460800545736, + 10.668430625367279, + 10.718317202242535, + 10.741529975125363 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 63.58677621763311, + "scoreError" : 1.0991141129662108, + "scoreConfidence" : [ + 62.487662104666896, + 64.68589033059932 + ], + "scorePercentiles" : { + "0.0" : 62.48094268209959, + "50.0" : 63.613894836020286, + "90.0" : 64.58842462778182, + "95.0" : 64.59575518645082, + "99.0" : 64.59575518645082, + "99.9" : 64.59575518645082, + "99.99" : 64.59575518645082, + "99.999" : 64.59575518645082, + "99.9999" : 64.59575518645082, + "100.0" : 64.59575518645082 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 63.448578656518784, + 64.2540829856607, + 64.52244959976082, + 63.77921101552179, + 64.59575518645082 + ], + [ + 63.04584383620834, + 62.853924283629404, + 62.48094268209959, + 63.07732765989857, + 63.809646270582355 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 65.29786158750338, + "scoreError" : 4.1470661532790505, + "scoreConfidence" : [ + 61.15079543422433, + 69.44492774078243 + ], + "scorePercentiles" : { + "0.0" : 63.707467158903725, + "50.0" : 64.33377224502867, + "90.0" : 72.19240672204707, + "95.0" : 72.86317373403224, + "99.0" : 72.86317373403224, + "99.9" : 72.86317373403224, + "99.99" : 72.86317373403224, + "99.999" : 72.86317373403224, + "99.9999" : 72.86317373403224, + "100.0" : 72.86317373403224 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 64.06116161424062, + 72.86317373403224, + 64.7163322606876, + 64.56734099931579, + 64.08276315917554 + ], + [ + 66.15550361418052, + 64.10020349074155, + 63.707467158903725, + 64.64198939543488, + 64.08268044832143 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 244.4520302150931, + "scoreError" : 4.76592545864011, + "scoreConfidence" : [ + 239.68610475645298, + 249.2179556737332 + ], + "scorePercentiles" : { + "0.0" : 240.1337274243679, + "50.0" : 244.12577857163814, + "90.0" : 251.73823180369263, + "95.0" : 252.4893448709839, + "99.0" : 252.4893448709839, + "99.9" : 252.4893448709839, + "99.99" : 252.4893448709839, + "99.999" : 252.4893448709839, + "99.9999" : 252.4893448709839, + "100.0" : 252.4893448709839 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 244.97821419807119, + 244.1998060505206, + 243.06134308926178, + 244.05175109275567, + 240.1337274243679 + ], + [ + 252.4893448709839, + 243.39272976713752, + 242.86073670957495, + 244.65646867642505, + 244.6961802718326 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 248.1042859004609, + "scoreError" : 2.144938168197828, + "scoreConfidence" : [ + 245.95934773226307, + 250.24922406865872 + ], + "scorePercentiles" : { + "0.0" : 245.04926673147605, + "50.0" : 248.3081321762757, + "90.0" : 250.1386390242701, + "95.0" : 250.2521820090192, + "99.0" : 250.2521820090192, + "99.9" : 250.2521820090192, + "99.99" : 250.2521820090192, + "99.999" : 250.2521820090192, + "99.9999" : 250.2521820090192, + "100.0" : 250.2521820090192 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 248.8575314950172, + 248.71992032684688, + 249.11675216152827, + 250.2521820090192, + 247.8963440257045 + ], + [ + 247.56053168873788, + 248.91607703854714, + 247.23117038185083, + 245.04926673147605, + 247.44308314588068 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.63590869823184, + "scoreError" : 0.03414256099868764, + "scoreConfidence" : [ + 2.6017661372331524, + 2.6700512592305277 + ], + "scorePercentiles" : { + "0.0" : 2.6124794846248642, + "50.0" : 2.6299981008811466, + "90.0" : 2.6861213284074257, + "95.0" : 2.689749647543167, + "99.0" : 2.689749647543167, + "99.9" : 2.689749647543167, + "99.99" : 2.689749647543167, + "99.999" : 2.689749647543167, + "99.9999" : 2.689749647543167, + "100.0" : 2.689749647543167 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.6439500643592573, + 2.6353504017925604, + 2.6534664561857553, + 2.6185852633106275, + 2.630579367750259 + ], + [ + 2.627867320484346, + 2.6176421422555336, + 2.6124794846248642, + 2.689749647543167, + 2.6294168340120345 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.62455991341434, + "scoreError" : 0.02254138957546219, + "scoreConfidence" : [ + 2.6020185238388778, + 2.647101302989802 + ], + "scorePercentiles" : { + "0.0" : 2.6052610415456545, + "50.0" : 2.623747226835005, + "90.0" : 2.6508630266830258, + "95.0" : 2.6522024530622614, + "99.0" : 2.6522024530622614, + "99.9" : 2.6522024530622614, + "99.99" : 2.6522024530622614, + "99.999" : 2.6522024530622614, + "99.9999" : 2.6522024530622614, + "100.0" : 2.6522024530622614 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.61376312921922, + 2.6522024530622614, + 2.6336234189863585, + 2.631445657319735, + 2.61845688411011 + ], + [ + 2.6388081892699065, + 2.608619247347937, + 2.6290375695598995, + 2.6052610415456545, + 2.6143815437223163 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.9222865364974524, + "scoreError" : 0.056320827867634364, + "scoreConfidence" : [ + 2.865965708629818, + 2.9786073643650868 + ], + "scorePercentiles" : { + "0.0" : 2.879045739597878, + "50.0" : 2.909405929151599, + "90.0" : 2.980976101536824, + "95.0" : 2.981591456349566, + "99.0" : 2.981591456349566, + "99.9" : 2.981591456349566, + "99.99" : 2.981591456349566, + "99.999" : 2.981591456349566, + "99.9999" : 2.981591456349566, + "100.0" : 2.981591456349566 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.930042214520313, + 2.957632307074211, + 2.9175600344397727, + 2.895009142392334, + 2.981591456349566 + ], + [ + 2.9754379082221445, + 2.879045739597878, + 2.9012518238634244, + 2.8938096956929567, + 2.8914850428219205 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.9147315781116427, + "scoreError" : 0.027041224167240595, + "scoreConfidence" : [ + 2.8876903539444023, + 2.941772802278883 + ], + "scorePercentiles" : { + "0.0" : 2.8864585303857435, + "50.0" : 2.917358565824019, + "90.0" : 2.939566208642999, + "95.0" : 2.9398694794429145, + "99.0" : 2.9398694794429145, + "99.9" : 2.9398694794429145, + "99.99" : 2.9398694794429145, + "99.999" : 2.9398694794429145, + "99.9999" : 2.9398694794429145, + "100.0" : 2.9398694794429145 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.911821632730229, + 2.9218517082789255, + 2.9211237464518764, + 2.9135933851961613, + 2.9066048518081065 + ], + [ + 2.9398694794429145, + 2.9368367714437587, + 2.8874644960774285, + 2.8864585303857435, + 2.9216911793012876 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 6.363810130651673, + "scoreError" : 0.06888298600960742, + "scoreConfidence" : [ + 6.294927144642065, + 6.43269311666128 + ], + "scorePercentiles" : { + "0.0" : 6.286272085275035, + "50.0" : 6.371819765766768, + "90.0" : 6.435294518601208, + "95.0" : 6.438878168989564, + "99.0" : 6.438878168989564, + "99.9" : 6.438878168989564, + "99.99" : 6.438878168989564, + "99.999" : 6.438878168989564, + "99.9999" : 6.438878168989564, + "100.0" : 6.438878168989564 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 6.337970326414909, + 6.379954448142297, + 6.363685083391238, + 6.438878168989564, + 6.403041665106003 + ], + [ + 6.286272085275035, + 6.318151269947962, + 6.331513925336121, + 6.380977295791974, + 6.397657038121629 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 6.576895834176592, + "scoreError" : 0.06775384883018548, + "scoreConfidence" : [ + 6.509141985346407, + 6.644649683006778 + ], + "scorePercentiles" : { + "0.0" : 6.509552367238491, + "50.0" : 6.5701960995922235, + "90.0" : 6.675194670963748, + "95.0" : 6.683942895953146, + "99.0" : 6.683942895953146, + "99.9" : 6.683942895953146, + "99.99" : 6.683942895953146, + "99.999" : 6.683942895953146, + "99.9999" : 6.683942895953146, + "100.0" : 6.683942895953146 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 6.5451271338293795, + 6.509552367238491, + 6.568173426991116, + 6.57507815303023, + 6.559119650890671 + ], + [ + 6.571182227670947, + 6.596460646059159, + 6.591111868589291, + 6.683942895953146, + 6.5692099715135 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 11.954015136921258, + "scoreError" : 0.1819042893855178, + "scoreConfidence" : [ + 11.77211084753574, + 12.135919426306776 + ], + "scorePercentiles" : { + "0.0" : 11.801905400412542, + "50.0" : 11.927553232682175, + "90.0" : 12.15825559280119, + "95.0" : 12.161768396577383, + "99.0" : 12.161768396577383, + "99.9" : 12.161768396577383, + "99.99" : 12.161768396577383, + "99.999" : 12.161768396577383, + "99.9999" : 12.161768396577383, + "100.0" : 12.161768396577383 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 12.043889768710764, + 12.161768396577383, + 12.126640358815449, + 11.91319865279766, + 11.941907812566688 + ], + [ + 11.944516801188138, + 11.901361162288737, + 11.832237786812291, + 11.801905400412542, + 11.872725229042924 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 12.080706825328019, + "scoreError" : 0.15712505580150243, + "scoreConfidence" : [ + 11.923581769526516, + 12.237831881129521 + ], + "scorePercentiles" : { + "0.0" : 11.897750365273344, + "50.0" : 12.07829857300295, + "90.0" : 12.239977853211512, + "95.0" : 12.248196744031386, + "99.0" : 12.248196744031386, + "99.9" : 12.248196744031386, + "99.99" : 12.248196744031386, + "99.999" : 12.248196744031386, + "99.9999" : 12.248196744031386, + "100.0" : 12.248196744031386 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 11.974933458703179, + 11.897750365273344, + 12.067841182723518, + 12.076370816109806, + 11.996053035091242 + ], + [ + 12.080226329896094, + 12.137410462089743, + 12.162278023529238, + 12.166007835832637, + 12.248196744031386 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 102.94482498300347, + "scoreError" : 1.421817481611439, + "scoreConfidence" : [ + 101.52300750139203, + 104.36664246461491 + ], + "scorePercentiles" : { + "0.0" : 101.56647515997815, + "50.0" : 102.88306408264899, + "90.0" : 104.25367359994367, + "95.0" : 104.27284507274828, + "99.0" : 104.27284507274828, + "99.9" : 104.27284507274828, + "99.99" : 104.27284507274828, + "99.999" : 104.27284507274828, + "99.9999" : 104.27284507274828, + "100.0" : 104.27284507274828 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 102.33942491372069, + 104.08113034470215, + 104.27284507274828, + 103.15700072272338, + 102.08902775685777 + ], + [ + 102.69060677178342, + 103.07552139351456, + 101.56647515997815, + 104.02045991512406, + 102.15575777888203 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 102.99446459010274, + "scoreError" : 1.996982579588295, + "scoreConfidence" : [ + 100.99748201051445, + 104.99144716969103 + ], + "scorePercentiles" : { + "0.0" : 101.41380682736306, + "50.0" : 102.85505597717767, + "90.0" : 105.10495668049722, + "95.0" : 105.17205447151959, + "99.0" : 105.17205447151959, + "99.9" : 105.17205447151959, + "99.99" : 105.17205447151959, + "99.999" : 105.17205447151959, + "99.9999" : 105.17205447151959, + "100.0" : 105.17205447151959 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 101.91705159346759, + 101.41380682736306, + 102.0106301068334, + 103.46781592430416, + 101.50420566485592 + ], + [ + 104.24789279703232, + 104.50107656129589, + 102.92075740696738, + 102.78935454738796, + 105.17205447151959 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 352.69363232783377, + "scoreError" : 6.982850499402118, + "scoreConfidence" : [ + 345.71078182843166, + 359.6764828272359 + ], + "scorePercentiles" : { + "0.0" : 348.40517505013923, + "50.0" : 350.9066266984965, + "90.0" : 360.6645487961345, + "95.0" : 360.91759949081944, + "99.0" : 360.91759949081944, + "99.9" : 360.91759949081944, + "99.99" : 360.91759949081944, + "99.999" : 360.91759949081944, + "99.9999" : 360.91759949081944, + "100.0" : 360.91759949081944 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 348.9139694876906, + 348.85154812287357, + 357.63564550567986, + 358.38709254397025, + 352.71718574352275 + ], + [ + 349.29485393664805, + 349.87138142867235, + 348.40517505013923, + 351.94187196832064, + 360.91759949081944 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-21-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "21.0.11", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "21.0.11+10-1-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 358.89921220679116, + "scoreError" : 5.381668597733139, + "scoreConfidence" : [ + 353.517543609058, + 364.2808808045243 + ], + "scorePercentiles" : { + "0.0" : 353.1615030892504, + "50.0" : 358.9698936685112, + "90.0" : 363.73545093625455, + "95.0" : 363.7407228036036, + "99.0" : 363.7407228036036, + "99.9" : 363.7407228036036, + "99.99" : 363.7407228036036, + "99.999" : 363.7407228036036, + "99.9999" : 363.7407228036036, + "100.0" : 363.7407228036036 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 356.689066988444, + 354.91358677221575, + 353.1615030892504, + 361.46710466415294, + 358.6659332639361 + ], + [ + 363.6880041301131, + 359.2738540730863, + 363.7407228036036, + 360.5808562393929, + 356.8114900437168 + ] + ] + }, + "secondaryMetrics" : { + } + } +] diff --git a/research/issue-67/raw/results-jdk25.json b/research/issue-67/raw/results-jdk25.json new file mode 100644 index 0000000..69a0893 --- /dev/null +++ b/research/issue-67/raw/results-jdk25.json @@ -0,0 +1,1490 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.2532805643754843, + "scoreError" : 0.039091759130486924, + "scoreConfidence" : [ + 2.2141888052449974, + 2.292372323505971 + ], + "scorePercentiles" : { + "0.0" : 2.215506542805391, + "50.0" : 2.2515918388820912, + "90.0" : 2.2965518190745304, + "95.0" : 2.2977298454811703, + "99.0" : 2.2977298454811703, + "99.9" : 2.2977298454811703, + "99.99" : 2.2977298454811703, + "99.999" : 2.2977298454811703, + "99.9999" : 2.2977298454811703, + "100.0" : 2.2977298454811703 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.233089857869085, + 2.2977298454811703, + 2.262409241378738, + 2.2298218073566383, + 2.266983668275838 + ], + [ + 2.285949581414771, + 2.2381314214090273, + 2.245150137452601, + 2.215506542805391, + 2.2580335403115814 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.2552545138906916, + "scoreError" : 0.027431053191989067, + "scoreConfidence" : [ + 2.2278234606987026, + 2.2826855670826807 + ], + "scorePercentiles" : { + "0.0" : 2.2270993565693487, + "50.0" : 2.25675013399081, + "90.0" : 2.286981891775343, + "95.0" : 2.2886317732393877, + "99.0" : 2.2886317732393877, + "99.9" : 2.2886317732393877, + "99.99" : 2.2886317732393877, + "99.999" : 2.2886317732393877, + "99.9999" : 2.2886317732393877, + "100.0" : 2.2886317732393877 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.2576601364205504, + 2.2400333630539127, + 2.255121057368562, + 2.2721329585989376, + 2.2558401315610697 + ], + [ + 2.2270993565693487, + 2.258880975983375, + 2.2338942739473406, + 2.263251112164425, + 2.2886317732393877 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.5506598079337963, + "scoreError" : 0.0354837797777491, + "scoreConfidence" : [ + 2.515176028156047, + 2.5861435877115455 + ], + "scorePercentiles" : { + "0.0" : 2.5248846580101416, + "50.0" : 2.548807750894693, + "90.0" : 2.591234919458527, + "95.0" : 2.5924912578854094, + "99.0" : 2.5924912578854094, + "99.9" : 2.5924912578854094, + "99.99" : 2.5924912578854094, + "99.999" : 2.5924912578854094, + "99.9999" : 2.5924912578854094, + "100.0" : 2.5924912578854094 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.5276358312588814, + 2.579927873616587, + 2.5248846580101416, + 2.530735280721697, + 2.530520894182612 + ], + [ + 2.5550141214775377, + 2.5924912578854094, + 2.5569283929872713, + 2.5658583888859794, + 2.542601380311849 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.5723617422894707, + "scoreError" : 0.03590992017483338, + "scoreConfidence" : [ + 2.5364518221146373, + 2.608271662464304 + ], + "scorePercentiles" : { + "0.0" : 2.545602004066211, + "50.0" : 2.5603347924976916, + "90.0" : 2.6204465221360076, + "95.0" : 2.6232566025884223, + "99.0" : 2.6232566025884223, + "99.9" : 2.6232566025884223, + "99.99" : 2.6232566025884223, + "99.999" : 2.6232566025884223, + "99.9999" : 2.6232566025884223, + "100.0" : 2.6232566025884223 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.5951557980642734, + 2.545602004066211, + 2.6232566025884223, + 2.5581345593001066, + 2.5594062417095187 + ], + [ + 2.560233153299823, + 2.588527657338205, + 2.577841617714963, + 2.555023357117621, + 2.560436431695561 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 5.243190414496563, + "scoreError" : 0.0677288742534086, + "scoreConfidence" : [ + 5.175461540243154, + 5.310919288749972 + ], + "scorePercentiles" : { + "0.0" : 5.176359163042727, + "50.0" : 5.244540687341767, + "90.0" : 5.334807740897845, + "95.0" : 5.343196407521046, + "99.0" : 5.343196407521046, + "99.9" : 5.343196407521046, + "99.99" : 5.343196407521046, + "99.999" : 5.343196407521046, + "99.9999" : 5.343196407521046, + "100.0" : 5.343196407521046 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.233424799825537, + 5.22187149916685, + 5.343196407521046, + 5.236756908297018, + 5.252324466386517 + ], + [ + 5.195372339879096, + 5.259309741289033, + 5.176359163042727, + 5.259031412217144, + 5.25425740734066 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 5.278596277104297, + "scoreError" : 0.1511076537448161, + "scoreConfidence" : [ + 5.127488623359481, + 5.429703930849113 + ], + "scorePercentiles" : { + "0.0" : 5.155652518624207, + "50.0" : 5.2444103118511105, + "90.0" : 5.505929475275121, + "95.0" : 5.524665650068238, + "99.0" : 5.524665650068238, + "99.9" : 5.524665650068238, + "99.99" : 5.524665650068238, + "99.999" : 5.524665650068238, + "99.9999" : 5.524665650068238, + "100.0" : 5.524665650068238 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 5.225718683091775, + 5.247661017834626, + 5.228253772077546, + 5.524665650068238, + 5.279594819459429 + ], + [ + 5.155652518624207, + 5.337303902137064, + 5.233975684634829, + 5.311977117247665, + 5.241159605867594 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 9.28425587110276, + "scoreError" : 0.15512632613853583, + "scoreConfidence" : [ + 9.129129544964224, + 9.439382197241295 + ], + "scorePercentiles" : { + "0.0" : 9.102157341882762, + "50.0" : 9.298559929366117, + "90.0" : 9.414850092796941, + "95.0" : 9.420281166204338, + "99.0" : 9.420281166204338, + "99.9" : 9.420281166204338, + "99.99" : 9.420281166204338, + "99.999" : 9.420281166204338, + "99.9999" : 9.420281166204338, + "100.0" : 9.420281166204338 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 9.274447821764534, + 9.250463220187633, + 9.365970432130373, + 9.13688222249955, + 9.102157341882762 + ], + [ + 9.420281166204338, + 9.361207042419078, + 9.322672036967699, + 9.355520776103218, + 9.252956650868402 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 9.327773211229323, + "scoreError" : 0.13081623246841234, + "scoreConfidence" : [ + 9.19695697876091, + 9.458589443697734 + ], + "scorePercentiles" : { + "0.0" : 9.240649969098389, + "50.0" : 9.302406085116527, + "90.0" : 9.47871575551012, + "95.0" : 9.48617984036394, + "99.0" : 9.48617984036394, + "99.9" : 9.48617984036394, + "99.99" : 9.48617984036394, + "99.999" : 9.48617984036394, + "99.9999" : 9.48617984036394, + "100.0" : 9.48617984036394 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 9.254052553744751, + 9.315408073801667, + 9.370369737504847, + 9.409888740317212, + 9.48617984036394 + ], + [ + 9.248547248744094, + 9.240649969098389, + 9.411538991825726, + 9.289404096431387, + 9.251692860461212 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 58.175308335985406, + "scoreError" : 1.463461698642683, + "scoreConfidence" : [ + 56.711846637342724, + 59.63877003462809 + ], + "scorePercentiles" : { + "0.0" : 57.50653043953951, + "50.0" : 57.89170391900723, + "90.0" : 60.48241171702306, + "95.0" : 60.661294474952875, + "99.0" : 60.661294474952875, + "99.9" : 60.661294474952875, + "99.99" : 60.661294474952875, + "99.999" : 60.661294474952875, + "99.9999" : 60.661294474952875, + "100.0" : 60.661294474952875 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 58.02856860096857, + 58.073056515358395, + 57.60639752080003, + 57.5634311037589, + 57.5332116716547 + ], + [ + 57.50653043953951, + 60.661294474952875, + 58.87246689565477, + 58.15328690012048, + 57.75483923704589 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 58.87297762865908, + "scoreError" : 0.7219333171137329, + "scoreConfidence" : [ + 58.15104431154535, + 59.59491094577281 + ], + "scorePercentiles" : { + "0.0" : 58.02141293964041, + "50.0" : 58.98303745443211, + "90.0" : 59.39176915634423, + "95.0" : 59.39989038089374, + "99.0" : 59.39989038089374, + "99.9" : 59.39989038089374, + "99.99" : 59.39989038089374, + "99.999" : 59.39989038089374, + "99.9999" : 59.39989038089374, + "100.0" : 59.39989038089374 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 58.91413108974038, + 59.226821018153785, + 58.209271524720435, + 59.1953408572834, + 58.02141293964041 + ], + [ + 59.051943819123835, + 59.318678135398656, + 58.90210141808179, + 59.39989038089374, + 58.490185103554396 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 217.42413801457673, + "scoreError" : 2.051774850621203, + "scoreConfidence" : [ + 215.37236316395553, + 219.47591286519793 + ], + "scorePercentiles" : { + "0.0" : 215.2856258752665, + "50.0" : 217.7643457568352, + "90.0" : 219.03249599881124, + "95.0" : 219.0443235568853, + "99.0" : 219.0443235568853, + "99.9" : 219.0443235568853, + "99.99" : 219.0443235568853, + "99.999" : 219.0443235568853, + "99.9999" : 219.0443235568853, + "100.0" : 219.0443235568853 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 219.0443235568853, + 215.2856258752665, + 218.92604797614456, + 216.41340011959912, + 217.75277490625538 + ], + [ + 217.77591660741507, + 215.5138590270028, + 218.7327054447134, + 216.89543779235402, + 217.90128884013103 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 226.19156847510126, + "scoreError" : 4.090567959541127, + "scoreConfidence" : [ + 222.10100051556014, + 230.28213643464238 + ], + "scorePercentiles" : { + "0.0" : 222.52227403512254, + "50.0" : 225.72055654185957, + "90.0" : 230.3665121105654, + "95.0" : 230.3997039639267, + "99.0" : 230.3997039639267, + "99.9" : 230.3997039639267, + "99.99" : 230.3997039639267, + "99.999" : 230.3997039639267, + "99.9999" : 230.3997039639267, + "100.0" : 230.3997039639267 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 227.0384955212068, + 224.52659395125718, + 224.27957424158924, + 224.89717233592006, + 226.54394074779907 + ], + [ + 230.0677854303137, + 223.53235927079814, + 230.3997039639267, + 222.52227403512254, + 228.10778525307921 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.6389835279659684, + "scoreError" : 0.045576869611622176, + "scoreConfidence" : [ + 2.593406658354346, + 2.6845603975775907 + ], + "scorePercentiles" : { + "0.0" : 2.5850013815374404, + "50.0" : 2.639225647165664, + "90.0" : 2.6888311971848053, + "95.0" : 2.691511233196144, + "99.0" : 2.691511233196144, + "99.9" : 2.691511233196144, + "99.99" : 2.691511233196144, + "99.999" : 2.691511233196144, + "99.9999" : 2.691511233196144, + "100.0" : 2.691511233196144 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.6173355650960093, + 2.6335682683483, + 2.5850013815374404, + 2.691511233196144, + 2.6394396920238523 + ], + [ + 2.6098730488494835, + 2.6390116023074754, + 2.6647108730827567, + 2.6562675268631617, + 2.6531160883550604 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "8", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.6511253751751633, + "scoreError" : 0.07283725095847653, + "scoreConfidence" : [ + 2.578288124216687, + 2.72396262613364 + ], + "scorePercentiles" : { + "0.0" : 2.588387901044044, + "50.0" : 2.654983148211075, + "90.0" : 2.728807665847352, + "95.0" : 2.7325001668910214, + "99.0" : 2.7325001668910214, + "99.9" : 2.7325001668910214, + "99.99" : 2.7325001668910214, + "99.999" : 2.7325001668910214, + "99.9999" : 2.7325001668910214, + "100.0" : 2.7325001668910214 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.678431307764877, + 2.6832228254135417, + 2.6955751564543307, + 2.7325001668910214, + 2.671920713150256 + ], + [ + 2.588387901044044, + 2.6211372554597365, + 2.6380455832718943, + 2.6062784549440376, + 2.595754387357897 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 2.928727371363295, + "scoreError" : 0.08893090258702649, + "scoreConfidence" : [ + 2.8397964687762687, + 3.0176582739503215 + ], + "scorePercentiles" : { + "0.0" : 2.8199153266917647, + "50.0" : 2.9327036075363107, + "90.0" : 3.005844894109203, + "95.0" : 3.0059022252235374, + "99.0" : 3.0059022252235374, + "99.9" : 3.0059022252235374, + "99.99" : 3.0059022252235374, + "99.999" : 3.0059022252235374, + "99.9999" : 3.0059022252235374, + "100.0" : 3.0059022252235374 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.9691037964366878, + 2.8912885056706084, + 2.9153343007372396, + 2.8199153266917647, + 2.867761297539233 + ], + [ + 3.0059022252235374, + 2.9472321321810675, + 2.9420451369169927, + 2.9233620781556287, + 3.0053289140801915 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "16", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 2.9107508920707166, + "scoreError" : 0.07882507743100899, + "scoreConfidence" : [ + 2.8319258146397077, + 2.9895759695017254 + ], + "scorePercentiles" : { + "0.0" : 2.845546195563729, + "50.0" : 2.895055131205348, + "90.0" : 3.007507747319725, + "95.0" : 3.0135361214943446, + "99.0" : 3.0135361214943446, + "99.9" : 3.0135361214943446, + "99.99" : 3.0135361214943446, + "99.999" : 3.0135361214943446, + "99.9999" : 3.0135361214943446, + "100.0" : 3.0135361214943446 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 2.9468233206091234, + 2.911924505636409, + 2.941897257040418, + 3.0135361214943446, + 2.9532523797481502 + ], + [ + 2.875382858518873, + 2.845546195563729, + 2.8677513073034926, + 2.8781857567742866, + 2.873209218018341 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 6.421405382440909, + "scoreError" : 0.2625676458531426, + "scoreConfidence" : [ + 6.158837736587767, + 6.6839730282940515 + ], + "scorePercentiles" : { + "0.0" : 6.3031854724788, + "50.0" : 6.373935806131226, + "90.0" : 6.837298568447582, + "95.0" : 6.868328452452032, + "99.0" : 6.868328452452032, + "99.9" : 6.868328452452032, + "99.99" : 6.868328452452032, + "99.999" : 6.868328452452032, + "99.9999" : 6.868328452452032, + "100.0" : 6.868328452452032 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 6.3031854724788, + 6.324485884148902, + 6.31553058892561, + 6.367330170012992, + 6.311605393658213 + ], + [ + 6.868328452452032, + 6.558029612407527, + 6.383758919796362, + 6.401257888279191, + 6.38054144224946 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "64", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 6.549510832790155, + "scoreError" : 0.15761929430146884, + "scoreConfidence" : [ + 6.391891538488686, + 6.707130127091624 + ], + "scorePercentiles" : { + "0.0" : 6.427873722402822, + "50.0" : 6.520412833387149, + "90.0" : 6.733609143656767, + "95.0" : 6.737810637812478, + "99.0" : 6.737810637812478, + "99.9" : 6.737810637812478, + "99.99" : 6.737810637812478, + "99.999" : 6.737810637812478, + "99.9999" : 6.737810637812478, + "100.0" : 6.737810637812478 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 6.501775171126128, + 6.5090889420592655, + 6.472952078774841, + 6.427873722402822, + 6.442876803712855 + ], + [ + 6.617674011076478, + 6.531736724715032, + 6.6957956962553675, + 6.737810637812478, + 6.557524539966279 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 11.556289076456354, + "scoreError" : 0.14331349782061553, + "scoreConfidence" : [ + 11.412975578635738, + 11.69960257427697 + ], + "scorePercentiles" : { + "0.0" : 11.434575671327789, + "50.0" : 11.53818950818122, + "90.0" : 11.72721731151168, + "95.0" : 11.730368748118833, + "99.0" : 11.730368748118833, + "99.9" : 11.730368748118833, + "99.99" : 11.730368748118833, + "99.999" : 11.730368748118833, + "99.9999" : 11.730368748118833, + "100.0" : 11.730368748118833 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 11.53220704525304, + 11.730368748118833, + 11.483692097267152, + 11.506642373340172, + 11.600840788845696 + ], + [ + 11.544907776485124, + 11.486629910769016, + 11.698854382047308, + 11.434575671327789, + 11.544171971109401 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "128", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 11.953926848534547, + "scoreError" : 0.16820805084241394, + "scoreConfidence" : [ + 11.785718797692132, + 12.122134899376961 + ], + "scorePercentiles" : { + "0.0" : 11.736078470804086, + "50.0" : 11.95680841489828, + "90.0" : 12.14540066591131, + "95.0" : 12.154412700279245, + "99.0" : 12.154412700279245, + "99.9" : 12.154412700279245, + "99.99" : 12.154412700279245, + "99.999" : 12.154412700279245, + "99.9999" : 12.154412700279245, + "100.0" : 12.154412700279245 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 11.964569850420023, + 11.964228942233596, + 11.865399130058272, + 11.949387887562962, + 11.92414138294399 + ], + [ + 12.154412700279245, + 12.064292356599895, + 11.922528573385673, + 11.994229191057729, + 11.736078470804086 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 91.49390547056063, + "scoreError" : 0.9114828686701805, + "scoreConfidence" : [ + 90.58242260189046, + 92.40538833923081 + ], + "scorePercentiles" : { + "0.0" : 90.69342255750992, + "50.0" : 91.4613662700062, + "90.0" : 92.48939202473741, + "95.0" : 92.49561550563298, + "99.0" : 92.49561550563298, + "99.9" : 92.49561550563298, + "99.99" : 92.49561550563298, + "99.999" : 92.49561550563298, + "99.9999" : 92.49561550563298, + "100.0" : 92.49561550563298 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 91.05115431607544, + 91.65873840834229, + 91.23009003032134, + 90.85081675777073, + 90.69342255750992 + ], + [ + 92.43338069667733, + 92.49561550563298, + 91.3516623398773, + 91.6031038932639, + 91.5710702001351 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "1024", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 92.72936320747445, + "scoreError" : 1.565146312111046, + "scoreConfidence" : [ + 91.16421689536341, + 94.29450951958549 + ], + "scorePercentiles" : { + "0.0" : 91.51730685212006, + "50.0" : 92.53937073920667, + "90.0" : 94.95128177368022, + "95.0" : 95.10961111866496, + "99.0" : 95.10961111866496, + "99.9" : 95.10961111866496, + "99.99" : 95.10961111866496, + "99.999" : 95.10961111866496, + "99.9999" : 95.10961111866496, + "100.0" : 95.10961111866496 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 92.3645971852709, + 92.34330979576545, + 93.0422245843691, + 92.48606556392089, + 95.10961111866496 + ], + [ + 91.53934106817542, + 91.51730685212006, + 93.52631766881765, + 92.59267591449247, + 92.77218232314763 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "0" + }, + "primaryMetric" : { + "score" : 299.68574889815875, + "scoreError" : 6.361573570388821, + "scoreConfidence" : [ + 293.3241753277699, + 306.0473224685476 + ], + "scorePercentiles" : { + "0.0" : 295.7693716585681, + "50.0" : 298.3161556048606, + "90.0" : 308.253348614852, + "95.0" : 308.70618488293354, + "99.0" : 308.70618488293354, + "99.9" : 308.70618488293354, + "99.99" : 308.70618488293354, + "99.999" : 308.70618488293354, + "99.9999" : 308.70618488293354, + "100.0" : 308.70618488293354 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 304.1778222021178, + 300.98036663627914, + 308.70618488293354, + 295.8703813257011, + 297.5965162599328 + ], + [ + 295.96296883654213, + 301.30213993757184, + 297.4559422921531, + 299.03579494978845, + 295.7693716585681 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/usr/lib/jvm/java-25-openjdk-amd64/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "25.0.3", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "25.0.3+9-2-24.04.2-Ubuntu", + "warmupIterations" : 3, + "warmupTime" : "500 ms", + "warmupBatchSize" : 1, + "measurementIterations" : 5, + "measurementTime" : "500 ms", + "measurementBatchSize" : 1, + "params" : { + "length" : "4096", + "startAlign" : "1" + }, + "primaryMetric" : { + "score" : 301.6941821490189, + "scoreError" : 5.2490861128871265, + "scoreConfidence" : [ + 296.44509603613176, + 306.94326826190604 + ], + "scorePercentiles" : { + "0.0" : 297.50813408966826, + "50.0" : 300.8595810599954, + "90.0" : 307.7952307633854, + "95.0" : 308.0111983696238, + "99.0" : 308.0111983696238, + "99.9" : 308.0111983696238, + "99.99" : 308.0111983696238, + "99.999" : 308.0111983696238, + "99.9999" : 308.0111983696238, + "100.0" : 308.0111983696238 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 305.85152230723986, + 308.0111983696238, + 304.1380969378479, + 301.84502644844935, + 298.2582758674144 + ], + [ + 302.83455467391354, + 299.3046531835493, + 299.3162239409412, + 299.8741356715414, + 297.50813408966826 + ] + ] + }, + "secondaryMetrics" : { + } + } +] diff --git a/research/issue-67/raw/run-jdk11.log b/research/issue-67/raw/run-jdk11.log new file mode 100644 index 0000000..8ac83c3 --- /dev/null +++ b/research/issue-67/raw/run-jdk11.log @@ -0,0 +1,1043 @@ +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 0.00% complete, ETA 00:03:12 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.173 ns/op +# Warmup Iteration 2: 3.148 ns/op +# Warmup Iteration 3: 3.057 ns/op +Iteration 1: 2.848 ns/op +Iteration 2: 3.051 ns/op +Iteration 3: 2.898 ns/op +Iteration 4: 2.915 ns/op +Iteration 5: 2.912 ns/op + +# Run progress: 2.08% complete, ETA 00:03:15 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.171 ns/op +# Warmup Iteration 2: 3.138 ns/op +# Warmup Iteration 3: 2.923 ns/op +Iteration 1: 2.923 ns/op +Iteration 2: 2.934 ns/op +Iteration 3: 2.901 ns/op +Iteration 4: 2.889 ns/op +Iteration 5: 2.884 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.915 ±(99.9%) 0.080 ns/op [Average] + (min, avg, max) = (2.848, 2.915, 3.051), stdev = 0.053 + CI (99.9%): [2.835, 2.996] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 4.17% complete, ETA 00:03:11 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.116 ns/op +# Warmup Iteration 2: 3.142 ns/op +# Warmup Iteration 3: 3.018 ns/op +Iteration 1: 2.876 ns/op +Iteration 2: 2.854 ns/op +Iteration 3: 2.850 ns/op +Iteration 4: 2.851 ns/op +Iteration 5: 2.913 ns/op + +# Run progress: 6.25% complete, ETA 00:03:06 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.117 ns/op +# Warmup Iteration 2: 3.145 ns/op +# Warmup Iteration 3: 2.851 ns/op +Iteration 1: 2.892 ns/op +Iteration 2: 2.886 ns/op +Iteration 3: 2.927 ns/op +Iteration 4: 2.921 ns/op +Iteration 5: 2.879 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.885 ±(99.9%) 0.043 ns/op [Average] + (min, avg, max) = (2.850, 2.885, 2.927), stdev = 0.029 + CI (99.9%): [2.842, 2.928] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 8.33% complete, ETA 00:03:02 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.293 ns/op +# Warmup Iteration 2: 3.251 ns/op +# Warmup Iteration 3: 3.051 ns/op +Iteration 1: 3.081 ns/op +Iteration 2: 3.056 ns/op +Iteration 3: 3.030 ns/op +Iteration 4: 3.054 ns/op +Iteration 5: 3.043 ns/op + +# Run progress: 10.42% complete, ETA 00:02:58 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.363 ns/op +# Warmup Iteration 2: 3.307 ns/op +# Warmup Iteration 3: 3.063 ns/op +Iteration 1: 3.091 ns/op +Iteration 2: 3.101 ns/op +Iteration 3: 3.094 ns/op +Iteration 4: 3.038 ns/op +Iteration 5: 3.223 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 3.081 ±(99.9%) 0.084 ns/op [Average] + (min, avg, max) = (3.030, 3.081, 3.223), stdev = 0.056 + CI (99.9%): [2.997, 3.166] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 12.50% complete, ETA 00:02:54 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.397 ns/op +# Warmup Iteration 2: 3.320 ns/op +# Warmup Iteration 3: 3.082 ns/op +Iteration 1: 3.078 ns/op +Iteration 2: 3.075 ns/op +Iteration 3: 3.079 ns/op +Iteration 4: 3.116 ns/op +Iteration 5: 3.094 ns/op + +# Run progress: 14.58% complete, ETA 00:02:50 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.338 ns/op +# Warmup Iteration 2: 3.236 ns/op +# Warmup Iteration 3: 3.105 ns/op +Iteration 1: 3.015 ns/op +Iteration 2: 3.025 ns/op +Iteration 3: 3.010 ns/op +Iteration 4: 3.043 ns/op +Iteration 5: 3.031 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 3.057 ±(99.9%) 0.055 ns/op [Average] + (min, avg, max) = (3.010, 3.057, 3.116), stdev = 0.036 + CI (99.9%): [3.002, 3.111] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 16.67% complete, ETA 00:02:45 +# Fork: 1 of 2 +# Warmup Iteration 1: 6.702 ns/op +# Warmup Iteration 2: 6.556 ns/op +# Warmup Iteration 3: 5.687 ns/op +Iteration 1: 5.684 ns/op +Iteration 2: 5.686 ns/op +Iteration 3: 5.645 ns/op +Iteration 4: 5.734 ns/op +Iteration 5: 5.625 ns/op + +# Run progress: 18.75% complete, ETA 00:02:41 +# Fork: 2 of 2 +# Warmup Iteration 1: 6.702 ns/op +# Warmup Iteration 2: 6.940 ns/op +# Warmup Iteration 3: 5.580 ns/op +Iteration 1: 5.655 ns/op +Iteration 2: 6.005 ns/op +Iteration 3: 6.235 ns/op +Iteration 4: 5.877 ns/op +Iteration 5: 5.848 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.799 ±(99.9%) 0.297 ns/op [Average] + (min, avg, max) = (5.625, 5.799, 6.235), stdev = 0.196 + CI (99.9%): [5.503, 6.096] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 20.83% complete, ETA 00:02:37 +# Fork: 1 of 2 +# Warmup Iteration 1: 6.820 ns/op +# Warmup Iteration 2: 6.746 ns/op +# Warmup Iteration 3: 5.634 ns/op +Iteration 1: 5.753 ns/op +Iteration 2: 5.679 ns/op +Iteration 3: 5.639 ns/op +Iteration 4: 5.706 ns/op +Iteration 5: 5.658 ns/op + +# Run progress: 22.92% complete, ETA 00:02:33 +# Fork: 2 of 2 +# Warmup Iteration 1: 6.810 ns/op +# Warmup Iteration 2: 6.636 ns/op +# Warmup Iteration 3: 5.642 ns/op +Iteration 1: 5.792 ns/op +Iteration 2: 5.760 ns/op +Iteration 3: 5.757 ns/op +Iteration 4: 5.802 ns/op +Iteration 5: 5.724 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.727 ±(99.9%) 0.084 ns/op [Average] + (min, avg, max) = (5.639, 5.727, 5.802), stdev = 0.056 + CI (99.9%): [5.643, 5.811] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 25.00% complete, ETA 00:02:29 +# Fork: 1 of 2 +# Warmup Iteration 1: 10.491 ns/op +# Warmup Iteration 2: 10.248 ns/op +# Warmup Iteration 3: 9.864 ns/op +Iteration 1: 9.934 ns/op +Iteration 2: 9.983 ns/op +Iteration 3: 9.828 ns/op +Iteration 4: 10.204 ns/op +Iteration 5: 9.925 ns/op + +# Run progress: 27.08% complete, ETA 00:02:25 +# Fork: 2 of 2 +# Warmup Iteration 1: 10.478 ns/op +# Warmup Iteration 2: 10.557 ns/op +# Warmup Iteration 3: 9.949 ns/op +Iteration 1: 9.932 ns/op +Iteration 2: 9.921 ns/op +Iteration 3: 9.978 ns/op +Iteration 4: 9.890 ns/op +Iteration 5: 9.969 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 9.956 ±(99.9%) 0.149 ns/op [Average] + (min, avg, max) = (9.828, 9.956, 10.204), stdev = 0.098 + CI (99.9%): [9.808, 10.105] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 29.17% complete, ETA 00:02:20 +# Fork: 1 of 2 +# Warmup Iteration 1: 10.601 ns/op +# Warmup Iteration 2: 10.310 ns/op +# Warmup Iteration 3: 9.880 ns/op +Iteration 1: 10.163 ns/op +Iteration 2: 9.980 ns/op +Iteration 3: 9.947 ns/op +Iteration 4: 9.884 ns/op +Iteration 5: 9.993 ns/op + +# Run progress: 31.25% complete, ETA 00:02:16 +# Fork: 2 of 2 +# Warmup Iteration 1: 10.667 ns/op +# Warmup Iteration 2: 10.433 ns/op +# Warmup Iteration 3: 10.006 ns/op +Iteration 1: 9.979 ns/op +Iteration 2: 9.976 ns/op +Iteration 3: 10.036 ns/op +Iteration 4: 9.883 ns/op +Iteration 5: 9.961 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 9.980 ±(99.9%) 0.120 ns/op [Average] + (min, avg, max) = (9.883, 9.980, 10.163), stdev = 0.080 + CI (99.9%): [9.860, 10.100] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 33.33% complete, ETA 00:02:12 +# Fork: 1 of 2 +# Warmup Iteration 1: 64.711 ns/op +# Warmup Iteration 2: 63.979 ns/op +# Warmup Iteration 3: 63.603 ns/op +Iteration 1: 63.009 ns/op +Iteration 2: 62.882 ns/op +Iteration 3: 63.803 ns/op +Iteration 4: 64.300 ns/op +Iteration 5: 64.364 ns/op + +# Run progress: 35.42% complete, ETA 00:02:08 +# Fork: 2 of 2 +# Warmup Iteration 1: 65.601 ns/op +# Warmup Iteration 2: 62.983 ns/op +# Warmup Iteration 3: 62.889 ns/op +Iteration 1: 62.564 ns/op +Iteration 2: 63.068 ns/op +Iteration 3: 63.701 ns/op +Iteration 4: 63.306 ns/op +Iteration 5: 62.614 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 63.361 ±(99.9%) 0.987 ns/op [Average] + (min, avg, max) = (62.564, 63.361, 64.364), stdev = 0.653 + CI (99.9%): [62.374, 64.348] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 37.50% complete, ETA 00:02:04 +# Fork: 1 of 2 +# Warmup Iteration 1: 71.696 ns/op +# Warmup Iteration 2: 65.875 ns/op +# Warmup Iteration 3: 65.444 ns/op +Iteration 1: 64.739 ns/op +Iteration 2: 65.396 ns/op +Iteration 3: 64.724 ns/op +Iteration 4: 65.437 ns/op +Iteration 5: 65.459 ns/op + +# Run progress: 39.58% complete, ETA 00:02:00 +# Fork: 2 of 2 +# Warmup Iteration 1: 77.079 ns/op +# Warmup Iteration 2: 74.789 ns/op +# Warmup Iteration 3: 77.910 ns/op +Iteration 1: 76.796 ns/op +Iteration 2: 78.437 ns/op +Iteration 3: 77.804 ns/op +Iteration 4: 78.901 ns/op +Iteration 5: 76.982 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 71.468 ±(99.9%) 10.115 ns/op [Average] + (min, avg, max) = (64.724, 71.468, 78.901), stdev = 6.690 + CI (99.9%): [61.353, 81.582] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 41.67% complete, ETA 00:01:56 +# Fork: 1 of 2 +# Warmup Iteration 1: 268.689 ns/op +# Warmup Iteration 2: 249.789 ns/op +# Warmup Iteration 3: 254.922 ns/op +Iteration 1: 255.463 ns/op +Iteration 2: 258.539 ns/op +Iteration 3: 254.412 ns/op +Iteration 4: 255.004 ns/op +Iteration 5: 254.727 ns/op + +# Run progress: 43.75% complete, ETA 00:01:51 +# Fork: 2 of 2 +# Warmup Iteration 1: 269.492 ns/op +# Warmup Iteration 2: 256.614 ns/op +# Warmup Iteration 3: 256.658 ns/op +Iteration 1: 252.535 ns/op +Iteration 2: 252.808 ns/op +Iteration 3: 254.198 ns/op +Iteration 4: 249.914 ns/op +Iteration 5: 249.641 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 253.724 ±(99.9%) 4.000 ns/op [Average] + (min, avg, max) = (249.641, 253.724, 258.539), stdev = 2.646 + CI (99.9%): [249.724, 257.724] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 45.83% complete, ETA 00:01:47 +# Fork: 1 of 2 +# Warmup Iteration 1: 273.437 ns/op +# Warmup Iteration 2: 255.365 ns/op +# Warmup Iteration 3: 252.717 ns/op +Iteration 1: 256.211 ns/op +Iteration 2: 259.065 ns/op +Iteration 3: 254.942 ns/op +Iteration 4: 256.127 ns/op +Iteration 5: 254.709 ns/op + +# Run progress: 47.92% complete, ETA 00:01:43 +# Fork: 2 of 2 +# Warmup Iteration 1: 275.732 ns/op +# Warmup Iteration 2: 260.899 ns/op +# Warmup Iteration 3: 257.301 ns/op +Iteration 1: 259.025 ns/op +Iteration 2: 256.438 ns/op +Iteration 3: 262.719 ns/op +Iteration 4: 254.148 ns/op +Iteration 5: 254.437 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 256.782 ±(99.9%) 4.109 ns/op [Average] + (min, avg, max) = (254.148, 256.782, 262.719), stdev = 2.718 + CI (99.9%): [252.673, 260.891] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 50.00% complete, ETA 00:01:39 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.711 ns/op +# Warmup Iteration 2: 3.493 ns/op +# Warmup Iteration 3: 3.115 ns/op +Iteration 1: 3.154 ns/op +Iteration 2: 3.076 ns/op +Iteration 3: 3.083 ns/op +Iteration 4: 3.080 ns/op +Iteration 5: 3.086 ns/op + +# Run progress: 52.08% complete, ETA 00:01:35 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.605 ns/op +# Warmup Iteration 2: 3.514 ns/op +# Warmup Iteration 3: 3.088 ns/op +Iteration 1: 3.060 ns/op +Iteration 2: 3.076 ns/op +Iteration 3: 3.103 ns/op +Iteration 4: 3.141 ns/op +Iteration 5: 3.110 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 3.097 ±(99.9%) 0.046 ns/op [Average] + (min, avg, max) = (3.060, 3.097, 3.154), stdev = 0.030 + CI (99.9%): [3.051, 3.143] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 54.17% complete, ETA 00:01:31 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.760 ns/op +# Warmup Iteration 2: 3.507 ns/op +# Warmup Iteration 3: 3.105 ns/op +Iteration 1: 3.057 ns/op +Iteration 2: 3.064 ns/op +Iteration 3: 3.050 ns/op +Iteration 4: 3.043 ns/op +Iteration 5: 3.064 ns/op + +# Run progress: 56.25% complete, ETA 00:01:27 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.566 ns/op +# Warmup Iteration 2: 3.519 ns/op +# Warmup Iteration 3: 3.138 ns/op +Iteration 1: 3.114 ns/op +Iteration 2: 3.105 ns/op +Iteration 3: 3.285 ns/op +Iteration 4: 3.131 ns/op +Iteration 5: 3.045 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 3.096 ±(99.9%) 0.111 ns/op [Average] + (min, avg, max) = (3.043, 3.096, 3.285), stdev = 0.073 + CI (99.9%): [2.985, 3.207] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 58.33% complete, ETA 00:01:22 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.818 ns/op +# Warmup Iteration 2: 3.630 ns/op +# Warmup Iteration 3: 3.474 ns/op +Iteration 1: 3.661 ns/op +Iteration 2: 3.504 ns/op +Iteration 3: 3.479 ns/op +Iteration 4: 3.657 ns/op +Iteration 5: 3.420 ns/op + +# Run progress: 60.42% complete, ETA 00:01:18 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.717 ns/op +# Warmup Iteration 2: 3.637 ns/op +# Warmup Iteration 3: 3.413 ns/op +Iteration 1: 3.489 ns/op +Iteration 2: 3.474 ns/op +Iteration 3: 3.470 ns/op +Iteration 4: 3.512 ns/op +Iteration 5: 3.484 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 3.515 ±(99.9%) 0.121 ns/op [Average] + (min, avg, max) = (3.420, 3.515, 3.661), stdev = 0.080 + CI (99.9%): [3.394, 3.636] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 62.50% complete, ETA 00:01:14 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.784 ns/op +# Warmup Iteration 2: 3.685 ns/op +# Warmup Iteration 3: 3.455 ns/op +Iteration 1: 3.445 ns/op +Iteration 2: 3.467 ns/op +Iteration 3: 3.492 ns/op +Iteration 4: 3.507 ns/op +Iteration 5: 3.478 ns/op + +# Run progress: 64.58% complete, ETA 00:01:10 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.813 ns/op +# Warmup Iteration 2: 3.867 ns/op +# Warmup Iteration 3: 3.684 ns/op +Iteration 1: 3.465 ns/op +Iteration 2: 3.521 ns/op +Iteration 3: 3.517 ns/op +Iteration 4: 3.506 ns/op +Iteration 5: 3.531 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 3.493 ±(99.9%) 0.043 ns/op [Average] + (min, avg, max) = (3.445, 3.493, 3.531), stdev = 0.028 + CI (99.9%): [3.450, 3.536] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 66.67% complete, ETA 00:01:06 +# Fork: 1 of 2 +# Warmup Iteration 1: 7.686 ns/op +# Warmup Iteration 2: 7.578 ns/op +# Warmup Iteration 3: 7.608 ns/op +Iteration 1: 7.706 ns/op +Iteration 2: 7.382 ns/op +Iteration 3: 7.405 ns/op +Iteration 4: 7.372 ns/op +Iteration 5: 7.335 ns/op + +# Run progress: 68.75% complete, ETA 00:01:02 +# Fork: 2 of 2 +# Warmup Iteration 1: 7.577 ns/op +# Warmup Iteration 2: 7.503 ns/op +# Warmup Iteration 3: 7.236 ns/op +Iteration 1: 7.204 ns/op +Iteration 2: 7.178 ns/op +Iteration 3: 7.181 ns/op +Iteration 4: 7.291 ns/op +Iteration 5: 7.179 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 7.323 ±(99.9%) 0.245 ns/op [Average] + (min, avg, max) = (7.178, 7.323, 7.706), stdev = 0.162 + CI (99.9%): [7.078, 7.568] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 70.83% complete, ETA 00:00:58 +# Fork: 1 of 2 +# Warmup Iteration 1: 7.682 ns/op +# Warmup Iteration 2: 7.670 ns/op +# Warmup Iteration 3: 7.364 ns/op +Iteration 1: 7.208 ns/op +Iteration 2: 7.361 ns/op +Iteration 3: 7.320 ns/op +Iteration 4: 7.376 ns/op +Iteration 5: 7.445 ns/op + +# Run progress: 72.92% complete, ETA 00:00:53 +# Fork: 2 of 2 +# Warmup Iteration 1: 7.716 ns/op +# Warmup Iteration 2: 7.677 ns/op +# Warmup Iteration 3: 7.131 ns/op +Iteration 1: 7.119 ns/op +Iteration 2: 7.277 ns/op +Iteration 3: 7.212 ns/op +Iteration 4: 7.290 ns/op +Iteration 5: 7.156 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 7.276 ±(99.9%) 0.156 ns/op [Average] + (min, avg, max) = (7.119, 7.276, 7.445), stdev = 0.103 + CI (99.9%): [7.120, 7.432] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 75.00% complete, ETA 00:00:49 +# Fork: 1 of 2 +# Warmup Iteration 1: 13.119 ns/op +# Warmup Iteration 2: 12.861 ns/op +# Warmup Iteration 3: 12.243 ns/op +Iteration 1: 12.229 ns/op +Iteration 2: 12.239 ns/op +Iteration 3: 12.252 ns/op +Iteration 4: 12.167 ns/op +Iteration 5: 12.198 ns/op + +# Run progress: 77.08% complete, ETA 00:00:45 +# Fork: 2 of 2 +# Warmup Iteration 1: 13.207 ns/op +# Warmup Iteration 2: 12.953 ns/op +# Warmup Iteration 3: 12.267 ns/op +Iteration 1: 12.302 ns/op +Iteration 2: 12.269 ns/op +Iteration 3: 12.214 ns/op +Iteration 4: 12.231 ns/op +Iteration 5: 12.212 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 12.231 ±(99.9%) 0.057 ns/op [Average] + (min, avg, max) = (12.167, 12.231, 12.302), stdev = 0.038 + CI (99.9%): [12.174, 12.288] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 79.17% complete, ETA 00:00:41 +# Fork: 1 of 2 +# Warmup Iteration 1: 13.255 ns/op +# Warmup Iteration 2: 13.094 ns/op +# Warmup Iteration 3: 12.416 ns/op +Iteration 1: 12.514 ns/op +Iteration 2: 12.506 ns/op +Iteration 3: 12.267 ns/op +Iteration 4: 12.408 ns/op +Iteration 5: 12.308 ns/op + +# Run progress: 81.25% complete, ETA 00:00:37 +# Fork: 2 of 2 +# Warmup Iteration 1: 13.312 ns/op +# Warmup Iteration 2: 12.846 ns/op +# Warmup Iteration 3: 12.342 ns/op +Iteration 1: 12.231 ns/op +Iteration 2: 12.288 ns/op +Iteration 3: 12.285 ns/op +Iteration 4: 12.582 ns/op +Iteration 5: 12.371 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 12.376 ±(99.9%) 0.184 ns/op [Average] + (min, avg, max) = (12.231, 12.376, 12.582), stdev = 0.122 + CI (99.9%): [12.192, 12.560] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 83.33% complete, ETA 00:00:33 +# Fork: 1 of 2 +# Warmup Iteration 1: 115.322 ns/op +# Warmup Iteration 2: 111.508 ns/op +# Warmup Iteration 3: 112.845 ns/op +Iteration 1: 112.843 ns/op +Iteration 2: 117.094 ns/op +Iteration 3: 111.384 ns/op +Iteration 4: 111.868 ns/op +Iteration 5: 111.862 ns/op + +# Run progress: 85.42% complete, ETA 00:00:29 +# Fork: 2 of 2 +# Warmup Iteration 1: 81.710 ns/op +# Warmup Iteration 2: 78.567 ns/op +# Warmup Iteration 3: 79.221 ns/op +Iteration 1: 78.755 ns/op +Iteration 2: 79.165 ns/op +Iteration 3: 77.975 ns/op +Iteration 4: 79.829 ns/op +Iteration 5: 78.680 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 95.946 ±(99.9%) 27.306 ns/op [Average] + (min, avg, max) = (77.975, 95.946, 117.094), stdev = 18.061 + CI (99.9%): [68.640, 123.251] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 87.50% complete, ETA 00:00:24 +# Fork: 1 of 2 +# Warmup Iteration 1: 83.459 ns/op +# Warmup Iteration 2: 82.008 ns/op +# Warmup Iteration 3: 80.312 ns/op +Iteration 1: 79.838 ns/op +Iteration 2: 80.587 ns/op +Iteration 3: 80.255 ns/op +Iteration 4: 79.404 ns/op +Iteration 5: 79.603 ns/op + +# Run progress: 89.58% complete, ETA 00:00:20 +# Fork: 2 of 2 +# Warmup Iteration 1: 114.973 ns/op +# Warmup Iteration 2: 110.679 ns/op +# Warmup Iteration 3: 111.619 ns/op +Iteration 1: 113.303 ns/op +Iteration 2: 112.983 ns/op +Iteration 3: 111.417 ns/op +Iteration 4: 110.802 ns/op +Iteration 5: 116.351 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 96.454 ±(99.9%) 26.416 ns/op [Average] + (min, avg, max) = (79.404, 96.454, 116.351), stdev = 17.473 + CI (99.9%): [70.038, 122.870] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 91.67% complete, ETA 00:00:16 +# Fork: 1 of 2 +# Warmup Iteration 1: 309.083 ns/op +# Warmup Iteration 2: 290.918 ns/op +# Warmup Iteration 3: 282.767 ns/op +Iteration 1: 283.786 ns/op +Iteration 2: 286.263 ns/op +Iteration 3: 282.917 ns/op +Iteration 4: 284.553 ns/op +Iteration 5: 284.153 ns/op + +# Run progress: 93.75% complete, ETA 00:00:12 +# Fork: 2 of 2 +# Warmup Iteration 1: 307.516 ns/op +# Warmup Iteration 2: 288.049 ns/op +# Warmup Iteration 3: 286.253 ns/op +Iteration 1: 285.413 ns/op +Iteration 2: 285.002 ns/op +Iteration 3: 287.553 ns/op +Iteration 4: 292.968 ns/op +Iteration 5: 286.171 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 285.878 ±(99.9%) 4.281 ns/op [Average] + (min, avg, max) = (282.917, 285.878, 292.968), stdev = 2.831 + CI (99.9%): [281.597, 290.159] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 11.0.31, OpenJDK 64-Bit Server VM, 11.0.31+11-post-1ubuntu1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-11-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 95.83% complete, ETA 00:00:08 +# Fork: 1 of 2 +# Warmup Iteration 1: 337.251 ns/op +# Warmup Iteration 2: 292.664 ns/op +# Warmup Iteration 3: 300.677 ns/op +Iteration 1: 288.609 ns/op +Iteration 2: 295.608 ns/op +Iteration 3: 305.567 ns/op +Iteration 4: 290.167 ns/op +Iteration 5: 290.504 ns/op + +# Run progress: 97.92% complete, ETA 00:00:04 +# Fork: 2 of 2 +# Warmup Iteration 1: 310.673 ns/op +# Warmup Iteration 2: 293.245 ns/op +# Warmup Iteration 3: 292.453 ns/op +Iteration 1: 292.897 ns/op +Iteration 2: 289.284 ns/op +Iteration 3: 287.021 ns/op +Iteration 4: 294.598 ns/op +Iteration 5: 295.941 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 293.020 ±(99.9%) 8.111 ns/op [Average] + (min, avg, max) = (287.021, 293.020, 305.567), stdev = 5.365 + CI (99.9%): [284.909, 301.131] (assumes normal distribution) + + +# Run complete. Total time: 00:03:19 + +REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on +why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial +experiments, perform baseline and negative tests that provide experimental control, make sure +the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts. +Do not assume the numbers tell you what you want them to tell. + +Benchmark (length) (startAlign) Mode Cnt Score Error Units +VarHandleVsUnsafeBenchmark.unsafe 8 0 avgt 10 2.915 ± 0.080 ns/op +VarHandleVsUnsafeBenchmark.unsafe 8 1 avgt 10 2.885 ± 0.043 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 0 avgt 10 3.081 ± 0.084 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 1 avgt 10 3.057 ± 0.055 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 0 avgt 10 5.799 ± 0.297 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 1 avgt 10 5.727 ± 0.084 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 0 avgt 10 9.956 ± 0.149 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 1 avgt 10 9.980 ± 0.120 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 0 avgt 10 63.361 ± 0.987 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 1 avgt 10 71.468 ± 10.115 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 0 avgt 10 253.724 ± 4.000 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 1 avgt 10 256.782 ± 4.109 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 0 avgt 10 3.097 ± 0.046 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 1 avgt 10 3.096 ± 0.111 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 0 avgt 10 3.515 ± 0.121 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 1 avgt 10 3.493 ± 0.043 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 0 avgt 10 7.323 ± 0.245 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 1 avgt 10 7.276 ± 0.156 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 0 avgt 10 12.231 ± 0.057 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 1 avgt 10 12.376 ± 0.184 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 0 avgt 10 95.946 ± 27.306 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 1 avgt 10 96.454 ± 26.416 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 0 avgt 10 285.878 ± 4.281 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 1 avgt 10 293.020 ± 8.111 ns/op + +Benchmark result is saved to /home/peter/Build-All/needs-info-research/Zero-Allocation-Hashing-67/results-jdk11.json diff --git a/research/issue-67/raw/run-jdk17.log b/research/issue-67/raw/run-jdk17.log new file mode 100644 index 0000000..a726743 --- /dev/null +++ b/research/issue-67/raw/run-jdk17.log @@ -0,0 +1,1049 @@ +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 0.00% complete, ETA 00:03:12 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.405 ns/op +# Warmup Iteration 2: 2.543 ns/op +# Warmup Iteration 3: 2.230 ns/op +Iteration 1: 2.231 ns/op +Iteration 2: 2.267 ns/op +Iteration 3: 2.391 ns/op +Iteration 4: 2.296 ns/op +Iteration 5: 2.302 ns/op + +# Run progress: 2.08% complete, ETA 00:03:15 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.399 ns/op +# Warmup Iteration 2: 2.393 ns/op +# Warmup Iteration 3: 2.362 ns/op +Iteration 1: 2.329 ns/op +Iteration 2: 2.252 ns/op +Iteration 3: 2.246 ns/op +Iteration 4: 2.237 ns/op +Iteration 5: 2.274 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.283 ±(99.9%) 0.074 ns/op [Average] + (min, avg, max) = (2.231, 2.283, 2.391), stdev = 0.049 + CI (99.9%): [2.208, 2.357] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 4.17% complete, ETA 00:03:10 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.382 ns/op +# Warmup Iteration 2: 2.381 ns/op +# Warmup Iteration 3: 2.199 ns/op +Iteration 1: 2.211 ns/op +Iteration 2: 2.225 ns/op +Iteration 3: 2.250 ns/op +Iteration 4: 2.242 ns/op +Iteration 5: 2.253 ns/op + +# Run progress: 6.25% complete, ETA 00:03:06 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.433 ns/op +# Warmup Iteration 2: 2.384 ns/op +# Warmup Iteration 3: 2.279 ns/op +Iteration 1: 2.290 ns/op +Iteration 2: 2.310 ns/op +Iteration 3: 2.238 ns/op +Iteration 4: 2.250 ns/op +Iteration 5: 2.218 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.249 ±(99.9%) 0.047 ns/op [Average] + (min, avg, max) = (2.211, 2.249, 2.310), stdev = 0.031 + CI (99.9%): [2.202, 2.295] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 8.33% complete, ETA 00:03:02 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.586 ns/op +# Warmup Iteration 2: 2.492 ns/op +# Warmup Iteration 3: 2.422 ns/op +Iteration 1: 2.397 ns/op +Iteration 2: 2.447 ns/op +Iteration 3: 2.363 ns/op +Iteration 4: 2.361 ns/op +Iteration 5: 2.400 ns/op + +# Run progress: 10.42% complete, ETA 00:02:58 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.592 ns/op +# Warmup Iteration 2: 2.531 ns/op +# Warmup Iteration 3: 2.399 ns/op +Iteration 1: 2.421 ns/op +Iteration 2: 2.410 ns/op +Iteration 3: 2.463 ns/op +Iteration 4: 2.440 ns/op +Iteration 5: 2.364 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.406 ±(99.9%) 0.055 ns/op [Average] + (min, avg, max) = (2.361, 2.406, 2.463), stdev = 0.037 + CI (99.9%): [2.351, 2.462] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 12.50% complete, ETA 00:02:53 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.579 ns/op +# Warmup Iteration 2: 2.594 ns/op +# Warmup Iteration 3: 2.415 ns/op +Iteration 1: 2.435 ns/op +Iteration 2: 2.449 ns/op +Iteration 3: 2.441 ns/op +Iteration 4: 2.442 ns/op +Iteration 5: 2.452 ns/op + +# Run progress: 14.58% complete, ETA 00:02:49 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.646 ns/op +# Warmup Iteration 2: 2.830 ns/op +# Warmup Iteration 3: 2.420 ns/op +Iteration 1: 2.425 ns/op +Iteration 2: 2.556 ns/op +Iteration 3: 2.462 ns/op +Iteration 4: 2.458 ns/op +Iteration 5: 2.467 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.459 ±(99.9%) 0.055 ns/op [Average] + (min, avg, max) = (2.425, 2.459, 2.556), stdev = 0.036 + CI (99.9%): [2.404, 2.514] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 16.67% complete, ETA 00:02:45 +# Fork: 1 of 2 +# Warmup Iteration 1: 5.254 ns/op +# Warmup Iteration 2: 5.189 ns/op +# Warmup Iteration 3: 5.071 ns/op +Iteration 1: 5.157 ns/op +Iteration 2: 5.193 ns/op +Iteration 3: 5.221 ns/op +Iteration 4: 5.128 ns/op +Iteration 5: 5.084 ns/op + +# Run progress: 18.75% complete, ETA 00:02:41 +# Fork: 2 of 2 +# Warmup Iteration 1: 5.104 ns/op +# Warmup Iteration 2: 5.123 ns/op +# Warmup Iteration 3: 5.081 ns/op +Iteration 1: 5.207 ns/op +Iteration 2: 5.112 ns/op +Iteration 3: 5.149 ns/op +Iteration 4: 5.152 ns/op +Iteration 5: 5.128 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.153 ±(99.9%) 0.065 ns/op [Average] + (min, avg, max) = (5.084, 5.153, 5.221), stdev = 0.043 + CI (99.9%): [5.088, 5.219] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 20.83% complete, ETA 00:02:37 +# Fork: 1 of 2 +# Warmup Iteration 1: 5.222 ns/op +# Warmup Iteration 2: 5.140 ns/op +# Warmup Iteration 3: 5.201 ns/op +Iteration 1: 5.199 ns/op +Iteration 2: 5.136 ns/op +Iteration 3: 5.120 ns/op +Iteration 4: 5.146 ns/op +Iteration 5: 5.194 ns/op + +# Run progress: 22.92% complete, ETA 00:02:33 +# Fork: 2 of 2 +# Warmup Iteration 1: 5.176 ns/op +# Warmup Iteration 2: 5.119 ns/op +# Warmup Iteration 3: 5.203 ns/op +Iteration 1: 5.234 ns/op +Iteration 2: 5.366 ns/op +Iteration 3: 5.402 ns/op +Iteration 4: 5.262 ns/op +Iteration 5: 5.282 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.234 ±(99.9%) 0.144 ns/op [Average] + (min, avg, max) = (5.120, 5.234, 5.402), stdev = 0.095 + CI (99.9%): [5.090, 5.378] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 25.00% complete, ETA 00:02:28 +# Fork: 1 of 2 +# Warmup Iteration 1: 11.083 ns/op +# Warmup Iteration 2: 11.129 ns/op +# Warmup Iteration 3: 10.858 ns/op +Iteration 1: 10.736 ns/op +Iteration 2: 10.761 ns/op +Iteration 3: 10.544 ns/op +Iteration 4: 10.593 ns/op +Iteration 5: 10.749 ns/op + +# Run progress: 27.08% complete, ETA 00:02:24 +# Fork: 2 of 2 +# Warmup Iteration 1: 11.219 ns/op +# Warmup Iteration 2: 10.999 ns/op +# Warmup Iteration 3: 10.754 ns/op +Iteration 1: 10.741 ns/op +Iteration 2: 10.639 ns/op +Iteration 3: 10.893 ns/op +Iteration 4: 10.820 ns/op +Iteration 5: 10.675 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 10.715 ±(99.9%) 0.158 ns/op [Average] + (min, avg, max) = (10.544, 10.715, 10.893), stdev = 0.105 + CI (99.9%): [10.557, 10.873] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 29.17% complete, ETA 00:02:20 +# Fork: 1 of 2 +# Warmup Iteration 1: 11.405 ns/op +# Warmup Iteration 2: 11.141 ns/op +# Warmup Iteration 3: 10.957 ns/op +Iteration 1: 10.838 ns/op +Iteration 2: 10.795 ns/op +Iteration 3: 10.956 ns/op +Iteration 4: 10.883 ns/op +Iteration 5: 10.888 ns/op + +# Run progress: 31.25% complete, ETA 00:02:16 +# Fork: 2 of 2 +# Warmup Iteration 1: 11.249 ns/op +# Warmup Iteration 2: 11.214 ns/op +# Warmup Iteration 3: 10.978 ns/op +Iteration 1: 10.921 ns/op +Iteration 2: 10.940 ns/op +Iteration 3: 10.865 ns/op +Iteration 4: 10.966 ns/op +Iteration 5: 11.709 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 10.976 ±(99.9%) 0.397 ns/op [Average] + (min, avg, max) = (10.795, 10.976, 11.709), stdev = 0.263 + CI (99.9%): [10.579, 11.374] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 33.33% complete, ETA 00:02:12 +# Fork: 1 of 2 +# Warmup Iteration 1: 75.119 ns/op +# Warmup Iteration 2: 71.039 ns/op +# Warmup Iteration 3: 68.559 ns/op +Iteration 1: 68.807 ns/op +Iteration 2: 68.489 ns/op +Iteration 3: 68.997 ns/op +Iteration 4: 68.547 ns/op +Iteration 5: 68.614 ns/op + +# Run progress: 35.42% complete, ETA 00:02:08 +# Fork: 2 of 2 +# Warmup Iteration 1: 71.840 ns/op +# Warmup Iteration 2: 69.091 ns/op +# Warmup Iteration 3: 68.314 ns/op +Iteration 1: 68.110 ns/op +Iteration 2: 69.005 ns/op +Iteration 3: 68.221 ns/op +Iteration 4: 68.282 ns/op +Iteration 5: 69.081 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 68.615 ±(99.9%) 0.527 ns/op [Average] + (min, avg, max) = (68.110, 68.615, 69.081), stdev = 0.349 + CI (99.9%): [68.088, 69.142] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 37.50% complete, ETA 00:02:04 +# Fork: 1 of 2 +# Warmup Iteration 1: 71.653 ns/op +# Warmup Iteration 2: 69.925 ns/op +# Warmup Iteration 3: 69.783 ns/op +Iteration 1: 70.220 ns/op +Iteration 2: 69.608 ns/op +Iteration 3: 69.889 ns/op +Iteration 4: 70.138 ns/op +Iteration 5: 69.892 ns/op + +# Run progress: 39.58% complete, ETA 00:01:59 +# Fork: 2 of 2 +# Warmup Iteration 1: 72.209 ns/op +# Warmup Iteration 2: 69.719 ns/op +# Warmup Iteration 3: 70.431 ns/op +Iteration 1: 70.606 ns/op +Iteration 2: 70.720 ns/op +Iteration 3: 69.773 ns/op +Iteration 4: 72.096 ns/op +Iteration 5: 70.004 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 70.294 ±(99.9%) 1.093 ns/op [Average] + (min, avg, max) = (69.608, 70.294, 72.096), stdev = 0.723 + CI (99.9%): [69.201, 71.388] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 41.67% complete, ETA 00:01:55 +# Fork: 1 of 2 +# Warmup Iteration 1: 280.429 ns/op +# Warmup Iteration 2: 264.027 ns/op +# Warmup Iteration 3: 265.272 ns/op +Iteration 1: 262.950 ns/op +Iteration 2: 262.049 ns/op +Iteration 3: 263.271 ns/op +Iteration 4: 262.254 ns/op +Iteration 5: 261.862 ns/op + +# Run progress: 43.75% complete, ETA 00:01:51 +# Fork: 2 of 2 +# Warmup Iteration 1: 277.369 ns/op +# Warmup Iteration 2: 262.699 ns/op +# Warmup Iteration 3: 262.135 ns/op +Iteration 1: 265.737 ns/op +Iteration 2: 264.660 ns/op +Iteration 3: 266.484 ns/op +Iteration 4: 264.096 ns/op +Iteration 5: 265.741 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 263.911 ±(99.9%) 2.552 ns/op [Average] + (min, avg, max) = (261.862, 263.911, 266.484), stdev = 1.688 + CI (99.9%): [261.359, 266.463] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 45.83% complete, ETA 00:01:47 +# Fork: 1 of 2 +# Warmup Iteration 1: 279.552 ns/op +# Warmup Iteration 2: 268.848 ns/op +# Warmup Iteration 3: 283.655 ns/op +Iteration 1: 268.958 ns/op +Iteration 2: 267.452 ns/op +Iteration 3: 266.246 ns/op +Iteration 4: 271.055 ns/op +Iteration 5: 265.577 ns/op + +# Run progress: 47.92% complete, ETA 00:01:43 +# Fork: 2 of 2 +# Warmup Iteration 1: 286.917 ns/op +# Warmup Iteration 2: 274.874 ns/op +# Warmup Iteration 3: 270.780 ns/op +Iteration 1: 267.394 ns/op +Iteration 2: 268.054 ns/op +Iteration 3: 265.933 ns/op +Iteration 4: 266.499 ns/op +Iteration 5: 272.947 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 268.011 ±(99.9%) 3.594 ns/op [Average] + (min, avg, max) = (265.577, 268.011, 272.947), stdev = 2.377 + CI (99.9%): [264.417, 271.606] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 50.00% complete, ETA 00:01:39 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.730 ns/op +# Warmup Iteration 2: 2.655 ns/op +# Warmup Iteration 3: 2.735 ns/op +Iteration 1: 2.712 ns/op +Iteration 2: 2.771 ns/op +Iteration 3: 2.801 ns/op +Iteration 4: 2.771 ns/op +Iteration 5: 2.833 ns/op + +# Run progress: 52.08% complete, ETA 00:01:35 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.686 ns/op +# Warmup Iteration 2: 2.660 ns/op +# Warmup Iteration 3: 2.609 ns/op +Iteration 1: 2.588 ns/op +Iteration 2: 2.659 ns/op +Iteration 3: 2.609 ns/op +Iteration 4: 2.629 ns/op +Iteration 5: 2.588 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.696 ±(99.9%) 0.141 ns/op [Average] + (min, avg, max) = (2.588, 2.696, 2.833), stdev = 0.093 + CI (99.9%): [2.555, 2.837] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 54.17% complete, ETA 00:01:30 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.712 ns/op +# Warmup Iteration 2: 2.656 ns/op +# Warmup Iteration 3: 2.609 ns/op +Iteration 1: 2.622 ns/op +Iteration 2: 2.628 ns/op +Iteration 3: 2.642 ns/op +Iteration 4: 2.678 ns/op +Iteration 5: 2.621 ns/op + +# Run progress: 56.25% complete, ETA 00:01:26 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.710 ns/op +# Warmup Iteration 2: 2.652 ns/op +# Warmup Iteration 3: 2.697 ns/op +Iteration 1: 2.736 ns/op +Iteration 2: 2.786 ns/op +Iteration 3: 2.779 ns/op +Iteration 4: 2.741 ns/op +Iteration 5: 2.688 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.692 ±(99.9%) 0.097 ns/op [Average] + (min, avg, max) = (2.621, 2.692, 2.786), stdev = 0.064 + CI (99.9%): [2.594, 2.789] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 58.33% complete, ETA 00:01:22 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.907 ns/op +# Warmup Iteration 2: 2.871 ns/op +# Warmup Iteration 3: 2.667 ns/op +Iteration 1: 2.618 ns/op +Iteration 2: 2.634 ns/op +Iteration 3: 2.649 ns/op +Iteration 4: 2.682 ns/op +Iteration 5: 2.628 ns/op + +# Run progress: 60.42% complete, ETA 00:01:18 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.884 ns/op +# Warmup Iteration 2: 2.883 ns/op +# Warmup Iteration 3: 2.622 ns/op +Iteration 1: 2.624 ns/op +Iteration 2: 2.614 ns/op +Iteration 3: 2.647 ns/op +Iteration 4: 2.619 ns/op +Iteration 5: 2.670 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.638 ±(99.9%) 0.035 ns/op [Average] + (min, avg, max) = (2.614, 2.638, 2.682), stdev = 0.023 + CI (99.9%): [2.603, 2.673] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 62.50% complete, ETA 00:01:14 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.880 ns/op +# Warmup Iteration 2: 2.838 ns/op +# Warmup Iteration 3: 2.761 ns/op +Iteration 1: 2.876 ns/op +Iteration 2: 2.702 ns/op +Iteration 3: 2.708 ns/op +Iteration 4: 2.741 ns/op +Iteration 5: 2.702 ns/op + +# Run progress: 64.58% complete, ETA 00:01:10 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.919 ns/op +# Warmup Iteration 2: 2.895 ns/op +# Warmup Iteration 3: 2.763 ns/op +Iteration 1: 2.736 ns/op +Iteration 2: 2.731 ns/op +Iteration 3: 2.796 ns/op +Iteration 4: 2.719 ns/op +Iteration 5: 2.816 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.753 ±(99.9%) 0.088 ns/op [Average] + (min, avg, max) = (2.702, 2.753, 2.876), stdev = 0.058 + CI (99.9%): [2.665, 2.840] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 66.67% complete, ETA 00:01:06 +# Fork: 1 of 2 +# Warmup Iteration 1: 6.352 ns/op +# Warmup Iteration 2: 6.526 ns/op +# Warmup Iteration 3: 6.426 ns/op +Iteration 1: 6.657 ns/op +Iteration 2: 6.508 ns/op +Iteration 3: 6.530 ns/op +Iteration 4: 6.522 ns/op +Iteration 5: 6.554 ns/op + +# Run progress: 68.75% complete, ETA 00:01:02 +# Fork: 2 of 2 +# Warmup Iteration 1: 6.418 ns/op +# Warmup Iteration 2: 6.305 ns/op +# Warmup Iteration 3: 6.480 ns/op +Iteration 1: 6.498 ns/op +Iteration 2: 6.437 ns/op +Iteration 3: 6.471 ns/op +Iteration 4: 6.324 ns/op +Iteration 5: 6.511 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 6.501 ±(99.9%) 0.128 ns/op [Average] + (min, avg, max) = (6.324, 6.501, 6.657), stdev = 0.085 + CI (99.9%): [6.373, 6.630] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 70.83% complete, ETA 00:00:57 +# Fork: 1 of 2 +# Warmup Iteration 1: 6.644 ns/op +# Warmup Iteration 2: 6.363 ns/op +# Warmup Iteration 3: 6.536 ns/op +Iteration 1: 6.535 ns/op +Iteration 2: 6.525 ns/op +Iteration 3: 6.391 ns/op +Iteration 4: 6.410 ns/op +Iteration 5: 6.444 ns/op + +# Run progress: 72.92% complete, ETA 00:00:53 +# Fork: 2 of 2 +# Warmup Iteration 1: 6.405 ns/op +# Warmup Iteration 2: 6.421 ns/op +# Warmup Iteration 3: 6.539 ns/op +Iteration 1: 6.454 ns/op +Iteration 2: 6.516 ns/op +Iteration 3: 6.541 ns/op +Iteration 4: 6.524 ns/op +Iteration 5: 6.479 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 6.482 ±(99.9%) 0.082 ns/op [Average] + (min, avg, max) = (6.391, 6.482, 6.541), stdev = 0.055 + CI (99.9%): [6.399, 6.564] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 75.00% complete, ETA 00:00:49 +# Fork: 1 of 2 +# Warmup Iteration 1: 12.311 ns/op +# Warmup Iteration 2: 12.058 ns/op +# Warmup Iteration 3: 12.011 ns/op +Iteration 1: 11.914 ns/op +Iteration 2: 11.778 ns/op +Iteration 3: 11.851 ns/op +Iteration 4: 11.797 ns/op +Iteration 5: 11.816 ns/op + +# Run progress: 77.08% complete, ETA 00:00:45 +# Fork: 2 of 2 +# Warmup Iteration 1: 12.292 ns/op +# Warmup Iteration 2: 12.165 ns/op +# Warmup Iteration 3: 12.067 ns/op +Iteration 1: 11.921 ns/op +Iteration 2: 11.913 ns/op +Iteration 3: 12.210 ns/op +Iteration 4: 12.067 ns/op +Iteration 5: 12.096 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 11.936 ±(99.9%) 0.217 ns/op [Average] + (min, avg, max) = (11.778, 11.936, 12.210), stdev = 0.143 + CI (99.9%): [11.720, 12.153] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 79.17% complete, ETA 00:00:41 +# Fork: 1 of 2 +# Warmup Iteration 1: 12.612 ns/op +# Warmup Iteration 2: 12.353 ns/op +# Warmup Iteration 3: 12.001 ns/op +Iteration 1: 12.180 ns/op +Iteration 2: 12.155 ns/op +Iteration 3: 12.208 ns/op +Iteration 4: 12.015 ns/op +Iteration 5: 12.118 ns/op + +# Run progress: 81.25% complete, ETA 00:00:37 +# Fork: 2 of 2 +# Warmup Iteration 1: 12.347 ns/op +# Warmup Iteration 2: 12.068 ns/op +# Warmup Iteration 3: 11.953 ns/op +Iteration 1: 12.340 ns/op +Iteration 2: 12.135 ns/op +Iteration 3: 12.261 ns/op +Iteration 4: 12.359 ns/op +Iteration 5: 12.104 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 12.187 ±(99.9%) 0.162 ns/op [Average] + (min, avg, max) = (12.015, 12.187, 12.359), stdev = 0.107 + CI (99.9%): [12.025, 12.350] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 83.33% complete, ETA 00:00:33 +# Fork: 1 of 2 +# Warmup Iteration 1: 102.912 ns/op +# Warmup Iteration 2: 97.829 ns/op +# Warmup Iteration 3: 97.392 ns/op +Iteration 1: 96.930 ns/op +Iteration 2: 96.927 ns/op +Iteration 3: 98.160 ns/op +Iteration 4: 98.589 ns/op +Iteration 5: 97.853 ns/op + +# Run progress: 85.42% complete, ETA 00:00:28 +# Fork: 2 of 2 +# Warmup Iteration 1: 102.082 ns/op +# Warmup Iteration 2: 100.328 ns/op +# Warmup Iteration 3: 99.297 ns/op +Iteration 1: 98.849 ns/op +Iteration 2: 99.195 ns/op +Iteration 3: 97.898 ns/op +Iteration 4: 100.529 ns/op +Iteration 5: 102.116 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 98.705 ±(99.9%) 2.429 ns/op [Average] + (min, avg, max) = (96.927, 98.705, 102.116), stdev = 1.606 + CI (99.9%): [96.276, 101.133] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 87.50% complete, ETA 00:00:24 +# Fork: 1 of 2 +# Warmup Iteration 1: 103.452 ns/op +# Warmup Iteration 2: 99.535 ns/op +# Warmup Iteration 3: 99.376 ns/op +Iteration 1: 99.819 ns/op +Iteration 2: 99.679 ns/op +Iteration 3: 98.620 ns/op +Iteration 4: 99.412 ns/op +Iteration 5: 99.242 ns/op + +# Run progress: 89.58% complete, ETA 00:00:20 +# Fork: 2 of 2 +# Warmup Iteration 1: 101.988 ns/op +# Warmup Iteration 2: 98.993 ns/op +# Warmup Iteration 3: 98.438 ns/op +Iteration 1: 99.444 ns/op +Iteration 2: 99.810 ns/op +Iteration 3: 98.386 ns/op +Iteration 4: 100.557 ns/op +Iteration 5: 100.161 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 99.513 ±(99.9%) 0.992 ns/op [Average] + (min, avg, max) = (98.386, 99.513, 100.557), stdev = 0.656 + CI (99.9%): [98.521, 100.505] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 91.67% complete, ETA 00:00:16 +# Fork: 1 of 2 +# Warmup Iteration 1: 412.615 ns/op +# Warmup Iteration 2: 377.715 ns/op +# Warmup Iteration 3: 379.609 ns/op +Iteration 1: 377.415 ns/op +Iteration 2: 376.830 ns/op +Iteration 3: 374.274 ns/op +Iteration 4: 377.986 ns/op +Iteration 5: 382.374 ns/op + +# Run progress: 93.75% complete, ETA 00:00:12 +# Fork: 2 of 2 +# Warmup Iteration 1: 411.593 ns/op +# Warmup Iteration 2: 382.458 ns/op +# Warmup Iteration 3: 378.967 ns/op +Iteration 1: 381.804 ns/op +Iteration 2: 375.825 ns/op +Iteration 3: 378.185 ns/op +Iteration 4: 383.896 ns/op +Iteration 5: 382.226 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 379.082 ±(99.9%) 4.909 ns/op [Average] + (min, avg, max) = (374.274, 379.082, 383.896), stdev = 3.247 + CI (99.9%): [374.172, 383.991] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 17.0.19, OpenJDK 64-Bit Server VM, 17.0.19+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-17-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 95.83% complete, ETA 00:00:08 +# Fork: 1 of 2 +# Warmup Iteration 1: 409.088 ns/op +# Warmup Iteration 2: 378.690 ns/op +# Warmup Iteration 3: 377.706 ns/op +Iteration 1: 383.419 ns/op +Iteration 2: 386.996 ns/op +Iteration 3: 380.037 ns/op +Iteration 4: 384.063 ns/op +Iteration 5: 377.535 ns/op + +# Run progress: 97.92% complete, ETA 00:00:04 +# Fork: 2 of 2 +# Warmup Iteration 1: 409.857 ns/op +# Warmup Iteration 2: 386.360 ns/op +# Warmup Iteration 3: 377.190 ns/op +Iteration 1: 374.101 ns/op +Iteration 2: 375.472 ns/op +Iteration 3: 376.975 ns/op +Iteration 4: 381.806 ns/op +Iteration 5: 379.557 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 379.996 ±(99.9%) 6.195 ns/op [Average] + (min, avg, max) = (374.101, 379.996, 386.996), stdev = 4.098 + CI (99.9%): [373.801, 386.191] (assumes normal distribution) + + +# Run complete. Total time: 00:03:18 + +REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on +why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial +experiments, perform baseline and negative tests that provide experimental control, make sure +the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts. +Do not assume the numbers tell you what you want them to tell. + +NOTE: Current JVM experimentally supports Compiler Blackholes, and they are in use. Please exercise +extra caution when trusting the results, look into the generated code to check the benchmark still +works, and factor in a small probability of new VM bugs. Additionally, while comparisons between +different JVMs are already problematic, the performance difference caused by different Blackhole +modes can be very significant. Please make sure you use the consistent Blackhole mode for comparisons. + +Benchmark (length) (startAlign) Mode Cnt Score Error Units +VarHandleVsUnsafeBenchmark.unsafe 8 0 avgt 10 2.283 ± 0.074 ns/op +VarHandleVsUnsafeBenchmark.unsafe 8 1 avgt 10 2.249 ± 0.047 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 0 avgt 10 2.406 ± 0.055 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 1 avgt 10 2.459 ± 0.055 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 0 avgt 10 5.153 ± 0.065 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 1 avgt 10 5.234 ± 0.144 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 0 avgt 10 10.715 ± 0.158 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 1 avgt 10 10.976 ± 0.397 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 0 avgt 10 68.615 ± 0.527 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 1 avgt 10 70.294 ± 1.093 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 0 avgt 10 263.911 ± 2.552 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 1 avgt 10 268.011 ± 3.594 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 0 avgt 10 2.696 ± 0.141 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 1 avgt 10 2.692 ± 0.097 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 0 avgt 10 2.638 ± 0.035 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 1 avgt 10 2.753 ± 0.088 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 0 avgt 10 6.501 ± 0.128 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 1 avgt 10 6.482 ± 0.082 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 0 avgt 10 11.936 ± 0.217 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 1 avgt 10 12.187 ± 0.162 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 0 avgt 10 98.705 ± 2.429 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 1 avgt 10 99.513 ± 0.992 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 0 avgt 10 379.082 ± 4.909 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 1 avgt 10 379.996 ± 6.195 ns/op + +Benchmark result is saved to /home/peter/Build-All/needs-info-research/Zero-Allocation-Hashing-67/results-jdk17.json diff --git a/research/issue-67/raw/run-jdk21.log b/research/issue-67/raw/run-jdk21.log new file mode 100644 index 0000000..f57fb2c --- /dev/null +++ b/research/issue-67/raw/run-jdk21.log @@ -0,0 +1,1049 @@ +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 0.00% complete, ETA 00:03:12 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.523 ns/op +# Warmup Iteration 2: 2.534 ns/op +# Warmup Iteration 3: 2.279 ns/op +Iteration 1: 2.367 ns/op +Iteration 2: 2.309 ns/op +Iteration 3: 2.264 ns/op +Iteration 4: 2.271 ns/op +Iteration 5: 2.284 ns/op + +# Run progress: 2.08% complete, ETA 00:03:15 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.520 ns/op +# Warmup Iteration 2: 2.489 ns/op +# Warmup Iteration 3: 2.276 ns/op +Iteration 1: 2.259 ns/op +Iteration 2: 2.239 ns/op +Iteration 3: 2.273 ns/op +Iteration 4: 2.276 ns/op +Iteration 5: 2.282 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.283 ±(99.9%) 0.053 ns/op [Average] + (min, avg, max) = (2.239, 2.283, 2.367), stdev = 0.035 + CI (99.9%): [2.230, 2.335] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 4.17% complete, ETA 00:03:11 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.512 ns/op +# Warmup Iteration 2: 2.496 ns/op +# Warmup Iteration 3: 2.291 ns/op +Iteration 1: 2.286 ns/op +Iteration 2: 2.297 ns/op +Iteration 3: 2.302 ns/op +Iteration 4: 2.289 ns/op +Iteration 5: 2.283 ns/op + +# Run progress: 6.25% complete, ETA 00:03:07 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.498 ns/op +# Warmup Iteration 2: 2.453 ns/op +# Warmup Iteration 3: 2.263 ns/op +Iteration 1: 2.258 ns/op +Iteration 2: 2.278 ns/op +Iteration 3: 2.269 ns/op +Iteration 4: 2.281 ns/op +Iteration 5: 2.254 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.280 ±(99.9%) 0.024 ns/op [Average] + (min, avg, max) = (2.254, 2.280, 2.302), stdev = 0.016 + CI (99.9%): [2.256, 2.303] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 8.33% complete, ETA 00:03:02 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.835 ns/op +# Warmup Iteration 2: 2.659 ns/op +# Warmup Iteration 3: 2.418 ns/op +Iteration 1: 2.461 ns/op +Iteration 2: 2.483 ns/op +Iteration 3: 2.440 ns/op +Iteration 4: 2.580 ns/op +Iteration 5: 2.485 ns/op + +# Run progress: 10.42% complete, ETA 00:02:58 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.690 ns/op +# Warmup Iteration 2: 2.654 ns/op +# Warmup Iteration 3: 2.455 ns/op +Iteration 1: 2.478 ns/op +Iteration 2: 2.467 ns/op +Iteration 3: 2.426 ns/op +Iteration 4: 2.478 ns/op +Iteration 5: 2.463 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.476 ±(99.9%) 0.062 ns/op [Average] + (min, avg, max) = (2.426, 2.476, 2.580), stdev = 0.041 + CI (99.9%): [2.414, 2.538] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 12.50% complete, ETA 00:02:54 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.792 ns/op +# Warmup Iteration 2: 2.725 ns/op +# Warmup Iteration 3: 2.561 ns/op +Iteration 1: 2.584 ns/op +Iteration 2: 2.542 ns/op +Iteration 3: 2.527 ns/op +Iteration 4: 2.564 ns/op +Iteration 5: 2.534 ns/op + +# Run progress: 14.58% complete, ETA 00:02:50 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.689 ns/op +# Warmup Iteration 2: 2.713 ns/op +# Warmup Iteration 3: 2.458 ns/op +Iteration 1: 2.481 ns/op +Iteration 2: 2.454 ns/op +Iteration 3: 2.504 ns/op +Iteration 4: 2.540 ns/op +Iteration 5: 2.414 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.514 ±(99.9%) 0.078 ns/op [Average] + (min, avg, max) = (2.414, 2.514, 2.584), stdev = 0.052 + CI (99.9%): [2.436, 2.593] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 16.67% complete, ETA 00:02:46 +# Fork: 1 of 2 +# Warmup Iteration 1: 5.351 ns/op +# Warmup Iteration 2: 5.403 ns/op +# Warmup Iteration 3: 5.218 ns/op +Iteration 1: 5.149 ns/op +Iteration 2: 5.212 ns/op +Iteration 3: 5.159 ns/op +Iteration 4: 5.148 ns/op +Iteration 5: 5.167 ns/op + +# Run progress: 18.75% complete, ETA 00:02:41 +# Fork: 2 of 2 +# Warmup Iteration 1: 5.453 ns/op +# Warmup Iteration 2: 5.448 ns/op +# Warmup Iteration 3: 5.175 ns/op +Iteration 1: 5.215 ns/op +Iteration 2: 5.093 ns/op +Iteration 3: 5.217 ns/op +Iteration 4: 5.227 ns/op +Iteration 5: 5.152 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.174 ±(99.9%) 0.065 ns/op [Average] + (min, avg, max) = (5.093, 5.174, 5.227), stdev = 0.043 + CI (99.9%): [5.109, 5.239] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 20.83% complete, ETA 00:02:37 +# Fork: 1 of 2 +# Warmup Iteration 1: 5.462 ns/op +# Warmup Iteration 2: 5.348 ns/op +# Warmup Iteration 3: 5.191 ns/op +Iteration 1: 5.169 ns/op +Iteration 2: 5.204 ns/op +Iteration 3: 5.186 ns/op +Iteration 4: 5.211 ns/op +Iteration 5: 5.271 ns/op + +# Run progress: 22.92% complete, ETA 00:02:33 +# Fork: 2 of 2 +# Warmup Iteration 1: 5.442 ns/op +# Warmup Iteration 2: 5.345 ns/op +# Warmup Iteration 3: 5.594 ns/op +Iteration 1: 5.221 ns/op +Iteration 2: 5.213 ns/op +Iteration 3: 5.159 ns/op +Iteration 4: 5.209 ns/op +Iteration 5: 5.221 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.207 ±(99.9%) 0.047 ns/op [Average] + (min, avg, max) = (5.159, 5.207, 5.271), stdev = 0.031 + CI (99.9%): [5.160, 5.254] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 25.00% complete, ETA 00:02:29 +# Fork: 1 of 2 +# Warmup Iteration 1: 11.130 ns/op +# Warmup Iteration 2: 11.125 ns/op +# Warmup Iteration 3: 10.555 ns/op +Iteration 1: 10.478 ns/op +Iteration 2: 10.523 ns/op +Iteration 3: 10.516 ns/op +Iteration 4: 10.457 ns/op +Iteration 5: 10.423 ns/op + +# Run progress: 27.08% complete, ETA 00:02:25 +# Fork: 2 of 2 +# Warmup Iteration 1: 10.900 ns/op +# Warmup Iteration 2: 10.741 ns/op +# Warmup Iteration 3: 10.460 ns/op +Iteration 1: 10.422 ns/op +Iteration 2: 10.555 ns/op +Iteration 3: 10.425 ns/op +Iteration 4: 10.469 ns/op +Iteration 5: 10.438 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 10.471 ±(99.9%) 0.071 ns/op [Average] + (min, avg, max) = (10.422, 10.471, 10.555), stdev = 0.047 + CI (99.9%): [10.400, 10.542] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 29.17% complete, ETA 00:02:21 +# Fork: 1 of 2 +# Warmup Iteration 1: 11.118 ns/op +# Warmup Iteration 2: 11.014 ns/op +# Warmup Iteration 3: 10.674 ns/op +Iteration 1: 10.769 ns/op +Iteration 2: 10.633 ns/op +Iteration 3: 10.719 ns/op +Iteration 4: 10.692 ns/op +Iteration 5: 10.883 ns/op + +# Run progress: 31.25% complete, ETA 00:02:16 +# Fork: 2 of 2 +# Warmup Iteration 1: 11.119 ns/op +# Warmup Iteration 2: 10.978 ns/op +# Warmup Iteration 3: 10.651 ns/op +Iteration 1: 10.616 ns/op +Iteration 2: 10.614 ns/op +Iteration 3: 10.668 ns/op +Iteration 4: 10.718 ns/op +Iteration 5: 10.742 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 10.705 ±(99.9%) 0.124 ns/op [Average] + (min, avg, max) = (10.614, 10.705, 10.883), stdev = 0.082 + CI (99.9%): [10.582, 10.829] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 33.33% complete, ETA 00:02:12 +# Fork: 1 of 2 +# Warmup Iteration 1: 65.958 ns/op +# Warmup Iteration 2: 64.334 ns/op +# Warmup Iteration 3: 63.893 ns/op +Iteration 1: 63.449 ns/op +Iteration 2: 64.254 ns/op +Iteration 3: 64.522 ns/op +Iteration 4: 63.779 ns/op +Iteration 5: 64.596 ns/op + +# Run progress: 35.42% complete, ETA 00:02:08 +# Fork: 2 of 2 +# Warmup Iteration 1: 64.935 ns/op +# Warmup Iteration 2: 63.354 ns/op +# Warmup Iteration 3: 63.788 ns/op +Iteration 1: 63.046 ns/op +Iteration 2: 62.854 ns/op +Iteration 3: 62.481 ns/op +Iteration 4: 63.077 ns/op +Iteration 5: 63.810 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 63.587 ±(99.9%) 1.099 ns/op [Average] + (min, avg, max) = (62.481, 63.587, 64.596), stdev = 0.727 + CI (99.9%): [62.488, 64.686] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 37.50% complete, ETA 00:02:04 +# Fork: 1 of 2 +# Warmup Iteration 1: 66.415 ns/op +# Warmup Iteration 2: 64.564 ns/op +# Warmup Iteration 3: 64.713 ns/op +Iteration 1: 64.061 ns/op +Iteration 2: 72.863 ns/op +Iteration 3: 64.716 ns/op +Iteration 4: 64.567 ns/op +Iteration 5: 64.083 ns/op + +# Run progress: 39.58% complete, ETA 00:02:00 +# Fork: 2 of 2 +# Warmup Iteration 1: 66.575 ns/op +# Warmup Iteration 2: 64.396 ns/op +# Warmup Iteration 3: 64.819 ns/op +Iteration 1: 66.156 ns/op +Iteration 2: 64.100 ns/op +Iteration 3: 63.707 ns/op +Iteration 4: 64.642 ns/op +Iteration 5: 64.083 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 65.298 ±(99.9%) 4.147 ns/op [Average] + (min, avg, max) = (63.707, 65.298, 72.863), stdev = 2.743 + CI (99.9%): [61.151, 69.445] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 41.67% complete, ETA 00:01:56 +# Fork: 1 of 2 +# Warmup Iteration 1: 260.720 ns/op +# Warmup Iteration 2: 242.988 ns/op +# Warmup Iteration 3: 248.306 ns/op +Iteration 1: 244.978 ns/op +Iteration 2: 244.200 ns/op +Iteration 3: 243.061 ns/op +Iteration 4: 244.052 ns/op +Iteration 5: 240.134 ns/op + +# Run progress: 43.75% complete, ETA 00:01:52 +# Fork: 2 of 2 +# Warmup Iteration 1: 257.424 ns/op +# Warmup Iteration 2: 246.017 ns/op +# Warmup Iteration 3: 244.531 ns/op +Iteration 1: 252.489 ns/op +Iteration 2: 243.393 ns/op +Iteration 3: 242.861 ns/op +Iteration 4: 244.656 ns/op +Iteration 5: 244.696 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 244.452 ±(99.9%) 4.766 ns/op [Average] + (min, avg, max) = (240.134, 244.452, 252.489), stdev = 3.152 + CI (99.9%): [239.686, 249.218] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 45.83% complete, ETA 00:01:47 +# Fork: 1 of 2 +# Warmup Iteration 1: 271.407 ns/op +# Warmup Iteration 2: 256.119 ns/op +# Warmup Iteration 3: 247.269 ns/op +Iteration 1: 248.858 ns/op +Iteration 2: 248.720 ns/op +Iteration 3: 249.117 ns/op +Iteration 4: 250.252 ns/op +Iteration 5: 247.896 ns/op + +# Run progress: 47.92% complete, ETA 00:01:43 +# Fork: 2 of 2 +# Warmup Iteration 1: 267.592 ns/op +# Warmup Iteration 2: 251.142 ns/op +# Warmup Iteration 3: 247.165 ns/op +Iteration 1: 247.561 ns/op +Iteration 2: 248.916 ns/op +Iteration 3: 247.231 ns/op +Iteration 4: 245.049 ns/op +Iteration 5: 247.443 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 248.104 ±(99.9%) 2.145 ns/op [Average] + (min, avg, max) = (245.049, 248.104, 250.252), stdev = 1.419 + CI (99.9%): [245.959, 250.249] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 50.00% complete, ETA 00:01:39 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.941 ns/op +# Warmup Iteration 2: 2.878 ns/op +# Warmup Iteration 3: 2.754 ns/op +Iteration 1: 2.644 ns/op +Iteration 2: 2.635 ns/op +Iteration 3: 2.653 ns/op +Iteration 4: 2.619 ns/op +Iteration 5: 2.631 ns/op + +# Run progress: 52.08% complete, ETA 00:01:35 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.906 ns/op +# Warmup Iteration 2: 2.856 ns/op +# Warmup Iteration 3: 2.610 ns/op +Iteration 1: 2.628 ns/op +Iteration 2: 2.618 ns/op +Iteration 3: 2.612 ns/op +Iteration 4: 2.690 ns/op +Iteration 5: 2.629 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.636 ±(99.9%) 0.034 ns/op [Average] + (min, avg, max) = (2.612, 2.636, 2.690), stdev = 0.023 + CI (99.9%): [2.602, 2.670] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 54.17% complete, ETA 00:01:31 +# Fork: 1 of 2 +# Warmup Iteration 1: 2.914 ns/op +# Warmup Iteration 2: 2.865 ns/op +# Warmup Iteration 3: 2.613 ns/op +Iteration 1: 2.614 ns/op +Iteration 2: 2.652 ns/op +Iteration 3: 2.634 ns/op +Iteration 4: 2.631 ns/op +Iteration 5: 2.618 ns/op + +# Run progress: 56.25% complete, ETA 00:01:27 +# Fork: 2 of 2 +# Warmup Iteration 1: 2.862 ns/op +# Warmup Iteration 2: 2.850 ns/op +# Warmup Iteration 3: 2.610 ns/op +Iteration 1: 2.639 ns/op +Iteration 2: 2.609 ns/op +Iteration 3: 2.629 ns/op +Iteration 4: 2.605 ns/op +Iteration 5: 2.614 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.625 ±(99.9%) 0.023 ns/op [Average] + (min, avg, max) = (2.605, 2.625, 2.652), stdev = 0.015 + CI (99.9%): [2.602, 2.647] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 58.33% complete, ETA 00:01:22 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.128 ns/op +# Warmup Iteration 2: 3.100 ns/op +# Warmup Iteration 3: 2.958 ns/op +Iteration 1: 2.930 ns/op +Iteration 2: 2.958 ns/op +Iteration 3: 2.918 ns/op +Iteration 4: 2.895 ns/op +Iteration 5: 2.982 ns/op + +# Run progress: 60.42% complete, ETA 00:01:18 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.204 ns/op +# Warmup Iteration 2: 3.180 ns/op +# Warmup Iteration 3: 2.908 ns/op +Iteration 1: 2.975 ns/op +Iteration 2: 2.879 ns/op +Iteration 3: 2.901 ns/op +Iteration 4: 2.894 ns/op +Iteration 5: 2.891 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.922 ±(99.9%) 0.056 ns/op [Average] + (min, avg, max) = (2.879, 2.922, 2.982), stdev = 0.037 + CI (99.9%): [2.866, 2.979] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 62.50% complete, ETA 00:01:14 +# Fork: 1 of 2 +# Warmup Iteration 1: 3.183 ns/op +# Warmup Iteration 2: 3.193 ns/op +# Warmup Iteration 3: 3.019 ns/op +Iteration 1: 2.912 ns/op +Iteration 2: 2.922 ns/op +Iteration 3: 2.921 ns/op +Iteration 4: 2.914 ns/op +Iteration 5: 2.907 ns/op + +# Run progress: 64.58% complete, ETA 00:01:10 +# Fork: 2 of 2 +# Warmup Iteration 1: 3.166 ns/op +# Warmup Iteration 2: 3.147 ns/op +# Warmup Iteration 3: 2.884 ns/op +Iteration 1: 2.940 ns/op +Iteration 2: 2.937 ns/op +Iteration 3: 2.887 ns/op +Iteration 4: 2.886 ns/op +Iteration 5: 2.922 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.915 ±(99.9%) 0.027 ns/op [Average] + (min, avg, max) = (2.886, 2.915, 2.940), stdev = 0.018 + CI (99.9%): [2.888, 2.942] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 66.67% complete, ETA 00:01:06 +# Fork: 1 of 2 +# Warmup Iteration 1: 6.488 ns/op +# Warmup Iteration 2: 6.437 ns/op +# Warmup Iteration 3: 6.338 ns/op +Iteration 1: 6.338 ns/op +Iteration 2: 6.380 ns/op +Iteration 3: 6.364 ns/op +Iteration 4: 6.439 ns/op +Iteration 5: 6.403 ns/op + +# Run progress: 68.75% complete, ETA 00:01:02 +# Fork: 2 of 2 +# Warmup Iteration 1: 6.624 ns/op +# Warmup Iteration 2: 6.344 ns/op +# Warmup Iteration 3: 6.318 ns/op +Iteration 1: 6.286 ns/op +Iteration 2: 6.318 ns/op +Iteration 3: 6.332 ns/op +Iteration 4: 6.381 ns/op +Iteration 5: 6.398 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 6.364 ±(99.9%) 0.069 ns/op [Average] + (min, avg, max) = (6.286, 6.364, 6.439), stdev = 0.046 + CI (99.9%): [6.295, 6.433] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 70.83% complete, ETA 00:00:58 +# Fork: 1 of 2 +# Warmup Iteration 1: 6.711 ns/op +# Warmup Iteration 2: 6.638 ns/op +# Warmup Iteration 3: 6.689 ns/op +Iteration 1: 6.545 ns/op +Iteration 2: 6.510 ns/op +Iteration 3: 6.568 ns/op +Iteration 4: 6.575 ns/op +Iteration 5: 6.559 ns/op + +# Run progress: 72.92% complete, ETA 00:00:53 +# Fork: 2 of 2 +# Warmup Iteration 1: 6.715 ns/op +# Warmup Iteration 2: 6.668 ns/op +# Warmup Iteration 3: 6.669 ns/op +Iteration 1: 6.571 ns/op +Iteration 2: 6.596 ns/op +Iteration 3: 6.591 ns/op +Iteration 4: 6.684 ns/op +Iteration 5: 6.569 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 6.577 ±(99.9%) 0.068 ns/op [Average] + (min, avg, max) = (6.510, 6.577, 6.684), stdev = 0.045 + CI (99.9%): [6.509, 6.645] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 75.00% complete, ETA 00:00:49 +# Fork: 1 of 2 +# Warmup Iteration 1: 11.995 ns/op +# Warmup Iteration 2: 12.512 ns/op +# Warmup Iteration 3: 11.921 ns/op +Iteration 1: 12.044 ns/op +Iteration 2: 12.162 ns/op +Iteration 3: 12.127 ns/op +Iteration 4: 11.913 ns/op +Iteration 5: 11.942 ns/op + +# Run progress: 77.08% complete, ETA 00:00:45 +# Fork: 2 of 2 +# Warmup Iteration 1: 12.030 ns/op +# Warmup Iteration 2: 11.735 ns/op +# Warmup Iteration 3: 11.768 ns/op +Iteration 1: 11.945 ns/op +Iteration 2: 11.901 ns/op +Iteration 3: 11.832 ns/op +Iteration 4: 11.802 ns/op +Iteration 5: 11.873 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 11.954 ±(99.9%) 0.182 ns/op [Average] + (min, avg, max) = (11.802, 11.954, 12.162), stdev = 0.120 + CI (99.9%): [11.772, 12.136] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 79.17% complete, ETA 00:00:41 +# Fork: 1 of 2 +# Warmup Iteration 1: 12.054 ns/op +# Warmup Iteration 2: 11.813 ns/op +# Warmup Iteration 3: 11.951 ns/op +Iteration 1: 11.975 ns/op +Iteration 2: 11.898 ns/op +Iteration 3: 12.068 ns/op +Iteration 4: 12.076 ns/op +Iteration 5: 11.996 ns/op + +# Run progress: 81.25% complete, ETA 00:00:37 +# Fork: 2 of 2 +# Warmup Iteration 1: 12.117 ns/op +# Warmup Iteration 2: 11.862 ns/op +# Warmup Iteration 3: 12.057 ns/op +Iteration 1: 12.080 ns/op +Iteration 2: 12.137 ns/op +Iteration 3: 12.162 ns/op +Iteration 4: 12.166 ns/op +Iteration 5: 12.248 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 12.081 ±(99.9%) 0.157 ns/op [Average] + (min, avg, max) = (11.898, 12.081, 12.248), stdev = 0.104 + CI (99.9%): [11.924, 12.238] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 83.33% complete, ETA 00:00:33 +# Fork: 1 of 2 +# Warmup Iteration 1: 106.546 ns/op +# Warmup Iteration 2: 105.563 ns/op +# Warmup Iteration 3: 102.909 ns/op +Iteration 1: 102.339 ns/op +Iteration 2: 104.081 ns/op +Iteration 3: 104.273 ns/op +Iteration 4: 103.157 ns/op +Iteration 5: 102.089 ns/op + +# Run progress: 85.42% complete, ETA 00:00:29 +# Fork: 2 of 2 +# Warmup Iteration 1: 108.984 ns/op +# Warmup Iteration 2: 105.798 ns/op +# Warmup Iteration 3: 101.868 ns/op +Iteration 1: 102.691 ns/op +Iteration 2: 103.076 ns/op +Iteration 3: 101.566 ns/op +Iteration 4: 104.020 ns/op +Iteration 5: 102.156 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 102.945 ±(99.9%) 1.422 ns/op [Average] + (min, avg, max) = (101.566, 102.945, 104.273), stdev = 0.940 + CI (99.9%): [101.523, 104.367] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 87.50% complete, ETA 00:00:24 +# Fork: 1 of 2 +# Warmup Iteration 1: 106.526 ns/op +# Warmup Iteration 2: 103.445 ns/op +# Warmup Iteration 3: 104.212 ns/op +Iteration 1: 101.917 ns/op +Iteration 2: 101.414 ns/op +Iteration 3: 102.011 ns/op +Iteration 4: 103.468 ns/op +Iteration 5: 101.504 ns/op + +# Run progress: 89.58% complete, ETA 00:00:20 +# Fork: 2 of 2 +# Warmup Iteration 1: 106.703 ns/op +# Warmup Iteration 2: 106.199 ns/op +# Warmup Iteration 3: 101.734 ns/op +Iteration 1: 104.248 ns/op +Iteration 2: 104.501 ns/op +Iteration 3: 102.921 ns/op +Iteration 4: 102.789 ns/op +Iteration 5: 105.172 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 102.994 ±(99.9%) 1.997 ns/op [Average] + (min, avg, max) = (101.414, 102.994, 105.172), stdev = 1.321 + CI (99.9%): [100.997, 104.991] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 91.67% complete, ETA 00:00:16 +# Fork: 1 of 2 +# Warmup Iteration 1: 381.385 ns/op +# Warmup Iteration 2: 351.026 ns/op +# Warmup Iteration 3: 353.292 ns/op +Iteration 1: 348.914 ns/op +Iteration 2: 348.852 ns/op +Iteration 3: 357.636 ns/op +Iteration 4: 358.387 ns/op +Iteration 5: 352.717 ns/op + +# Run progress: 93.75% complete, ETA 00:00:12 +# Fork: 2 of 2 +# Warmup Iteration 1: 398.320 ns/op +# Warmup Iteration 2: 361.140 ns/op +# Warmup Iteration 3: 356.468 ns/op +Iteration 1: 349.295 ns/op +Iteration 2: 349.871 ns/op +Iteration 3: 348.405 ns/op +Iteration 4: 351.942 ns/op +Iteration 5: 360.918 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 352.694 ±(99.9%) 6.983 ns/op [Average] + (min, avg, max) = (348.405, 352.694, 360.918), stdev = 4.619 + CI (99.9%): [345.711, 359.676] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 21.0.11, OpenJDK 64-Bit Server VM, 21.0.11+10-1-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 95.83% complete, ETA 00:00:08 +# Fork: 1 of 2 +# Warmup Iteration 1: 392.808 ns/op +# Warmup Iteration 2: 356.765 ns/op +# Warmup Iteration 3: 355.739 ns/op +Iteration 1: 356.689 ns/op +Iteration 2: 354.914 ns/op +Iteration 3: 353.162 ns/op +Iteration 4: 361.467 ns/op +Iteration 5: 358.666 ns/op + +# Run progress: 97.92% complete, ETA 00:00:04 +# Fork: 2 of 2 +# Warmup Iteration 1: 389.375 ns/op +# Warmup Iteration 2: 359.682 ns/op +# Warmup Iteration 3: 356.211 ns/op +Iteration 1: 363.688 ns/op +Iteration 2: 359.274 ns/op +Iteration 3: 363.741 ns/op +Iteration 4: 360.581 ns/op +Iteration 5: 356.811 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 358.899 ±(99.9%) 5.382 ns/op [Average] + (min, avg, max) = (353.162, 358.899, 363.741), stdev = 3.560 + CI (99.9%): [353.518, 364.281] (assumes normal distribution) + + +# Run complete. Total time: 00:03:19 + +REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on +why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial +experiments, perform baseline and negative tests that provide experimental control, make sure +the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts. +Do not assume the numbers tell you what you want them to tell. + +NOTE: Current JVM experimentally supports Compiler Blackholes, and they are in use. Please exercise +extra caution when trusting the results, look into the generated code to check the benchmark still +works, and factor in a small probability of new VM bugs. Additionally, while comparisons between +different JVMs are already problematic, the performance difference caused by different Blackhole +modes can be very significant. Please make sure you use the consistent Blackhole mode for comparisons. + +Benchmark (length) (startAlign) Mode Cnt Score Error Units +VarHandleVsUnsafeBenchmark.unsafe 8 0 avgt 10 2.283 ± 0.053 ns/op +VarHandleVsUnsafeBenchmark.unsafe 8 1 avgt 10 2.280 ± 0.024 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 0 avgt 10 2.476 ± 0.062 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 1 avgt 10 2.514 ± 0.078 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 0 avgt 10 5.174 ± 0.065 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 1 avgt 10 5.207 ± 0.047 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 0 avgt 10 10.471 ± 0.071 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 1 avgt 10 10.705 ± 0.124 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 0 avgt 10 63.587 ± 1.099 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 1 avgt 10 65.298 ± 4.147 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 0 avgt 10 244.452 ± 4.766 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 1 avgt 10 248.104 ± 2.145 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 0 avgt 10 2.636 ± 0.034 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 1 avgt 10 2.625 ± 0.023 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 0 avgt 10 2.922 ± 0.056 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 1 avgt 10 2.915 ± 0.027 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 0 avgt 10 6.364 ± 0.069 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 1 avgt 10 6.577 ± 0.068 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 0 avgt 10 11.954 ± 0.182 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 1 avgt 10 12.081 ± 0.157 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 0 avgt 10 102.945 ± 1.422 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 1 avgt 10 102.994 ± 1.997 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 0 avgt 10 352.694 ± 6.983 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 1 avgt 10 358.899 ± 5.382 ns/op + +Benchmark result is saved to /home/peter/Build-All/needs-info-research/Zero-Allocation-Hashing-67/results-jdk21.json diff --git a/research/issue-67/raw/run-jdk25.log b/research/issue-67/raw/run-jdk25.log new file mode 100644 index 0000000..044bebd --- /dev/null +++ b/research/issue-67/raw/run-jdk25.log @@ -0,0 +1,1245 @@ +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 0.00% complete, ETA 00:03:12 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.518 ns/op +# Warmup Iteration 2: 2.512 ns/op +# Warmup Iteration 3: 2.270 ns/op +Iteration 1: 2.233 ns/op +Iteration 2: 2.298 ns/op +Iteration 3: 2.262 ns/op +Iteration 4: 2.230 ns/op +Iteration 5: 2.267 ns/op + +# Run progress: 2.08% complete, ETA 00:03:15 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.505 ns/op +# Warmup Iteration 2: 2.545 ns/op +# Warmup Iteration 3: 2.266 ns/op +Iteration 1: 2.286 ns/op +Iteration 2: 2.238 ns/op +Iteration 3: 2.245 ns/op +Iteration 4: 2.216 ns/op +Iteration 5: 2.258 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.253 ±(99.9%) 0.039 ns/op [Average] + (min, avg, max) = (2.216, 2.253, 2.298), stdev = 0.026 + CI (99.9%): [2.214, 2.292] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 4.17% complete, ETA 00:03:10 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.513 ns/op +# Warmup Iteration 2: 2.492 ns/op +# Warmup Iteration 3: 2.267 ns/op +Iteration 1: 2.258 ns/op +Iteration 2: 2.240 ns/op +Iteration 3: 2.255 ns/op +Iteration 4: 2.272 ns/op +Iteration 5: 2.256 ns/op + +# Run progress: 6.25% complete, ETA 00:03:06 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.692 ns/op +# Warmup Iteration 2: 2.484 ns/op +# Warmup Iteration 3: 2.292 ns/op +Iteration 1: 2.227 ns/op +Iteration 2: 2.259 ns/op +Iteration 3: 2.234 ns/op +Iteration 4: 2.263 ns/op +Iteration 5: 2.289 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.255 ±(99.9%) 0.027 ns/op [Average] + (min, avg, max) = (2.227, 2.255, 2.289), stdev = 0.018 + CI (99.9%): [2.228, 2.283] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 8.33% complete, ETA 00:03:02 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.737 ns/op +# Warmup Iteration 2: 2.648 ns/op +# Warmup Iteration 3: 2.534 ns/op +Iteration 1: 2.528 ns/op +Iteration 2: 2.580 ns/op +Iteration 3: 2.525 ns/op +Iteration 4: 2.531 ns/op +Iteration 5: 2.531 ns/op + +# Run progress: 10.42% complete, ETA 00:02:58 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.705 ns/op +# Warmup Iteration 2: 2.663 ns/op +# Warmup Iteration 3: 2.582 ns/op +Iteration 1: 2.555 ns/op +Iteration 2: 2.592 ns/op +Iteration 3: 2.557 ns/op +Iteration 4: 2.566 ns/op +Iteration 5: 2.543 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.551 ±(99.9%) 0.035 ns/op [Average] + (min, avg, max) = (2.525, 2.551, 2.592), stdev = 0.023 + CI (99.9%): [2.515, 2.586] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 12.50% complete, ETA 00:02:54 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.743 ns/op +# Warmup Iteration 2: 2.680 ns/op +# Warmup Iteration 3: 2.629 ns/op +Iteration 1: 2.595 ns/op +Iteration 2: 2.546 ns/op +Iteration 3: 2.623 ns/op +Iteration 4: 2.558 ns/op +Iteration 5: 2.559 ns/op + +# Run progress: 14.58% complete, ETA 00:02:50 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.664 ns/op +# Warmup Iteration 2: 2.621 ns/op +# Warmup Iteration 3: 2.511 ns/op +Iteration 1: 2.560 ns/op +Iteration 2: 2.589 ns/op +Iteration 3: 2.578 ns/op +Iteration 4: 2.555 ns/op +Iteration 5: 2.560 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 2.572 ±(99.9%) 0.036 ns/op [Average] + (min, avg, max) = (2.546, 2.572, 2.623), stdev = 0.024 + CI (99.9%): [2.536, 2.608] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 16.67% complete, ETA 00:02:45 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 5.508 ns/op +# Warmup Iteration 2: 5.401 ns/op +# Warmup Iteration 3: 5.212 ns/op +Iteration 1: 5.233 ns/op +Iteration 2: 5.222 ns/op +Iteration 3: 5.343 ns/op +Iteration 4: 5.237 ns/op +Iteration 5: 5.252 ns/op + +# Run progress: 18.75% complete, ETA 00:02:41 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 5.419 ns/op +# Warmup Iteration 2: 5.334 ns/op +# Warmup Iteration 3: 5.206 ns/op +Iteration 1: 5.195 ns/op +Iteration 2: 5.259 ns/op +Iteration 3: 5.176 ns/op +Iteration 4: 5.259 ns/op +Iteration 5: 5.254 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.243 ±(99.9%) 0.068 ns/op [Average] + (min, avg, max) = (5.176, 5.243, 5.343), stdev = 0.045 + CI (99.9%): [5.175, 5.311] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 20.83% complete, ETA 00:02:37 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 5.556 ns/op +# Warmup Iteration 2: 5.362 ns/op +# Warmup Iteration 3: 5.379 ns/op +Iteration 1: 5.226 ns/op +Iteration 2: 5.248 ns/op +Iteration 3: 5.228 ns/op +Iteration 4: 5.525 ns/op +Iteration 5: 5.280 ns/op + +# Run progress: 22.92% complete, ETA 00:02:33 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 5.484 ns/op +# Warmup Iteration 2: 5.380 ns/op +# Warmup Iteration 3: 5.187 ns/op +Iteration 1: 5.156 ns/op +Iteration 2: 5.337 ns/op +Iteration 3: 5.234 ns/op +Iteration 4: 5.312 ns/op +Iteration 5: 5.241 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 5.279 ±(99.9%) 0.151 ns/op [Average] + (min, avg, max) = (5.156, 5.279, 5.525), stdev = 0.100 + CI (99.9%): [5.127, 5.430] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 25.00% complete, ETA 00:02:29 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 9.742 ns/op +# Warmup Iteration 2: 9.601 ns/op +# Warmup Iteration 3: 9.310 ns/op +Iteration 1: 9.274 ns/op +Iteration 2: 9.250 ns/op +Iteration 3: 9.366 ns/op +Iteration 4: 9.137 ns/op +Iteration 5: 9.102 ns/op + +# Run progress: 27.08% complete, ETA 00:02:25 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 10.293 ns/op +# Warmup Iteration 2: 9.677 ns/op +# Warmup Iteration 3: 9.439 ns/op +Iteration 1: 9.420 ns/op +Iteration 2: 9.361 ns/op +Iteration 3: 9.323 ns/op +Iteration 4: 9.356 ns/op +Iteration 5: 9.253 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 9.284 ±(99.9%) 0.155 ns/op [Average] + (min, avg, max) = (9.102, 9.284, 9.420), stdev = 0.103 + CI (99.9%): [9.129, 9.439] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 29.17% complete, ETA 00:02:20 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 9.938 ns/op +# Warmup Iteration 2: 9.654 ns/op +# Warmup Iteration 3: 9.172 ns/op +Iteration 1: 9.254 ns/op +Iteration 2: 9.315 ns/op +Iteration 3: 9.370 ns/op +Iteration 4: 9.410 ns/op +Iteration 5: 9.486 ns/op + +# Run progress: 31.25% complete, ETA 00:02:16 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 9.765 ns/op +# Warmup Iteration 2: 9.641 ns/op +# Warmup Iteration 3: 9.349 ns/op +Iteration 1: 9.249 ns/op +Iteration 2: 9.241 ns/op +Iteration 3: 9.412 ns/op +Iteration 4: 9.289 ns/op +Iteration 5: 9.252 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 9.328 ±(99.9%) 0.131 ns/op [Average] + (min, avg, max) = (9.241, 9.328, 9.486), stdev = 0.087 + CI (99.9%): [9.197, 9.459] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 33.33% complete, ETA 00:02:12 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 60.821 ns/op +# Warmup Iteration 2: 58.046 ns/op +# Warmup Iteration 3: 57.366 ns/op +Iteration 1: 58.029 ns/op +Iteration 2: 58.073 ns/op +Iteration 3: 57.606 ns/op +Iteration 4: 57.563 ns/op +Iteration 5: 57.533 ns/op + +# Run progress: 35.42% complete, ETA 00:02:08 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 59.896 ns/op +# Warmup Iteration 2: 57.364 ns/op +# Warmup Iteration 3: 58.453 ns/op +Iteration 1: 57.507 ns/op +Iteration 2: 60.661 ns/op +Iteration 3: 58.872 ns/op +Iteration 4: 58.153 ns/op +Iteration 5: 57.755 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 58.175 ±(99.9%) 1.463 ns/op [Average] + (min, avg, max) = (57.507, 58.175, 60.661), stdev = 0.968 + CI (99.9%): [56.712, 59.639] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 37.50% complete, ETA 00:02:04 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 63.483 ns/op +# Warmup Iteration 2: 60.142 ns/op +# Warmup Iteration 3: 58.626 ns/op +Iteration 1: 58.914 ns/op +Iteration 2: 59.227 ns/op +Iteration 3: 58.209 ns/op +Iteration 4: 59.195 ns/op +Iteration 5: 58.021 ns/op + +# Run progress: 39.58% complete, ETA 00:02:00 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 63.435 ns/op +# Warmup Iteration 2: 61.252 ns/op +# Warmup Iteration 3: 59.456 ns/op +Iteration 1: 59.052 ns/op +Iteration 2: 59.319 ns/op +Iteration 3: 58.902 ns/op +Iteration 4: 59.400 ns/op +Iteration 5: 58.490 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 58.873 ±(99.9%) 0.722 ns/op [Average] + (min, avg, max) = (58.021, 58.873, 59.400), stdev = 0.478 + CI (99.9%): [58.151, 59.595] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 41.67% complete, ETA 00:01:56 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 230.239 ns/op +# Warmup Iteration 2: 255.822 ns/op +# Warmup Iteration 3: 215.497 ns/op +Iteration 1: 219.044 ns/op +Iteration 2: 215.286 ns/op +Iteration 3: 218.926 ns/op +Iteration 4: 216.413 ns/op +Iteration 5: 217.753 ns/op + +# Run progress: 43.75% complete, ETA 00:01:51 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 232.489 ns/op +# Warmup Iteration 2: 222.069 ns/op +# Warmup Iteration 3: 216.030 ns/op +Iteration 1: 217.776 ns/op +Iteration 2: 215.514 ns/op +Iteration 3: 218.733 ns/op +Iteration 4: 216.895 ns/op +Iteration 5: 217.901 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 217.424 ±(99.9%) 2.052 ns/op [Average] + (min, avg, max) = (215.286, 217.424, 219.044), stdev = 1.357 + CI (99.9%): [215.372, 219.476] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 45.83% complete, ETA 00:01:47 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 241.420 ns/op +# Warmup Iteration 2: 225.901 ns/op +# Warmup Iteration 3: 223.947 ns/op +Iteration 1: 227.038 ns/op +Iteration 2: 224.527 ns/op +Iteration 3: 224.280 ns/op +Iteration 4: 224.897 ns/op +Iteration 5: 226.544 ns/op + +# Run progress: 47.92% complete, ETA 00:01:43 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 244.209 ns/op +# Warmup Iteration 2: 223.486 ns/op +# Warmup Iteration 3: 222.225 ns/op +Iteration 1: 230.068 ns/op +Iteration 2: 223.532 ns/op +Iteration 3: 230.400 ns/op +Iteration 4: 222.522 ns/op +Iteration 5: 228.108 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.unsafe": + 226.192 ±(99.9%) 4.091 ns/op [Average] + (min, avg, max) = (222.522, 226.192, 230.400), stdev = 2.706 + CI (99.9%): [222.101, 230.282] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 0) + +# Run progress: 50.00% complete, ETA 00:01:39 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.924 ns/op +# Warmup Iteration 2: 2.832 ns/op +# Warmup Iteration 3: 2.609 ns/op +Iteration 1: 2.617 ns/op +Iteration 2: 2.634 ns/op +Iteration 3: 2.585 ns/op +Iteration 4: 2.692 ns/op +Iteration 5: 2.639 ns/op + +# Run progress: 52.08% complete, ETA 00:01:35 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.906 ns/op +# Warmup Iteration 2: 2.844 ns/op +# Warmup Iteration 3: 2.651 ns/op +Iteration 1: 2.610 ns/op +Iteration 2: 2.639 ns/op +Iteration 3: 2.665 ns/op +Iteration 4: 2.656 ns/op +Iteration 5: 2.653 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.639 ±(99.9%) 0.046 ns/op [Average] + (min, avg, max) = (2.585, 2.639, 2.692), stdev = 0.030 + CI (99.9%): [2.593, 2.685] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 8, startAlign = 1) + +# Run progress: 54.17% complete, ETA 00:01:31 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.911 ns/op +# Warmup Iteration 2: 2.869 ns/op +# Warmup Iteration 3: 2.702 ns/op +Iteration 1: 2.678 ns/op +Iteration 2: 2.683 ns/op +Iteration 3: 2.696 ns/op +Iteration 4: 2.733 ns/op +Iteration 5: 2.672 ns/op + +# Run progress: 56.25% complete, ETA 00:01:26 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 2.964 ns/op +# Warmup Iteration 2: 2.850 ns/op +# Warmup Iteration 3: 2.642 ns/op +Iteration 1: 2.588 ns/op +Iteration 2: 2.621 ns/op +Iteration 3: 2.638 ns/op +Iteration 4: 2.606 ns/op +Iteration 5: 2.596 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.651 ±(99.9%) 0.073 ns/op [Average] + (min, avg, max) = (2.588, 2.651, 2.733), stdev = 0.048 + CI (99.9%): [2.578, 2.724] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 0) + +# Run progress: 58.33% complete, ETA 00:01:22 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 3.176 ns/op +# Warmup Iteration 2: 3.085 ns/op +# Warmup Iteration 3: 2.953 ns/op +Iteration 1: 2.969 ns/op +Iteration 2: 2.891 ns/op +Iteration 3: 2.915 ns/op +Iteration 4: 2.820 ns/op +Iteration 5: 2.868 ns/op + +# Run progress: 60.42% complete, ETA 00:01:18 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 3.200 ns/op +# Warmup Iteration 2: 3.159 ns/op +# Warmup Iteration 3: 2.991 ns/op +Iteration 1: 3.006 ns/op +Iteration 2: 2.947 ns/op +Iteration 3: 2.942 ns/op +Iteration 4: 2.923 ns/op +Iteration 5: 3.005 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.929 ±(99.9%) 0.089 ns/op [Average] + (min, avg, max) = (2.820, 2.929, 3.006), stdev = 0.059 + CI (99.9%): [2.840, 3.018] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 16, startAlign = 1) + +# Run progress: 62.50% complete, ETA 00:01:14 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 3.128 ns/op +# Warmup Iteration 2: 3.146 ns/op +# Warmup Iteration 3: 3.017 ns/op +Iteration 1: 2.947 ns/op +Iteration 2: 2.912 ns/op +Iteration 3: 2.942 ns/op +Iteration 4: 3.014 ns/op +Iteration 5: 2.953 ns/op + +# Run progress: 64.58% complete, ETA 00:01:10 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 3.127 ns/op +# Warmup Iteration 2: 3.123 ns/op +# Warmup Iteration 3: 2.935 ns/op +Iteration 1: 2.875 ns/op +Iteration 2: 2.846 ns/op +Iteration 3: 2.868 ns/op +Iteration 4: 2.878 ns/op +Iteration 5: 2.873 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 2.911 ±(99.9%) 0.079 ns/op [Average] + (min, avg, max) = (2.846, 2.911, 3.014), stdev = 0.052 + CI (99.9%): [2.832, 2.990] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 0) + +# Run progress: 66.67% complete, ETA 00:01:06 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 6.732 ns/op +# Warmup Iteration 2: 6.314 ns/op +# Warmup Iteration 3: 6.343 ns/op +Iteration 1: 6.303 ns/op +Iteration 2: 6.324 ns/op +Iteration 3: 6.316 ns/op +Iteration 4: 6.367 ns/op +Iteration 5: 6.312 ns/op + +# Run progress: 68.75% complete, ETA 00:01:02 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 6.440 ns/op +# Warmup Iteration 2: 6.253 ns/op +# Warmup Iteration 3: 6.271 ns/op +Iteration 1: 6.868 ns/op +Iteration 2: 6.558 ns/op +Iteration 3: 6.384 ns/op +Iteration 4: 6.401 ns/op +Iteration 5: 6.381 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 6.421 ±(99.9%) 0.263 ns/op [Average] + (min, avg, max) = (6.303, 6.421, 6.868), stdev = 0.174 + CI (99.9%): [6.159, 6.684] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 64, startAlign = 1) + +# Run progress: 70.83% complete, ETA 00:00:57 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 6.705 ns/op +# Warmup Iteration 2: 6.551 ns/op +# Warmup Iteration 3: 6.482 ns/op +Iteration 1: 6.502 ns/op +Iteration 2: 6.509 ns/op +Iteration 3: 6.473 ns/op +Iteration 4: 6.428 ns/op +Iteration 5: 6.443 ns/op + +# Run progress: 72.92% complete, ETA 00:00:53 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 6.609 ns/op +# Warmup Iteration 2: 6.546 ns/op +# Warmup Iteration 3: 6.639 ns/op +Iteration 1: 6.618 ns/op +Iteration 2: 6.532 ns/op +Iteration 3: 6.696 ns/op +Iteration 4: 6.738 ns/op +Iteration 5: 6.558 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 6.550 ±(99.9%) 0.158 ns/op [Average] + (min, avg, max) = (6.428, 6.550, 6.738), stdev = 0.104 + CI (99.9%): [6.392, 6.707] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 0) + +# Run progress: 75.00% complete, ETA 00:00:49 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 11.736 ns/op +# Warmup Iteration 2: 11.604 ns/op +# Warmup Iteration 3: 11.486 ns/op +Iteration 1: 11.532 ns/op +Iteration 2: 11.730 ns/op +Iteration 3: 11.484 ns/op +Iteration 4: 11.507 ns/op +Iteration 5: 11.601 ns/op + +# Run progress: 77.08% complete, ETA 00:00:45 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 11.649 ns/op +# Warmup Iteration 2: 11.553 ns/op +# Warmup Iteration 3: 11.503 ns/op +Iteration 1: 11.545 ns/op +Iteration 2: 11.487 ns/op +Iteration 3: 11.699 ns/op +Iteration 4: 11.435 ns/op +Iteration 5: 11.544 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 11.556 ±(99.9%) 0.143 ns/op [Average] + (min, avg, max) = (11.435, 11.556, 11.730), stdev = 0.095 + CI (99.9%): [11.413, 11.700] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 128, startAlign = 1) + +# Run progress: 79.17% complete, ETA 00:00:41 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 12.200 ns/op +# Warmup Iteration 2: 11.965 ns/op +# Warmup Iteration 3: 11.813 ns/op +Iteration 1: 11.965 ns/op +Iteration 2: 11.964 ns/op +Iteration 3: 11.865 ns/op +Iteration 4: 11.949 ns/op +Iteration 5: 11.924 ns/op + +# Run progress: 81.25% complete, ETA 00:00:37 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 12.156 ns/op +# Warmup Iteration 2: 11.969 ns/op +# Warmup Iteration 3: 12.170 ns/op +Iteration 1: 12.154 ns/op +Iteration 2: 12.064 ns/op +Iteration 3: 11.923 ns/op +Iteration 4: 11.994 ns/op +Iteration 5: 11.736 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 11.954 ±(99.9%) 0.168 ns/op [Average] + (min, avg, max) = (11.736, 11.954, 12.154), stdev = 0.111 + CI (99.9%): [11.786, 12.122] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 0) + +# Run progress: 83.33% complete, ETA 00:00:33 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 96.058 ns/op +# Warmup Iteration 2: 90.494 ns/op +# Warmup Iteration 3: 90.501 ns/op +Iteration 1: 91.051 ns/op +Iteration 2: 91.659 ns/op +Iteration 3: 91.230 ns/op +Iteration 4: 90.851 ns/op +Iteration 5: 90.693 ns/op + +# Run progress: 85.42% complete, ETA 00:00:28 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 95.969 ns/op +# Warmup Iteration 2: 91.687 ns/op +# Warmup Iteration 3: 91.455 ns/op +Iteration 1: 92.433 ns/op +Iteration 2: 92.496 ns/op +Iteration 3: 91.352 ns/op +Iteration 4: 91.603 ns/op +Iteration 5: 91.571 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 91.494 ±(99.9%) 0.911 ns/op [Average] + (min, avg, max) = (90.693, 91.494, 92.496), stdev = 0.603 + CI (99.9%): [90.582, 92.405] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 1024, startAlign = 1) + +# Run progress: 87.50% complete, ETA 00:00:24 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 96.065 ns/op +# Warmup Iteration 2: 91.749 ns/op +# Warmup Iteration 3: 90.813 ns/op +Iteration 1: 92.365 ns/op +Iteration 2: 92.343 ns/op +Iteration 3: 93.042 ns/op +Iteration 4: 92.486 ns/op +Iteration 5: 95.110 ns/op + +# Run progress: 89.58% complete, ETA 00:00:20 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 95.315 ns/op +# Warmup Iteration 2: 92.435 ns/op +# Warmup Iteration 3: 91.577 ns/op +Iteration 1: 91.539 ns/op +Iteration 2: 91.517 ns/op +Iteration 3: 93.526 ns/op +Iteration 4: 92.593 ns/op +Iteration 5: 92.772 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 92.729 ±(99.9%) 1.565 ns/op [Average] + (min, avg, max) = (91.517, 92.729, 95.110), stdev = 1.035 + CI (99.9%): [91.164, 94.295] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 0) + +# Run progress: 91.67% complete, ETA 00:00:16 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 333.566 ns/op +# Warmup Iteration 2: 299.873 ns/op +# Warmup Iteration 3: 296.653 ns/op +Iteration 1: 304.178 ns/op +Iteration 2: 300.980 ns/op +Iteration 3: 308.706 ns/op +Iteration 4: 295.870 ns/op +Iteration 5: 297.597 ns/op + +# Run progress: 93.75% complete, ETA 00:00:12 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 327.283 ns/op +# Warmup Iteration 2: 299.528 ns/op +# Warmup Iteration 3: 299.310 ns/op +Iteration 1: 295.963 ns/op +Iteration 2: 301.302 ns/op +Iteration 3: 297.456 ns/op +Iteration 4: 299.036 ns/op +Iteration 5: 295.769 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 299.686 ±(99.9%) 6.362 ns/op [Average] + (min, avg, max) = (295.769, 299.686, 308.706), stdev = 4.208 + CI (99.9%): [293.324, 306.047] (assumes normal distribution) + + +# JMH version: 1.37 +# VM version: JDK 25.0.3, OpenJDK 64-Bit Server VM, 25.0.3+9-2-24.04.2-Ubuntu +# VM invoker: /usr/lib/jvm/java-25-openjdk-amd64/bin/java +# VM options: +# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable) +# Warmup: 3 iterations, 500 ms each +# Measurement: 5 iterations, 500 ms each +# Timeout: 10 min per iteration +# Threads: 1 thread, will synchronize iterations +# Benchmark mode: Average time, time/op +# Benchmark: net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle +# Parameters: (length = 4096, startAlign = 1) + +# Run progress: 95.83% complete, ETA 00:00:08 +# Fork: 1 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 333.803 ns/op +# Warmup Iteration 2: 301.611 ns/op +# Warmup Iteration 3: 300.879 ns/op +Iteration 1: 305.852 ns/op +Iteration 2: 308.011 ns/op +Iteration 3: 304.138 ns/op +Iteration 4: 301.845 ns/op +Iteration 5: 298.258 ns/op + +# Run progress: 97.92% complete, ETA 00:00:04 +# Fork: 2 of 2 +WARNING: A terminally deprecated method in sun.misc.Unsafe has been called +WARNING: sun.misc.Unsafe::objectFieldOffset has been called by org.openjdk.jmh.util.Utils (file:/home/peter/.m2/repository/org/openjdk/jmh/jmh-core/1.37/jmh-core-1.37.jar) +WARNING: Please consider reporting this to the maintainers of class org.openjdk.jmh.util.Utils +WARNING: sun.misc.Unsafe::objectFieldOffset will be removed in a future release +# Warmup Iteration 1: 336.336 ns/op +# Warmup Iteration 2: 299.272 ns/op +# Warmup Iteration 3: 304.570 ns/op +Iteration 1: 302.835 ns/op +Iteration 2: 299.305 ns/op +Iteration 3: 299.316 ns/op +Iteration 4: 299.874 ns/op +Iteration 5: 297.508 ns/op + + +Result "net.openhft.hashing.VarHandleVsUnsafeBenchmark.varHandle": + 301.694 ±(99.9%) 5.249 ns/op [Average] + (min, avg, max) = (297.508, 301.694, 308.011), stdev = 3.472 + CI (99.9%): [296.445, 306.943] (assumes normal distribution) + + +# Run complete. Total time: 00:03:18 + +REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on +why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial +experiments, perform baseline and negative tests that provide experimental control, make sure +the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts. +Do not assume the numbers tell you what you want them to tell. + +NOTE: Current JVM experimentally supports Compiler Blackholes, and they are in use. Please exercise +extra caution when trusting the results, look into the generated code to check the benchmark still +works, and factor in a small probability of new VM bugs. Additionally, while comparisons between +different JVMs are already problematic, the performance difference caused by different Blackhole +modes can be very significant. Please make sure you use the consistent Blackhole mode for comparisons. + +Benchmark (length) (startAlign) Mode Cnt Score Error Units +VarHandleVsUnsafeBenchmark.unsafe 8 0 avgt 10 2.253 ± 0.039 ns/op +VarHandleVsUnsafeBenchmark.unsafe 8 1 avgt 10 2.255 ± 0.027 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 0 avgt 10 2.551 ± 0.035 ns/op +VarHandleVsUnsafeBenchmark.unsafe 16 1 avgt 10 2.572 ± 0.036 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 0 avgt 10 5.243 ± 0.068 ns/op +VarHandleVsUnsafeBenchmark.unsafe 64 1 avgt 10 5.279 ± 0.151 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 0 avgt 10 9.284 ± 0.155 ns/op +VarHandleVsUnsafeBenchmark.unsafe 128 1 avgt 10 9.328 ± 0.131 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 0 avgt 10 58.175 ± 1.463 ns/op +VarHandleVsUnsafeBenchmark.unsafe 1024 1 avgt 10 58.873 ± 0.722 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 0 avgt 10 217.424 ± 2.052 ns/op +VarHandleVsUnsafeBenchmark.unsafe 4096 1 avgt 10 226.192 ± 4.091 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 0 avgt 10 2.639 ± 0.046 ns/op +VarHandleVsUnsafeBenchmark.varHandle 8 1 avgt 10 2.651 ± 0.073 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 0 avgt 10 2.929 ± 0.089 ns/op +VarHandleVsUnsafeBenchmark.varHandle 16 1 avgt 10 2.911 ± 0.079 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 0 avgt 10 6.421 ± 0.263 ns/op +VarHandleVsUnsafeBenchmark.varHandle 64 1 avgt 10 6.550 ± 0.158 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 0 avgt 10 11.556 ± 0.143 ns/op +VarHandleVsUnsafeBenchmark.varHandle 128 1 avgt 10 11.954 ± 0.168 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 0 avgt 10 91.494 ± 0.911 ns/op +VarHandleVsUnsafeBenchmark.varHandle 1024 1 avgt 10 92.729 ± 1.565 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 0 avgt 10 299.686 ± 6.362 ns/op +VarHandleVsUnsafeBenchmark.varHandle 4096 1 avgt 10 301.694 ± 5.249 ns/op + +Benchmark result is saved to /home/peter/Build-All/needs-info-research/Zero-Allocation-Hashing-67/results-jdk25.json diff --git a/research/issue-67/results-summary.txt b/research/issue-67/results-summary.txt new file mode 100644 index 0000000..5f4e254 --- /dev/null +++ b/research/issue-67/results-summary.txt @@ -0,0 +1,65 @@ +Zero-Allocation-Hashing #67 — VarHandle vs Unsafe go/no-go, whole XXH3 hash of byte[] +JMH 1.37, AverageTime ns/op (lower=better), 2 forks x (3x0.5s warmup + 5x0.5s meas). +Hardware: single host, same run. Score +/- 99.9% CI half-width. VH/U = varHandle/unsafe %. +hash: LongHashFunction.xx3().hash(input, ACCESS, BYTE_BASE+startAlign, length) +==================================================================================================== + +--- JDK 11 --- + len align | unsafe ns/op | varHandle ns/op | VH/U + 8 0 | 2.92 +/- 0.08 | 3.10 +/- 0.05 | 106% + 8 1 | 2.88 +/- 0.04 | 3.10 +/- 0.11 | 107% + 16 0 | 3.08 +/- 0.08 | 3.51 +/- 0.12 | 114% + 16 1 | 3.06 +/- 0.05 | 3.49 +/- 0.04 | 114% + 64 0 | 5.80 +/- 0.30 | 7.32 +/- 0.25 | 126% + 64 1 | 5.73 +/- 0.08 | 7.28 +/- 0.16 | 127% + 128 0 | 9.96 +/- 0.15 | 12.23 +/- 0.06 | 123% + 128 1 | 9.98 +/- 0.12 | 12.38 +/- 0.18 | 124% + 1024 0 | 63.36 +/- 0.99 | 95.95 +/- 27.31 | 151% + 1024 1 | 71.47 +/- 10.11 | 96.45 +/- 26.42 | 135% + 4096 0 | 253.72 +/- 4.00 | 285.88 +/- 4.28 | 113% + 4096 1 | 256.78 +/- 4.11 | 293.02 +/- 8.11 | 114% + +--- JDK 17 --- + len align | unsafe ns/op | varHandle ns/op | VH/U + 8 0 | 2.28 +/- 0.07 | 2.70 +/- 0.14 | 118% + 8 1 | 2.25 +/- 0.05 | 2.69 +/- 0.10 | 120% + 16 0 | 2.41 +/- 0.06 | 2.64 +/- 0.04 | 110% + 16 1 | 2.46 +/- 0.05 | 2.75 +/- 0.09 | 112% + 64 0 | 5.15 +/- 0.07 | 6.50 +/- 0.13 | 126% + 64 1 | 5.23 +/- 0.14 | 6.48 +/- 0.08 | 124% + 128 0 | 10.71 +/- 0.16 | 11.94 +/- 0.22 | 111% + 128 1 | 10.98 +/- 0.40 | 12.19 +/- 0.16 | 111% + 1024 0 | 68.62 +/- 0.53 | 98.70 +/- 2.43 | 144% + 1024 1 | 70.29 +/- 1.09 | 99.51 +/- 0.99 | 142% + 4096 0 | 263.91 +/- 2.55 | 379.08 +/- 4.91 | 144% + 4096 1 | 268.01 +/- 3.59 | 380.00 +/- 6.20 | 142% + +--- JDK 21 --- + len align | unsafe ns/op | varHandle ns/op | VH/U + 8 0 | 2.28 +/- 0.05 | 2.64 +/- 0.03 | 115% + 8 1 | 2.28 +/- 0.02 | 2.62 +/- 0.02 | 115% + 16 0 | 2.48 +/- 0.06 | 2.92 +/- 0.06 | 118% + 16 1 | 2.51 +/- 0.08 | 2.91 +/- 0.03 | 116% + 64 0 | 5.17 +/- 0.06 | 6.36 +/- 0.07 | 123% + 64 1 | 5.21 +/- 0.05 | 6.58 +/- 0.07 | 126% + 128 0 | 10.47 +/- 0.07 | 11.95 +/- 0.18 | 114% + 128 1 | 10.71 +/- 0.12 | 12.08 +/- 0.16 | 113% + 1024 0 | 63.59 +/- 1.10 | 102.94 +/- 1.42 | 162% + 1024 1 | 65.30 +/- 4.15 | 102.99 +/- 2.00 | 158% + 4096 0 | 244.45 +/- 4.77 | 352.69 +/- 6.98 | 144% + 4096 1 | 248.10 +/- 2.14 | 358.90 +/- 5.38 | 145% + +--- JDK 25 --- + len align | unsafe ns/op | varHandle ns/op | VH/U + 8 0 | 2.25 +/- 0.04 | 2.64 +/- 0.05 | 117% + 8 1 | 2.26 +/- 0.03 | 2.65 +/- 0.07 | 118% + 16 0 | 2.55 +/- 0.04 | 2.93 +/- 0.09 | 115% + 16 1 | 2.57 +/- 0.04 | 2.91 +/- 0.08 | 113% + 64 0 | 5.24 +/- 0.07 | 6.42 +/- 0.26 | 122% + 64 1 | 5.28 +/- 0.15 | 6.55 +/- 0.16 | 124% + 128 0 | 9.28 +/- 0.16 | 11.56 +/- 0.14 | 124% + 128 1 | 9.33 +/- 0.13 | 11.95 +/- 0.17 | 128% + 1024 0 | 58.18 +/- 1.46 | 91.49 +/- 0.91 | 157% + 1024 1 | 58.87 +/- 0.72 | 92.73 +/- 1.57 | 158% + 4096 0 | 217.42 +/- 2.05 | 299.69 +/- 6.36 | 138% + 4096 1 | 226.19 +/- 4.09 | 301.69 +/- 5.25 | 133%