Add OffHeapDemoWithEvictionAndOperationCounters.

Author: aaronriekenberg

examples/map/README.md

@@ -5,7 +5,8 @@
 * Put 20,000 CacheObject instances into a ConcurrentHashMap.
 * Each CacheObject instance contains a random string of length 500KB.
 * This is a total of 10 GB of data stored on the normal Java heap.
-* This application does not make use of any features of the native_memory_allocator library.  It is provided for comparison with NativeMemoryMap demos using off-heap storage.
+* This application does not make use of any features of the native_memory_allocator library. It is provided for
+  comparison with NativeMemoryMap demos using off-heap storage.
 
 ## OffHeapDemo
 
@@ -17,4 +18,8 @@
 ## OffHeapDemoWithEviction
 
 * Same as OffHeapDemo but uses the Caffeine backend with maximumSize of 10,000 entries.
-* Expect 10,000 entries at end of run with 10,000 total evictions.
+* Expect 10,000 entries at end of run with 10,000 total evictions.
+
+## OffHeapDemoWithEvictionAndOperationCounters
+
+* Same as OffHeapDemoWithEviction but enables operation counters and logs them at the end of the demo.

examples/map/src/main/kotlin/com/target/nativememoryallocator/examples/map/OffHeapDemoWithEvictionAndOperationCounters.kt

@@ -0,0 +1,95 @@
+package com.target.nativememoryallocator.examples.map
+
+import com.target.nativememoryallocator.allocator.NativeMemoryAllocatorBuilder
+import com.target.nativememoryallocator.examples.map.utils.CacheObject
+import com.target.nativememoryallocator.examples.map.utils.CacheObjectSerializer
+import com.target.nativememoryallocator.examples.map.utils.buildRandomString
+import com.target.nativememoryallocator.map.NativeMemoryMapBackend
+import com.target.nativememoryallocator.map.NativeMemoryMapBuilder
+import kotlinx.coroutines.*
+import mu.KotlinLogging
+import kotlin.random.Random
+
+private val logger = KotlinLogging.logger {}
+
+
+/**
+ * Same as [OffHeapDemoWithEviction] but enables operation counters
+ */
+class OffHeapDemoWithEvictionAndOperationCounters {
+
+    private val numEntries = 20_000
+
+    private val randomIndex = Random.nextInt(0, numEntries)
+
+    private val nativeMemoryAllocator = NativeMemoryAllocatorBuilder(
+        pageSizeBytes = 4_096, // 4 KB
+        nativeMemorySizeBytes = (20L * 1_024L * 1_024L * 1_024L), // 20 GB
+    ).build()
+
+    private val nativeMemoryMap = NativeMemoryMapBuilder<Int, CacheObject>(
+        valueSerializer = CacheObjectSerializer(),
+        nativeMemoryAllocator = nativeMemoryAllocator,
+        backend = NativeMemoryMapBackend.CAFFEINE,
+        caffeineConfigFunction = { caffeineConfigBuilder ->
+            caffeineConfigBuilder
+                .maximumSize(10_000)
+                .recordStats()
+        },
+        enableOperationCounters = true
+    ).build()
+
+    private fun putValueIntoMap(i: Int) {
+        if ((i % 100) == 0) {
+            logger.info { "put i = $i" }
+        }
+        val value = buildRandomString(length = 500 * 1_024)
+        if (i == randomIndex) {
+            logger.info { "put randomIndex = $randomIndex value.length = ${value.length}" }
+            logger.info { "value.substring(0,20) = ${value.substring(0, 20)}" }
+        }
+        nativeMemoryMap.put(
+            key = i,
+            value = CacheObject(
+                s = value,
+            ),
+        )
+    }
+
+    suspend fun run() {
+        logger.info { "begin run randomIndex = $randomIndex" }
+
+        coroutineScope {
+            (0 until numEntries).forEach { i ->
+                launch {
+                    putValueIntoMap(i = i)
+                }
+            }
+        }
+
+        logger.info { "nativeMemoryMap.size = ${nativeMemoryMap.size}" }
+        logger.info { "nativeMemoryAllocator.nativeMemoryAllocatorMetadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}" }
+
+        val randomIndexValue = nativeMemoryMap.get(key = randomIndex)
+        randomIndexValue?.let {
+            logger.info { "get randomIndex = $randomIndex" }
+            logger.info { "randomIndexValue.s.length = ${it.s.length}" }
+            logger.info { "randomIndexValue.s.substring(0,20) = ${it.s.substring(0, 20)}" }
+        }
+
+        logger.info { "caffeine eviction count = ${nativeMemoryMap.stats.caffeineStats?.evictionCount()}" }
+
+        logger.info { "nativeMemoryMap.operationCounters = ${nativeMemoryMap.operationCounters}" }
+
+        while (true) {
+            delay(1_000)
+        }
+    }
+
+}
+
+suspend fun main() {
+    withContext(Dispatchers.Default) {
+        OffHeapDemoWithEvictionAndOperationCounters().run()
+    }
+}

src/main/kotlin/com/target/nativememoryallocator/map/impl/OperationCountedNativeMemoryMapImpl.kt

@@ -18,7 +18,13 @@ internal class OperationCountersImpl(
     override val numDeletesNoChange: AtomicLong = AtomicLong(0),
     override val numGetsNullValue: AtomicLong = AtomicLong(0),
     override val numGetsNonNullValue: AtomicLong = AtomicLong(0),
-) : NativeMemoryMapOperationCounters
+) : NativeMemoryMapOperationCounters {
+
+    override fun toString(): String {
+        return "OperationCountersImpl(numPutsNoChange=$numPutsNoChange, numPutsFreedBuffer=$numPutsFreedBuffer, numPutsReusedBuffer=$numPutsReusedBuffer, numPutsNewBuffer=$numPutsNewBuffer, numDeletesFreedBuffer=$numDeletesFreedBuffer, numDeletesNoChange=$numDeletesNoChange, numGetsNullValue=$numGetsNullValue, numGetsNonNullValue=$numGetsNonNullValue)"
+    }
+
+}
 
 /**
  * Implementation of [NativeMemoryMap] supporting operation counters.