Benchmarking other immutable collections libraries

Author: Abduqodiri Qurbonzoda

benchmarks-libraries/build.gradle

@@ -0,0 +1,39 @@
+plugins {
+    id 'org.jetbrains.kotlin.jvm' version '1.3.21'
+    id "me.champeau.gradle.jmh" version "0.4.8"
+}
+
+repositories {
+    mavenCentral()
+    jcenter()
+    maven { url 'http://nexus.usethesource.io/content/repositories/public/' }
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    
+    implementation project(path: ':kotlinx-collections-immutable')
+    implementation 'io.usethesource:capsule:0.6.1'
+    implementation 'org.organicdesign:Paguro:3.1.2'
+}
+
+compileKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
+jmh {
+    include = ['immutableList', 'immutableMap', 'immutableSet']
+    exclude = ['builder']
+
+    warmup = '1s'
+    warmupIterations = 5
+    timeOnIteration = '1s'
+    iterations = 5
+    benchmarkMode = ['avgt']
+    benchmarkParameters = [
+            'size':['10000'], 
+            'implementation': ['hash'], 
+            'hashCodeType':['random'], 
+            'immutablePercentage':['0']
+    ]
+}

benchmarks-libraries/src/jmh/java/benchmarks/IntWrapper.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.
+ */
+
+// Auto-generated file. DO NOT EDIT!
+
+package benchmarks
+
+
+class IntWrapper(val obj: Int, val hashCode: Int) : Comparable<IntWrapper> {
+    override fun hashCode(): Int {
+        return hashCode
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (other !is IntWrapper) {
+            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: IntWrapper): Int {
+        return obj.compareTo(other.obj)
+    }
+}

benchmarks-libraries/src/jmh/java/benchmarks/immutableList/kotlin/Add.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+// Auto-generated file. DO NOT EDIT!
+
+package benchmarks.immutableList.kotlin
+
+import org.openjdk.jmh.annotations.*
+import java.util.concurrent.TimeUnit
+import org.openjdk.jmh.infra.Blackhole
+
+@Fork(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Thread)
+open class Add {
+    @Param("10000", "100000")
+    var size: Int = 0
+
+    @Benchmark
+    fun addLast(): kotlinx.collections.immutable.PersistentList<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-libraries/src/jmh/java/benchmarks/immutableList/kotlin/Get.kt

@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+
+// Auto-generated file. DO NOT EDIT!
+
+package benchmarks.immutableList.kotlin
+
+import org.openjdk.jmh.annotations.*
+import java.util.concurrent.TimeUnit
+import org.openjdk.jmh.infra.Blackhole
+
+@Fork(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Thread)
+open class Get {
+    @Param("10000", "100000")
+    var size: Int = 0
+
+    private var persistentList = kotlinx.collections.immutable.persistentListOf<String>()
+
+    @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-libraries/src/jmh/java/benchmarks/immutableList/kotlin/Iterate.kt

@@ -0,0 +1,57 @@
+/*
+ * 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.
+ */
+
+// Auto-generated file. DO NOT EDIT!
+
+package benchmarks.immutableList.kotlin
+
+import org.openjdk.jmh.annotations.*
+import java.util.concurrent.TimeUnit
+import org.openjdk.jmh.infra.Blackhole
+
+@Fork(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Thread)
+open class Iterate {
+    @Param("10000", "100000")
+    var size: Int = 0
+
+    private var persistentList = kotlinx.collections.immutable.persistentListOf<String>()
+
+    @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-libraries/src/jmh/java/benchmarks/immutableList/kotlin/Remove.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.
+ */
+
+// Auto-generated file. DO NOT EDIT!
+
+package benchmarks.immutableList.kotlin
+
+import org.openjdk.jmh.annotations.*
+import java.util.concurrent.TimeUnit
+
+@Fork(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Thread)
+open class Remove {
+    @Param("10000", "100000")
+    var size: Int = 0
+
+    private var persistentList = kotlinx.collections.immutable.persistentListOf<String>()
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        persistentList = persistentListAdd(size)
+    }
+
+    @Benchmark
+    fun removeLast(): kotlinx.collections.immutable.PersistentList<String> {
+        var list = persistentList
+        repeat(times = size) {
+            list = list.removeAt(list.size - 1)
+        }
+        return list
+    }
+}

benchmarks-libraries/src/jmh/java/benchmarks/immutableList/kotlin/Set.kt

@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+// Auto-generated file. DO NOT EDIT!
+
+package benchmarks.immutableList.kotlin
+
+import org.openjdk.jmh.annotations.*
+import java.util.concurrent.TimeUnit
+
+@Fork(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Thread)
+open class Set {
+    @Param("10000", "100000")
+    var size: Int = 0
+
+    private var persistentList = kotlinx.collections.immutable.persistentListOf<String>()
+    private var randomIndices = listOf<Int>()
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        persistentList = persistentListAdd(size)
+        randomIndices = List(size) { it }.shuffled()
+    }
+
+    @Benchmark
+    fun setByIndex(): kotlinx.collections.immutable.PersistentList<String> {
+        repeat(times = size) { index ->
+            persistentList = persistentList.set(index, "another element")
+        }
+        return persistentList
+    }
+
+    @Benchmark
+    fun setByRandomIndex(): kotlinx.collections.immutable.PersistentList<String> {
+        repeat(times = size) { index ->
+            persistentList = persistentList.set(randomIndices[index], "another element")
+        }
+        return persistentList
+    }
+}