JMH benchmark for LruCache.

selekt-java/src/jmh/kotlin/com/bloomberg/selekt/cache/benchmarks/LruCacheBenchmark.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2024 Bloomberg Finance L.P.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.bloomberg.selekt.cache.benchmarks
+
+import com.bloomberg.selekt.cache.LruCache
+import org.openjdk.jmh.annotations.Benchmark
+import org.openjdk.jmh.annotations.BenchmarkMode
+import org.openjdk.jmh.annotations.Level
+import org.openjdk.jmh.annotations.Mode
+import org.openjdk.jmh.annotations.Scope
+import org.openjdk.jmh.annotations.Setup
+import org.openjdk.jmh.annotations.State
+
+@State(Scope.Thread)
+open class CacheInput {
+    internal lateinit var cache: LruCache<Any>
+
+    @Setup(Level.Iteration)
+    fun setUp() {
+        cache = LruCache(1) {}
+    }
+}
+
+open class LruCacheBenchmark {
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    fun getEntry(input: CacheInput) = input.cache.run {
+        this["1", {}]
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    fun getEntryWithEviction(input: CacheInput) = input.cache.run {
+        this["1", {}]
+        this["2", {}]
+    }
+}

selekt-java/src/main/kotlin/com/bloomberg/selekt/SQLConnection.kt

@@ -16,6 +16,7 @@
 
 package com.bloomberg.selekt
 
+import com.bloomberg.selekt.cache.LruCache
 import com.bloomberg.selekt.commons.forEachByPosition
 import com.bloomberg.selekt.commons.forUntil
 import javax.annotation.concurrent.NotThreadSafe

selekt-java/src/main/kotlin/com/bloomberg/selekt/LruCache.kt → selekt-java/src/main/kotlin/com/bloomberg/selekt/cache/LruCache.kt

@@ -14,15 +14,18 @@
  * limitations under the License.
  */
 
-package com.bloomberg.selekt
+package com.bloomberg.selekt.cache
 
 import javax.annotation.concurrent.NotThreadSafe
 
 private const val NO_RESIZE_LOAD_FACTOR = 1.1f
 
 @NotThreadSafe
-internal class LruCache<T : Any>(private val maxSize: Int, private val disposal: (T) -> Unit) {
-    private val store = object : LinkedHashMap<String, T>(maxSize, NO_RESIZE_LOAD_FACTOR, true) {
+class LruCache<T : Any>(private val maxSize: Int, private val disposal: (T) -> Unit) {
+    @PublishedApi
+    @JvmField
+    @JvmSynthetic
+    internal val store = object : LinkedHashMap<String, T>(maxSize, NO_RESIZE_LOAD_FACTOR, true) {
         override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, T>) = (size > maxSize).also {
             if (it) {
                 disposal(eldest.value)

selekt-java/src/test/kotlin/com/bloomberg/selekt/LruCacheTest.kt → selekt-java/src/test/kotlin/com/bloomberg/selekt/cache/LruCacheTest.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.bloomberg.selekt
+package com.bloomberg.selekt.cache
 
 import org.junit.jupiter.api.Test
 import org.mockito.kotlin.anyOrNull
@@ -29,8 +29,42 @@ import org.mockito.kotlin.whenever
 import kotlin.test.assertFalse
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
+import kotlin.test.fail
 
 internal class LruCacheTest {
+    @Test
+    fun get() {
+        val first = Any()
+        val disposal: (Any) -> Unit = mock { onGeneric { invoke(it) } doReturn Unit }
+        val cache = LruCache(1, disposal)
+        cache["1", { first }]
+        assertSame(first, cache["1", { fail() }])
+    }
+
+    @Test
+    fun getTwo() {
+        val first = Any()
+        val second = Any()
+        val disposal: (Any) -> Unit = mock { onGeneric { invoke(it) } doReturn Unit }
+        val cache = LruCache(2, disposal)
+        cache["1", { first }]
+        cache["2", { second }]
+        assertSame(first, cache["1", { fail() }])
+        assertSame(second, cache["2", { fail() }])
+    }
+
+    @Test
+    fun getAfterEvict() {
+        val first = Any()
+        val second = Any()
+        val disposal: (Any) -> Unit = mock { onGeneric { invoke(it) } doReturn Unit }
+        val cache = LruCache(1, disposal)
+        cache["1", { first }]
+        cache["2", { second }]
+        assertFalse(cache.containsKey("1"))
+        assertSame(second, cache["2", { fail() }])
+    }
+
     @Test
     fun evict() {
         val first = Any()
@@ -43,6 +77,7 @@ internal class LruCacheTest {
         inOrder(disposal) {
             verify(disposal, times(1)).invoke(same(first))
         }
+        assertSame(second, cache["2", { fail() }])
     }
 
     @Test