diff --git a/.gitignore b/.gitignore index 15a025ce..e53a45ab 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,7 @@ /.idea/* !/.idea/copyright +/benchmarks-libraries/.idea/* +!/benchmarks-libraries/.idea/copyright .gradle *.iml target diff --git a/benchmarks-libraries/.idea/copyright/apache_2_0.xml b/benchmarks-libraries/.idea/copyright/apache_2_0.xml new file mode 100644 index 00000000..bb5022fc --- /dev/null +++ b/benchmarks-libraries/.idea/copyright/apache_2_0.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/benchmarks-libraries/.idea/copyright/profiles_settings.xml b/benchmarks-libraries/.idea/copyright/profiles_settings.xml new file mode 100644 index 00000000..915114f1 --- /dev/null +++ b/benchmarks-libraries/.idea/copyright/profiles_settings.xml @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/benchmarks-libraries/build.gradle b/benchmarks-libraries/build.gradle new file mode 100644 index 00000000..4c2572f0 --- /dev/null +++ b/benchmarks-libraries/build.gradle @@ -0,0 +1,61 @@ +plugins { + id 'org.jetbrains.kotlin.jvm' version '1.3.40' + id "me.champeau.gradle.jmh" version "0.4.8" +} + +repositories { + mavenLocal() + mavenCentral() + jcenter() + maven { url 'http://nexus.usethesource.io/content/repositories/public/' } +} + +dependencies { + implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8" + + implementation 'org.jetbrains.kotlinx:kotlinx-collections-immutable:0.2-SNAPSHOT' + 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 +} + +jmh { +// include = ['immutableList.*.Add', 'immutableMap', 'immutableSet'] +// exclude = ['builder'] + + profilers = ['gc'] + + resultFormat = "csv" + + fork = 1 + warmupIterations = 7 + iterations = 10 + warmup = '500ms' + timeOnIteration = '500ms' + + benchmarkMode = ['avgt'] + timeUnit = "us" + + benchmarkParameters = [ + 'size':['1', '10', '100', '1000', '10000'], +// 'implementation': ['hash'], + 'hashCodeType':['random', 'collision'], + 'immutablePercentage':['0.0', '80.0'] + ] +} \ No newline at end of file diff --git a/benchmarks-libraries/gradle/wrapper/gradle-wrapper.jar b/benchmarks-libraries/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 00000000..91ca28c8 Binary files /dev/null and b/benchmarks-libraries/gradle/wrapper/gradle-wrapper.jar differ diff --git a/benchmarks-libraries/gradle/wrapper/gradle-wrapper.properties b/benchmarks-libraries/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000..29c490fc --- /dev/null +++ b/benchmarks-libraries/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,6 @@ +#Tue Jun 11 01:45:01 MSK 2019 +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-5.1-all.zip diff --git a/benchmarks-libraries/settings.gradle b/benchmarks-libraries/settings.gradle new file mode 100644 index 00000000..2a56bba5 --- /dev/null +++ b/benchmarks-libraries/settings.gradle @@ -0,0 +1,17 @@ +/* + * 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. + */ + +rootProject.name = 'Collection Frameworks Benchmarks' diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/IntWrapper.kt b/benchmarks-libraries/src/jmh/java/benchmarks/IntWrapper.kt new file mode 100644 index 00000000..bf5e903f --- /dev/null +++ b/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 { + 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) + } +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/List.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/List.kt new file mode 100644 index 00000000..9d622223 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/List.kt @@ -0,0 +1,166 @@ +/* + * 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 +import benchmarks.* + +@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)) + } + } +} + + +@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)) + } + } +} + + +@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()) + } + } +} + + +@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 + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = clojure.lang.PersistentVector.EMPTY + private var randomIndices = listOf() + + @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 + } +} + + +private fun persistentListAdd(size: Int): clojure.lang.PersistentVector { + var list = clojure.lang.PersistentVector.EMPTY + repeat(times = size) { + list = list.cons("some element") + } + return list +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/builder/ListBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/builder/ListBuilder.kt new file mode 100644 index 00000000..d833b2f6 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/clojure/builder/ListBuilder.kt @@ -0,0 +1,146 @@ +/* + * 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 +import benchmarks.* + +@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)) + } + } + + +} + + +@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)) + } + } +} + + + + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + @Benchmark + fun addAndRemoveLast(): clojure.lang.ITransientVector { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (i in 0 until size) { + builder.pop() + } + return builder + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = clojure.lang.PersistentVector.EMPTY.asTransient() as clojure.lang.ITransientVector + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): clojure.lang.ITransientVector { + for (i in 0 until size) { + builder.assocN(i, "another element") + } + return builder + } + + @Benchmark + fun setByRandomIndex(): clojure.lang.ITransientVector { + for (i in 0 until size) { + builder.assocN(randomIndices[i], "another element") + } + return builder + } +} + + +private fun persistentListBuilderAdd(size: Int, immutablePercentage: Double): clojure.lang.ITransientVector { + val immutableSize = immutableSize(size, immutablePercentage) + + var list = clojure.lang.PersistentVector.EMPTY + repeat(times = immutableSize) { + list = list.cons("another element") + } + + val builder = list.asTransient() as clojure.lang.ITransientVector + repeat(times = size - immutableSize) { + builder.conj("some element") + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/cyclops/List.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/cyclops/List.kt new file mode 100644 index 00000000..f1beecfb --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/cyclops/List.kt @@ -0,0 +1,166 @@ +/* + * 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.cyclops + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Benchmark + fun addLast(): cyclops.data.Vector { + 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)) + } + } +} + + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = cyclops.data.Vector.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)) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = cyclops.data.Vector.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.reverse().iterator() + + while (iterator.hasNext()) { + bh.consume(iterator.next()) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = cyclops.data.Vector.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun removeLast(): cyclops.data.Vector { + var list = persistentList + repeat(times = size) { + list = list.dropRight(1) + } + return list + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = cyclops.data.Vector.empty() + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): cyclops.data.Vector { + repeat(times = size) { index -> + persistentList = persistentList.updateAt(index, "another element") + } + return persistentList + } + + @Benchmark + fun setByRandomIndex(): cyclops.data.Vector { + repeat(times = size) { index -> + persistentList = persistentList.updateAt(randomIndices[index], "another element") + } + return persistentList + } +} + + +private fun persistentListAdd(size: Int): cyclops.data.Vector { + var list = cyclops.data.Vector.empty() + repeat(times = size) { + list = list.plus("some element") + } + return list +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/kotlin/List.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/kotlin/List.kt new file mode 100644 index 00000000..39a24526 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/kotlin/List.kt @@ -0,0 +1,166 @@ +/* + * 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 +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Benchmark + fun addLast(): kotlinx.collections.immutable.PersistentList { + 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)) + } + } +} + + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = kotlinx.collections.immutable.persistentListOf() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun getByIndex(bh: Blackhole) { + for (i in 0 until size) { + bh.consume(persistentList.get(i)) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = kotlinx.collections.immutable.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()) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = kotlinx.collections.immutable.persistentListOf() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun removeLast(): kotlinx.collections.immutable.PersistentList { + var list = persistentList + repeat(times = size) { + list = list.removeAt(list.size - 1) + } + return list + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = kotlinx.collections.immutable.persistentListOf() + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): kotlinx.collections.immutable.PersistentList { + repeat(times = size) { index -> + persistentList = persistentList.set(index, "another element") + } + return persistentList + } + + @Benchmark + fun setByRandomIndex(): kotlinx.collections.immutable.PersistentList { + repeat(times = size) { index -> + persistentList = persistentList.set(randomIndices[index], "another element") + } + return persistentList + } +} + + +private fun persistentListAdd(size: Int): kotlinx.collections.immutable.PersistentList { + var list = kotlinx.collections.immutable.persistentListOf() + repeat(times = size) { + list = list.add("some element") + } + return list +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/kotlin/builder/ListBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/kotlin/builder/ListBuilder.kt new file mode 100644 index 00000000..67b4d60b --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/kotlin/builder/ListBuilder.kt @@ -0,0 +1,184 @@ +/* + * 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.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@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(): kotlinx.collections.immutable.PersistentList.Builder { + return persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun addLastAndGet(bh: Blackhole) { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (i in 0 until size) { + bh.consume(builder.get(i)) + } + } + + + @Benchmark + fun addLastAndIterate(bh: Blackhole) { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (e in builder) { + bh.consume(e) + } + } +} + + +@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: kotlinx.collections.immutable.PersistentList.Builder = kotlinx.collections.immutable.persistentListOf().builder() + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun getByIndex(bh: Blackhole) { + for (i in 0 until size) { + bh.consume(builder.get(i)) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = kotlinx.collections.immutable.persistentListOf().builder() + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun firstToLast(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } + + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = builder.listIterator(size) + + while (iterator.hasPrevious()) { + bh.consume(iterator.previous()) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + @Benchmark + fun addAndRemoveLast(): kotlinx.collections.immutable.PersistentList.Builder { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (i in 0 until size) { + builder.removeAt(builder.size - 1) + } + return builder + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = kotlinx.collections.immutable.persistentListOf().builder() + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): kotlinx.collections.immutable.PersistentList.Builder { + for (i in 0 until size) { + builder.set(i, "another element") + } + return builder + } + + @Benchmark + fun setByRandomIndex(): kotlinx.collections.immutable.PersistentList.Builder { + for (i in 0 until size) { + builder.set(randomIndices[i], "another element") + } + return builder + } +} + + +private fun persistentListBuilderAdd(size: Int, immutablePercentage: Double): kotlinx.collections.immutable.PersistentList.Builder { + val immutableSize = immutableSize(size, immutablePercentage) + + var list = kotlinx.collections.immutable.persistentListOf() + repeat(times = immutableSize) { + list = list.add("another element") + } + + val builder = list.builder() + repeat(times = size - immutableSize) { + builder.add("some element") + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/paguro/List.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/paguro/List.kt new file mode 100644 index 00000000..91964acb --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/paguro/List.kt @@ -0,0 +1,166 @@ +/* + * 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.paguro + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Benchmark + fun addLast(): org.organicdesign.fp.collections.RrbTree.ImRrbt { + 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)) + } + } +} + + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = org.organicdesign.fp.collections.RrbTree.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)) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = org.organicdesign.fp.collections.RrbTree.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()) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = org.organicdesign.fp.collections.RrbTree.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun removeLast(): org.organicdesign.fp.collections.RrbTree.ImRrbt { + var list = persistentList + repeat(times = size) { + list = list.without(list.size - 1) + } + return list + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = org.organicdesign.fp.collections.RrbTree.empty() + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): org.organicdesign.fp.collections.RrbTree.ImRrbt { + repeat(times = size) { index -> + persistentList = persistentList.replace(index, "another element") + } + return persistentList + } + + @Benchmark + fun setByRandomIndex(): org.organicdesign.fp.collections.RrbTree.ImRrbt { + repeat(times = size) { index -> + persistentList = persistentList.replace(randomIndices[index], "another element") + } + return persistentList + } +} + + +private fun persistentListAdd(size: Int): org.organicdesign.fp.collections.RrbTree.ImRrbt { + var list = org.organicdesign.fp.collections.RrbTree.empty() + repeat(times = size) { + list = list.append("some element") + } + return list +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/paguro/builder/ListBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/paguro/builder/ListBuilder.kt new file mode 100644 index 00000000..8d303afd --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/paguro/builder/ListBuilder.kt @@ -0,0 +1,184 @@ +/* + * 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.paguro.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@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(): org.organicdesign.fp.collections.RrbTree.MutableRrbt { + return persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun addLastAndGet(bh: Blackhole) { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (i in 0 until size) { + bh.consume(builder.get(i)) + } + } + + + @Benchmark + fun addLastAndIterate(bh: Blackhole) { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (e in builder) { + bh.consume(e) + } + } +} + + +@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: org.organicdesign.fp.collections.RrbTree.MutableRrbt = org.organicdesign.fp.collections.RrbTree.emptyMutable() + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun getByIndex(bh: Blackhole) { + for (i in 0 until size) { + bh.consume(builder.get(i)) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = org.organicdesign.fp.collections.RrbTree.emptyMutable() + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun firstToLast(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } + + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = builder.listIterator(size) + + while (iterator.hasPrevious()) { + bh.consume(iterator.previous()) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + @Benchmark + fun addAndRemoveLast(): org.organicdesign.fp.collections.RrbTree.MutableRrbt { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (i in 0 until size) { + builder.without(builder.size - 1) + } + return builder + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = org.organicdesign.fp.collections.RrbTree.emptyMutable() + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): org.organicdesign.fp.collections.RrbTree.MutableRrbt { + for (i in 0 until size) { + builder.replace(i, "another element") + } + return builder + } + + @Benchmark + fun setByRandomIndex(): org.organicdesign.fp.collections.RrbTree.MutableRrbt { + for (i in 0 until size) { + builder.replace(randomIndices[i], "another element") + } + return builder + } +} + + +private fun persistentListBuilderAdd(size: Int, immutablePercentage: Double): org.organicdesign.fp.collections.RrbTree.MutableRrbt { + val immutableSize = immutableSize(size, immutablePercentage) + + var list = org.organicdesign.fp.collections.RrbTree.empty() + repeat(times = immutableSize) { + list = list.append("another element") + } + + val builder = list.mutable() + repeat(times = size - immutableSize) { + builder.append("some element") + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/scala/List.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/scala/List.kt new file mode 100644 index 00000000..a475e7bc --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/scala/List.kt @@ -0,0 +1,166 @@ +/* + * 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.scala + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Benchmark + fun addLast(): scala.collection.immutable.Vector { + 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.apply(i)) + } + } +} + + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = scala.collection.immutable.`Vector$`.`MODULE$`.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun getByIndex(bh: Blackhole) { + for (i in 0 until size) { + bh.consume(persistentList.apply(i)) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = scala.collection.immutable.`Vector$`.`MODULE$`.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.reverseIterator() + + while (iterator.hasNext()) { + bh.consume(iterator.next()) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = scala.collection.immutable.`Vector$`.`MODULE$`.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun removeLast(): scala.collection.immutable.Vector { + var list = persistentList + repeat(times = size) { + list = list.dropRight(1) + } + return list + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = scala.collection.immutable.`Vector$`.`MODULE$`.empty() + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): scala.collection.immutable.Vector { + repeat(times = size) { index -> + persistentList = persistentList.updateAt(index, "another element") + } + return persistentList + } + + @Benchmark + fun setByRandomIndex(): scala.collection.immutable.Vector { + repeat(times = size) { index -> + persistentList = persistentList.updateAt(randomIndices[index], "another element") + } + return persistentList + } +} + + +private fun persistentListAdd(size: Int): scala.collection.immutable.Vector { + var list = scala.collection.immutable.`Vector$`.`MODULE$`.empty() + repeat(times = size) { + list = list.appended("some element") as scala.collection.immutable.Vector + } + return list +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/vavr/List.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/vavr/List.kt new file mode 100644 index 00000000..414364b0 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableList/vavr/List.kt @@ -0,0 +1,166 @@ +/* + * 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.vavr + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Benchmark + fun addLast(): io.vavr.collection.Vector { + 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.apply(i)) + } + } +} + + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = io.vavr.collection.Vector.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun getByIndex(bh: Blackhole) { + for (i in 0 until size) { + bh.consume(persistentList.apply(i)) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = io.vavr.collection.Vector.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.reverseIterator() + + while (iterator.hasNext()) { + bh.consume(iterator.next()) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = io.vavr.collection.Vector.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun removeLast(): io.vavr.collection.Vector { + var list = persistentList + repeat(times = size) { + list = list.dropRight(1) + } + return list + } +} + + +@State(Scope.Thread) +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = io.vavr.collection.Vector.empty() + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): io.vavr.collection.Vector { + repeat(times = size) { index -> + persistentList = persistentList.update(index, "another element") + } + return persistentList + } + + @Benchmark + fun setByRandomIndex(): io.vavr.collection.Vector { + repeat(times = size) { index -> + persistentList = persistentList.update(randomIndices[index], "another element") + } + return persistentList + } +} + + +private fun persistentListAdd(size: Int): io.vavr.collection.Vector { + var list = io.vavr.collection.Vector.empty() + repeat(times = size) { + list = list.append("some element") + } + return list +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/capsule/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/capsule/Map.kt new file mode 100644 index 00000000..bb70955a --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/capsule/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.capsule + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = io.usethesource.capsule.core.PersistentTrieMap.of() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = io.usethesource.capsule.core.PersistentTrieMap.of() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): io.usethesource.capsule.Map.Immutable { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = io.usethesource.capsule.core.PersistentTrieMap.of() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): io.usethesource.capsule.Map.Immutable { + var map = persistentMap + repeat(times = size) { index -> + map = map.__remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): io.usethesource.capsule.Map.Immutable { + var map = io.usethesource.capsule.core.PersistentTrieMap.of() + for (key in keys) { + map = map.__put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/capsule/builder/MapBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/capsule/builder/MapBuilder.kt new file mode 100644 index 00000000..e4ba081c --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/capsule/builder/MapBuilder.kt @@ -0,0 +1,196 @@ +/* + * 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.immutableMap.capsule.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var builder = io.usethesource.capsule.core.PersistentTrieMap.of().asTransient() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.get(keys[index])) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = io.usethesource.capsule.core.PersistentTrieMap.of().asTransient() + + @Setup(Level.Trial) + fun prepare() { + val keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in builder.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in builder.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): io.usethesource.capsule.Map.Transient { + return persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.get(keys[index])) + } + } + + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + for (key in builder.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var keysToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + + keysToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateKeys(hashCodeType, size) + } else { + keys + } + } + + @Benchmark + fun putAndRemove(): io.usethesource.capsule.Map.Transient { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + builder.remove(keysToRemove[index]) + } + return builder + } +} + + +private fun persistentMapBuilderPut( + keys: List, + immutablePercentage: Double +): io.usethesource.capsule.Map.Transient { + val immutableSize = immutableSize(keys.size, immutablePercentage) + + var map = io.usethesource.capsule.core.PersistentTrieMap.of() + for (index in 0 until immutableSize) { + map = map.__put(keys[index], "some element") + } + + val builder = map.asTransient() + for (index in immutableSize until keys.size) { + builder.put(keys[index], "some element") + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojure/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojure/Map.kt new file mode 100644 index 00000000..21adb693 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojure/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.clojure + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = clojure.lang.PersistentHashMap.EMPTY + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.valAt(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = clojure.lang.PersistentHashMap.EMPTY + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): clojure.lang.PersistentHashMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.valAt(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = clojure.lang.PersistentHashMap.EMPTY + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): clojure.lang.PersistentHashMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.without(keys[index]) as clojure.lang.PersistentHashMap + } + return map + } +} + + +private fun persistentMapPut(keys: List): clojure.lang.PersistentHashMap { + var map = clojure.lang.PersistentHashMap.EMPTY + for (key in keys) { + map = map.assoc(key, "some element") as clojure.lang.PersistentHashMap + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojure/builder/MapBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojure/builder/MapBuilder.kt new file mode 100644 index 00000000..61c80c21 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojure/builder/MapBuilder.kt @@ -0,0 +1,149 @@ +/* + * 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.immutableMap.clojure.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var builder = clojure.lang.PersistentHashMap.EMPTY.asTransient() as clojure.lang.ATransientMap + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.valAt(keys[index])) + } + } +} + + + + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): clojure.lang.ATransientMap { + return persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.valAt(keys[index])) + } + } + + +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var keysToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + + keysToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateKeys(hashCodeType, size) + } else { + keys + } + } + + @Benchmark + fun putAndRemove(): clojure.lang.ATransientMap { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + builder.without(keysToRemove[index]) + } + return builder + } +} + + +private fun persistentMapBuilderPut( + keys: List, + immutablePercentage: Double +): clojure.lang.ATransientMap { + val immutableSize = immutableSize(keys.size, immutablePercentage) + + var map = clojure.lang.PersistentHashMap.EMPTY as clojure.lang.IPersistentMap + for (index in 0 until immutableSize) { + map = map.assoc(keys[index], "some element") + } + + val builder = (map as clojure.lang.PersistentHashMap).asTransient() as clojure.lang.ATransientMap + for (index in immutableSize until keys.size) { + builder.assoc(keys[index], "some element") + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojureSorted/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojureSorted/Map.kt new file mode 100644 index 00000000..6a515b43 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/clojureSorted/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.clojureSorted + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = clojure.lang.PersistentTreeMap.EMPTY + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.valAt(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = clojure.lang.PersistentTreeMap.EMPTY + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): clojure.lang.PersistentTreeMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.valAt(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = clojure.lang.PersistentTreeMap.EMPTY + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): clojure.lang.PersistentTreeMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.without(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): clojure.lang.PersistentTreeMap { + var map = clojure.lang.PersistentTreeMap.EMPTY + for (key in keys) { + map = map.assoc(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclops/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclops/Map.kt new file mode 100644 index 00000000..b4c9b08a --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclops/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.cyclops + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = cyclops.data.HashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = cyclops.data.HashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys()) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values()) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): cyclops.data.HashMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys()) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = cyclops.data.HashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): cyclops.data.HashMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): cyclops.data.HashMap { + var map = cyclops.data.HashMap.empty() + for (key in keys) { + map = map.put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclopsOrdered/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclopsOrdered/Map.kt new file mode 100644 index 00000000..5a8bbd79 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclopsOrdered/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.cyclopsOrdered + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = cyclops.data.LinkedMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = cyclops.data.LinkedMap.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys()) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values()) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): cyclops.data.LinkedMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys()) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = cyclops.data.LinkedMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): cyclops.data.LinkedMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): cyclops.data.LinkedMap { + var map = cyclops.data.LinkedMap.empty() + for (key in keys) { + map = map.put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclopsTrie/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclopsTrie/Map.kt new file mode 100644 index 00000000..9c665391 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/cyclopsTrie/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.cyclopsTrie + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = cyclops.data.TrieMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = cyclops.data.TrieMap.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys()) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values()) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): cyclops.data.TrieMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys()) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = cyclops.data.TrieMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): cyclops.data.TrieMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): cyclops.data.TrieMap { + var map = cyclops.data.TrieMap.empty() + for (key in keys) { + map = map.put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlin/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlin/Map.kt new file mode 100644 index 00000000..a73a2e12 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlin/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.kotlin + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = kotlinx.collections.immutable.persistentHashMapOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = kotlinx.collections.immutable.persistentHashMapOf() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): kotlinx.collections.immutable.PersistentMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = kotlinx.collections.immutable.persistentHashMapOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): kotlinx.collections.immutable.PersistentMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): kotlinx.collections.immutable.PersistentMap { + var map = kotlinx.collections.immutable.persistentHashMapOf() + for (key in keys) { + map = map.put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlin/builder/MapBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlin/builder/MapBuilder.kt new file mode 100644 index 00000000..3ebea2fc --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlin/builder/MapBuilder.kt @@ -0,0 +1,196 @@ +/* + * 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.immutableMap.kotlin.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var builder = kotlinx.collections.immutable.persistentHashMapOf().builder() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.get(keys[index])) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = kotlinx.collections.immutable.persistentHashMapOf().builder() + + @Setup(Level.Trial) + fun prepare() { + val keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in builder.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in builder.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): kotlinx.collections.immutable.PersistentMap.Builder { + return persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.get(keys[index])) + } + } + + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + for (key in builder.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var keysToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + + keysToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateKeys(hashCodeType, size) + } else { + keys + } + } + + @Benchmark + fun putAndRemove(): kotlinx.collections.immutable.PersistentMap.Builder { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + builder.remove(keysToRemove[index]) + } + return builder + } +} + + +private fun persistentMapBuilderPut( + keys: List, + immutablePercentage: Double +): kotlinx.collections.immutable.PersistentMap.Builder { + val immutableSize = immutableSize(keys.size, immutablePercentage) + + var map = kotlinx.collections.immutable.persistentHashMapOf() + for (index in 0 until immutableSize) { + map = map.put(keys[index], "some element") + } + + val builder = map.builder() + for (index in immutableSize until keys.size) { + builder.put(keys[index], "some element") + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlinOrdered/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlinOrdered/Map.kt new file mode 100644 index 00000000..006ede4f --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlinOrdered/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.kotlinOrdered + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = kotlinx.collections.immutable.persistentMapOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = kotlinx.collections.immutable.persistentMapOf() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): kotlinx.collections.immutable.PersistentMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = kotlinx.collections.immutable.persistentMapOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): kotlinx.collections.immutable.PersistentMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): kotlinx.collections.immutable.PersistentMap { + var map = kotlinx.collections.immutable.persistentMapOf() + for (key in keys) { + map = map.put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlinOrdered/builder/MapBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlinOrdered/builder/MapBuilder.kt new file mode 100644 index 00000000..3f210703 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/kotlinOrdered/builder/MapBuilder.kt @@ -0,0 +1,196 @@ +/* + * 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.immutableMap.kotlinOrdered.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var builder = kotlinx.collections.immutable.persistentMapOf().builder() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.get(keys[index])) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = kotlinx.collections.immutable.persistentMapOf().builder() + + @Setup(Level.Trial) + fun prepare() { + val keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in builder.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in builder.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): kotlinx.collections.immutable.PersistentMap.Builder { + return persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.get(keys[index])) + } + } + + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + for (key in builder.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var keysToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + + keysToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateKeys(hashCodeType, size) + } else { + keys + } + } + + @Benchmark + fun putAndRemove(): kotlinx.collections.immutable.PersistentMap.Builder { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + builder.remove(keysToRemove[index]) + } + return builder + } +} + + +private fun persistentMapBuilderPut( + keys: List, + immutablePercentage: Double +): kotlinx.collections.immutable.PersistentMap.Builder { + val immutableSize = immutableSize(keys.size, immutablePercentage) + + var map = kotlinx.collections.immutable.persistentMapOf() + for (index in 0 until immutableSize) { + map = map.put(keys[index], "some element") + } + + val builder = map.builder() + for (index in immutableSize until keys.size) { + builder.put(keys[index], "some element") + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguro/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguro/Map.kt new file mode 100644 index 00000000..400da089 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguro/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.paguro + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = org.organicdesign.fp.collections.PersistentHashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = org.organicdesign.fp.collections.PersistentHashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): org.organicdesign.fp.collections.PersistentHashMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = org.organicdesign.fp.collections.PersistentHashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): org.organicdesign.fp.collections.PersistentHashMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.without(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): org.organicdesign.fp.collections.PersistentHashMap { + var map = org.organicdesign.fp.collections.PersistentHashMap.empty() + for (key in keys) { + map = map.assoc(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguro/builder/MapBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguro/builder/MapBuilder.kt new file mode 100644 index 00000000..5034aacb --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguro/builder/MapBuilder.kt @@ -0,0 +1,196 @@ +/* + * 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.immutableMap.paguro.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var builder = org.organicdesign.fp.collections.PersistentHashMap.emptyMutable() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.get(keys[index])) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = org.organicdesign.fp.collections.PersistentHashMap.emptyMutable() + + @Setup(Level.Trial) + fun prepare() { + val keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in builder.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in builder.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): org.organicdesign.fp.collections.PersistentHashMap.MutableHashMap { + return persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.get(keys[index])) + } + } + + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + for (key in builder.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf() + private var keysToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + + keysToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateKeys(hashCodeType, size) + } else { + keys + } + } + + @Benchmark + fun putAndRemove(): org.organicdesign.fp.collections.PersistentHashMap.MutableHashMap { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + builder.without(keysToRemove[index]) + } + return builder + } +} + + +private fun persistentMapBuilderPut( + keys: List, + immutablePercentage: Double +): org.organicdesign.fp.collections.PersistentHashMap.MutableHashMap { + val immutableSize = immutableSize(keys.size, immutablePercentage) + + var map = org.organicdesign.fp.collections.PersistentHashMap.empty() + for (index in 0 until immutableSize) { + map = map.assoc(keys[index], "some element") + } + + val builder = map.mutable() + for (index in immutableSize until keys.size) { + builder.assoc(keys[index], "some element") + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguroSorted/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguroSorted/Map.kt new file mode 100644 index 00000000..610935ea --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/paguroSorted/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.paguroSorted + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = org.organicdesign.fp.collections.PersistentTreeMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = org.organicdesign.fp.collections.PersistentTreeMap.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): org.organicdesign.fp.collections.PersistentTreeMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = org.organicdesign.fp.collections.PersistentTreeMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): org.organicdesign.fp.collections.PersistentTreeMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.without(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): org.organicdesign.fp.collections.PersistentTreeMap { + var map = org.organicdesign.fp.collections.PersistentTreeMap.empty() + for (key in keys) { + map = map.assoc(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/scala/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/scala/Map.kt new file mode 100644 index 00000000..cde2153e --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/scala/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.scala + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = scala.collection.immutable.`HashMap$`.`MODULE$`.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = scala.collection.immutable.`HashMap$`.`MODULE$`.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys()) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values()) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): scala.collection.immutable.HashMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys()) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = scala.collection.immutable.`HashMap$`.`MODULE$`.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): scala.collection.immutable.HashMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.removed(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): scala.collection.immutable.HashMap { + var map = scala.collection.immutable.`HashMap$`.`MODULE$`.empty() + for (key in keys) { + map = map.updated(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/scalaSorted/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/scalaSorted/Map.kt new file mode 100644 index 00000000..be18c193 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/scalaSorted/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.scalaSorted + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = scala.collection.immutable.`TreeMap$`.`MODULE$`.empty(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder())) + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = scala.collection.immutable.`TreeMap$`.`MODULE$`.empty(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder())) + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keys()) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.values()) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): scala.collection.immutable.TreeMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keys()) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = scala.collection.immutable.`TreeMap$`.`MODULE$`.empty(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder())) + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): scala.collection.immutable.TreeMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.removed(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): scala.collection.immutable.TreeMap { + var map = scala.collection.immutable.`TreeMap$`.`MODULE$`.empty(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder())) + for (key in keys) { + map = map.updated(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavr/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavr/Map.kt new file mode 100644 index 00000000..3ae150b4 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavr/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.vavr + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = io.vavr.collection.HashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = io.vavr.collection.HashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keysIterator()) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.valuesIterator()) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): io.vavr.collection.HashMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keysIterator()) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = io.vavr.collection.HashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): io.vavr.collection.HashMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): io.vavr.collection.HashMap { + var map = io.vavr.collection.HashMap.empty() + for (key in keys) { + map = map.put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavrOrdered/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavrOrdered/Map.kt new file mode 100644 index 00000000..c4936220 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavrOrdered/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.vavrOrdered + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = io.vavr.collection.LinkedHashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = io.vavr.collection.LinkedHashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keysIterator()) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.valuesIterator()) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): io.vavr.collection.LinkedHashMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keysIterator()) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = io.vavr.collection.LinkedHashMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): io.vavr.collection.LinkedHashMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): io.vavr.collection.LinkedHashMap { + var map = io.vavr.collection.LinkedHashMap.empty() + for (key in keys) { + map = map.put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavrSorted/Map.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavrSorted/Map.kt new file mode 100644 index 00000000..452a9be6 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableMap/vavrSorted/Map.kt @@ -0,0 +1,169 @@ +/* + * 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.immutableMap.vavrSorted + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = io.vavr.collection.TreeMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentMap.get(keys[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = io.vavr.collection.TreeMap.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in persistentMap.keysIterator()) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in persistentMap.valuesIterator()) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): io.vavr.collection.TreeMap { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(map.get(keys[index])) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in map.keysIterator()) { + bh.consume(key) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf() + private var persistentMap = io.vavr.collection.TreeMap.empty() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): io.vavr.collection.TreeMap { + var map = persistentMap + repeat(times = size) { index -> + map = map.remove(keys[index]) + } + return map + } +} + + +private fun persistentMapPut(keys: List): io.vavr.collection.TreeMap { + var map = io.vavr.collection.TreeMap.empty() + for (key in keys) { + map = map.put(key, "some element") + } + return map +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/capsule/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/capsule/Set.kt new file mode 100644 index 00000000..bd3143d7 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/capsule/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.capsule + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): io.usethesource.capsule.Set.Immutable { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = io.usethesource.capsule.core.PersistentTrieSet.of() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = io.usethesource.capsule.core.PersistentTrieSet.of() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = io.usethesource.capsule.core.PersistentTrieSet.of() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): io.usethesource.capsule.Set.Immutable { + var set = persistentSet + repeat(times = size) { index -> + set = set.__remove(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): io.usethesource.capsule.Set.Immutable { + var set = io.usethesource.capsule.core.PersistentTrieSet.of() + for (element in elements) { + set = set.__insert(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/capsule/builder/SetBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/capsule/builder/SetBuilder.kt new file mode 100644 index 00000000..c9a27188 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/capsule/builder/SetBuilder.kt @@ -0,0 +1,182 @@ +/* + * 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.immutableSet.capsule.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): io.usethesource.capsule.Set.Transient { + return persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } + + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetBuilderAdd(elements, immutablePercentage) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + private var builder = io.usethesource.capsule.core.PersistentTrieSet.of().asTransient() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = io.usethesource.capsule.core.PersistentTrieSet.of().asTransient() + + @Setup(Level.Trial) + fun prepare() { + val elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + private var elementsToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + + elementsToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateElements(hashCodeType, size) + } else { + elements + } + } + + @Benchmark + fun addAndRemove(): io.usethesource.capsule.Set.Transient { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + builder.__remove(elementsToRemove[index]) + } + return builder + } +} + + +private fun persistentSetBuilderAdd( + elements: List, + immutablePercentage: Double +): io.usethesource.capsule.Set.Transient { + val immutableSize = immutableSize(elements.size, immutablePercentage) + + var set = io.usethesource.capsule.core.PersistentTrieSet.of() + for (index in 0 until immutableSize) { + set = set.__insert(elements[index]) + } + + val builder = set.asTransient() + for (index in immutableSize until elements.size) { + builder.add(elements[index]) + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojure/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojure/Set.kt new file mode 100644 index 00000000..250ad636 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojure/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.clojure + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): clojure.lang.PersistentHashSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = clojure.lang.PersistentHashSet.EMPTY + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = clojure.lang.PersistentHashSet.EMPTY + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = clojure.lang.PersistentHashSet.EMPTY + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): clojure.lang.PersistentHashSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.disjoin(elements[index]) as clojure.lang.PersistentHashSet + } + return set + } +} + + +private fun persistentSetAdd(elements: List): clojure.lang.PersistentHashSet { + var set = clojure.lang.PersistentHashSet.EMPTY + for (element in elements) { + set = set.cons(element) as clojure.lang.PersistentHashSet + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojure/builder/SetBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojure/builder/SetBuilder.kt new file mode 100644 index 00000000..40e64495 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojure/builder/SetBuilder.kt @@ -0,0 +1,149 @@ +/* + * 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.immutableSet.clojure.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): clojure.lang.ATransientSet { + return persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } + + +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + private var builder = clojure.lang.PersistentHashSet.EMPTY.asTransient() as clojure.lang.ATransientSet + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } +} + + + + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + private var elementsToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + + elementsToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateElements(hashCodeType, size) + } else { + elements + } + } + + @Benchmark + fun addAndRemove(): clojure.lang.ATransientSet { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + builder.disjoin(elementsToRemove[index]) + } + return builder + } +} + + +private fun persistentSetBuilderAdd( + elements: List, + immutablePercentage: Double +): clojure.lang.ATransientSet { + val immutableSize = immutableSize(elements.size, immutablePercentage) + + var set = clojure.lang.PersistentHashSet.EMPTY + for (index in 0 until immutableSize) { + set = set.cons(elements[index]) as clojure.lang.PersistentHashSet + } + + val builder = set.asTransient() as clojure.lang.ATransientSet + for (index in immutableSize until elements.size) { + builder.conj(elements[index]) + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojureSorted/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojureSorted/Set.kt new file mode 100644 index 00000000..8d4ecfc7 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/clojureSorted/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.clojureSorted + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): clojure.lang.PersistentTreeSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = clojure.lang.PersistentTreeSet.EMPTY + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = clojure.lang.PersistentTreeSet.EMPTY + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = clojure.lang.PersistentTreeSet.EMPTY + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): clojure.lang.PersistentTreeSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.disjoin(elements[index]) as clojure.lang.PersistentTreeSet + } + return set + } +} + + +private fun persistentSetAdd(elements: List): clojure.lang.PersistentTreeSet { + var set = clojure.lang.PersistentTreeSet.EMPTY + for (element in elements) { + set = set.cons(element) as clojure.lang.PersistentTreeSet + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclops/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclops/Set.kt new file mode 100644 index 00000000..9bee89aa --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclops/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.cyclops + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): cyclops.data.HashSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = cyclops.data.HashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = cyclops.data.HashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = cyclops.data.HashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): cyclops.data.HashSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.removeValue(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): cyclops.data.HashSet { + var set = cyclops.data.HashSet.empty() + for (element in elements) { + set = set.add(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclopsSorted/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclopsSorted/Set.kt new file mode 100644 index 00000000..d727ea6b --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclopsSorted/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.cyclopsSorted + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): cyclops.data.TreeSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = cyclops.data.TreeSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = cyclops.data.TreeSet.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = cyclops.data.TreeSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): cyclops.data.TreeSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.removeValue(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): cyclops.data.TreeSet { + var set = cyclops.data.TreeSet.empty() + for (element in elements) { + set = set.add(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclopsTrie/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclopsTrie/Set.kt new file mode 100644 index 00000000..959122ab --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/cyclopsTrie/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.cyclopsTrie + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): cyclops.data.TrieSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = cyclops.data.TrieSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = cyclops.data.TrieSet.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = cyclops.data.TrieSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): cyclops.data.TrieSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.removeValue(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): cyclops.data.TrieSet { + var set = cyclops.data.TrieSet.empty() + for (element in elements) { + set = set.add(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlin/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlin/Set.kt new file mode 100644 index 00000000..a1f533fa --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlin/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.kotlin + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): kotlinx.collections.immutable.PersistentSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = kotlinx.collections.immutable.persistentHashSetOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = kotlinx.collections.immutable.persistentHashSetOf() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = kotlinx.collections.immutable.persistentHashSetOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): kotlinx.collections.immutable.PersistentSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.remove(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): kotlinx.collections.immutable.PersistentSet { + var set = kotlinx.collections.immutable.persistentHashSetOf() + for (element in elements) { + set = set.add(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlin/builder/SetBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlin/builder/SetBuilder.kt new file mode 100644 index 00000000..2de42747 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlin/builder/SetBuilder.kt @@ -0,0 +1,182 @@ +/* + * 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.immutableSet.kotlin.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): kotlinx.collections.immutable.PersistentSet.Builder { + return persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } + + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetBuilderAdd(elements, immutablePercentage) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + private var builder = kotlinx.collections.immutable.persistentHashSetOf().builder() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = kotlinx.collections.immutable.persistentHashSetOf().builder() + + @Setup(Level.Trial) + fun prepare() { + val elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + private var elementsToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + + elementsToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateElements(hashCodeType, size) + } else { + elements + } + } + + @Benchmark + fun addAndRemove(): kotlinx.collections.immutable.PersistentSet.Builder { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + builder.remove(elementsToRemove[index]) + } + return builder + } +} + + +private fun persistentSetBuilderAdd( + elements: List, + immutablePercentage: Double +): kotlinx.collections.immutable.PersistentSet.Builder { + val immutableSize = immutableSize(elements.size, immutablePercentage) + + var set = kotlinx.collections.immutable.persistentHashSetOf() + for (index in 0 until immutableSize) { + set = set.add(elements[index]) + } + + val builder = set.builder() + for (index in immutableSize until elements.size) { + builder.add(elements[index]) + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlinOrdered/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlinOrdered/Set.kt new file mode 100644 index 00000000..0faeb0db --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlinOrdered/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.kotlinOrdered + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): kotlinx.collections.immutable.PersistentSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = kotlinx.collections.immutable.persistentSetOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = kotlinx.collections.immutable.persistentSetOf() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = kotlinx.collections.immutable.persistentSetOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): kotlinx.collections.immutable.PersistentSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.remove(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): kotlinx.collections.immutable.PersistentSet { + var set = kotlinx.collections.immutable.persistentSetOf() + for (element in elements) { + set = set.add(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlinOrdered/builder/SetBuilder.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlinOrdered/builder/SetBuilder.kt new file mode 100644 index 00000000..b24f0a2c --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/kotlinOrdered/builder/SetBuilder.kt @@ -0,0 +1,182 @@ +/* + * 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.immutableSet.kotlinOrdered.builder + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): kotlinx.collections.immutable.PersistentSet.Builder { + return persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } + + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetBuilderAdd(elements, immutablePercentage) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + private var builder = kotlinx.collections.immutable.persistentSetOf().builder() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } +} + + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = kotlinx.collections.immutable.persistentSetOf().builder() + + @Setup(Level.Trial) + fun prepare() { + val elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf() + private var elementsToRemove = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + + elementsToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateElements(hashCodeType, size) + } else { + elements + } + } + + @Benchmark + fun addAndRemove(): kotlinx.collections.immutable.PersistentSet.Builder { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + builder.remove(elementsToRemove[index]) + } + return builder + } +} + + +private fun persistentSetBuilderAdd( + elements: List, + immutablePercentage: Double +): kotlinx.collections.immutable.PersistentSet.Builder { + val immutableSize = immutableSize(elements.size, immutablePercentage) + + var set = kotlinx.collections.immutable.persistentSetOf() + for (index in 0 until immutableSize) { + set = set.add(elements[index]) + } + + val builder = set.builder() + for (index in immutableSize until elements.size) { + builder.add(elements[index]) + } + + return builder +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/scala/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/scala/Set.kt new file mode 100644 index 00000000..74caf33b --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/scala/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.scala + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): scala.collection.immutable.HashSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = scala.collection.immutable.`HashSet$`.`MODULE$`.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = scala.collection.immutable.`HashSet$`.`MODULE$`.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = scala.collection.immutable.`HashSet$`.`MODULE$`.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): scala.collection.immutable.HashSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.excl(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): scala.collection.immutable.HashSet { + var set = scala.collection.immutable.`HashSet$`.`MODULE$`.empty() + for (element in elements) { + set = set.incl(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/scalaSorted/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/scalaSorted/Set.kt new file mode 100644 index 00000000..d19d0a8d --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/scalaSorted/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.scalaSorted + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): scala.collection.immutable.TreeSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = scala.collection.immutable.TreeSet(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder())) + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = scala.collection.immutable.TreeSet(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder())) + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = scala.collection.immutable.TreeSet(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder())) + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): scala.collection.immutable.TreeSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.excl(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): scala.collection.immutable.TreeSet { + var set = scala.collection.immutable.TreeSet(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder())) + for (element in elements) { + set = set.incl(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavr/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavr/Set.kt new file mode 100644 index 00000000..fd4939e6 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavr/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.vavr + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): io.vavr.collection.HashSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = io.vavr.collection.HashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = io.vavr.collection.HashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = io.vavr.collection.HashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): io.vavr.collection.HashSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.remove(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): io.vavr.collection.HashSet { + var set = io.vavr.collection.HashSet.empty() + for (element in elements) { + set = set.add(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavrOrdered/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavrOrdered/Set.kt new file mode 100644 index 00000000..aef8d3b0 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavrOrdered/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.vavrOrdered + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): io.vavr.collection.LinkedHashSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = io.vavr.collection.LinkedHashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = io.vavr.collection.LinkedHashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = io.vavr.collection.LinkedHashSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): io.vavr.collection.LinkedHashSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.remove(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): io.vavr.collection.LinkedHashSet { + var set = io.vavr.collection.LinkedHashSet.empty() + for (element in elements) { + set = set.add(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavrSorted/Set.kt b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavrSorted/Set.kt new file mode 100644 index 00000000..c9498706 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/immutableSet/vavrSorted/Set.kt @@ -0,0 +1,154 @@ +/* + * 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.immutableSet.vavrSorted + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.infra.Blackhole +import benchmarks.* + +@State(Scope.Thread) +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): io.vavr.collection.TreeSet { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +@State(Scope.Thread) +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = io.vavr.collection.TreeSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +@State(Scope.Thread) +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = io.vavr.collection.TreeSet.empty() + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +@State(Scope.Thread) +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf() + private var persistentSet = io.vavr.collection.TreeSet.empty() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): io.vavr.collection.TreeSet { + var set = persistentSet + repeat(times = size) { index -> + set = set.remove(elements[index]) + } + return set + } +} + + +private fun persistentSetAdd(elements: List): io.vavr.collection.TreeSet { + var set = io.vavr.collection.TreeSet.empty() + for (element in elements) { + set = set.add(element) + } + return set +} diff --git a/benchmarks-libraries/src/jmh/java/benchmarks/utils.kt b/benchmarks-libraries/src/jmh/java/benchmarks/utils.kt new file mode 100644 index 00000000..c7382070 --- /dev/null +++ b/benchmarks-libraries/src/jmh/java/benchmarks/utils.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. + */ + +// Auto-generated file. DO NOT EDIT! + +package benchmarks + + +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 { + val keys = mutableListOf() + repeat(size) { + keys.add(IntWrapper(it, hashCodeGenerator(it))) + } + return keys +} + +private fun generateIntWrappers(hashCodeType: String, size: Int): List { + val random = java.util.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) + + +fun immutableSize(size: Int, immutablePercentage: Double): Int { + return kotlin.math.floor(size * immutablePercentage / 100.0).toInt() +} diff --git a/benchmarks-libraries/src/main/kotlin/generators/CommonUtilsGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/CommonUtilsGenerator.kt new file mode 100644 index 00000000..156a4f8d --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/CommonUtilsGenerator.kt @@ -0,0 +1,62 @@ +/* + * 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 generators + +import java.io.PrintWriter + +class CommonUtilsGenerator: SourceGenerator() { + override val outputFileName: String = "utils" + + override val imports: Set = setOf() + + override fun generateBody(out: PrintWriter) { + out.println(""" +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 { + val keys = mutableListOf() + repeat(size) { + keys.add(IntWrapper(it, hashCodeGenerator(it))) + } + return keys +} + +private fun generateIntWrappers(hashCodeType: String, size: Int): List { + val random = java.util.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) + + +fun immutableSize(size: Int, immutablePercentage: Double): Int { + return kotlin.math.floor(size * immutablePercentage / 100.0).toInt() +} + """.trimIndent() + ) + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/IntWrapperGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/IntWrapperGenerator.kt new file mode 100644 index 00000000..82707499 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/IntWrapperGenerator.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. + */ + +package generators + +import java.io.PrintWriter + +class IntWrapperGenerator: SourceGenerator() { + override val outputFileName: String = "IntWrapper" + + override val imports: Set = setOf() + + override fun generateBody(out: PrintWriter) { + out.println(""" +class IntWrapper(val obj: Int, val hashCode: Int) : Comparable { + 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) + } +} + """.trimIndent() + ) + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/benchmarkSourceGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/benchmarkSourceGenerator.kt new file mode 100644 index 00000000..38562e62 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/benchmarkSourceGenerator.kt @@ -0,0 +1,210 @@ +/* + * 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 generators + +import generators.immutableList.* +import generators.immutableList.impl.* +import generators.immutableListBuilder.* +import generators.immutableListBuilder.impl.* +import generators.immutableMap.* +import generators.immutableMap.impl.* +import generators.immutableMapBuilder.* +import generators.immutableMapBuilder.impl.* +import generators.immutableSet.* +import generators.immutableSet.impl.* +import generators.immutableSetBuilder.* +import generators.immutableSetBuilder.impl.* +import org.xml.sax.InputSource +import java.io.File +import java.io.PrintWriter +import java.nio.file.Files +import java.nio.file.Path +import java.nio.file.Paths +import javax.xml.xpath.XPathFactory + + +private const val BENCHMARKS_ROOT = "src/jmh/java/" + + +abstract class SourceGenerator { + abstract val outputFileName: String + open fun getPackage(): String = "benchmarks" + + fun generate(out: PrintWriter) { + out.println(readCopyrightNoticeFromProfile(File(".idea/copyright/apache_2_0.xml"))) + out.println("// Auto-generated file. DO NOT EDIT!") + out.println() + out.println("package ${getPackage()}") + out.println() + imports.forEach { + out.println("import $it") + } + out.println() + + generateBody(out) + } + + protected abstract val imports: Set + protected abstract fun generateBody(out: PrintWriter): Unit +} + +fun readCopyrightNoticeFromProfile(copyrightProfile: File): String { + val template = copyrightProfile.reader().use { reader -> + XPathFactory.newInstance().newXPath().evaluate("/component/copyright/option[@name='notice']/@value", InputSource(reader)) + } + val yearTemplate = "$today.year" + val year = java.time.LocalDate.now().year.toString() + assert(yearTemplate in template) + + return template.replace(yearTemplate, year).lines().joinToString("", prefix = "/*\n", postfix = " */\n") { " * $it\n" } +} + + +abstract class BenchmarkSourceGenerator: SourceGenerator() { + override val imports: Set = setOf( + "org.openjdk.jmh.annotations.*", + "java.util.concurrent.TimeUnit", + "org.openjdk.jmh.infra.Blackhole", + "benchmarks.*" + ) + + override fun generateBody(out: PrintWriter) { + generateBenchmark(out, "@State(Scope.Thread)") + } + + protected abstract fun generateBenchmark(out: PrintWriter, header: String) +} + + +private val listImpls = listOf( + KotlinListImplementation, + PaguroListImplementation, + CyclopsListImplementation, + ClojureListImplementation, + ScalaListImplementation, + VavrListImplementation +) +private val listBuilderImpls = listOf( + KotlinListBuilderImplementation, + PaguroListBuilderImplementation, + ClojureListBuilderImplementation +) + +private val mapImpls = listOf( + KotlinMapImplementation, + KotlinOrderedMapImplementation, + CapsuleMapImplementation, + PaguroMapImplementation, + PaguroSortedMapImplementation, + CyclopsMapImplementation, + CyclopsOrderedMapImplementation, + CyclopsTrieMapImplementation, + ClojureMapImplementation, + ClojureSortedMapImplementation, + ScalaMapImplementation, + ScalaSortedMapImplementation, + VavrMapImplementation, + VavrSortedMapImplementation, + VavrOrderedMapImplementation +) +private val mapBuilderImpls = listOf( + KotlinMapBuilderImplementation, + KotlinOrderedMapBuilderImplementation, + CapsuleMapBuilderImplementation, + PaguroMapBuilderImplementation, + ClojureMapBuilderImplementation +) + +private val setImpls = listOf( + KotlinSetImplementation, + KotlinOrderedSetImplementation, + CapsuleSetImplementation, + CyclopsSetImplementation, + CyclopsTrieSetImplementation, + CyclopsSortedSetImplementation, + ClojureSetImplementation, + ClojureSortedSetImplementation, + ScalaSetImplementation, + ScalaSortedSetImplementation, + VavrSetImplementation, + VavrSortedSetImplementation, + VavrOrderedSetImplementation +) +private val setBuilderImpls = listOf( + KotlinSetBuilderImplementation, + KotlinOrderedSetBuilderImplementation, + CapsuleSetBuilderImplementation, + ClojureSetBuilderImplementation +) + +fun generateBenchmarks() { + val listBenchmarks = listImpls.map { + ListBenchmarksGenerator(it) + } + val listBuilderBenchmarks = listBuilderImpls.map { + ListBuilderBenchmarksGenerator(it) + } + + val mapBenchmarks = mapImpls.map { + MapBenchmarksGenerator(it) + } + val mapBuilderBenchmarks = mapBuilderImpls.map { + MapBuilderBenchmarksGenerator(it) + } + + val setBenchmarks = setImpls.map { + SetBenchmarksGenerator(it) + } + val setBuilderBenchmarks = setBuilderImpls.map { + SetBuilderBenchmarksGenerator(it) + } + + val commonUtils = listOf( + IntWrapperGenerator(), + CommonUtilsGenerator() + ) + + + val allGenerators = listOf( + commonUtils, + listBenchmarks, + listBuilderBenchmarks, + mapBenchmarks, + mapBuilderBenchmarks, + setBenchmarks, + setBuilderBenchmarks + ).flatten() + + allGenerators.forEach { generator -> + val path = generator.getPackage().replace('.', '/') + "/" + generator.outputFileName + ".kt" + val file = File(BENCHMARKS_ROOT + path) + file.parentFile?.mkdirs() + val out = PrintWriter(file) + generator.generate(out) + out.flush() + } +} + + +fun main() { + Files.walk(Paths.get(BENCHMARKS_ROOT)) + .sorted(Comparator.reverseOrder()) + .map(Path::toFile) + .forEach { it.delete() } + + generateBenchmarks() +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/clojure.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/clojure.kt new file mode 100644 index 00000000..ad66639d --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/clojure.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. + */ + +package generators.immutableList.impl + +object ClojureListImplementation: ListImplementation { + override val packageName: String + = "clojure" + + override fun type(): String + = "clojure.lang.PersistentVector" + override fun empty(): String + = "clojure.lang.PersistentVector.EMPTY" + + override fun getOperation(list: String, index: String): String + = "$list.get($index)" + override fun setOperation(list: String, index: String, newValue: String): String + = "$list.assocN($index, $newValue)" + override fun addOperation(list: String, element: String): String + = "$list.cons($element)" + override fun removeLastOperation(list: String): String + = "$list.pop()" + + override fun iterateLastToFirst(list: String, size: String): String { + return """ + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = $list.listIterator($size) + + while (iterator.hasPrevious()) { + bh.consume(iterator.previous()) + } + }""" + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/cyclops.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/cyclops.kt new file mode 100644 index 00000000..db60c790 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/cyclops.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. + */ + +package generators.immutableList.impl + +object CyclopsListImplementation: ListImplementation { + override val packageName: String + = "cyclops" + + override fun type(): String + = "cyclops.data.Vector<$listElementType>" + override fun empty(): String + = "cyclops.data.Vector.empty<$listElementType>()" + + override fun getOperation(list: String, index: String): String + = "$list.get($index)" + override fun setOperation(list: String, index: String, newValue: String): String + = "$list.updateAt($index, $newValue)" + override fun addOperation(list: String, element: String): String + = "$list.plus($element)" + override fun removeLastOperation(list: String): String + = "$list.dropRight(1)" + + override fun iterateLastToFirst(list: String, size: String): String { + return """ + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = $list.reverse().iterator() + + while (iterator.hasNext()) { + bh.consume(iterator.next()) + } + }""" + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/kotlin.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/kotlin.kt new file mode 100644 index 00000000..8cb5f698 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/kotlin.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. + */ + +package generators.immutableList.impl + +object KotlinListImplementation: ListImplementation { + override val packageName: String + = "kotlin" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentList<$listElementType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentListOf<$listElementType>()" + + override fun getOperation(list: String, index: String): String + = "$list.get($index)" + override fun setOperation(list: String, index: String, newValue: String): String + = "$list.set($index, $newValue)" + override fun addOperation(list: String, element: String): String + = "$list.add($element)" + override fun removeLastOperation(list: String): String + = "$list.removeAt($list.size - 1)" + + override fun iterateLastToFirst(list: String, size: String): String { + return """ + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = $list.listIterator($size) + + while (iterator.hasPrevious()) { + bh.consume(iterator.previous()) + } + }""" + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/listImplementation.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/listImplementation.kt new file mode 100644 index 00000000..22559509 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/listImplementation.kt @@ -0,0 +1,36 @@ +/* + * 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 generators.immutableList.impl + +interface ListImplementation { + val packageName: String + + fun type(): String + fun empty(): String + + fun getOperation(list: String, index: String): String + fun setOperation(list: String, index: String, newValue: String): String + fun addOperation(list: String, element: String): String + fun removeLastOperation(list: String): String + + fun iterateLastToFirst(list: String, size: String): String +} + +const val listElementType = "String" + +const val listElement = "\"some element\"" +const val listNewElement = "\"another element\"" \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/paguro.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/paguro.kt new file mode 100644 index 00000000..95301fd2 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/paguro.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. + */ + +package generators.immutableList.impl + +object PaguroListImplementation: ListImplementation { + override val packageName: String + = "paguro" + + override fun type(): String + = "org.organicdesign.fp.collections.RrbTree.ImRrbt<$listElementType>" + override fun empty(): String + = "org.organicdesign.fp.collections.RrbTree.empty<$listElementType>()" + + override fun getOperation(list: String, index: String): String + = "$list.get($index)" + override fun setOperation(list: String, index: String, newValue: String): String + = "$list.replace($index, $newValue)" + override fun addOperation(list: String, element: String): String + = "$list.append($element)" + override fun removeLastOperation(list: String): String + = "$list.without($list.size - 1)" + + override fun iterateLastToFirst(list: String, size: String): String { + return """ + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = $list.listIterator($size) + + while (iterator.hasPrevious()) { + bh.consume(iterator.previous()) + } + }""" + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/scala.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/scala.kt new file mode 100644 index 00000000..2ab72a79 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/scala.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. + */ + +package generators.immutableList.impl + +object ScalaListImplementation: ListImplementation { + override val packageName: String + = "scala" + + override fun type(): String + = "scala.collection.immutable.Vector<$listElementType>" + override fun empty(): String + = "scala.collection.immutable.`Vector\$`.`MODULE\$`.empty<$listElementType>()" + + override fun getOperation(list: String, index: String): String + = "$list.apply($index)" + override fun setOperation(list: String, index: String, newValue: String): String + = "$list.updateAt($index, $newValue)" + override fun addOperation(list: String, element: String): String + = "$list.appended($element) as " + type() + override fun removeLastOperation(list: String): String + = "$list.dropRight(1)" + + override fun iterateLastToFirst(list: String, size: String): String { + return """ + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = $list.reverseIterator() + + while (iterator.hasNext()) { + bh.consume(iterator.next()) + } + }""" + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/vavr.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/vavr.kt new file mode 100644 index 00000000..d5de3bc4 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableList/impl/vavr.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. + */ + +package generators.immutableList.impl + +object VavrListImplementation: ListImplementation { + override val packageName: String + = "vavr" + + override fun type(): String + = "io.vavr.collection.Vector<$listElementType>" + override fun empty(): String + = "io.vavr.collection.Vector.empty<$listElementType>()" + + override fun getOperation(list: String, index: String): String + = "$list.apply($index)" + override fun setOperation(list: String, index: String, newValue: String): String + = "$list.update($index, $newValue)" + override fun addOperation(list: String, element: String): String + = "$list.append($element)" + override fun removeLastOperation(list: String): String + = "$list.dropRight(1)" + + override fun iterateLastToFirst(list: String, size: String): String { + return """ + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = $list.reverseIterator() + + while (iterator.hasNext()) { + bh.consume(iterator.next()) + } + }""" + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableList/listBenchmarksGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableList/listBenchmarksGenerator.kt new file mode 100644 index 00000000..cd5f4cb3 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableList/listBenchmarksGenerator.kt @@ -0,0 +1,170 @@ +/* + * 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 generators.immutableList + +import generators.BenchmarkSourceGenerator +import generators.immutableList.impl.ListImplementation +import generators.immutableList.impl.listElement +import generators.immutableList.impl.listNewElement +import java.io.PrintWriter + +class ListBenchmarksGenerator(private val impl: ListImplementation) : BenchmarkSourceGenerator() { + override val outputFileName: String get() = "List" + + override fun getPackage(): String { + return super.getPackage() + ".immutableList." + impl.packageName + } + + override fun generateBenchmark(out: PrintWriter, header: String) { + out.println(""" +$header +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Benchmark + fun addLast(): ${impl.type()} { + 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(${impl.getOperation("list", "i")}) + } + } +} + + +$header +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun getByIndex(bh: Blackhole) { + for (i in 0 until size) { + bh.consume(${impl.getOperation("persistentList", "i")}) + } + } +} + + +$header +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun firstToLast(bh: Blackhole) { + for (e in persistentList) { + bh.consume(e) + } + } +${impl.iterateLastToFirst("persistentList", "size")} +} + + +$header +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + } + + @Benchmark + fun removeLast(): ${impl.type()} { + var list = persistentList + repeat(times = size) { + list = ${impl.removeLastOperation("list")} + } + return list + } +} + + +$header +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + private var persistentList = ${impl.empty()} + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + persistentList = persistentListAdd(size) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): ${impl.type()} { + repeat(times = size) { index -> + persistentList = ${impl.setOperation("persistentList", "index", listNewElement)} + } + return persistentList + } + + @Benchmark + fun setByRandomIndex(): ${impl.type()} { + repeat(times = size) { index -> + persistentList = ${impl.setOperation("persistentList", "randomIndices[index]", listNewElement)} + } + return persistentList + } +} + + +private fun persistentListAdd(size: Int): ${impl.type()} { + var list = ${impl.empty()} + repeat(times = size) { + list = ${impl.addOperation("list", listElement)} + } + return list +} + """.trimIndent() + ) + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/clojure.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/clojure.kt new file mode 100644 index 00000000..6fab7f70 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/clojure.kt @@ -0,0 +1,47 @@ +/* + * 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 generators.immutableListBuilder.impl + +object ClojureListBuilderImplementation: ListBuilderImplementation { + override val packageName: String + = "clojure.builder" + + override fun type(): String + = "clojure.lang.ITransientVector" + override fun empty(): String + = "clojure.lang.PersistentVector.EMPTY.asTransient() as clojure.lang.ITransientVector" + + override fun getOperation(builder: String, index: String): String + = "$builder.valAt($index)" + override fun setOperation(builder: String, index: String, newValue: String): String + = "$builder.assocN($index, $newValue)" + override fun addOperation(builder: String, element: String): String + = "$builder.conj($element)" + override fun removeLastOperation(builder: String): String + = "$builder.pop()" + + override val isIterable: Boolean + = false + + override fun builderOperation(immutable: String): String + = "$immutable.asTransient() as clojure.lang.ITransientVector" + + override fun immutableEmpty(): String + = "clojure.lang.PersistentVector.EMPTY" + override fun immutableAddOperation(immutable: String, element: String): String + = "$immutable.cons($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/kotlin.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/kotlin.kt new file mode 100644 index 00000000..69ffcbc4 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/kotlin.kt @@ -0,0 +1,47 @@ +/* + * 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 generators.immutableListBuilder.impl + +object KotlinListBuilderImplementation: ListBuilderImplementation { + override val packageName: String + = "kotlin.builder" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentList.Builder<$listBuilderElementType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentListOf<$listBuilderElementType>().builder()" + + override fun getOperation(builder: String, index: String): String + = "$builder.get($index)" + override fun setOperation(builder: String, index: String, newValue: String): String + = "$builder.set($index, $newValue)" + override fun addOperation(builder: String, element: String): String + = "$builder.add($element)" + override fun removeLastOperation(builder: String): String + = "$builder.removeAt($builder.size - 1)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String + = "$immutable.builder()" + + override fun immutableEmpty(): String + = "kotlinx.collections.immutable.persistentListOf<$listBuilderElementType>()" + override fun immutableAddOperation(immutable: String, element: String): String + = "$immutable.add($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/listBuilderImplementation.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/listBuilderImplementation.kt new file mode 100644 index 00000000..c46af5bc --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/listBuilderImplementation.kt @@ -0,0 +1,41 @@ +/* + * 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 generators.immutableListBuilder.impl + +interface ListBuilderImplementation { + val packageName: String + + fun type(): String + fun empty(): String + + fun getOperation(builder: String, index: String): String + fun setOperation(builder: String, index: String, newValue: String): String + fun addOperation(builder: String, element: String): String + fun removeLastOperation(builder: String): String + + val isIterable: Boolean + + fun builderOperation(immutable: String): String + + fun immutableEmpty(): String + fun immutableAddOperation(immutable: String, element: String): String +} + +const val listBuilderElementType = "String" + +const val listBuilderElement = "\"some element\"" +const val listBuilderNewElement = "\"another element\"" \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/paguro.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/paguro.kt new file mode 100644 index 00000000..a414a8e4 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/impl/paguro.kt @@ -0,0 +1,47 @@ +/* + * 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 generators.immutableListBuilder.impl + +object PaguroListBuilderImplementation: ListBuilderImplementation { + override val packageName: String + = "paguro.builder" + + override fun type(): String + = "org.organicdesign.fp.collections.RrbTree.MutableRrbt<$listBuilderElementType>" + override fun empty(): String + = "org.organicdesign.fp.collections.RrbTree.emptyMutable<$listBuilderElementType>()" + + override fun getOperation(builder: String, index: String): String + = "$builder.get($index)" + override fun setOperation(builder: String, index: String, newValue: String): String + = "$builder.replace($index, $newValue)" + override fun addOperation(builder: String, element: String): String + = "$builder.append($element)" + override fun removeLastOperation(builder: String): String + = "$builder.without($builder.size - 1)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String + = "$immutable.mutable()" + + override fun immutableEmpty(): String + = "org.organicdesign.fp.collections.RrbTree.empty<$listBuilderElementType>()" + override fun immutableAddOperation(immutable: String, element: String): String + = "$immutable.append($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/listBuilderBenchmarksGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/listBuilderBenchmarksGenerator.kt new file mode 100644 index 00000000..0734767a --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableListBuilder/listBuilderBenchmarksGenerator.kt @@ -0,0 +1,202 @@ +/* + * 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 generators.immutableListBuilder + +import generators.BenchmarkSourceGenerator +import generators.immutableListBuilder.impl.ListBuilderImplementation +import generators.immutableListBuilder.impl.listBuilderElement +import generators.immutableListBuilder.impl.listBuilderNewElement +import java.io.PrintWriter + +class ListBuilderBenchmarksGenerator(private val impl: ListBuilderImplementation) : BenchmarkSourceGenerator() { + override val outputFileName: String = "ListBuilder" + + override fun getPackage(): String { + return super.getPackage() + ".immutableList." + impl.packageName + } + + override fun generateBenchmark(out: PrintWriter, header: String) { + out.println(""" +$header +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + @Benchmark + fun addLast(): ${impl.type()} { + return persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun addLastAndGet(bh: Blackhole) { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (i in 0 until size) { + bh.consume(${impl.getOperation("builder", "i")}) + } + } + +${ +if (impl.isIterable) """ + @Benchmark + fun addLastAndIterate(bh: Blackhole) { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (e in builder) { + bh.consume(e) + } + }""" +else "" +} +} + + +$header +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder: ${impl.type()} = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun getByIndex(bh: Blackhole) { + for (i in 0 until size) { + bh.consume(${impl.getOperation("builder", "i")}) + } + } +} + + +${ +if (impl.isIterable) """ +$header +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + } + + @Benchmark + fun firstToLast(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } + + @Benchmark + fun lastToFirst(bh: Blackhole) { + val iterator = builder.listIterator(size) + + while (iterator.hasPrevious()) { + bh.consume(iterator.previous()) + } + } +}""" +else "" +} + + +$header +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + @Benchmark + fun addAndRemoveLast(): ${impl.type()} { + val builder = persistentListBuilderAdd(size, immutablePercentage) + for (i in 0 until size) { + ${impl.removeLastOperation("builder")} + } + return builder + } +} + + +$header +open class Set { + @Param("10000", "100000") + var size: Int = 0 + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = ${impl.empty()} + private var randomIndices = listOf() + + @Setup(Level.Trial) + fun prepare() { + builder = persistentListBuilderAdd(size, immutablePercentage) + randomIndices = List(size) { it }.shuffled() + } + + @Benchmark + fun setByIndex(): ${impl.type()} { + for (i in 0 until size) { + ${impl.setOperation("builder", "i", listBuilderNewElement)} + } + return builder + } + + @Benchmark + fun setByRandomIndex(): ${impl.type()} { + for (i in 0 until size) { + ${impl.setOperation("builder", "randomIndices[i]", listBuilderNewElement)} + } + return builder + } +} + + +private fun persistentListBuilderAdd(size: Int, immutablePercentage: Double): ${impl.type()} { + val immutableSize = immutableSize(size, immutablePercentage) + + var list = ${impl.immutableEmpty()} + repeat(times = immutableSize) { + list = ${impl.immutableAddOperation("list", listBuilderNewElement)} + } + + val builder = ${impl.builderOperation("list")} + repeat(times = size - immutableSize) { + ${impl.addOperation("builder", listBuilderElement)} + } + + return builder +} + """.trimIndent() + ) + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/capsule.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/capsule.kt new file mode 100644 index 00000000..c437c02e --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/capsule.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object CapsuleMapImplementation: MapImplementation { + override val packageName: String + = "capsule" + + override fun type(): String + = "io.usethesource.capsule.Map.Immutable<$mapKeyType, $mapValueType>" + override fun empty(): String + = "io.usethesource.capsule.core.PersistentTrieMap.of<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys" + override fun valuesOperation(map: String): String + = "$map.values" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.__put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.__remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/clojure.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/clojure.kt new file mode 100644 index 00000000..da611d6e --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/clojure.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object ClojureMapImplementation: MapImplementation { + override val packageName: String + = "clojure" + + override fun type(): String + = "clojure.lang.PersistentHashMap" + override fun empty(): String + = "clojure.lang.PersistentHashMap.EMPTY" + + override fun keysOperation(map: String): String + = "$map.keys" + override fun valuesOperation(map: String): String + = "$map.values" + + override fun getOperation(map: String, key: String): String + = "$map.valAt($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.assoc($key, $value) as clojure.lang.PersistentHashMap" + override fun removeOperation(map: String, key: String): String + = "$map.without($key) as clojure.lang.PersistentHashMap" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/clojureSorted.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/clojureSorted.kt new file mode 100644 index 00000000..2a5fe566 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/clojureSorted.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object ClojureSortedMapImplementation: MapImplementation { + override val packageName: String + = "clojureSorted" + + override fun type(): String + = "clojure.lang.PersistentTreeMap" + override fun empty(): String + = "clojure.lang.PersistentTreeMap.EMPTY" + + override fun keysOperation(map: String): String + = "$map.keys" + override fun valuesOperation(map: String): String + = "$map.values" + + override fun getOperation(map: String, key: String): String + = "$map.valAt($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.assoc($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.without($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclops.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclops.kt new file mode 100644 index 00000000..60500668 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclops.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object CyclopsMapImplementation: MapImplementation { + override val packageName: String + = "cyclops" + + override fun type(): String + = "cyclops.data.HashMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "cyclops.data.HashMap.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys()" + override fun valuesOperation(map: String): String + = "$map.values()" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclopsOrdered.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclopsOrdered.kt new file mode 100644 index 00000000..0896ed58 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclopsOrdered.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object CyclopsOrderedMapImplementation: MapImplementation { + override val packageName: String + = "cyclopsOrdered" + + override fun type(): String + = "cyclops.data.LinkedMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "cyclops.data.LinkedMap.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys()" + override fun valuesOperation(map: String): String + = "$map.values()" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclopsTrie.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclopsTrie.kt new file mode 100644 index 00000000..a5ef11b4 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/cyclopsTrie.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object CyclopsTrieMapImplementation: MapImplementation { + override val packageName: String + = "cyclopsTrie" + + override fun type(): String + = "cyclops.data.TrieMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "cyclops.data.TrieMap.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys()" + override fun valuesOperation(map: String): String + = "$map.values()" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/kotlin.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/kotlin.kt new file mode 100644 index 00000000..1fc51486 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/kotlin.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object KotlinMapImplementation: MapImplementation { + override val packageName: String + = "kotlin" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentHashMapOf<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys" + override fun valuesOperation(map: String): String + = "$map.values" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/kotlinOrdered.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/kotlinOrdered.kt new file mode 100644 index 00000000..f2b89d32 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/kotlinOrdered.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object KotlinOrderedMapImplementation: MapImplementation { + override val packageName: String + = "kotlinOrdered" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentMapOf<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys" + override fun valuesOperation(map: String): String + = "$map.values" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/mapImplementation.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/mapImplementation.kt new file mode 100644 index 00000000..ea506075 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/mapImplementation.kt @@ -0,0 +1,34 @@ +/* + * 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 generators.immutableMap.impl + +interface MapImplementation { + val packageName: String + + fun type(): String + fun empty(): String + + fun keysOperation(map: String): String + fun valuesOperation(map: String): String + + fun getOperation(map: String, key: String): String + fun putOperation(map: String, key: String, value: String): String + fun removeOperation(map: String, key: String): String +} + +const val mapKeyType = "IntWrapper" +const val mapValueType = "String" \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/paguro.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/paguro.kt new file mode 100644 index 00000000..2f95cf85 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/paguro.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object PaguroMapImplementation: MapImplementation { + override val packageName: String + = "paguro" + + override fun type(): String + = "org.organicdesign.fp.collections.PersistentHashMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "org.organicdesign.fp.collections.PersistentHashMap.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys" + override fun valuesOperation(map: String): String + = "$map.values" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.assoc($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.without($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/paguroSorted.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/paguroSorted.kt new file mode 100644 index 00000000..48bb868a --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/paguroSorted.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object PaguroSortedMapImplementation: MapImplementation { + override val packageName: String + = "paguroSorted" + + override fun type(): String + = "org.organicdesign.fp.collections.PersistentTreeMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "org.organicdesign.fp.collections.PersistentTreeMap.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys" + override fun valuesOperation(map: String): String + = "$map.values" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.assoc($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.without($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/scala.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/scala.kt new file mode 100644 index 00000000..3407d760 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/scala.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object ScalaMapImplementation: MapImplementation { + override val packageName: String + = "scala" + + override fun type(): String + = "scala.collection.immutable.HashMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "scala.collection.immutable.`HashMap\$`.`MODULE\$`.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keys()" + override fun valuesOperation(map: String): String + = "$map.values()" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.updated($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.removed($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/scalaSorted.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/scalaSorted.kt new file mode 100644 index 00000000..75c73296 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/scalaSorted.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object ScalaSortedMapImplementation: MapImplementation { + override val packageName: String + = "scalaSorted" + + override fun type(): String + = "scala.collection.immutable.TreeMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "scala.collection.immutable.`TreeMap\$`.`MODULE\$`.empty<$mapKeyType, $mapValueType>(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder<$mapKeyType>()))" + + override fun keysOperation(map: String): String + = "$map.keys()" + override fun valuesOperation(map: String): String + = "$map.values()" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.updated($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.removed($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavr.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavr.kt new file mode 100644 index 00000000..f65cbe47 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavr.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object VavrMapImplementation: MapImplementation { + override val packageName: String + = "vavr" + + override fun type(): String + = "io.vavr.collection.HashMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "io.vavr.collection.HashMap.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keysIterator()" + override fun valuesOperation(map: String): String + = "$map.valuesIterator()" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavrOrdered.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavrOrdered.kt new file mode 100644 index 00000000..6fd60627 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavrOrdered.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object VavrOrderedMapImplementation: MapImplementation { + override val packageName: String + = "vavrOrdered" + + override fun type(): String + = "io.vavr.collection.LinkedHashMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "io.vavr.collection.LinkedHashMap.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keysIterator()" + override fun valuesOperation(map: String): String + = "$map.valuesIterator()" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavrSorted.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavrSorted.kt new file mode 100644 index 00000000..c412fd85 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/impl/vavrSorted.kt @@ -0,0 +1,39 @@ +/* + * 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 generators.immutableMap.impl + +object VavrSortedMapImplementation: MapImplementation { + override val packageName: String + = "vavrSorted" + + override fun type(): String + = "io.vavr.collection.TreeMap<$mapKeyType, $mapValueType>" + override fun empty(): String + = "io.vavr.collection.TreeMap.empty<$mapKeyType, $mapValueType>()" + + override fun keysOperation(map: String): String + = "$map.keysIterator()" + override fun valuesOperation(map: String): String + = "$map.valuesIterator()" + + override fun getOperation(map: String, key: String): String + = "$map.get($key)" + override fun putOperation(map: String, key: String, value: String): String + = "$map.put($key, $value)" + override fun removeOperation(map: String, key: String): String + = "$map.remove($key)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMap/mapBenchmarksGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/mapBenchmarksGenerator.kt new file mode 100644 index 00000000..dec41082 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMap/mapBenchmarksGenerator.kt @@ -0,0 +1,180 @@ +/* + * 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 generators.immutableMap + +import generators.BenchmarkSourceGenerator +import generators.immutableMap.impl.MapImplementation +import generators.immutableMap.impl.mapKeyType +import java.io.PrintWriter + +class MapBenchmarksGenerator(private val impl: MapImplementation) : BenchmarkSourceGenerator() { + override val outputFileName: String = "Map" + + override fun getPackage(): String { + return super.getPackage() + ".immutableMap." + impl.packageName + } + + override fun generateBenchmark(out: PrintWriter, header: String) { + out.println(""" +$header +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf<$mapKeyType>() + private var persistentMap = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(${impl.getOperation("persistentMap", "keys[index]")}) + } + } +} + + +$header +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentMap = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + persistentMap = persistentMapPut(generateKeys(hashCodeType, size)) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in ${impl.keysOperation("persistentMap")}) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in ${impl.valuesOperation("persistentMap")}) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in persistentMap) { + bh.consume(e) + } + } +} + + +$header +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf<$mapKeyType>() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): ${impl.type()} { + return persistentMapPut(keys) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val map = persistentMapPut(keys) + repeat(times = size) { index -> + bh.consume(${impl.getOperation("map", "keys[index]")}) + } + } + + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val map = persistentMapPut(keys) + for (key in ${impl.keysOperation("map")}) { + bh.consume(key) + } + } +} + + +$header +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var keys = listOf<$mapKeyType>() + private var persistentMap = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + persistentMap = persistentMapPut(keys) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun remove(): ${impl.type()} { + var map = persistentMap + repeat(times = size) { index -> + map = ${impl.removeOperation("map", "keys[index]")} + } + return map + } +} + + +private fun persistentMapPut(keys: List<$mapKeyType>): ${impl.type()} { + var map = ${impl.empty()} + for (key in keys) { + map = ${impl.putOperation("map", "key", "\"some element\"")} + } + return map +} + """.trimIndent() + ) + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/capsule.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/capsule.kt new file mode 100644 index 00000000..b3491fc1 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/capsule.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 generators.immutableMapBuilder.impl + +object CapsuleMapBuilderImplementation: MapBuilderImplementation { + override val packageName: String + = "capsule.builder" + + override fun type(): String + = "io.usethesource.capsule.Map.Transient<$mapBuilderKeyType, $mapBuilderValueType>" + override fun empty(): String + = "io.usethesource.capsule.core.PersistentTrieMap.of<$mapBuilderKeyType, $mapBuilderValueType>().asTransient()" + + override fun getOperation(builder: String, key: String): String + = "$builder.get($key)" + override fun putOperation(builder: String, key: String, value: String): String + = "$builder.put($key, $value)" + override fun removeOperation(builder: String, key: String): String + = "$builder.remove($key)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String = + "$immutable.asTransient()" + + override fun immutableEmpty(): String + = "io.usethesource.capsule.core.PersistentTrieMap.of<$mapBuilderKeyType, $mapBuilderValueType>()" + override fun immutablePutOperation(immutable: String, key: String, value: String): String + = "$immutable.__put($key, $value)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/clojure.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/clojure.kt new file mode 100644 index 00000000..24c74d56 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/clojure.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 generators.immutableMapBuilder.impl + +object ClojureMapBuilderImplementation: MapBuilderImplementation { + override val packageName: String + = "clojure.builder" + + override fun type(): String + = "clojure.lang.ATransientMap" + override fun empty(): String + = "clojure.lang.PersistentHashMap.EMPTY.asTransient() as clojure.lang.ATransientMap" + + override fun getOperation(builder: String, key: String): String + = "$builder.valAt($key)" + override fun putOperation(builder: String, key: String, value: String): String + = "$builder.assoc($key, $value)" + override fun removeOperation(builder: String, key: String): String + = "$builder.without($key)" + + override val isIterable: Boolean + = false + + override fun builderOperation(immutable: String): String + = "($immutable as clojure.lang.PersistentHashMap).asTransient() as clojure.lang.ATransientMap" + + override fun immutableEmpty(): String + = "clojure.lang.PersistentHashMap.EMPTY as clojure.lang.IPersistentMap" + override fun immutablePutOperation(immutable: String, key: String, value: String): String + = "$immutable.assoc($key, $value)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/kotlin.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/kotlin.kt new file mode 100644 index 00000000..873f7074 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/kotlin.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 generators.immutableMapBuilder.impl + +object KotlinMapBuilderImplementation: MapBuilderImplementation { + override val packageName: String + = "kotlin.builder" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentMap.Builder<$mapBuilderKeyType, $mapBuilderValueType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentHashMapOf<$mapBuilderKeyType, $mapBuilderValueType>().builder()" + + override fun getOperation(builder: String, key: String): String + = "$builder.get($key)" + override fun putOperation(builder: String, key: String, value: String): String + = "$builder.put($key, $value)" + override fun removeOperation(builder: String, key: String): String + = "$builder.remove($key)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String = + "$immutable.builder()" + + override fun immutableEmpty(): String + = "kotlinx.collections.immutable.persistentHashMapOf<$mapBuilderKeyType, $mapBuilderValueType>()" + override fun immutablePutOperation(immutable: String, key: String, value: String): String + = "$immutable.put($key, $value)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/kotlinOrdered.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/kotlinOrdered.kt new file mode 100644 index 00000000..f1c91bd6 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/kotlinOrdered.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 generators.immutableMapBuilder.impl + +object KotlinOrderedMapBuilderImplementation: MapBuilderImplementation { + override val packageName: String + = "kotlinOrdered.builder" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentMap.Builder<$mapBuilderKeyType, $mapBuilderValueType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentMapOf<$mapBuilderKeyType, $mapBuilderValueType>().builder()" + + override fun getOperation(builder: String, key: String): String + = "$builder.get($key)" + override fun putOperation(builder: String, key: String, value: String): String + = "$builder.put($key, $value)" + override fun removeOperation(builder: String, key: String): String + = "$builder.remove($key)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String = + "$immutable.builder()" + + override fun immutableEmpty(): String + = "kotlinx.collections.immutable.persistentMapOf<$mapBuilderKeyType, $mapBuilderValueType>()" + override fun immutablePutOperation(immutable: String, key: String, value: String): String + = "$immutable.put($key, $value)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/mapBuilderImplementation.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/mapBuilderImplementation.kt new file mode 100644 index 00000000..88a5d8f4 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/mapBuilderImplementation.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 generators.immutableMapBuilder.impl + +interface MapBuilderImplementation { + val packageName: String + + fun type(): String + fun empty(): String + + fun getOperation(builder: String, key: String): String + fun putOperation(builder: String, key: String, value: String): String + fun removeOperation(builder: String, key: String): String + + val isIterable: Boolean + + fun builderOperation(immutable: String): String + + fun immutableEmpty(): String + fun immutablePutOperation(immutable: String, key: String, value: String): String +} + +const val mapBuilderKeyType: String = "IntWrapper" +const val mapBuilderValueType: String = "String" \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/paguro.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/paguro.kt new file mode 100644 index 00000000..9244fd77 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/impl/paguro.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 generators.immutableMapBuilder.impl + +object PaguroMapBuilderImplementation: MapBuilderImplementation { + override val packageName: String + = "paguro.builder" + + override fun type(): String + = "org.organicdesign.fp.collections.PersistentHashMap.MutableHashMap<$mapBuilderKeyType, $mapBuilderValueType>" + override fun empty(): String + = "org.organicdesign.fp.collections.PersistentHashMap.emptyMutable<$mapBuilderKeyType, $mapBuilderValueType>()" + + override fun getOperation(builder: String, key: String): String + = "$builder.get($key)" + override fun putOperation(builder: String, key: String, value: String): String + = "$builder.assoc($key, $value)" + override fun removeOperation(builder: String, key: String): String + = "$builder.without($key)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String = + "$immutable.mutable()" + + override fun immutableEmpty(): String + = "org.organicdesign.fp.collections.PersistentHashMap.empty<$mapBuilderKeyType, $mapBuilderValueType>()" + override fun immutablePutOperation(immutable: String, key: String, value: String): String + = "$immutable.assoc($key, $value)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/mapBuilderBenchmarksGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/mapBuilderBenchmarksGenerator.kt new file mode 100644 index 00000000..2d2b7cdd --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableMapBuilder/mapBuilderBenchmarksGenerator.kt @@ -0,0 +1,213 @@ +/* + * 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 generators.immutableMapBuilder + +import generators.BenchmarkSourceGenerator +import generators.immutableMapBuilder.impl.MapBuilderImplementation +import generators.immutableMapBuilder.impl.mapBuilderKeyType +import java.io.PrintWriter + +class MapBuilderBenchmarksGenerator(private val impl: MapBuilderImplementation) : BenchmarkSourceGenerator() { + override val outputFileName: String = "MapBuilder" + + override fun getPackage(): String { + return super.getPackage() + ".immutableMap." + impl.packageName + } + + override fun generateBenchmark(out: PrintWriter, header: String) { + out.println(""" +$header +open class Get { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf<$mapBuilderKeyType>() + private var builder = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun get(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(${impl.getOperation("builder", "keys[index]")}) + } + } +} + + +${ +if (impl.isIterable) """ +$header +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + val keys = generateKeys(hashCodeType, size) + builder = persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun iterateKeys(bh: Blackhole) { + for (k in builder.keys) { + bh.consume(k) + } + } + + @Benchmark + fun iterateValues(bh: Blackhole) { + for (v in builder.values) { + bh.consume(v) + } + } + + @Benchmark + fun iterateEntries(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +}""" +else "" +} + + +$header +open class Put { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf<$mapBuilderKeyType>() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + } + + @Benchmark + fun put(): ${impl.type()} { + return persistentMapBuilderPut(keys, immutablePercentage) + } + + @Benchmark + fun putAndGet(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + bh.consume(${impl.getOperation("builder", "keys[index]")}) + } + } + +${ +if (impl.isIterable) """ + @Benchmark + fun putAndIterateKeys(bh: Blackhole) { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + for (key in builder.keys) { + bh.consume(key) + } + }""" +else "" +} +} + + +$header +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var keys = listOf<$mapBuilderKeyType>() + private var keysToRemove = listOf<$mapBuilderKeyType>() + + @Setup(Level.Trial) + fun prepare() { + keys = generateKeys(hashCodeType, size) + + keysToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateKeys(hashCodeType, size) + } else { + keys + } + } + + @Benchmark + fun putAndRemove(): ${impl.type()} { + val builder = persistentMapBuilderPut(keys, immutablePercentage) + repeat(times = size) { index -> + ${impl.removeOperation("builder", "keysToRemove[index]")} + } + return builder + } +} + + +private fun persistentMapBuilderPut( + keys: List<$mapBuilderKeyType>, + immutablePercentage: Double +): ${impl.type()} { + val immutableSize = immutableSize(keys.size, immutablePercentage) + + var map = ${impl.immutableEmpty()} + for (index in 0 until immutableSize) { + map = ${impl.immutablePutOperation("map", "keys[index]", "\"some element\"")} + } + + val builder = ${impl.builderOperation("map")} + for (index in immutableSize until keys.size) { + ${impl.putOperation("builder", "keys[index]", "\"some element\"")} + } + + return builder +} + """.trimIndent() + ) + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/capsule.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/capsule.kt new file mode 100644 index 00000000..1ecc7b2a --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/capsule.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object CapsuleSetImplementation: SetImplementation { + override val packageName: String + = "capsule" + + override fun type(): String + = "io.usethesource.capsule.Set.Immutable<$setElementType>" + override fun empty(): String + = "io.usethesource.capsule.core.PersistentTrieSet.of<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.__insert($element)" + override fun removeOperation(set: String, element: String): String + = "$set.__remove($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/clojure.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/clojure.kt new file mode 100644 index 00000000..50eed726 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/clojure.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object ClojureSetImplementation: SetImplementation { + override val packageName: String + = "clojure" + + override fun type(): String + = "clojure.lang.PersistentHashSet" + override fun empty(): String + = "clojure.lang.PersistentHashSet.EMPTY" + + override fun addOperation(set: String, element: String): String + = "$set.cons($element) as clojure.lang.PersistentHashSet" + override fun removeOperation(set: String, element: String): String + = "$set.disjoin($element) as clojure.lang.PersistentHashSet" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/clojureSorted.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/clojureSorted.kt new file mode 100644 index 00000000..7dec7237 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/clojureSorted.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object ClojureSortedSetImplementation: SetImplementation { + override val packageName: String + = "clojureSorted" + + override fun type(): String + = "clojure.lang.PersistentTreeSet" + override fun empty(): String + = "clojure.lang.PersistentTreeSet.EMPTY" + + override fun addOperation(set: String, element: String): String + = "$set.cons($element) as clojure.lang.PersistentTreeSet" + override fun removeOperation(set: String, element: String): String + = "$set.disjoin($element) as clojure.lang.PersistentTreeSet" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclops.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclops.kt new file mode 100644 index 00000000..9a30149e --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclops.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object CyclopsSetImplementation: SetImplementation { + override val packageName: String + = "cyclops" + + override fun type(): String + = "cyclops.data.HashSet<$setElementType>" + override fun empty(): String + = "cyclops.data.HashSet.empty<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.add($element)" + override fun removeOperation(set: String, element: String): String + = "$set.removeValue($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclopsSorted.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclopsSorted.kt new file mode 100644 index 00000000..f600b0a3 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclopsSorted.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object CyclopsSortedSetImplementation: SetImplementation { + override val packageName: String + = "cyclopsSorted" + + override fun type(): String + = "cyclops.data.TreeSet<$setElementType>" + override fun empty(): String + = "cyclops.data.TreeSet.empty<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.add($element)" + override fun removeOperation(set: String, element: String): String + = "$set.removeValue($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclopsTrie.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclopsTrie.kt new file mode 100644 index 00000000..94bb2148 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/cyclopsTrie.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object CyclopsTrieSetImplementation: SetImplementation { + override val packageName: String + = "cyclopsTrie" + + override fun type(): String + = "cyclops.data.TrieSet<$setElementType>" + override fun empty(): String + = "cyclops.data.TrieSet.empty<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.add($element)" + override fun removeOperation(set: String, element: String): String + = "$set.removeValue($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/kotlin.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/kotlin.kt new file mode 100644 index 00000000..21bdd625 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/kotlin.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object KotlinSetImplementation: SetImplementation { + override val packageName: String + = "kotlin" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentSet<$setElementType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentHashSetOf<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.add($element)" + override fun removeOperation(set: String, element: String): String + = "$set.remove($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/kotlinOrdered.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/kotlinOrdered.kt new file mode 100644 index 00000000..3fe960cd --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/kotlinOrdered.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object KotlinOrderedSetImplementation: SetImplementation { + override val packageName: String + = "kotlinOrdered" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentSet<$setElementType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentSetOf<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.add($element)" + override fun removeOperation(set: String, element: String): String + = "$set.remove($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/scala.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/scala.kt new file mode 100644 index 00000000..fcdbf884 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/scala.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object ScalaSetImplementation: SetImplementation { + override val packageName: String + = "scala" + + override fun type(): String + = "scala.collection.immutable.HashSet<$setElementType>" + override fun empty(): String + = "scala.collection.immutable.`HashSet\$`.`MODULE$`.empty<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.incl($element)" + override fun removeOperation(set: String, element: String): String + = "$set.excl($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/scalaSorted.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/scalaSorted.kt new file mode 100644 index 00000000..f1d83fdb --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/scalaSorted.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object ScalaSortedSetImplementation: SetImplementation { + override val packageName: String + = "scalaSorted" + + override fun type(): String + = "scala.collection.immutable.TreeSet<$setElementType>" + override fun empty(): String + = "scala.collection.immutable.TreeSet(scala.math.Ordering.comparatorToOrdering(Comparator.naturalOrder<$setElementType>()))" + + override fun addOperation(set: String, element: String): String + = "$set.incl($element)" + override fun removeOperation(set: String, element: String): String + = "$set.excl($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/setImplementation.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/setImplementation.kt new file mode 100644 index 00000000..b338a585 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/setImplementation.kt @@ -0,0 +1,29 @@ +/* + * 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 generators.immutableSet.impl + +interface SetImplementation { + val packageName: String + + fun type(): String + fun empty(): String + + fun addOperation(set: String, element: String): String + fun removeOperation(set: String, element: String): String +} + +const val setElementType = "IntWrapper" \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavr.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavr.kt new file mode 100644 index 00000000..01410511 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavr.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object VavrSetImplementation: SetImplementation { + override val packageName: String + = "vavr" + + override fun type(): String + = "io.vavr.collection.HashSet<$setElementType>" + override fun empty(): String + = "io.vavr.collection.HashSet.empty<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.add($element)" + override fun removeOperation(set: String, element: String): String + = "$set.remove($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavrOrdered.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavrOrdered.kt new file mode 100644 index 00000000..b3ccf706 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavrOrdered.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object VavrOrderedSetImplementation: SetImplementation { + override val packageName: String + = "vavrOrdered" + + override fun type(): String + = "io.vavr.collection.LinkedHashSet<$setElementType>" + override fun empty(): String + = "io.vavr.collection.LinkedHashSet.empty<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.add($element)" + override fun removeOperation(set: String, element: String): String + = "$set.remove($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavrSorted.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavrSorted.kt new file mode 100644 index 00000000..f37171a1 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/impl/vavrSorted.kt @@ -0,0 +1,32 @@ +/* + * 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 generators.immutableSet.impl + +object VavrSortedSetImplementation: SetImplementation { + override val packageName: String + = "vavrSorted" + + override fun type(): String + = "io.vavr.collection.TreeSet<$setElementType>" + override fun empty(): String + = "io.vavr.collection.TreeSet.empty<$setElementType>()" + + override fun addOperation(set: String, element: String): String + = "$set.add($element)" + override fun removeOperation(set: String, element: String): String + = "$set.remove($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSet/setBenchmarksGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/setBenchmarksGenerator.kt new file mode 100644 index 00000000..7135eb11 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSet/setBenchmarksGenerator.kt @@ -0,0 +1,165 @@ +/* + * 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 generators.immutableSet + +import generators.BenchmarkSourceGenerator +import generators.immutableSet.impl.SetImplementation +import generators.immutableSet.impl.setElementType +import java.io.PrintWriter + +class SetBenchmarksGenerator(private val impl: SetImplementation) : BenchmarkSourceGenerator() { + override val outputFileName: String = "Set" + + override fun getPackage(): String { + return super.getPackage() + ".immutableSet." + impl.packageName + } + + override fun generateBenchmark(out: PrintWriter, header: String) { + out.println(""" +$header +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf<$setElementType>() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): ${impl.type()} { + return persistentSetAdd(elements) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val set = persistentSetAdd(elements) + repeat(times = size) { index -> + bh.consume(set.contains(elements[index])) + } + } + + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetAdd(elements) + for (element in set) { + bh.consume(element) + } + } +} + + +$header +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf<$setElementType>() + private var persistentSet = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(persistentSet.contains(elements[index])) + } + } +} + + +$header +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + private var persistentSet = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + persistentSet = persistentSetAdd(generateElements(hashCodeType, size)) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in persistentSet) { + bh.consume(e) + } + } +} + + +$header +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + private var elements = listOf<$setElementType>() + private var persistentSet = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + persistentSet = persistentSetAdd(elements) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun remove(): ${impl.type()} { + var set = persistentSet + repeat(times = size) { index -> + set = ${impl.removeOperation("set", "elements[index]")} + } + return set + } +} + + +private fun persistentSetAdd(elements: List<$setElementType>): ${impl.type()} { + var set = ${impl.empty()} + for (element in elements) { + set = ${impl.addOperation("set", "element")} + } + return set +} + """.trimIndent() + ) + } +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/capsule.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/capsule.kt new file mode 100644 index 00000000..dcc7e51a --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/capsule.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 generators.immutableSetBuilder.impl + +object CapsuleSetBuilderImplementation: SetBuilderImplementation { + override val packageName: String + = "capsule.builder" + + override fun type(): String + = "io.usethesource.capsule.Set.Transient<$setBuilderElementType>" + override fun empty(): String + = "io.usethesource.capsule.core.PersistentTrieSet.of<$setBuilderElementType>().asTransient()" + + override fun addOperation(builder: String, element: String): String + = "$builder.add($element)" + override fun removeOperation(builder: String, element: String): String + = "$builder.__remove($element)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String + = "$immutable.asTransient()" + + override fun immutableEmpty(): String + = "io.usethesource.capsule.core.PersistentTrieSet.of<$setBuilderElementType>()" + override fun immutableAddOperation(immutable: String, element: String): String + = "$immutable.__insert($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/clojure.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/clojure.kt new file mode 100644 index 00000000..696bff3c --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/clojure.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 generators.immutableSetBuilder.impl + +object ClojureSetBuilderImplementation: SetBuilderImplementation { + override val packageName: String + = "clojure.builder" + + override fun type(): String + = "clojure.lang.ATransientSet" + override fun empty(): String + = "clojure.lang.PersistentHashSet.EMPTY.asTransient() as clojure.lang.ATransientSet" + + override fun addOperation(builder: String, element: String): String + = "$builder.conj($element)" + override fun removeOperation(builder: String, element: String): String + = "$builder.disjoin($element)" + + override val isIterable: Boolean + = false + + override fun builderOperation(immutable: String): String + = "$immutable.asTransient() as clojure.lang.ATransientSet" + + override fun immutableEmpty(): String + = "clojure.lang.PersistentHashSet.EMPTY" + override fun immutableAddOperation(immutable: String, element: String): String + = "$immutable.cons($element) as clojure.lang.PersistentHashSet" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/kotlin.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/kotlin.kt new file mode 100644 index 00000000..1b0d9cc8 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/kotlin.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 generators.immutableSetBuilder.impl + +object KotlinSetBuilderImplementation: SetBuilderImplementation { + override val packageName: String + = "kotlin.builder" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentSet.Builder<$setBuilderElementType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentHashSetOf<$setBuilderElementType>().builder()" + + override fun addOperation(builder: String, element: String): String + = "$builder.add($element)" + override fun removeOperation(builder: String, element: String): String + = "$builder.remove($element)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String + = "$immutable.builder()" + + override fun immutableEmpty(): String + = "kotlinx.collections.immutable.persistentHashSetOf<$setBuilderElementType>()" + override fun immutableAddOperation(immutable: String, element: String): String + = "$immutable.add($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/kotlinOrdered.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/kotlinOrdered.kt new file mode 100644 index 00000000..306aab42 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/kotlinOrdered.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 generators.immutableSetBuilder.impl + +object KotlinOrderedSetBuilderImplementation: SetBuilderImplementation { + override val packageName: String + = "kotlinOrdered.builder" + + override fun type(): String + = "kotlinx.collections.immutable.PersistentSet.Builder<$setBuilderElementType>" + override fun empty(): String + = "kotlinx.collections.immutable.persistentSetOf<$setBuilderElementType>().builder()" + + override fun addOperation(builder: String, element: String): String + = "$builder.add($element)" + override fun removeOperation(builder: String, element: String): String + = "$builder.remove($element)" + + override val isIterable: Boolean + = true + + override fun builderOperation(immutable: String): String + = "$immutable.builder()" + + override fun immutableEmpty(): String + = "kotlinx.collections.immutable.persistentSetOf<$setBuilderElementType>()" + override fun immutableAddOperation(immutable: String, element: String): String + = "$immutable.add($element)" +} \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/setBuilderImplementation.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/setBuilderImplementation.kt new file mode 100644 index 00000000..dba55a43 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/impl/setBuilderImplementation.kt @@ -0,0 +1,36 @@ +/* + * 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 generators.immutableSetBuilder.impl + +interface SetBuilderImplementation { + val packageName: String + + fun type(): String + fun empty(): String + + fun addOperation(builder: String, element: String): String + fun removeOperation(builder: String, element: String): String + + val isIterable: Boolean + + fun builderOperation(immutable: String): String + + fun immutableEmpty(): String + fun immutableAddOperation(immutable: String, element: String): String +} + +const val setBuilderElementType = "IntWrapper" \ No newline at end of file diff --git a/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/setBuilderBenchmarksGenerator.kt b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/setBuilderBenchmarksGenerator.kt new file mode 100644 index 00000000..f7fa12c4 --- /dev/null +++ b/benchmarks-libraries/src/main/kotlin/generators/immutableSetBuilder/setBuilderBenchmarksGenerator.kt @@ -0,0 +1,199 @@ +/* + * 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 generators.immutableSetBuilder + +import generators.BenchmarkSourceGenerator +import generators.immutableSetBuilder.impl.SetBuilderImplementation +import generators.immutableSetBuilder.impl.setBuilderElementType +import java.io.PrintWriter + +class SetBuilderBenchmarksGenerator(private val impl: SetBuilderImplementation) : BenchmarkSourceGenerator() { + override val outputFileName: String = "SetBuilder" + + override fun getPackage(): String { + return super.getPackage() + ".immutableSet." + impl.packageName + } + + override fun generateBenchmark(out: PrintWriter, header: String) { + out.println(""" +$header +open class Add { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf<$setBuilderElementType>() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun add(): ${impl.type()} { + return persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun addAndContains(bh: Blackhole) { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } + +${ +if (impl.isIterable) """ + @Benchmark + fun addAndIterate(bh: Blackhole) { + val set = persistentSetBuilderAdd(elements, immutablePercentage) + for (element in set) { + bh.consume(element) + } + }""" +else "" +} +} + + +$header +open class Contains { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf<$setBuilderElementType>() + private var builder = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + + if (hashCodeType == NON_EXISTING_HASH_CODE) + elements = generateElements(hashCodeType, size) + } + + @Benchmark + fun contains(bh: Blackhole) { + repeat(times = size) { index -> + bh.consume(builder.contains(elements[index])) + } + } +} + + +${ +if (impl.isIterable) """ +$header +open class Iterate { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var builder = ${impl.empty()} + + @Setup(Level.Trial) + fun prepare() { + val elements = generateElements(hashCodeType, size) + builder = persistentSetBuilderAdd(elements, immutablePercentage) + } + + @Benchmark + fun iterate(bh: Blackhole) { + for (e in builder) { + bh.consume(e) + } + } +}""" +else "" +} + + +$header +open class Remove { + @Param("10000", "100000") + var size: Int = 0 + + @Param(ASCENDING_HASH_CODE, RANDOM_HASH_CODE, COLLISION_HASH_CODE, NON_EXISTING_HASH_CODE) + var hashCodeType = "" + + @Param("0.0", "50.0") + var immutablePercentage: Double = 0.0 + + private var elements = listOf<$setBuilderElementType>() + private var elementsToRemove = listOf<$setBuilderElementType>() + + @Setup(Level.Trial) + fun prepare() { + elements = generateElements(hashCodeType, size) + + elementsToRemove = if (hashCodeType == NON_EXISTING_HASH_CODE) { + generateElements(hashCodeType, size) + } else { + elements + } + } + + @Benchmark + fun addAndRemove(): ${impl.type()} { + val builder = persistentSetBuilderAdd(elements, immutablePercentage) + repeat(times = size) { index -> + ${impl.removeOperation("builder", "elementsToRemove[index]")} + } + return builder + } +} + + +private fun persistentSetBuilderAdd( + elements: List<$setBuilderElementType>, + immutablePercentage: Double +): ${impl.type()} { + val immutableSize = immutableSize(elements.size, immutablePercentage) + + var set = ${impl.immutableEmpty()} + for (index in 0 until immutableSize) { + set = ${impl.immutableAddOperation("set", "elements[index]")} + } + + val builder = ${impl.builderOperation("set")} + for (index in immutableSize until elements.size) { + ${impl.addOperation("builder", "elements[index]")} + } + + return builder +} + """.trimIndent() + ) + } +} \ No newline at end of file