--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/org/openjdk/gcbench/fragger/CHMFragger.java	Wed Apr 26 20:35:48 2017 +0200
@@ -0,0 +1,55 @@
+package org.openjdk.gcbench.fragger;
+
+import org.openjdk.jmh.annotations.*;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+
+
+@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
+@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
+@Fork(value = 1)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Threads(1)
+@State(Scope.Benchmark)
+public class CHMFragger {
+
+    @Param({"1000"})
+    int size;
+
+    Object[] keys;
+    Map<Object, Object> cache;
+
+    @Setup
+    public void setup() {
+        keys = new Object[size];
+        cache = new ConcurrentHashMap<>();
+        for (int c = 0; c < size; c++) {
+            Object k = new Object();
+            keys[c] = k;
+            cache.put(k, new byte[1000]);
+        }
+    }
+
+    @Benchmark
+    public Object test() {
+        ThreadLocalRandom tlr = ThreadLocalRandom.current();
+        int idx = tlr.nextInt(size);
+        if (tlr.nextInt(5) == 0) {
+            Object pk = keys[idx];
+            Object nk = new Object();
+            byte[] v = new byte[1000];
+            cache.put(nk, v);
+            cache.remove(pk);
+            keys[idx] = nk;
+            return v;
+        } else {
+            return cache.get(keys[idx]);
+        }
+    }
+
+
+}

--- a/src/main/java/org/openjdk/gcbench/fragger/LRUFragger.java	Wed Apr 26 20:35:23 2017 +0200
+++ b/src/main/java/org/openjdk/gcbench/fragger/LRUFragger.java	Wed Apr 26 20:35:48 2017 +0200
@@ -1,17 +1,29 @@
 package org.openjdk.gcbench.fragger;
 
+import org.openjdk.gcbench.tests.Sequence;
 import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.profile.SafepointsProfiler;
+import org.openjdk.jmh.results.Result;
+import org.openjdk.jmh.results.RunResult;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+import org.openjdk.jmh.runner.options.TimeValue;
+import org.openjdk.jmh.runner.options.VerboseMode;
 
+import java.io.PrintStream;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 
 
 @Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
 @Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
 @Fork(value = 1)
-@BenchmarkMode(Mode.Throughput)
-@OutputTimeUnit(TimeUnit.SECONDS)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
 @Threads(1)
 @State(Scope.Benchmark)
 public class LRUFragger {
@@ -20,6 +32,7 @@
     int size;
 
     Map<Object, Object> cache;
+    int keyCount;
 
     @Setup
     public void setup() {
@@ -29,11 +42,86 @@
                 return size() > size;
             }
         };
+        keyCount = (int) (size * (1D / 0.8D)); // 80% hit rate
+        for (int c = 0; c < size; c++) {
+            cache.put("Key " + c, new byte[1000]);
+        }
     }
 
     @Benchmark
-    public void test() {
-        cache.put(new Object(), new byte[1000]);
+    public Object test() {
+        int idx = ThreadLocalRandom.current().nextInt(keyCount);
+        Object k = "Key " + idx;
+        Object o = cache.get(k);
+        if (o == null) {
+            o = new byte[1000];
+            cache.put(k, o);
+        }
+        return o;
     }
 
+    public static void main(String... args) throws RunnerException {
+        Options parent = new OptionsBuilder()
+                .detectJvmArgs()
+                .jvmArgsAppend("-Xmx16g", "-Xms16g", "-XX:MaxGCPauseMillis=10")
+                .include(LRUFragger.class.getCanonicalName())
+                .verbosity(VerboseMode.SILENT)
+                .addProfiler(SafepointsProfiler.class)
+                .warmupIterations(5)
+                .warmupTime(TimeValue.seconds(10))
+                .measurementIterations(5)
+                .measurementTime(TimeValue.seconds(10))
+                .build();
+
+        PrintStream pw = System.out;
+
+        Sequence sizeSeq = Sequence.steps(0, 15_000_000, 20);
+
+//        for (String gc : new String[]{"-XX:+UseShenandoahGC"}) {
+        for (String gc : new String[]{"-XX:+UseParallelOldGC", "-XX:+UseG1GC", "-XX:+UseConcMarkSweepGC", "-XX:+UseShenandoahGC"}) {
+            for (Object size : sizeSeq) {
+                if (size.toString().equals("0")) continue;
+
+                Options opt = new OptionsBuilder()
+                        .parent(parent)
+                        .jvmArgsPrepend(gc)
+                        .param("size", size.toString())
+                        .build();
+
+                try {
+                    RunResult res = new Runner(opt).runSingle();
+                    Result pr = res.getPrimaryResult();
+                    Map<String, Result> sec = res.getSecondaryResults();
+
+                    pw.printf("%10s, %30s,      %10.3f, %10.3f,     %5.0f, %10.3f,     %10.3f, %10.3f,       %10.3f, %10.3f, %10.3f, %10.3f, %10.3f, %10.3f, %10.3f, %10.3f, %10.3f%n",
+                            size.toString(),
+                            gc,
+
+                            pr.getScore(),
+                            pr.getScoreError(),
+
+                            sec.get("·safepoints.pause.count").getScore(),
+                            sec.get("·safepoints.pause").getScore(),
+
+                            sec.get("·safepoints.interval").getScore(),
+                            sec.get("·safepoints.pause.avg").getScore(),
+
+                            sec.get("·safepoints.pause.p0.00").getScore(),
+                            sec.get("·safepoints.pause.p0.01").getScore(),
+                            sec.get("·safepoints.pause.p0.05").getScore(),
+                            sec.get("·safepoints.pause.p0.10").getScore(),
+                            sec.get("·safepoints.pause.p0.50").getScore(),
+                            sec.get("·safepoints.pause.p0.90").getScore(),
+                            sec.get("·safepoints.pause.p0.95").getScore(),
+                            sec.get("·safepoints.pause.p0.99").getScore(),
+                            sec.get("·safepoints.pause.p1.00").getScore()
+                    );
+                } catch (RunnerException e) {
+                    // okay
+                }
+            }
+        }
+    }
+
+
 }