From f75e06dba0855fefe54a24bd1461684250fc11cf Mon Sep 17 00:00:00 2001 From: "Aaron.Riekenberg" Date: Mon, 10 Jun 2024 18:14:27 -0500 Subject: [PATCH 1/8] Add ReferenceCountMap. --- examples/map/referencecount/build.gradle.kts | 29 ++++ .../map/referencecount/ReferenceCount.kt | 81 +++++++++ settings.gradle.kts | 1 + .../map/ReferenceCountMap.kt | 162 ++++++++++++++++++ 4 files changed, 273 insertions(+) create mode 100644 examples/map/referencecount/build.gradle.kts create mode 100644 examples/map/referencecount/src/main/kotlin/com/target/nativememoryallocator/examples/map/referencecount/ReferenceCount.kt create mode 100644 src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt diff --git a/examples/map/referencecount/build.gradle.kts b/examples/map/referencecount/build.gradle.kts new file mode 100644 index 0000000..b7863eb --- /dev/null +++ b/examples/map/referencecount/build.gradle.kts @@ -0,0 +1,29 @@ +import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar + +plugins { + kotlin("jvm") + id("com.github.johnrengelman.shadow") version "7.1.2" +} + +repositories { + mavenCentral() +} + +dependencies { + implementation(project(":examples:map:utils")) +} + +tasks { + named("shadowJar") { + archiveBaseName.set("referencecount-shadowjar") + manifest { + attributes(mapOf("Main-Class" to "com.target.nativememoryallocator.examples.map.referencecount.ReferenceCountKt")) + } + } +} + +tasks { + build { + dependsOn(shadowJar) + } +} \ No newline at end of file diff --git a/examples/map/referencecount/src/main/kotlin/com/target/nativememoryallocator/examples/map/referencecount/ReferenceCount.kt b/examples/map/referencecount/src/main/kotlin/com/target/nativememoryallocator/examples/map/referencecount/ReferenceCount.kt new file mode 100644 index 0000000..7c1aece --- /dev/null +++ b/examples/map/referencecount/src/main/kotlin/com/target/nativememoryallocator/examples/map/referencecount/ReferenceCount.kt @@ -0,0 +1,81 @@ +package com.target.nativememoryallocator.examples.map.referencecount + +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 com.target.nativememoryallocator.map.ReferenceCountMap +import kotlinx.coroutines.* +import mu.KotlinLogging +import kotlin.random.Random + +private val logger = KotlinLogging.logger {} + +private class OffHeap { + + 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 referenceCountMap = ReferenceCountMap( + valueSerializer = CacheObjectSerializer(), + nativeMemoryAllocator = nativeMemoryAllocator, + ) + + 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)}" } + } + referenceCountMap.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 = ${referenceCountMap.size}" } + logger.info { "nativeMemoryAllocator.nativeMemoryAllocatorMetadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}" } + + val randomIndexValue = referenceCountMap.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)}" } + } + + while (true) { + delay(1_000) + } + } + +} + +suspend fun main() { + withContext(Dispatchers.Default) { + OffHeap().run() + } +} \ No newline at end of file diff --git a/settings.gradle.kts b/settings.gradle.kts index e1d0be0..375a6d9 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -10,4 +10,5 @@ include( "examples:map:offheap-eviction", "examples:map:offheap-eviction-operationcounters", "examples:map:offheap-flatbuffers", + "examples:map:referencecount", ) diff --git a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt new file mode 100644 index 0000000..c523b1b --- /dev/null +++ b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt @@ -0,0 +1,162 @@ +package com.target.nativememoryallocator.map + +import com.target.nativememoryallocator.allocator.NativeMemoryAllocator +import com.target.nativememoryallocator.allocator.NativeMemoryAllocatorBuilder +import com.target.nativememoryallocator.buffer.NativeMemoryBuffer +import com.target.nativememoryallocator.buffer.OnHeapMemoryBuffer +import com.target.nativememoryallocator.buffer.OnHeapMemoryBufferFactory +import java.lang.annotation.Native +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.ConcurrentMap +import java.util.concurrent.atomic.AtomicInteger + +private class ReferenceCountValue( + val nativeMemoryBuffer: NativeMemoryBuffer, +) { + private val referenceCount = AtomicInteger(0) + + fun incrementReferenceCount(): Int { + return referenceCount.incrementAndGet() + } + + fun decrementReferenceCount(): Int { + return referenceCount.decrementAndGet() + } + +} + +class ReferenceCountMap( + private val valueSerializer: NativeMemoryMapSerializer, + private val nativeMemoryAllocator: NativeMemoryAllocator, +) { + + private val innerMap = ConcurrentHashMap() + + private fun freeNativeMemoryBuffer( + nativeMemoryBuffer: NativeMemoryBuffer, + ) { + nativeMemoryAllocator.freeNativeMemoryBuffer(nativeMemoryBuffer) + } + + fun put(key: KEY_TYPE, value: VALUE_TYPE) { + + val newValueByteArray = valueSerializer.serializeToByteArray(value = value) + val newCapacityBytes = newValueByteArray.size + + val nativeMemoryBuffer = + nativeMemoryAllocator.allocateNativeMemoryBuffer(capacityBytes = newCapacityBytes) + + nativeMemoryBuffer.copyFromArray(byteArray = newValueByteArray) + + val newRefCountedValue = ReferenceCountValue( + nativeMemoryBuffer = nativeMemoryBuffer, + ) + newRefCountedValue.incrementReferenceCount() + + val previousValue = innerMap.put(key = key, value = newRefCountedValue) + + if (previousValue != null) { + if (previousValue.decrementReferenceCount() == 0) { + freeNativeMemoryBuffer(previousValue.nativeMemoryBuffer) + } + } + } + + fun get(key: KEY_TYPE): VALUE_TYPE? { + val mapValue = innerMap.computeIfPresent(key) { _, currentValue -> + currentValue.incrementReferenceCount() + + currentValue + } ?: return null + + try { + // copy NMA to onheap buffer + val onHeapMemoryBuffer = + OnHeapMemoryBufferFactory.newOnHeapMemoryBuffer(initialCapacityBytes = mapValue.nativeMemoryBuffer.capacityBytes) + + mapValue.nativeMemoryBuffer.copyToOnHeapMemoryBuffer(onHeapMemoryBuffer) + + val deserializedValue = + valueSerializer.deserializeFromOnHeapMemoryBuffer(onHeapMemoryBuffer = onHeapMemoryBuffer) + + return deserializedValue + } finally { + if (mapValue.decrementReferenceCount() == 0) { + freeNativeMemoryBuffer(mapValue.nativeMemoryBuffer) + } + } + + } + + fun delete(key: KEY_TYPE) { + val previousValue = innerMap.remove(key) + + if (previousValue != null) { + if (previousValue.decrementReferenceCount() == 0) { + freeNativeMemoryBuffer(previousValue.nativeMemoryBuffer) + } + } + } + + val size: Int = innerMap.size +} + +fun main() { + class TestSerializer : NativeMemoryMapSerializer { + + override fun deserializeFromOnHeapMemoryBuffer(onHeapMemoryBuffer: OnHeapMemoryBuffer): String { + return String(onHeapMemoryBuffer.toTrimmedArray()) + } + + override fun serializeToByteArray(value: String): ByteArray { + return value.toByteArray() + } + + } + + val nativeMemoryAllocator = NativeMemoryAllocatorBuilder( + zeroNativeMemoryOnStartup = false, + nativeMemorySizeBytes = 100 * 1024 * 1024, + pageSizeBytes = 1024, + ).build() + + val map = ReferenceCountMap( + nativeMemoryAllocator = nativeMemoryAllocator, + valueSerializer = TestSerializer(), + ) + + println("map.size = ${map.size}") + + map.put( + key = "123", value = "234", + ) + + println("map.size = ${map.size}") + + var value = map.get(key = "123") + + println("got value = $value") + + map.put( + key = "123", value = "345", + ) + + println("map.size = ${map.size}") + + value = map.get(key = "123") + + println("got value = $value") + + value = map.get(key = "234") + + println("got value = $value") + + map.delete(key = "234") + map.delete(key = "123") + + value = map.get(key = "123") + + println("after delete got value = $value") + + println("map.size = ${map.size}") +} \ No newline at end of file From 0f986b9b19bd6b724aa0fc6d2e44b12688484bb2 Mon Sep 17 00:00:00 2001 From: "Aaron.Riekenberg" Date: Tue, 11 Jun 2024 07:34:53 -0500 Subject: [PATCH 2/8] Cleanup. --- .../map/ReferenceCountMap.kt | 52 +++++++++++++++---- 1 file changed, 41 insertions(+), 11 deletions(-) diff --git a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt index c523b1b..bff5c2b 100644 --- a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt +++ b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt @@ -35,9 +35,18 @@ class ReferenceCountMap( private fun freeNativeMemoryBuffer( nativeMemoryBuffer: NativeMemoryBuffer, ) { + println("freeNativeMemoryBuffer") nativeMemoryAllocator.freeNativeMemoryBuffer(nativeMemoryBuffer) } + private fun decrementReferenceCount( + referenceCountValue: ReferenceCountValue, + ) { + if (referenceCountValue.decrementReferenceCount() == 0) { + freeNativeMemoryBuffer(referenceCountValue.nativeMemoryBuffer) + } + } + fun put(key: KEY_TYPE, value: VALUE_TYPE) { val newValueByteArray = valueSerializer.serializeToByteArray(value = value) @@ -56,9 +65,7 @@ class ReferenceCountMap( val previousValue = innerMap.put(key = key, value = newRefCountedValue) if (previousValue != null) { - if (previousValue.decrementReferenceCount() == 0) { - freeNativeMemoryBuffer(previousValue.nativeMemoryBuffer) - } + decrementReferenceCount(previousValue) } } @@ -81,24 +88,43 @@ class ReferenceCountMap( return deserializedValue } finally { - if (mapValue.decrementReferenceCount() == 0) { - freeNativeMemoryBuffer(mapValue.nativeMemoryBuffer) - } + decrementReferenceCount(mapValue) } + } + + + fun getWithBuffer( + key: KEY_TYPE, + onHeapMemoryBuffer: OnHeapMemoryBuffer, + ): VALUE_TYPE? { + val mapValue = innerMap.computeIfPresent(key) { _, currentValue -> + currentValue.incrementReferenceCount() + + currentValue + } ?: return null + try { + mapValue.nativeMemoryBuffer.copyToOnHeapMemoryBuffer(onHeapMemoryBuffer) + + val deserializedValue = + valueSerializer.deserializeFromOnHeapMemoryBuffer(onHeapMemoryBuffer = onHeapMemoryBuffer) + + return deserializedValue + } finally { + decrementReferenceCount(mapValue) + } } fun delete(key: KEY_TYPE) { val previousValue = innerMap.remove(key) if (previousValue != null) { - if (previousValue.decrementReferenceCount() == 0) { - freeNativeMemoryBuffer(previousValue.nativeMemoryBuffer) - } + decrementReferenceCount(previousValue) } } - val size: Int = innerMap.size + val size: Int + get() = innerMap.size } fun main() { @@ -134,8 +160,12 @@ fun main() { println("map.size = ${map.size}") var value = map.get(key = "123") + println("get value = $value") - println("got value = $value") + val onHeapMemoryBuffer = OnHeapMemoryBufferFactory.newOnHeapMemoryBuffer(initialCapacityBytes = 2) + value = map.getWithBuffer(key = "123", onHeapMemoryBuffer = onHeapMemoryBuffer) + + println("getWithBuffer value = $value") map.put( key = "123", value = "345", From 0ef68287ee3248a54b5cdb9455afc826e319bcfe Mon Sep 17 00:00:00 2001 From: "Aaron.Riekenberg" Date: Tue, 11 Jun 2024 07:36:24 -0500 Subject: [PATCH 3/8] Add MicrometerReferenceCountMapMetrics. --- .../metrics/micrometer/MicrometerMetrics.kt | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/main/kotlin/com/target/nativememoryallocator/metrics/micrometer/MicrometerMetrics.kt b/src/main/kotlin/com/target/nativememoryallocator/metrics/micrometer/MicrometerMetrics.kt index 4bcc043..e0798d0 100644 --- a/src/main/kotlin/com/target/nativememoryallocator/metrics/micrometer/MicrometerMetrics.kt +++ b/src/main/kotlin/com/target/nativememoryallocator/metrics/micrometer/MicrometerMetrics.kt @@ -2,6 +2,7 @@ package com.target.nativememoryallocator.metrics.micrometer import com.target.nativememoryallocator.allocator.NativeMemoryAllocator import com.target.nativememoryallocator.map.BaseNativeMemoryMap +import com.target.nativememoryallocator.map.ReferenceCountMap import io.micrometer.core.instrument.Gauge import io.micrometer.core.instrument.MeterRegistry import io.micrometer.core.instrument.Tags @@ -151,4 +152,18 @@ class MicrometerNativeMemoryMapMetrics( ) { operationCounters.numGetsNonNullValue.toDouble() } } } +} + +class MicrometerReferenceCountMapMetrics( + referenceCountMap: ReferenceCountMap<*, *>, + meterRegistry: MeterRegistry, + tags: Tags = Tags.empty(), +) { + init { + meterRegistry.registerGauge( + name = "nativeMemoryMap.size", + gaugeObject = referenceCountMap, + tags = tags, + ) { referenceCountMap.size.toDouble() } + } } \ No newline at end of file From 9cf1c69d5d78bab3cef6e92c0abe7be71b4db96d Mon Sep 17 00:00:00 2001 From: "Aaron.Riekenberg" Date: Tue, 11 Jun 2024 07:37:04 -0500 Subject: [PATCH 4/8] remove println. --- .../com/target/nativememoryallocator/map/ReferenceCountMap.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt index bff5c2b..89db017 100644 --- a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt +++ b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt @@ -35,7 +35,6 @@ class ReferenceCountMap( private fun freeNativeMemoryBuffer( nativeMemoryBuffer: NativeMemoryBuffer, ) { - println("freeNativeMemoryBuffer") nativeMemoryAllocator.freeNativeMemoryBuffer(nativeMemoryBuffer) } From 06b0b9a05bd623f3a747db4663bd52d5030bcfbb Mon Sep 17 00:00:00 2001 From: "Aaron.Riekenberg" Date: Tue, 11 Jun 2024 07:47:20 -0500 Subject: [PATCH 5/8] Remove blank line, print nma metadata. --- .../com/target/nativememoryallocator/map/ReferenceCountMap.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt index 89db017..f8e0e95 100644 --- a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt +++ b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt @@ -91,7 +91,6 @@ class ReferenceCountMap( } } - fun getWithBuffer( key: KEY_TYPE, onHeapMemoryBuffer: OnHeapMemoryBuffer, @@ -188,4 +187,6 @@ fun main() { println("after delete got value = $value") println("map.size = ${map.size}") + + println("nma metadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}") } \ No newline at end of file From e42bd1212da434ad5e82267f2cd1e3392c42db71 Mon Sep 17 00:00:00 2001 From: "Aaron.Riekenberg" Date: Tue, 11 Jun 2024 07:50:34 -0500 Subject: [PATCH 6/8] Add ReferenceCountMapSpec. --- .../map/ReferenceCountMap.kt | 69 ----------------- .../map/impl/ReferenceCountMapSpec.kt | 74 +++++++++++++++++++ 2 files changed, 74 insertions(+), 69 deletions(-) create mode 100644 src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt diff --git a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt index f8e0e95..f62a414 100644 --- a/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt +++ b/src/main/kotlin/com/target/nativememoryallocator/map/ReferenceCountMap.kt @@ -1,13 +1,10 @@ package com.target.nativememoryallocator.map import com.target.nativememoryallocator.allocator.NativeMemoryAllocator -import com.target.nativememoryallocator.allocator.NativeMemoryAllocatorBuilder import com.target.nativememoryallocator.buffer.NativeMemoryBuffer import com.target.nativememoryallocator.buffer.OnHeapMemoryBuffer import com.target.nativememoryallocator.buffer.OnHeapMemoryBufferFactory -import java.lang.annotation.Native import java.util.concurrent.ConcurrentHashMap -import java.util.concurrent.ConcurrentMap import java.util.concurrent.atomic.AtomicInteger private class ReferenceCountValue( @@ -123,70 +120,4 @@ class ReferenceCountMap( val size: Int get() = innerMap.size -} - -fun main() { - class TestSerializer : NativeMemoryMapSerializer { - - override fun deserializeFromOnHeapMemoryBuffer(onHeapMemoryBuffer: OnHeapMemoryBuffer): String { - return String(onHeapMemoryBuffer.toTrimmedArray()) - } - - override fun serializeToByteArray(value: String): ByteArray { - return value.toByteArray() - } - - } - - val nativeMemoryAllocator = NativeMemoryAllocatorBuilder( - zeroNativeMemoryOnStartup = false, - nativeMemorySizeBytes = 100 * 1024 * 1024, - pageSizeBytes = 1024, - ).build() - - val map = ReferenceCountMap( - nativeMemoryAllocator = nativeMemoryAllocator, - valueSerializer = TestSerializer(), - ) - - println("map.size = ${map.size}") - - map.put( - key = "123", value = "234", - ) - - println("map.size = ${map.size}") - - var value = map.get(key = "123") - println("get value = $value") - - val onHeapMemoryBuffer = OnHeapMemoryBufferFactory.newOnHeapMemoryBuffer(initialCapacityBytes = 2) - value = map.getWithBuffer(key = "123", onHeapMemoryBuffer = onHeapMemoryBuffer) - - println("getWithBuffer value = $value") - - map.put( - key = "123", value = "345", - ) - - println("map.size = ${map.size}") - - value = map.get(key = "123") - - println("got value = $value") - - value = map.get(key = "234") - - println("got value = $value") - - map.delete(key = "234") - map.delete(key = "123") - - value = map.get(key = "123") - - println("after delete got value = $value") - - println("map.size = ${map.size}") - - println("nma metadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}") } \ No newline at end of file diff --git a/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt b/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt new file mode 100644 index 0000000..25447d0 --- /dev/null +++ b/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt @@ -0,0 +1,74 @@ +package com.target.nativememoryallocator.map.impl + +import com.target.nativememoryallocator.allocator.NativeMemoryAllocatorBuilder +import com.target.nativememoryallocator.buffer.OnHeapMemoryBuffer +import com.target.nativememoryallocator.buffer.OnHeapMemoryBufferFactory +import com.target.nativememoryallocator.map.NativeMemoryMapSerializer +import com.target.nativememoryallocator.map.ReferenceCountMap + +// TODO make unit test +fun main() { + class TestSerializer : NativeMemoryMapSerializer { + + override fun deserializeFromOnHeapMemoryBuffer(onHeapMemoryBuffer: OnHeapMemoryBuffer): String { + return String(onHeapMemoryBuffer.toTrimmedArray()) + } + + override fun serializeToByteArray(value: String): ByteArray { + return value.toByteArray() + } + + } + + val nativeMemoryAllocator = NativeMemoryAllocatorBuilder( + zeroNativeMemoryOnStartup = false, + nativeMemorySizeBytes = 100 * 1024 * 1024, + pageSizeBytes = 1024, + ).build() + + val map = ReferenceCountMap( + nativeMemoryAllocator = nativeMemoryAllocator, + valueSerializer = TestSerializer(), + ) + + println("map.size = ${map.size}") + + map.put( + key = "123", value = "234", + ) + + println("map.size = ${map.size}") + + var value = map.get(key = "123") + println("get value = $value") + + val onHeapMemoryBuffer = OnHeapMemoryBufferFactory.newOnHeapMemoryBuffer(initialCapacityBytes = 2) + value = map.getWithBuffer(key = "123", onHeapMemoryBuffer = onHeapMemoryBuffer) + + println("getWithBuffer value = $value") + + map.put( + key = "123", value = "345", + ) + + println("map.size = ${map.size}") + + value = map.get(key = "123") + + println("got value = $value") + + value = map.get(key = "234") + + println("got value = $value") + + map.delete(key = "234") + map.delete(key = "123") + + value = map.get(key = "123") + + println("after delete got value = $value") + + println("map.size = ${map.size}") + + println("nma metadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}") +} \ No newline at end of file From 96aeb477e18fb78c5b1aa40b4caaa6fc3761f714 Mon Sep 17 00:00:00 2001 From: "Aaron.Riekenberg" Date: Tue, 11 Jun 2024 08:46:27 -0500 Subject: [PATCH 7/8] Use logger, more tests. --- .../map/impl/ReferenceCountMapSpec.kt | 31 +++++++++++++------ 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt b/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt index 25447d0..b65c7fa 100644 --- a/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt +++ b/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt @@ -5,6 +5,9 @@ import com.target.nativememoryallocator.buffer.OnHeapMemoryBuffer import com.target.nativememoryallocator.buffer.OnHeapMemoryBufferFactory import com.target.nativememoryallocator.map.NativeMemoryMapSerializer import com.target.nativememoryallocator.map.ReferenceCountMap +import mu.KotlinLogging + +private val logger = KotlinLogging.logger {} // TODO make unit test fun main() { @@ -31,44 +34,52 @@ fun main() { valueSerializer = TestSerializer(), ) - println("map.size = ${map.size}") + logger.info { "map.size = ${map.size}" } map.put( key = "123", value = "234", ) - println("map.size = ${map.size}") + logger.info { "map.size = ${map.size}" } var value = map.get(key = "123") - println("get value = $value") + logger.info { "get value = $value" } val onHeapMemoryBuffer = OnHeapMemoryBufferFactory.newOnHeapMemoryBuffer(initialCapacityBytes = 2) value = map.getWithBuffer(key = "123", onHeapMemoryBuffer = onHeapMemoryBuffer) - println("getWithBuffer value = $value") + logger.info { "getWithBuffer value = $value" } map.put( key = "123", value = "345", ) - println("map.size = ${map.size}") + map.put( + key = "234", value = "234", + ) + + logger.info { "map.size = ${map.size}" } + + logger.info { "nma metadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}" } value = map.get(key = "123") - println("got value = $value") + logger.info { "got value = $value" } value = map.get(key = "234") - println("got value = $value") + logger.info { "got value = $value" } map.delete(key = "234") + logger.info { "after delete 234 nma metadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}" } + map.delete(key = "123") value = map.get(key = "123") - println("after delete got value = $value") + logger.info { "after delete got value = $value" } - println("map.size = ${map.size}") + logger.info { "map.size = ${map.size}" } - println("nma metadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}") + logger.info { "nma metadata = ${nativeMemoryAllocator.nativeMemoryAllocatorMetadata}" } } \ No newline at end of file From 5971cfb07928318c8fabbcb09a18475ae3a10459 Mon Sep 17 00:00:00 2001 From: "Aaron.Riekenberg" Date: Tue, 11 Jun 2024 09:18:28 -0500 Subject: [PATCH 8/8] Add loops. --- .../map/impl/ReferenceCountMapSpec.kt | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt b/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt index b65c7fa..9b4be30 100644 --- a/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt +++ b/src/test/kotlin/com/target/nativememoryallocator/map/impl/ReferenceCountMapSpec.kt @@ -54,9 +54,11 @@ fun main() { key = "123", value = "345", ) - map.put( - key = "234", value = "234", - ) + for (i in 0 until 100) { + map.put( + key = "234", value = "234", + ) + } logger.info { "map.size = ${map.size}" } @@ -66,7 +68,9 @@ fun main() { logger.info { "got value = $value" } - value = map.get(key = "234") + for (i in 0 until 100) { + value = map.get(key = "234") + } logger.info { "got value = $value" }