gh-4610 Add perf test

Author: at055612

stroom-lmdb/src/test/java/stroom/lmdb/TestLmdbPerformance.java

@@ -2,9 +2,12 @@
 
 import stroom.bytebuffer.ByteBufferPool;
 import stroom.bytebuffer.ByteBufferPoolFactory;
+import stroom.bytebuffer.PooledByteBuffer;
 import stroom.lmdb.serde.IntegerSerde;
 import stroom.lmdb.serde.Serde;
 import stroom.lmdb.serde.StringSerde;
+import stroom.test.common.TestUtil;
+import stroom.test.common.TestUtil.TimedCase;
 import stroom.util.io.ByteSize;
 import stroom.util.logging.DurationTimer;
 import stroom.util.logging.LambdaLogger;
@@ -15,11 +18,15 @@
 import org.junit.jupiter.api.Test;
 import org.lmdbjava.DbiFlags;
 
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class TestLmdbPerformance extends AbstractDualEnvLmdbTest {
 
@@ -55,6 +62,17 @@ private BasicLmdbDb<Integer, String> createIntegerKeyDb(final LmdbEnv lmdbEnv,
                 DbiFlags.MDB_INTEGERKEY);
     }
 
+    private BasicLmdbDb<String, String> createStringStringDb(final LmdbEnv lmdbEnv,
+                                                             final String name) {
+        return new BasicLmdbDb<>(
+                lmdbEnv,
+                byteBufferPool,
+                new StringSerde(),
+                new StringSerde(),
+                name,
+                DbiFlags.MDB_CREATE);
+    }
+
     /**
      * Compare using MDB_APPEND vs not, when repeatedly putting a batch of entries.
      */
@@ -137,6 +155,75 @@ void testAppendVsAppendWithIntegerKey_withDeletes() {
         putData(db2, iterations, rounds, true, deleteBetweenRounds);
     }
 
+    @Disabled // manual perf test only
+    @Test
+    void testGetVsHeapMap() {
+        final int iterations = 10_000_000;
+        final int rounds = 4;
+        final BasicLmdbDb<String, String> db3 = createStringStringDb(lmdbEnv1, "db3");
+        final Map<String, String> hashMap = new HashMap<>();
+        final Map<String, String> concurrentHashMap = new ConcurrentHashMap<>();
+        lmdbEnv1.doWithWriteTxn(writeTxn -> {
+            db3.put(writeTxn, "foo", "bar", true);
+        });
+        hashMap.put("foo", "bar");
+        concurrentHashMap.put("foo", "bar");
+
+        lmdbEnv1.doWithReadTxn(txn -> {
+            try (PooledByteBuffer pooledByteBuffer = byteBufferPool.getPooledByteBuffer(10)) {
+                final ByteBuffer keyBuffer = pooledByteBuffer.getByteBuffer();
+                db3.serializeKey(keyBuffer, "foo");
+
+                final TimedCase lmdbGetCaseWithSer = TimedCase.of("lmdb-get-with-ser", (round, iterations2) -> {
+                    for (long i = 0; i < iterations2; i++) {
+                        final Optional<String> foo = db3.get(txn, "foo");
+                        if (foo.isEmpty()) {
+                            throw new RuntimeException("Empty");
+                        }
+                    }
+                });
+
+                final TimedCase lmdbGetCaseWithoutSer = TimedCase.of(
+                        "lmdb-get-without-ser",
+                        (round, iterations2) -> {
+                            for (long i = 0; i < iterations2; i++) {
+                                final Optional<ByteBuffer> foo = db3.getAsBytes(txn, keyBuffer);
+                                if (foo.isEmpty()) {
+                                    throw new RuntimeException("Empty");
+                                }
+                            }
+                        });
+
+                final TimedCase hashMapGet = TimedCase.of("hashMap", (round, iterations2) -> {
+                    for (long i = 0; i < iterations2; i++) {
+                        final String val = hashMap.get("foo");
+                        if (val == null) {
+                            throw new RuntimeException("Empty");
+                        }
+                    }
+                });
+
+                final TimedCase concurrentMapGet = TimedCase.of("concurrentMap", (round, iterations2) -> {
+                    for (long i = 0; i < iterations2; i++) {
+                        final String val = concurrentHashMap.get("foo");
+                        if (val == null) {
+                            throw new RuntimeException("Empty");
+                        }
+                    }
+                });
+
+                TestUtil.comparePerformance(
+                        rounds,
+                        iterations,
+                        LOGGER::info,
+                        lmdbGetCaseWithSer,
+                        lmdbGetCaseWithoutSer,
+                        hashMapGet,
+                        concurrentMapGet);
+            }
+        });
+    }
+
     private void putData(final AbstractLmdbDb<Integer, String> db,
                          final int iterations,
                          final int rounds,