Mercurial > hg > gc-bench
changeset 82:f8cde6220e90
Special retain tests
author | shade |
---|---|
date | Thu, 26 Oct 2017 12:11:04 +0200 |
parents | c1b1811b7730 |
children | 659166b70dd9 |
files | src/main/java/org/openjdk/gcbench/retain/Finalizables.java src/main/java/org/openjdk/gcbench/retain/LargeGraphPhantomRef.java src/main/java/org/openjdk/gcbench/retain/SoftRefs.java src/main/java/org/openjdk/gcbench/retain/WeakHashMaps.java |
diffstat | 4 files changed, 181 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/org/openjdk/gcbench/retain/Finalizables.java Thu Oct 26 12:11:04 2017 +0200 @@ -0,0 +1,42 @@ +package org.openjdk.gcbench.retain; + +import org.openjdk.jmh.annotations.*; + +import java.util.concurrent.TimeUnit; + +@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) +@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) +@Fork(1) +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@Threads(Threads.MAX) +@State(Scope.Benchmark) +public class Finalizables { + + Object retain; + + @Param({"100000"}) + private int size; + + @Setup + public void setup() { + Object[] objs = new Object[size]; + for (int c = 0; c < size; c++) { + objs[c] = new Finalizable(); + } + retain = objs; + } + + @Benchmark + public Object test() { + return new Object(); + } + + public static class Finalizable { + @Override + protected void finalize() throws Throwable { + super.finalize(); + } + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/org/openjdk/gcbench/retain/LargeGraphPhantomRef.java Thu Oct 26 12:11:04 2017 +0200 @@ -0,0 +1,49 @@ +package org.openjdk.gcbench.retain; + +import org.openjdk.jmh.annotations.*; + +import java.lang.ref.PhantomReference; +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.lang.ref.SoftReference; +import java.util.TreeMap; +import java.util.concurrent.TimeUnit; + +@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) +@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) +@Fork(1) +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@Threads(Threads.MAX) +@State(Scope.Benchmark) +public class LargeGraphPhantomRef { + + PhantomReference<TreeMap<String, Object>> ref; + ReferenceQueue<Object> rq; + + @Param({"100000"}) + private int size; + + public TreeMap<String, Object> createTreeMap() { + TreeMap<String, Object> t = new TreeMap<>(); + for (int c = 0; c < size; c++) { + t.put("String" + c, new Object()); + } + return t; + } + + @Setup + public void setup() { + rq = new ReferenceQueue<>(); + ref = new PhantomReference<>(createTreeMap(), rq); + } + + @Benchmark + public Object test() { + if (rq.poll() != null) { + ref = new PhantomReference<>(createTreeMap(), rq); + } + return new byte[100]; + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/org/openjdk/gcbench/retain/SoftRefs.java Thu Oct 26 12:11:04 2017 +0200 @@ -0,0 +1,46 @@ +package org.openjdk.gcbench.retain; + +import org.openjdk.jmh.annotations.*; + +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.lang.ref.SoftReference; +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.List; +import java.util.WeakHashMap; +import java.util.concurrent.TimeUnit; + +@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) +@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) +@Fork(1) +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@Threads(Threads.MAX) +@State(Scope.Benchmark) +public class SoftRefs { + + Reference[] retain; + ReferenceQueue<Object> rq; + + @Param({"100000"}) + private int size; + + @Setup + public void setup() { + rq = new ReferenceQueue<>(); + Reference[] list = new Reference[size]; + for (int c = 0; c < size; c++) { + list[c] = new SoftReference<>(new Object(), rq); + } + retain = list; + } + + @Benchmark + public Object test() { + while (rq.poll() != null); // drain + // allocation pressure to trigger GCs + return new Object(); + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/org/openjdk/gcbench/retain/WeakHashMaps.java Thu Oct 26 12:11:04 2017 +0200 @@ -0,0 +1,44 @@ +package org.openjdk.gcbench.retain; + +import org.openjdk.jmh.annotations.*; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.Optional; +import java.util.WeakHashMap; +import java.util.concurrent.TimeUnit; + +@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) +@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) +@Fork(1) +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@Threads(Threads.MAX) +@State(Scope.Benchmark) +public class WeakHashMaps { + + Object retain; + + @Param({"100000"}) + private int size; + + @Setup + public void setup() { + WeakHashMap<Object, Object> map = new WeakHashMap<>(); + for (int c = 0; c < size; c++) { + Object v = new Object(); + // deadly-embrace to keep weak key strongly reachable; + // also make sure the value is one dereference forward, in order + // to let VM discover the reference first, not the referent. + map.put(v, Optional.of(v)); + } + retain = map; + } + + @Benchmark + public Object test() { + // allocation pressure to trigger GCs + return new Object(); + } + +}