Kotlin immutable collections benchmarks

Author: Abduqodiri Qurbonzoda

benchmarks-mpp/build.gradle

@@ -0,0 +1,39 @@
+plugins {
+    id 'org.jetbrains.kotlin.multiplatform' version '1.3.31'
+    id 'org.jetbrains.gradle.benchmarks.plugin' version '0.1.7-dev-21'
+}
+
+repositories {
+    mavenCentral()
+    maven { url 'https://dl.bintray.com/orangy/maven' }
+}
+
+apply plugin: 'maven-publish'
+
+kotlin {
+    jvm()
+
+    sourceSets {
+        commonMain {
+        }
+        commonTest {
+        }
+        jvmMain {
+            dependencies {
+                implementation kotlin('stdlib-jdk8')
+                implementation project(path: ':kotlinx-collections-immutable')
+                implementation 'org.jetbrains.gradle.benchmarks:runtime-jvm:0.1.7-dev-21'
+            }
+        }
+        jvmTest {
+        }
+    }
+}
+
+benchmark {
+    configurations {
+        register("jvm") {
+            jmhVersion = "1.21"
+        }
+    }
+}

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/ObjectWrapper.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 benchmarks
+
+class ObjectWrapper<K: Comparable<K>>(val obj: K, val hashCode: Int) : Comparable<ObjectWrapper<K>> {
+    override fun hashCode(): Int {
+        return hashCode
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (other !is ObjectWrapper<*>) {
+            return false
+        }
+        assert(obj != other.obj || hashCode == other.hashCode)  // if elements are equal hashCodes must be equal
+        return obj == other.obj
+    }
+
+    override fun compareTo(other: ObjectWrapper<K>): Int {
+        return obj.compareTo(other.obj)
+    }
+}
+
+
+typealias IntWrapper = ObjectWrapper<Int>

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/benchmarkSize.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 benchmarks
+
+const val BM_1 = "1"
+const val BM_10 = "10"
+const val BM_100 = "100"
+const val BM_1000 = "1000"
+const val BM_10000 = "10000"
+const val BM_100000 = "100000"
+const val BM_1000000 = "1000000"
+const val BM_10000000 = "10000000"

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/hashCodeTypes.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 benchmarks
+
+import java.util.*
+
+const val ASCENDING_HASH_CODE = "ascending"
+const val RANDOM_HASH_CODE = "random"
+const val COLLISION_HASH_CODE = "collision"
+const val NON_EXISTING_HASH_CODE = "nonExisting"
+
+private inline fun intWrappers(size: Int, hashCodeGenerator: (index: Int) -> Int): List<IntWrapper> {
+    val keys = mutableListOf<IntWrapper>()
+    repeat(size) {
+        keys.add(IntWrapper(it, hashCodeGenerator(it)))
+    }
+    return keys
+}
+
+private fun generateIntWrappers(hashCodeType: String, size: Int): List<IntWrapper> {
+    val random = Random(40)
+    return when(hashCodeType) {
+        ASCENDING_HASH_CODE -> intWrappers(size) { it }
+        RANDOM_HASH_CODE,
+        NON_EXISTING_HASH_CODE -> intWrappers(size) { random.nextInt() }
+        COLLISION_HASH_CODE -> intWrappers(size) { random.nextInt((size + 1) / 2) }
+        else -> throw AssertionError("Unknown hashCodeType: $hashCodeType")
+    }
+}
+
+fun generateKeys(hashCodeType: String, size: Int) = generateIntWrappers(hashCodeType, size)
+fun generateElements(hashCodeType: String, size: Int) = generateIntWrappers(hashCodeType, size)
+
+
+const val HASH_IMPL = "hash"
+const val ORDERED_IMPL = "ordered"

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/immutableList/Add.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 benchmarks.immutableList
+
+import benchmarks.*
+import kotlinx.collections.immutable.ImmutableList
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+
+@State(Scope.Thread)
+open class Add {
+    @Param(BM_1, BM_10, BM_100, BM_1000, BM_10000, BM_100000, BM_1000000, BM_10000000)
+    var size: Int = 0
+
+    @Benchmark
+    fun addLast(): ImmutableList<String> {
+        return persistentListAdd(size)
+    }
+
+    @Benchmark
+    fun addLastAndIterate(bh: Blackhole) {
+        val list = persistentListAdd(size)
+        for (e in list) {
+            bh.consume(e)
+        }
+    }
+
+    @Benchmark
+    fun addLastAndGet(bh: Blackhole) {
+        val list = persistentListAdd(size)
+        for (i in 0 until list.size) {
+            bh.consume(list[i])
+        }
+    }
+}

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/immutableList/Get.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 benchmarks.immutableList
+
+import benchmarks.*
+import kotlinx.collections.immutable.PersistentList
+import kotlinx.collections.immutable.persistentListOf
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+
+@State(Scope.Benchmark)
+open class Get {
+    @Param(BM_1, BM_10, BM_100, BM_1000, BM_10000, BM_100000, BM_1000000, BM_10000000)
+    var size: Int = 0
+
+    private var persistentList: PersistentList<String> = persistentListOf()
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        persistentList = persistentListAdd(size)
+    }
+
+    @Benchmark
+    fun getByIndex(bh: Blackhole) {
+        for (i in 0 until persistentList.size) {
+            bh.consume(persistentList[i])
+        }
+    }
+}

benchmarks-mpp/src/jvmMain/kotlin/benchmarks/immutableList/Iterate.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 benchmarks.immutableList
+
+import benchmarks.*
+import kotlinx.collections.immutable.PersistentList
+import kotlinx.collections.immutable.persistentListOf
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+
+@State(Scope.Benchmark)
+open class Iterate {
+    @Param(BM_1, BM_10, BM_100, BM_1000, BM_10000, BM_100000, BM_1000000, BM_10000000)
+    var size: Int = 0
+
+    private var persistentList: PersistentList<String> = persistentListOf()
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        persistentList = persistentListAdd(size)
+    }
+
+    @Benchmark
+    fun firstToLast(bh: Blackhole) {
+        for (e in persistentList) {
+            bh.consume(e)
+        }
+    }
+
+    @Benchmark
+    fun lastToFirst(bh: Blackhole) {
+        val iterator = persistentList.listIterator(size)
+
+        while (iterator.hasPrevious()) {
+            bh.consume(iterator.previous())
+        }
+    }
+}

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 benchmarks.immutableList
+
+import benchmarks.*
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.PersistentList
+import kotlinx.collections.immutable.persistentListOf
+import org.openjdk.jmh.annotations.*
+
+@State(Scope.Thread)
+open class Remove {
+    @Param(BM_1, BM_10, BM_100, BM_1000, BM_10000, BM_100000, BM_1000000, BM_10000000)
+    var size: Int = 0
+
+    private var persistentList: PersistentList<String> = persistentListOf()
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        persistentList = persistentListAdd(size)
+    }
+
+    @Benchmark
+    fun removeLast(): ImmutableList<String> {
+        var list = persistentList
+        repeat(times = size) {
+            list = list.removeAt(list.size - 1)
+        }
+        return list
+    }
+}