Add canonicalization benchmarks

Author: Abduqodiri Qurbonzoda

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/immutableMap/Remove.kt

@@ -20,6 +20,7 @@ import benchmarks.*
 import kotlinx.collections.immutable.PersistentMap
 import kotlinx.collections.immutable.persistentMapOf
 import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
 
 @State(Scope.Thread)
 open class Remove {
@@ -34,11 +35,13 @@ open class Remove {
 
     private var keys = listOf<IntWrapper>()
     private var persistentMap = persistentMapOf<IntWrapper, String>()
+    private var halfHeightPersistentMap = persistentMapOf<IntWrapper, String>()
 
     @Setup(Level.Trial)
     fun prepare() {
         keys = generateKeys(hashCodeType, size)
         persistentMap = persistentMapPut(implementation, keys)
+        halfHeightPersistentMap = halfHeightPersistentMap(persistentMap, keys)
 
         if (hashCodeType == NON_EXISTING_HASH_CODE)
             keys = generateKeys(hashCodeType, size)
@@ -52,4 +55,45 @@ open class Remove {
         }
         return map
     }
+
+    /**
+     * Puts `size - entriesForHalfHeight(size)` new entries to a persistent map of size `entriesForHalfHeight(size)`
+     * that had initially [size] entries.
+     *
+     * Measures mean time and memory spent per (roughly one) `put` operation.
+     *
+     * Expected time: [Put.put]
+     * Expected memory: [Put.put]
+     */
+    @Benchmark
+    fun putAfterRemove(): PersistentMap<IntWrapper, String> {
+        var map = halfHeightPersistentMap
+
+        repeat(size - halfHeightPersistentMap.size) { index ->
+            map = map.put(keys[index], "some element")
+        }
+
+        return map
+    }
+
+    /**
+     * Iterates keys of a persistent map of size `entriesForHalfHeight(size)` several times until iterating [size] elements.
+     *
+     * Measures mean time and memory spent per `iterate` operation.
+     *
+     * Expected time: [Iterate.iterateKeys] with [Iterate.size] = `entriesForHalfHeight([size])`
+     * Expected memory: [Iterate.iterateKeys] with [Iterate.size] = `entriesForHalfHeight([size])`
+     */
+    @Benchmark
+    fun iterateKeysAfterRemove(bh: Blackhole) {
+        var count = 0
+        while (count < size) {
+            for (e in halfHeightPersistentMap) {
+                bh.consume(e)
+
+                if (++count == size)
+                    break
+            }
+        }
+    }
 }

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/immutableMap/utils.kt

@@ -20,6 +20,8 @@ import benchmarks.*
 import kotlinx.collections.immutable.PersistentMap
 import kotlinx.collections.immutable.persistentHashMapOf
 import kotlinx.collections.immutable.persistentMapOf
+import kotlin.math.ceil
+import kotlin.math.log
 
 
 fun <K, V> emptyPersistentMap(implementation: String): PersistentMap<K, V> = when (implementation) {
@@ -35,3 +37,22 @@ fun <K> persistentMapPut(implementation: String, keys: List<K>): PersistentMap<K
     }
     return map
 }
+
+private fun entriesForHalfHeight(size: Int): Int {
+    val branchingFactor = 32
+    val logBranchingFactor = 5
+
+    val approximateHeight = ceil(log(size.toDouble(), branchingFactor.toDouble())).toInt()
+    return 1 shl ((approximateHeight / 2) * logBranchingFactor)
+}
+
+
+fun <K> halfHeightPersistentMap(persistentMap: PersistentMap<K, String>, keys: List<K>): PersistentMap<K, String> {
+    val elementsToLeave = entriesForHalfHeight(persistentMap.size)
+
+    var map = persistentMap
+    repeat(persistentMap.size - elementsToLeave) { index ->
+        map = map.remove(keys[index])
+    }
+    return map
+}

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/immutableSet/Remove.kt

@@ -20,6 +20,7 @@ import benchmarks.*
 import kotlinx.collections.immutable.ImmutableSet
 import kotlinx.collections.immutable.persistentSetOf
 import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
 
 @State(Scope.Thread)
 open class Remove {
@@ -34,11 +35,13 @@ open class Remove {
 
     private var elements = listOf<IntWrapper>()
     private var persistentSet = persistentSetOf<IntWrapper>()
+    private var halfHeightPersistentSet = persistentSetOf<IntWrapper>()
 
     @Setup(Level.Trial)
     fun prepare() {
         elements = generateElements(hashCodeType, size)
         persistentSet = persistentSetAdd(implementation, elements)
+        halfHeightPersistentSet = halfHeightPersistentSet(persistentSet, elements)
 
         if (hashCodeType == NON_EXISTING_HASH_CODE)
             elements = generateElements(hashCodeType, size)
@@ -52,4 +55,45 @@ open class Remove {
         }
         return set
     }
+
+    /**
+     * Adds `size - elementsForHalfHeight(size)` new elements to a persistent set of size `elementsForHalfHeight(size)`
+     * that had initially [size] elements.
+     *
+     * Measures mean time and memory spent per (roughly one) `add` operation.
+     *
+     * Expected time: [Add.add]
+     * Expected memory: [Add.add]
+     */
+    @Benchmark
+    fun addAfterRemove(): ImmutableSet<IntWrapper> {
+        var set = halfHeightPersistentSet
+
+        repeat(size - halfHeightPersistentSet.size) { index ->
+            set = set.add(elements[index])
+        }
+
+        return set
+    }
+
+    /**
+     * Iterates elements of a persistent set of size `elementsForHalfHeight(size)` several times until iterating [size] elements.
+     *
+     * Measures mean time and memory spent per `iterate` operation.
+     *
+     * Expected time: [Iterate.iterate] with [Iterate.size] = `elementsForHalfHeight([size])`
+     * Expected memory: [Iterate.iterate] with [Iterate.size] = `elementsForHalfHeight([size])`
+     */
+    @Benchmark
+    fun iterateAfterRemove(bh: Blackhole) {
+        var count = 0
+        while (count < size) {
+            for (e in halfHeightPersistentSet) {
+                bh.consume(e)
+
+                if (++count == size)
+                    break
+            }
+        }
+    }
 }

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/immutableSet/utils.kt

@@ -20,6 +20,8 @@ import benchmarks.*
 import kotlinx.collections.immutable.PersistentSet
 import kotlinx.collections.immutable.persistentHashSetOf
 import kotlinx.collections.immutable.persistentSetOf
+import kotlin.math.ceil
+import kotlin.math.log
 
 
 fun <E> emptyPersistentSet(implementation: String): PersistentSet<E> = when (implementation) {
@@ -35,3 +37,21 @@ fun <E> persistentSetAdd(implementation: String, elements: List<E>): PersistentS
     }
     return set
 }
+
+private fun elementsForHalfHeight(size: Int): Int {
+    val branchingFactor = 32
+    val logBranchingFactor = 5
+
+    val approximateHeight = ceil(log(size.toDouble(), branchingFactor.toDouble())).toInt()
+    return 1 shl ((approximateHeight / 2) * logBranchingFactor)
+}
+
+fun <E> halfHeightPersistentSet(persistentSet: PersistentSet<E>, elements: List<E>): PersistentSet<E> {
+    val elementsToLeave = elementsForHalfHeight(persistentSet.size)
+
+    var set = persistentSet
+    repeat(persistentSet.size - elementsToLeave) { index ->
+        set = set.remove(elements[index])
+    }
+    return set
+}