Add clojure, scala and vavr benchmarks

Author: Abduqodiri Qurbonzoda

benchmarks-libraries/build.gradle

@@ -17,12 +17,19 @@ dependencies {
     implementation 'io.usethesource:capsule:0.6.1'
     implementation 'org.organicdesign:Paguro:3.1.2'
     implementation 'com.oath.cyclops:cyclops:10.3.0'
+    implementation 'org.clojure:clojure:1.10.0'
+    implementation 'org.scala-lang:scala-library:2.13.0'
+    implementation 'io.vavr:vavr:0.9.3'
 }
 
 compileKotlin {
     kotlinOptions.jvmTarget = "1.8"
 }
 
+compileJmhKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
 task generateBenchmarkSources(type: JavaExec) {
     main = 'generators.BenchmarkSourceGeneratorKt'
     classpath = sourceSets.main.runtimeClasspath

benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/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.clojure
+
+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(): clojure.lang.PersistentVector {
+        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 size) {
+            bh.consume(list.get(i))
+        }
+    }
+}

benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/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.clojure
+
+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 = clojure.lang.PersistentVector.EMPTY
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        persistentList = persistentListAdd(size)
+    }
+
+    @Benchmark
+    fun getByIndex(bh: Blackhole) {
+        for (i in 0 until size) {
+            bh.consume(persistentList.get(i))
+        }
+    }
+}

benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/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.clojure
+
+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 = clojure.lang.PersistentVector.EMPTY
+
+    @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/clojure/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.clojure
+
+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 = clojure.lang.PersistentVector.EMPTY
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        persistentList = persistentListAdd(size)
+    }
+
+    @Benchmark
+    fun removeLast(): clojure.lang.PersistentVector {
+        var list = persistentList
+        repeat(times = size) {
+            list = list.pop()
+        }
+        return list
+    }
+}

benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/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.clojure
+
+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 = clojure.lang.PersistentVector.EMPTY
+    private var randomIndices = listOf<Int>()
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        persistentList = persistentListAdd(size)
+        randomIndices = List(size) { it }.shuffled()
+    }
+
+    @Benchmark
+    fun setByIndex(): clojure.lang.PersistentVector {
+        repeat(times = size) { index ->
+            persistentList = persistentList.assocN(index, "another element")
+        }
+        return persistentList
+    }
+
+    @Benchmark
+    fun setByRandomIndex(): clojure.lang.PersistentVector {
+        repeat(times = size) { index ->
+            persistentList = persistentList.assocN(randomIndices[index], "another element")
+        }
+        return persistentList
+    }
+}

benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/builder/Add.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.
+ */
+
+// Auto-generated file. DO NOT EDIT!
+
+package benchmarks.immutableList.clojure.builder
+
+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
+
+    @Param("0.0", "50.0")
+    var immutablePercentage: Double = 0.0
+
+    @Benchmark
+    fun addLast(): clojure.lang.ITransientVector {
+        return persistentListBuilderAdd(size, immutablePercentage)
+    }
+
+    @Benchmark
+    fun addLastAndGet(bh: Blackhole) {
+        val builder = persistentListBuilderAdd(size, immutablePercentage)
+        for (i in 0 until size) {
+            bh.consume(builder.valAt(i))
+        }
+    }
+}

benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/builder/Get.kt

@@ -0,0 +1,51 @@
+/*
+ * 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.clojure.builder
+
+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
+
+    @Param("0.0", "50.0")
+    var immutablePercentage: Double = 0.0
+
+    private var builder: clojure.lang.ITransientVector = clojure.lang.PersistentVector.EMPTY.asTransient() as clojure.lang.ITransientVector
+
+    @Setup(Level.Trial)
+    fun prepare() {
+        builder = persistentListBuilderAdd(size, immutablePercentage)
+    }
+
+    @Benchmark
+    fun getByIndex(bh: Blackhole) {
+        for (i in 0 until size) {
+            bh.consume(builder.valAt(i))
+        }
+    }
+}