optimize SyncMap (#12)

* improve(syncmap): replace array in ValueTransaction with fields

* improve(syncmap): lock on the node instead of node.lock

* improve(syncmap): simplify getMutableValue

* improve(syncmap): extract some methods from SyncMap into Atomics and Sentinel

* improve(syncmap): swap out flags for lambdas in Atomics

* improve(syncmap): reduce aggressive fencing by going back to compareAndSet

* improve(syncmap): restructure put method to shortcircuit on the fast path

* improve(syncmap): further restructuring of the put method

* improve(syncmap): rework node access and bulk operation locking

* improve(syncmap): replace getAndSet with compareAndExchange

* improve(syncmap): clean up logic for the stamp lock

* improve(syncmap): clean up

* chore(syncmap): fix javadoc for the SyncMap class

* chore(syncmap): clean up minor style errors

Author: vectrixdevelops

.gitignore

@@ -1,4 +1,5 @@
 .gradle
+.kotlin
 build/
 !gradle/wrapper/gradle-wrapper.jar
 !**/src/main/**/build/

build-logic/src/main/kotlin/sync.common-conventions.gradle.kts

@@ -14,6 +14,18 @@ val libs = extensions.getByType(org.gradle.accessors.dm.LibrariesForLibs::class)
 plugins.withId("me.champeau.jmh") {
   extensions.configure(JmhParameters::class) {
     jmhVersion = libs.versions.jmh.get()
+
+    jvm.set(
+      javaToolchains
+        .launcherFor {
+          languageVersion.set(JavaLanguageVersion.of(21))
+        }
+        .map { launcher ->
+          launcher.executablePath
+            .asFile
+            .absolutePath
+        }
+    )
   }
 
   tasks.named("compileJmhJava") {

collections/benchmarks.md

@@ -4,53 +4,83 @@
 
 The following benchmarks are a comparison of `SyncMap` vs `Collections#synchronizedMap()` vs `ConcurrentHashMap`.
 
+### Summary
+
+The `SyncMap` has similar performance characteristics of the `ConcurrentHashMap`,
+with an advantage in write speed.
+
+The following results were recorded on an _M4 Macbook Pro_, using 8 threads and
+100,000 entries for each benchmark:
+
+- `SyncMap` **get()** speed is...
+  - 4.1% **SLOWER** than `ConcurrentHashMap` for an empty map.
+  - 3.9% **SLOWER** than `ConcurrentHashMap` for a presized empty map.
+  - 6.7% **SLOWER** than `ConcurrentHashMap` for a full map.
+
+- `SyncMap` **put()** speed is...
+  - 44.8% **FASTER** than `ConcurrentHashMap` for an empty map.
+  - 30.0% **SLOWER** than `ConcurrentHashMap` for a presized empty map.
+  - 53.9% **FASTER** than `ConcurrentHashMap` for a full map.
+
+- `SyncMap` **put()** then **get()** speed is...
+  - 135.6% **FASTER** than `ConcurrentHashMap` for an empty map.
+  - 66.1% **FASTER** than `ConcurrentHashMap` for a presized empty map.
+  - 86.0% **FASTER** than `ConcurrentHashMap` for a full map.
+
+- `SyncMap` random **put()** and **get()** speed is...
+  - 39.1% **FASTER** than `ConcurrentHashMap` for an empty map.
+  - 38.1% **FASTER** than `ConcurrentHashMap` for a presized empty map.
+  - 37.0% **FASTER** than `ConcurrentHashMap` for a full map.
+
+### Results
+
 ```txt
-Benchmark                          (implementation)       (mode)  (size)   Mode  Cnt   Score   Error   Units
-SyncMapBenchmark.getOnly          ConcurrentHashMap         none  100000  thrpt    5  28.412 ± 0.114  ops/ms
-SyncMapBenchmark.getOnly          ConcurrentHashMap      presize  100000  thrpt    5  28.349 ± 0.440  ops/ms
-SyncMapBenchmark.getOnly          ConcurrentHashMap  prepopulate  100000  thrpt    5  22.157 ± 0.216  ops/ms
-
-SyncMapBenchmark.getOnly                    SyncMap         none  100000  thrpt    5  26.269 ± 0.059  ops/ms
-SyncMapBenchmark.getOnly                    SyncMap      presize  100000  thrpt    5  26.239 ± 0.112  ops/ms
-SyncMapBenchmark.getOnly                    SyncMap  prepopulate  100000  thrpt    5  20.710 ± 0.596  ops/ms
-
-SyncMapBenchmark.getOnly            SynchronizedMap         none  100000  thrpt    5   0.097 ± 0.117  ops/ms
-SyncMapBenchmark.getOnly            SynchronizedMap      presize  100000  thrpt    5   0.235 ± 0.603  ops/ms
-SyncMapBenchmark.getOnly            SynchronizedMap  prepopulate  100000  thrpt    5   0.290 ± 0.630  ops/ms
-
-SyncMapBenchmark.putAndGet                  SyncMap         none  100000  thrpt    5   3.134 ± 0.091  ops/ms
-SyncMapBenchmark.putAndGet                  SyncMap      presize  100000  thrpt    5   3.123 ± 0.108  ops/ms
-SyncMapBenchmark.putAndGet                  SyncMap  prepopulate  100000  thrpt    5   2.947 ± 0.053  ops/ms
-
-SyncMapBenchmark.putAndGet        ConcurrentHashMap         none  100000  thrpt    5   1.269 ± 0.007  ops/ms
-SyncMapBenchmark.putAndGet        ConcurrentHashMap      presize  100000  thrpt    5   2.180 ± 0.141  ops/ms
-SyncMapBenchmark.putAndGet        ConcurrentHashMap  prepopulate  100000  thrpt    5   1.999 ± 0.264  ops/ms
-
-SyncMapBenchmark.putAndGet          SynchronizedMap         none  100000  thrpt    5   0.085 ± 0.254  ops/ms
-SyncMapBenchmark.putAndGet          SynchronizedMap      presize  100000  thrpt    5   0.065 ± 0.169  ops/ms
-SyncMapBenchmark.putAndGet          SynchronizedMap  prepopulate  100000  thrpt    5   0.068 ± 0.123  ops/ms
-
-SyncMapBenchmark.putOnly                    SyncMap         none  100000  thrpt    5   1.682 ± 0.269  ops/ms
-SyncMapBenchmark.putOnly                    SyncMap      presize  100000  thrpt    5   1.847 ± 0.738  ops/ms
-SyncMapBenchmark.putOnly                    SyncMap  prepopulate  100000  thrpt    5   3.320 ± 0.115  ops/ms
-
-SyncMapBenchmark.putOnly          ConcurrentHashMap         none  100000  thrpt    5   1.289 ± 0.050  ops/ms
-SyncMapBenchmark.putOnly          ConcurrentHashMap      presize  100000  thrpt    5   2.174 ± 0.359  ops/ms
-SyncMapBenchmark.putOnly          ConcurrentHashMap  prepopulate  100000  thrpt    5   2.342 ± 0.244  ops/ms
-
-SyncMapBenchmark.putOnly            SynchronizedMap         none  100000  thrpt    5   0.154 ± 0.331  ops/ms
-SyncMapBenchmark.putOnly            SynchronizedMap      presize  100000  thrpt    5   0.126 ± 0.414  ops/ms
-SyncMapBenchmark.putOnly            SynchronizedMap  prepopulate  100000  thrpt    5   0.110 ± 0.382  ops/ms
-
-SyncMapBenchmark.randomPutAndGet            SyncMap         none  100000  thrpt    5   1.484 ± 0.072  ops/ms
-SyncMapBenchmark.randomPutAndGet            SyncMap      presize  100000  thrpt    5   1.517 ± 0.012  ops/ms
-SyncMapBenchmark.randomPutAndGet            SyncMap  prepopulate  100000  thrpt    5   1.606 ± 0.007  ops/ms
-
-SyncMapBenchmark.randomPutAndGet  ConcurrentHashMap         none  100000  thrpt    5   1.149 ± 0.010  ops/ms
-SyncMapBenchmark.randomPutAndGet  ConcurrentHashMap      presize  100000  thrpt    5   1.215 ± 0.034  ops/ms
-SyncMapBenchmark.randomPutAndGet  ConcurrentHashMap  prepopulate  100000  thrpt    5   1.188 ± 0.023  ops/ms
-
-SyncMapBenchmark.randomPutAndGet    SynchronizedMap         none  100000  thrpt    5   0.130 ± 0.023  ops/ms
-SyncMapBenchmark.randomPutAndGet    SynchronizedMap      presize  100000  thrpt    5   0.137 ± 0.034  ops/ms
-SyncMapBenchmark.randomPutAndGet    SynchronizedMap  prepopulate  100000  thrpt    5   0.112 ± 0.033  ops/ms
+Benchmark                          (implementation)       (mode)   Mode  Cnt  Score   Error   Units
+SyncMapBenchmark.getOnly          ConcurrentHashMap         none  thrpt    5  2.954 ± 0.016  ops/ns
+SyncMapBenchmark.getOnly          ConcurrentHashMap      presize  thrpt    5  2.936 ± 0.005  ops/ns
+SyncMapBenchmark.getOnly          ConcurrentHashMap  prepopulate  thrpt    5  2.658 ± 0.011  ops/ns
+
+SyncMapBenchmark.getOnly                    SyncMap         none  thrpt    5  2.833 ± 0.018  ops/ns
+SyncMapBenchmark.getOnly                    SyncMap      presize  thrpt    5  2.821 ± 0.004  ops/ns
+SyncMapBenchmark.getOnly                    SyncMap  prepopulate  thrpt    5  2.479 ± 0.021  ops/ns
+
+SyncMapBenchmark.getOnly            SynchronizedMap         none  thrpt    5  0.033 ± 0.045  ops/ns
+SyncMapBenchmark.getOnly            SynchronizedMap      presize  thrpt    5  0.027 ± 0.004  ops/ns
+SyncMapBenchmark.getOnly            SynchronizedMap  prepopulate  thrpt    5  0.035 ± 0.045  ops/ns
+
+SyncMapBenchmark.putAndGet                  SyncMap         none  thrpt    5  0.391 ± 0.066  ops/ns
+SyncMapBenchmark.putAndGet                  SyncMap      presize  thrpt    5  0.427 ± 0.039  ops/ns
+SyncMapBenchmark.putAndGet                  SyncMap  prepopulate  thrpt    5  0.424 ± 0.020  ops/ns
+
+SyncMapBenchmark.putAndGet        ConcurrentHashMap         none  thrpt    5  0.166 ± 0.113  ops/ns
+SyncMapBenchmark.putAndGet        ConcurrentHashMap      presize  thrpt    5  0.257 ± 0.030  ops/ns
+SyncMapBenchmark.putAndGet        ConcurrentHashMap  prepopulate  thrpt    5  0.228 ± 0.064  ops/ns
+
+SyncMapBenchmark.putAndGet          SynchronizedMap         none  thrpt    5  0.012 ± 0.002  ops/ns
+SyncMapBenchmark.putAndGet          SynchronizedMap      presize  thrpt    5  0.012 ± 0.003  ops/ns
+SyncMapBenchmark.putAndGet          SynchronizedMap  prepopulate  thrpt    5  0.012 ± 0.007  ops/ns
+
+SyncMapBenchmark.putOnly                    SyncMap         none  thrpt    5  0.239 ± 0.025  ops/ns
+SyncMapBenchmark.putOnly                    SyncMap      presize  thrpt    5  0.235 ± 0.044  ops/ns
+SyncMapBenchmark.putOnly                    SyncMap  prepopulate  thrpt    5  0.457 ± 0.026  ops/ns
+
+SyncMapBenchmark.putOnly          ConcurrentHashMap         none  thrpt    5  0.165 ± 0.008  ops/ns
+SyncMapBenchmark.putOnly          ConcurrentHashMap      presize  thrpt    5  0.336 ± 0.010  ops/ns
+SyncMapBenchmark.putOnly          ConcurrentHashMap  prepopulate  thrpt    5  0.297 ± 0.043  ops/ns
+
+SyncMapBenchmark.putOnly            SynchronizedMap         none  thrpt    5  0.023 ± 0.004  ops/ns
+SyncMapBenchmark.putOnly            SynchronizedMap      presize  thrpt    5  0.023 ± 0.005  ops/ns
+SyncMapBenchmark.putOnly            SynchronizedMap  prepopulate  thrpt    5  0.022 ± 0.003  ops/ns
+
+SyncMapBenchmark.randomPutAndGet            SyncMap         none  thrpt    5  0.192 ± 0.009  ops/ns
+SyncMapBenchmark.randomPutAndGet            SyncMap      presize  thrpt    5  0.203 ± 0.007  ops/ns
+SyncMapBenchmark.randomPutAndGet            SyncMap  prepopulate  thrpt    5  0.200 ± 0.002  ops/ns
+
+SyncMapBenchmark.randomPutAndGet  ConcurrentHashMap         none  thrpt    5  0.138 ± 0.002  ops/ns
+SyncMapBenchmark.randomPutAndGet  ConcurrentHashMap      presize  thrpt    5  0.147 ± 0.001  ops/ns
+SyncMapBenchmark.randomPutAndGet  ConcurrentHashMap  prepopulate  thrpt    5  0.146 ± 0.003  ops/ns
+
+SyncMapBenchmark.randomPutAndGet    SynchronizedMap         none  thrpt    5  0.017 ± 0.009  ops/ns
+SyncMapBenchmark.randomPutAndGet    SynchronizedMap      presize  thrpt    5  0.016 ± 0.013  ops/ns
+SyncMapBenchmark.randomPutAndGet    SynchronizedMap  prepopulate  thrpt    5  0.018 ± 0.004  ops/ns
 ```

collections/readme.md

@@ -46,7 +46,7 @@ dependencies {
 
 ## Performance
 
-The benchmarks below were recorded on a _M4 Mac Pro_.
+The benchmarks below were recorded on a _M4 Macbook Pro_.
 
 - [SyncMap Benchmarks](benchmarks.md#syncmap)
 

collections/src/jmh/java/space/vectrix/collections/SyncMapBenchmark.java

@@ -35,6 +35,7 @@
 import org.openjdk.jmh.annotations.Level;
 import org.openjdk.jmh.annotations.Measurement;
 import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OperationsPerInvocation;
 import org.openjdk.jmh.annotations.OutputTimeUnit;
 import org.openjdk.jmh.annotations.Param;
 import org.openjdk.jmh.annotations.Scope;
@@ -45,19 +46,17 @@
 import org.openjdk.jmh.infra.Blackhole;
 
 @BenchmarkMode(Mode.Throughput)
-@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
 @State(Scope.Benchmark)
 @Fork(1)
 @Warmup(iterations = 5)
 @Measurement(iterations = 5)
-@Threads(16)
 public class SyncMapBenchmark {
+  private static final int SIZE = 100_000;
+
   @Param({ "SyncMap", "SynchronizedMap", "ConcurrentHashMap" })
   private String implementation;
 
-  @Param("100000")
-  private int size;
-
   @Param({ "none", "presize", "prepopulate" })
   private String mode;
 
@@ -69,57 +68,61 @@ public void setup() {
     final boolean prepopulate = "prepopulate".equalsIgnoreCase(this.mode);
 
     if ("SyncMap".equalsIgnoreCase(this.implementation)) {
-      this.map = presized ? new SyncMap<>(this.size) : new SyncMap<>();
+      this.map = presized ? new SyncMap<>(SyncMapBenchmark.SIZE) : new SyncMap<>();
     } else if ("SynchronizedMap".equalsIgnoreCase(this.implementation)) {
       this.map = presized
-        ? Collections.synchronizedMap(new HashMap<>(this.size))
+        ? Collections.synchronizedMap(new HashMap<>(SyncMapBenchmark.SIZE))
         : Collections.synchronizedMap(new HashMap<>());
     } else if ("ConcurrentHashMap".equalsIgnoreCase(this.implementation)) {
-      this.map = presized ? new ConcurrentHashMap<>(this.size) : new ConcurrentHashMap<>();
+      this.map = presized ? new ConcurrentHashMap<>(SyncMapBenchmark.SIZE) : new ConcurrentHashMap<>();
     }
 
     if(prepopulate) {
-      for(int i = 0; i < this.size; i++) {
+      for(int i = 0; i < SyncMapBenchmark.SIZE; i++) {
         this.map.put(i, i);
       }
+    }
 
-      for(int i = 0; i < this.size; i++) {
-        this.map.get(i);
-      }
+    if(presized && (this.map instanceof final SyncMap<Integer, Integer> sync)) {
+      sync.promote();
     }
   }
 
   @Benchmark
   @Threads(8)
+  @OperationsPerInvocation(SyncMapBenchmark.SIZE)
   public void getOnly(final Blackhole blackhole) {
-    for(int i = 0; i < this.size; i++) {
+    for(int i = 0; i < SyncMapBenchmark.SIZE; i++) {
       blackhole.consume(this.map.get(i));
     }
   }
 
   @Benchmark
   @Threads(8)
+  @OperationsPerInvocation(SyncMapBenchmark.SIZE)
   public void putOnly(final Blackhole blackhole) {
-    for(int i = 0; i < this.size; i++) {
+    for(int i = 0; i < SyncMapBenchmark.SIZE; i++) {
       blackhole.consume(this.map.put(i, i));
     }
   }
 
   @Benchmark
   @Threads(8)
+  @OperationsPerInvocation(SyncMapBenchmark.SIZE)
   public void putAndGet(final Blackhole blackhole) {
-    for(int i = 0; i < this.size; i++) {
+    for(int i = 0; i < SyncMapBenchmark.SIZE; i++) {
       blackhole.consume(this.map.put(i, i));
       blackhole.consume(this.map.get(i));
     }
   }
 
   @Benchmark
   @Threads(8)
+  @OperationsPerInvocation(SyncMapBenchmark.SIZE)
   public void randomPutAndGet(final Blackhole blackhole) {
     final Random random = new Random(8);
-    for(int i = 0; i < this.size; i++) {
-      final int key = random.nextInt(this.size);
+    for(int i = 0; i < SyncMapBenchmark.SIZE; i++) {
+      final int key = random.nextInt(SyncMapBenchmark.SIZE);
       if(random.nextBoolean()) {
         blackhole.consume(this.map.put(key, key));
       } else {