From 91fc291bfad30d7ad3740612cb55050a3769dab6 Mon Sep 17 00:00:00 2001 From: Konstantin Anisimov Date: Thu, 3 Aug 2017 18:15:05 +0700 Subject: [PATCH] Now each test normalized on Kotlin-jvm time Average value also is average of normalized values --- performance/src/main/kotlin/main.kt | 3 +- .../kotlin/org/jetbrains/ring/launcher.kt | 374 ++++++++---------- .../main/kotlin/org/jetbrains/ring/norma.kt | 177 +++++++++ 3 files changed, 353 insertions(+), 201 deletions(-) create mode 100644 performance/src/main/kotlin/org/jetbrains/ring/norma.kt diff --git a/performance/src/main/kotlin/main.kt b/performance/src/main/kotlin/main.kt index 18fa84bbeba..15bd313f0eb 100644 --- a/performance/src/main/kotlin/main.kt +++ b/performance/src/main/kotlin/main.kt @@ -9,6 +9,5 @@ fun main(args: Array) { numMeasureIterations = args[1].toInt() } - val average = Launcher(numWarmIterations, numMeasureIterations).runBenchmarks() - println("\nRingAverage: $average\n") + Launcher(numWarmIterations, numMeasureIterations).runBenchmarks() } \ No newline at end of file diff --git a/performance/src/main/kotlin/org/jetbrains/ring/launcher.kt b/performance/src/main/kotlin/org/jetbrains/ring/launcher.kt index 9d559ec8718..9410bad5e1f 100644 --- a/performance/src/main/kotlin/org/jetbrains/ring/launcher.kt +++ b/performance/src/main/kotlin/org/jetbrains/ring/launcher.kt @@ -23,9 +23,9 @@ val BENCHMARK_SIZE = 100 //-----------------------------------------------------------------------------// class Launcher(val numWarmIterations: Int, val numMeasureIterations: Int) { - val results = mutableListOf() + val results = mutableMapOf() - fun launch(benchmark: () -> Any?) { + fun launch(benchmark: () -> Any?): Long { var i = numWarmIterations var j = numMeasureIterations @@ -34,22 +34,12 @@ class Launcher(val numWarmIterations: Int, val numMeasureIterations: Int) { while (j-- > 0) benchmark() } - val timeNormalized = time / numMeasureIterations - results.add(timeNormalized) - printResult(benchmark.toString(), timeNormalized) + return time / numMeasureIterations } //-------------------------------------------------------------------------// - fun printResult(name: String, time: Long) { - val niceName = name.replace(" (Kotlin reflection is not available)", "").padEnd(45, ' ') - val niceTime = time.toString().padStart(10, ' ') - println(" $niceName : $niceTime") - } - - //-------------------------------------------------------------------------// - - fun runBenchmarks(): Long { + fun runBenchmarks() { runAbstractMethodBenchmark() runClassArrayBenchmark() runClassBaselineBenchmark() @@ -74,370 +64,356 @@ class Launcher(val numWarmIterations: Int, val numMeasureIterations: Int) { runSwitchBenchmark() runWithIndiciesBenchmark() - return average() + printResults() } - //-------------------------------------------------------------------------// - fun average(): Long { - val total = results.fold(0L) { total, next -> total + next } - return total / results.size + fun printResults() { + var total = 0L + results.forEach { + val normaTime = NormaResults[it.key] + val norma = it.value / normaTime!! + val niceName = it.key.padEnd(50, ' ') + val niceNorma = norma.toString().padStart(10, ' ') + println("$niceName : $niceNorma") + + total += norma + } + val average = total / results.size + println("\nRingAverage: $average") } //-------------------------------------------------------------------------// fun runAbstractMethodBenchmark() { - println("\nAbstractMethodBenchmark") val benchmark = AbstractMethodBenchmark() - launch(benchmark::sortStrings) - launch(benchmark::sortStringsWithComparator) + results["AbstractMethod.sortStrings"] = launch(benchmark::sortStrings) + results["AbstractMethod.sortStringsWithComparator"] = launch(benchmark::sortStringsWithComparator) } //-------------------------------------------------------------------------// fun runClassArrayBenchmark() { - println("\nClassArrayBenchmark") val benchmark = ClassArrayBenchmark() benchmark.setup() - launch(benchmark::copy) - launch(benchmark::copyManual) - launch(benchmark::filterAndCount) - launch(benchmark::filterAndMap) - launch(benchmark::filterAndMapManual) - launch(benchmark::filter) - launch(benchmark::filterManual) - launch(benchmark::countFilteredManual) - launch(benchmark::countFiltered) - launch(benchmark::countFilteredLocal) + results["ClassArray.copy"] = launch(benchmark::copy) + results["ClassArray.copyManual"] = launch(benchmark::copyManual) + results["ClassArray.filterAndCount"] = launch(benchmark::filterAndCount) + results["ClassArray.filterAndMap"] = launch(benchmark::filterAndMap) + results["ClassArray.filterAndMapManual"] = launch(benchmark::filterAndMapManual) + results["ClassArray.filter"] = launch(benchmark::filter) + results["ClassArray.filterManual"] = launch(benchmark::filterManual) + results["ClassArray.countFilteredManual"] = launch(benchmark::countFilteredManual) + results["ClassArray.countFiltered"] = launch(benchmark::countFiltered) + results["ClassArray.countFilteredLocal"] = launch(benchmark::countFilteredLocal) } //-------------------------------------------------------------------------// fun runClassBaselineBenchmark() { - println("\nClassBaselineBenchmark") val benchmark = ClassBaselineBenchmark() - launch(benchmark::consume) - launch(benchmark::consumeField) - launch(benchmark::allocateList) - launch(benchmark::allocateArray) - launch(benchmark::allocateListAndFill) - launch(benchmark::allocateListAndWrite) - launch(benchmark::allocateArrayAndFill) + results["ClassBaseline.consume"] = launch(benchmark::consume) + results["ClassBaseline.consumeField"] = launch(benchmark::consumeField) + results["ClassBaseline.allocateList"] = launch(benchmark::allocateList) + results["ClassBaseline.allocateArray"] = launch(benchmark::allocateArray) + results["ClassBaseline.allocateListAndFill"] = launch(benchmark::allocateListAndFill) + results["ClassBaseline.allocateListAndWrite"] = launch(benchmark::allocateListAndWrite) + results["ClassBaseline.allocateArrayAndFill"] = launch(benchmark::allocateArrayAndFill) } //-------------------------------------------------------------------------// fun runClassListBenchmark() { - println("\nClassListBenchmark") val benchmark = ClassListBenchmark() benchmark.setup() - launch(benchmark::copy) - launch(benchmark::copyManual) - launch(benchmark::filterAndCount) - launch(benchmark::filterAndCountWithLambda) - launch(benchmark::filterWithLambda) - launch(benchmark::mapWithLambda) - launch(benchmark::countWithLambda) - launch(benchmark::filterAndMapWithLambda) - launch(benchmark::filterAndMapWithLambdaAsSequence) - launch(benchmark::filterAndMap) - launch(benchmark::filterAndMapManual) - launch(benchmark::filter) - launch(benchmark::filterManual) - launch(benchmark::countFilteredManual) - launch(benchmark::countFiltered) - launch(benchmark::reduce) + results["ClassList.copy"] = launch(benchmark::copy) + results["ClassList.copyManual"] = launch(benchmark::copyManual) + results["ClassList.filterAndCount"] = launch(benchmark::filterAndCount) + results["ClassList.filterAndCountWithLambda"] = launch(benchmark::filterAndCountWithLambda) + results["ClassList.filterWithLambda"] = launch(benchmark::filterWithLambda) + results["ClassList.mapWithLambda"] = launch(benchmark::mapWithLambda) + results["ClassList.countWithLambda"] = launch(benchmark::countWithLambda) + results["ClassList.filterAndMapWithLambda"] = launch(benchmark::filterAndMapWithLambda) + results["ClassList.filterAndMapWithLambdaAsSequence"] = launch(benchmark::filterAndMapWithLambdaAsSequence) + results["ClassList.filterAndMap"] = launch(benchmark::filterAndMap) + results["ClassList.filterAndMapManual"] = launch(benchmark::filterAndMapManual) + results["ClassList.filter"] = launch(benchmark::filter) + results["ClassList.filterManual"] = launch(benchmark::filterManual) + results["ClassList.countFilteredManual"] = launch(benchmark::countFilteredManual) + results["ClassList.countFiltered"] = launch(benchmark::countFiltered) + results["ClassList.reduce"] = launch(benchmark::reduce) } //-------------------------------------------------------------------------// fun runClassStreamBenchmark() { - println("\nClassStreamBenchmark") val benchmark = ClassStreamBenchmark() benchmark.setup() - launch(benchmark::copy) - launch(benchmark::copyManual) - launch(benchmark::filterAndCount) - launch(benchmark::filterAndMap) - launch(benchmark::filterAndMapManual) - launch(benchmark::filter) - launch(benchmark::filterManual) - launch(benchmark::countFilteredManual) - launch(benchmark::countFiltered) - launch(benchmark::reduce) + results["ClassStream.copy"] = launch(benchmark::copy) + results["ClassStream.copyManual"] = launch(benchmark::copyManual) + results["ClassStream.filterAndCount"] = launch(benchmark::filterAndCount) + results["ClassStream.filterAndMap"] = launch(benchmark::filterAndMap) + results["ClassStream.filterAndMapManual"] = launch(benchmark::filterAndMapManual) + results["ClassStream.filter"] = launch(benchmark::filter) + results["ClassStream.filterManual"] = launch(benchmark::filterManual) + results["ClassStream.countFilteredManual"] = launch(benchmark::countFilteredManual) + results["ClassStream.countFiltered"] = launch(benchmark::countFiltered) + results["ClassStream.reduce"] = launch(benchmark::reduce) } //-------------------------------------------------------------------------// fun runCompanionObjectBenchmark() { - println("\nCompanionObjectBenchmark") val benchmark = CompanionObjectBenchmark() - launch(benchmark::invokeRegularFunction) - launch(benchmark::invokeJvmStaticFunction) + results["CompanionObject.invokeRegularFunction"] = launch(benchmark::invokeRegularFunction) + results["CompanionObject.invokeJvmStaticFunction"] = launch(benchmark::invokeJvmStaticFunction) } //-------------------------------------------------------------------------// fun runDefaultArgumentBenchmark() { - println("\nDefaultArgumentBenchmark") val benchmark = DefaultArgumentBenchmark() benchmark.setup() - launch(benchmark::testOneOfTwo) - launch(benchmark::testTwoOfTwo) - launch(benchmark::testOneOfFour) - launch(benchmark::testFourOfFour) - launch(benchmark::testOneOfEight) - launch(benchmark::testEightOfEight) + results["DefaultArgument.testOneOfTwo"] = launch(benchmark::testOneOfTwo) + results["DefaultArgument.testTwoOfTwo"] = launch(benchmark::testTwoOfTwo) + results["DefaultArgument.testOneOfFour"] = launch(benchmark::testOneOfFour) + results["DefaultArgument.testFourOfFour"] = launch(benchmark::testFourOfFour) + results["DefaultArgument.testOneOfEight"] = launch(benchmark::testOneOfEight) + results["DefaultArgument.testEightOfEight"] = launch(benchmark::testEightOfEight) } //-------------------------------------------------------------------------// fun runElvisBenchmark() { - println("\nElvisBenchmark") val benchmark = ElvisBenchmark() benchmark.setup() - launch(benchmark::testElvis) + results["Elvis.testElvis"] = launch(benchmark::testElvis) } //-------------------------------------------------------------------------// fun runEulerBenchmark() { - println("\nEulerBenchmark") val benchmark = EulerBenchmark() - launch(benchmark::problem1bySequence) - launch(benchmark::problem1) - launch(benchmark::problem2) - launch(benchmark::problem4) - launch(benchmark::problem8) - launch(benchmark::problem9) - launch(benchmark::problem14) - launch(benchmark::problem14full) + results["Euler.problem1bySequence"] = launch(benchmark::problem1bySequence) + results["Euler.problem1"] = launch(benchmark::problem1) + results["Euler.problem2"] = launch(benchmark::problem2) + results["Euler.problem4"] = launch(benchmark::problem4) + results["Euler.problem8"] = launch(benchmark::problem8) + results["Euler.problem9"] = launch(benchmark::problem9) + results["Euler.problem14"] = launch(benchmark::problem14) + results["Euler.problem14full"] = launch(benchmark::problem14full) } //-------------------------------------------------------------------------// fun runFibonacciBenchmark() { - println("\nFibonacciBenchmark") val benchmark = FibonacciBenchmark() - launch(benchmark::calcClassic) - launch(benchmark::calc) - launch(benchmark::calcWithProgression) - launch(benchmark::calcSquare) + results["Fibonacci.calcClassic"] = launch(benchmark::calcClassic) + results["Fibonacci.calc"] = launch(benchmark::calc) + results["Fibonacci.calcWithProgression"] = launch(benchmark::calcWithProgression) + results["Fibonacci.calcSquare"] = launch(benchmark::calcSquare) } //-------------------------------------------------------------------------// fun runInlineBenchmark() { - println("\nInlineBenchmark") val benchmark = InlineBenchmark() - launch(benchmark::calculate) - launch(benchmark::calculateInline) - launch(benchmark::calculateGeneric) - launch(benchmark::calculateGenericInline) + results["Inline.calculate"] = launch(benchmark::calculate) + results["Inline.calculateInline"] = launch(benchmark::calculateInline) + results["Inline.calculateGeneric"] = launch(benchmark::calculateGeneric) + results["Inline.calculateGenericInline"] = launch(benchmark::calculateGenericInline) } //-------------------------------------------------------------------------// fun runIntArrayBenchmark() { - println("\nIntArrayBenchmark") val benchmark = IntArrayBenchmark() benchmark.setup() - launch(benchmark::copy) - launch(benchmark::copyManual) - launch(benchmark::filterAndCount) - launch(benchmark::filterSomeAndCount) - launch(benchmark::filterAndMap) - launch(benchmark::filterAndMapManual) - launch(benchmark::filter) - launch(benchmark::filterSome) - launch(benchmark::filterPrime) - launch(benchmark::filterManual) - launch(benchmark::filterSomeManual) - launch(benchmark::countFilteredManual) - launch(benchmark::countFilteredSomeManual) - launch(benchmark::countFilteredPrimeManual) - launch(benchmark::countFiltered) - launch(benchmark::countFilteredSome) - launch(benchmark::countFilteredPrime) - launch(benchmark::countFilteredLocal) - launch(benchmark::countFilteredSomeLocal) - launch(benchmark::reduce) + results["IntArray.copy"] = launch(benchmark::copy) + results["IntArray.copyManual"] = launch(benchmark::copyManual) + results["IntArray.filterAndCount"] = launch(benchmark::filterAndCount) + results["IntArray.filterSomeAndCount"] = launch(benchmark::filterSomeAndCount) + results["IntArray.filterAndMap"] = launch(benchmark::filterAndMap) + results["IntArray.filterAndMapManual"] = launch(benchmark::filterAndMapManual) + results["IntArray.filter"] = launch(benchmark::filter) + results["IntArray.filterSome"] = launch(benchmark::filterSome) + results["IntArray.filterPrime"] = launch(benchmark::filterPrime) + results["IntArray.filterManual"] = launch(benchmark::filterManual) + results["IntArray.filterSomeManual"] = launch(benchmark::filterSomeManual) + results["IntArray.countFilteredManual"] = launch(benchmark::countFilteredManual) + results["IntArray.countFilteredSomeManual"] = launch(benchmark::countFilteredSomeManual) + results["IntArray.countFilteredPrimeManual"] = launch(benchmark::countFilteredPrimeManual) + results["IntArray.countFiltered"] = launch(benchmark::countFiltered) + results["IntArray.countFilteredSome"] = launch(benchmark::countFilteredSome) + results["IntArray.countFilteredPrime"] = launch(benchmark::countFilteredPrime) + results["IntArray.countFilteredLocal"] = launch(benchmark::countFilteredLocal) + results["IntArray.countFilteredSomeLocal"] = launch(benchmark::countFilteredSomeLocal) + results["IntArray.reduce"] = launch(benchmark::reduce) } //-------------------------------------------------------------------------// fun runIntBaselineBenchmark() { - println("\nIntBaselineBenchmark") val benchmark = IntBaselineBenchmark() - launch(benchmark::consume) - launch(benchmark::allocateList) - launch(benchmark::allocateArray) - launch(benchmark::allocateListAndFill) - launch(benchmark::allocateArrayAndFill) + results["IntBaseline.consume"] = launch(benchmark::consume) + results["IntBaseline.allocateList"] = launch(benchmark::allocateList) + results["IntBaseline.allocateArray"] = launch(benchmark::allocateArray) + results["IntBaseline.allocateListAndFill"] = launch(benchmark::allocateListAndFill) + results["IntBaseline.allocateArrayAndFill"] = launch(benchmark::allocateArrayAndFill) } //-------------------------------------------------------------------------// fun runIntListBenchmark() { - println("\nIntListBenchmark") val benchmark = IntListBenchmark() benchmark.setup() - launch(benchmark::copy) - launch(benchmark::copyManual) - launch(benchmark::filterAndCount) - launch(benchmark::filterAndMap) - launch(benchmark::filterAndMapManual) - launch(benchmark::filter) - launch(benchmark::filterManual) - launch(benchmark::countFilteredManual) - launch(benchmark::countFiltered) - launch(benchmark::countFilteredLocal) - launch(benchmark::reduce) + results["IntList.copy"] = launch(benchmark::copy) + results["IntList.copyManual"] = launch(benchmark::copyManual) + results["IntList.filterAndCount"] = launch(benchmark::filterAndCount) + results["IntList.filterAndMap"] = launch(benchmark::filterAndMap) + results["IntList.filterAndMapManual"] = launch(benchmark::filterAndMapManual) + results["IntList.filter"] = launch(benchmark::filter) + results["IntList.filterManual"] = launch(benchmark::filterManual) + results["IntList.countFilteredManual"] = launch(benchmark::countFilteredManual) + results["IntList.countFiltered"] = launch(benchmark::countFiltered) + results["IntList.countFilteredLocal"] = launch(benchmark::countFilteredLocal) + results["IntList.reduce"] = launch(benchmark::reduce) } //-------------------------------------------------------------------------// fun runIntStreamBenchmark() { - println("\nIntStreamBenchmark") val benchmark = IntStreamBenchmark() benchmark.setup() - launch(benchmark::copy) - launch(benchmark::copyManual) - launch(benchmark::filterAndCount) - launch(benchmark::filterAndMap) - launch(benchmark::filterAndMapManual) - launch(benchmark::filter) - launch(benchmark::filterManual) - launch(benchmark::countFilteredManual) - launch(benchmark::countFiltered) - launch(benchmark::countFilteredLocal) - launch(benchmark::reduce) + results["IntStream.copy"] = launch(benchmark::copy) + results["IntStream.copyManual"] = launch(benchmark::copyManual) + results["IntStream.filterAndCount"] = launch(benchmark::filterAndCount) + results["IntStream.filterAndMap"] = launch(benchmark::filterAndMap) + results["IntStream.filterAndMapManual"] = launch(benchmark::filterAndMapManual) + results["IntStream.filter"] = launch(benchmark::filter) + results["IntStream.filterManual"] = launch(benchmark::filterManual) + results["IntStream.countFilteredManual"] = launch(benchmark::countFilteredManual) + results["IntStream.countFiltered"] = launch(benchmark::countFiltered) + results["IntStream.countFilteredLocal"] = launch(benchmark::countFilteredLocal) + results["IntStream.reduce"] = launch(benchmark::reduce) } //-------------------------------------------------------------------------// fun runLambdaBenchmark() { - println("\nLambdaBenchmark") val benchmark = LambdaBenchmark() benchmark.setup() - launch(benchmark::noncapturingLambda) - launch(benchmark::noncapturingLambdaNoInline) - launch(benchmark::capturingLambda) - launch(benchmark::capturingLambdaNoInline) - launch(benchmark::mutatingLambda) - launch(benchmark::mutatingLambdaNoInline) - launch(benchmark::methodReference) - launch(benchmark::methodReferenceNoInline) + results["Lambda.noncapturingLambda"] = launch(benchmark::noncapturingLambda) + results["Lambda.noncapturingLambdaNoInline"] = launch(benchmark::noncapturingLambdaNoInline) + results["Lambda.capturingLambda"] = launch(benchmark::capturingLambda) + results["Lambda.capturingLambdaNoInline"] = launch(benchmark::capturingLambdaNoInline) + results["Lambda.mutatingLambda"] = launch(benchmark::mutatingLambda) + results["Lambda.mutatingLambdaNoInline"] = launch(benchmark::mutatingLambdaNoInline) + results["Lambda.methodReference"] = launch(benchmark::methodReference) + results["Lambda.methodReferenceNoInline"] = launch(benchmark::methodReferenceNoInline) } //-------------------------------------------------------------------------// fun runLoopBenchmark() { - println("\nLoopBenchmark") val benchmark = LoopBenchmark() benchmark.setup() - launch(benchmark::arrayLoop) - launch(benchmark::arrayIndexLoop) - launch(benchmark::rangeLoop) - launch(benchmark::arrayListLoop) - launch(benchmark::arrayWhileLoop) - launch(benchmark::arrayForeachLoop) - launch(benchmark::arrayListForeachLoop) + results["Loop.arrayLoop"] = launch(benchmark::arrayLoop) + results["Loop.arrayIndexLoop"] = launch(benchmark::arrayIndexLoop) + results["Loop.rangeLoop"] = launch(benchmark::rangeLoop) + results["Loop.arrayListLoop"] = launch(benchmark::arrayListLoop) + results["Loop.arrayWhileLoop"] = launch(benchmark::arrayWhileLoop) + results["Loop.arrayForeachLoop"] = launch(benchmark::arrayForeachLoop) + results["Loop.arrayListForeachLoop"] = launch(benchmark::arrayListForeachLoop) } //-------------------------------------------------------------------------// fun runMatrixMapBenchmark() { - println("\nMatrixMapBenchmark") val benchmark = MatrixMapBenchmark() - launch(benchmark::add) + results["MatrixMap.add"] = launch(benchmark::add) } //-------------------------------------------------------------------------// fun runParameterNotNullAssertionBenchmark() { - println("\nParameterNotNullAssertionBenchmark") val benchmark = ParameterNotNullAssertionBenchmark() - launch(benchmark::invokeOneArgWithNullCheck) - launch(benchmark::invokeOneArgWithoutNullCheck) - launch(benchmark::invokeTwoArgsWithNullCheck) - launch(benchmark::invokeTwoArgsWithoutNullCheck) - launch(benchmark::invokeEightArgsWithNullCheck) - launch(benchmark::invokeEightArgsWithoutNullCheck) + results["ParameterNotNull.invokeOneArgWithNullCheck"] = launch(benchmark::invokeOneArgWithNullCheck) + results["ParameterNotNull.invokeOneArgWithoutNullCheck"] = launch(benchmark::invokeOneArgWithoutNullCheck) + results["ParameterNotNull.invokeTwoArgsWithNullCheck"] = launch(benchmark::invokeTwoArgsWithNullCheck) + results["ParameterNotNull.invokeTwoArgsWithoutNullCheck"] = launch(benchmark::invokeTwoArgsWithoutNullCheck) + results["ParameterNotNull.invokeEightArgsWithNullCheck"] = launch(benchmark::invokeEightArgsWithNullCheck) + results["ParameterNotNull.invokeEightArgsWithoutNullCheck"] = launch(benchmark::invokeEightArgsWithoutNullCheck) } //-------------------------------------------------------------------------// fun runPrimeListBenchmark() { - println("\nPrimeListBenchmark") val benchmark = PrimeListBenchmark() - launch(benchmark::calcDirect) - launch(benchmark::calcEratosthenes) + results["PrimeList.calcDirect"] = launch(benchmark::calcDirect) + results["PrimeList.calcEratosthenes"] = launch(benchmark::calcEratosthenes) } //-------------------------------------------------------------------------// fun runStringBenchmark() { - println("\nStringBenchmark") val benchmark = StringBenchmark() benchmark.setup() - launch(benchmark::stringConcat) - launch(benchmark::stringConcatNullable) - launch(benchmark::stringBuilderConcat) - launch(benchmark::stringBuilderConcatNullable) - launch(benchmark::summarizeSplittedCsv) + results["String.stringConcat"] = launch(benchmark::stringConcat) + results["String.stringConcatNullable"] = launch(benchmark::stringConcatNullable) + results["String.stringBuilderConcat"] = launch(benchmark::stringBuilderConcat) + results["String.stringBuilderConcatNullable"] = launch(benchmark::stringBuilderConcatNullable) + results["String.summarizeSplittedCsv"] = launch(benchmark::summarizeSplittedCsv) } //-------------------------------------------------------------------------// fun runSwitchBenchmark() { - println("\nSwitchBenchmark") val benchmark = SwitchBenchmark() benchmark.setupInts() benchmark.setupStrings() benchmark.setupEnums() benchmark.setupSealedClassses() - launch(benchmark::testSparseIntSwitch) - launch(benchmark::testDenseIntSwitch) - launch(benchmark::testConstSwitch) - launch(benchmark::testObjConstSwitch) - launch(benchmark::testVarSwitch) - launch(benchmark::testStringsSwitch) - launch(benchmark::testEnumsSwitch) - launch(benchmark::testDenseEnumsSwitch) - launch(benchmark::testSealedWhenSwitch) + results["Switch.testSparseIntSwitch"] = launch(benchmark::testSparseIntSwitch) + results["Switch.testDenseIntSwitch"] = launch(benchmark::testDenseIntSwitch) + results["Switch.testConstSwitch"] = launch(benchmark::testConstSwitch) + results["Switch.testObjConstSwitch"] = launch(benchmark::testObjConstSwitch) + results["Switch.testVarSwitch"] = launch(benchmark::testVarSwitch) + results["Switch.testStringsSwitch"] = launch(benchmark::testStringsSwitch) + results["Switch.testEnumsSwitch"] = launch(benchmark::testEnumsSwitch) + results["Switch.testDenseEnumsSwitch"] = launch(benchmark::testDenseEnumsSwitch) + results["Switch.testSealedWhenSwitch"] = launch(benchmark::testSealedWhenSwitch) } //-------------------------------------------------------------------------// fun runWithIndiciesBenchmark() { - println("\nWithIndiciesBenchmark") val benchmark = WithIndiciesBenchmark() benchmark.setup() - launch(benchmark::withIndicies) - launch(benchmark::withIndiciesManual) + results["WithIndicies.withIndicies"] = launch(benchmark::withIndicies) + results["WithIndicies.withIndiciesManual"] = launch(benchmark::withIndiciesManual) } } \ No newline at end of file diff --git a/performance/src/main/kotlin/org/jetbrains/ring/norma.kt b/performance/src/main/kotlin/org/jetbrains/ring/norma.kt new file mode 100644 index 00000000000..4b55d880a61 --- /dev/null +++ b/performance/src/main/kotlin/org/jetbrains/ring/norma.kt @@ -0,0 +1,177 @@ +/* + * Copyright 2010-2017 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 org.jetbrains.ring + +val NormaResults = mapOf( + "AbstractMethod.sortStrings" to 1842L, + "AbstractMethod.sortStringsWithComparator" to 2775L, + "ClassArray.copy" to 148L, + "ClassArray.copyManual" to 456L, + "ClassArray.filterAndCount" to 2197L, + "ClassArray.filterAndMap" to 3081L, + "ClassArray.filterAndMapManual" to 2896L, + "ClassArray.filter" to 2281L, + "ClassArray.filterManual" to 2176L, + "ClassArray.countFilteredManual" to 2403L, + "ClassArray.countFiltered" to 2062L, + "ClassArray.countFilteredLocal" to 2065L, + "ClassBaseline.consume" to 8950L, + "ClassBaseline.consumeField" to 219L, + "ClassBaseline.allocateList" to 48L, + "ClassBaseline.allocateArray" to 30L, + "ClassBaseline.allocateListAndFill" to 6084L, + "ClassBaseline.allocateListAndWrite" to 314L, + "ClassBaseline.allocateArrayAndFill" to 5782L, + "ClassList.copy" to 41L, + "ClassList.copyManual" to 570L, + "ClassList.filterAndCount" to 2260L, + "ClassList.filterAndCountWithLambda" to 573L, + "ClassList.filterWithLambda" to 630L, + "ClassList.mapWithLambda" to 7750L, + "ClassList.countWithLambda" to 151L, + "ClassList.filterAndMapWithLambda" to 4686L, + "ClassList.filterAndMapWithLambdaAsSequence" to 4814L, + "ClassList.filterAndMap" to 3131L, + "ClassList.filterAndMapManual" to 3075L, + "ClassList.filter" to 2342L, + "ClassList.filterManual" to 2347L, + "ClassList.countFilteredManual" to 2186L, + "ClassList.countFiltered" to 2187L, + "ClassList.reduce" to 2208L, + "ClassStream.copy" to 820L, + "ClassStream.copyManual" to 705L, + "ClassStream.filterAndCount" to 2772L, + "ClassStream.filterAndMap" to 3654L, + "ClassStream.filterAndMapManual" to 2894L, + "ClassStream.filter" to 2377L, + "ClassStream.filterManual" to 2206L, + "ClassStream.countFilteredManual" to 2235L, + "ClassStream.countFiltered" to 2466L, + "ClassStream.reduce" to 2211L, + "CompanionObject.invokeRegularFunction" to 5L, + "CompanionObject.invokeJvmStaticFunction" to 5L, + "DefaultArgument.testOneOfTwo" to 5L, + "DefaultArgument.testTwoOfTwo" to 5L, + "DefaultArgument.testOneOfFour" to 5L, + "DefaultArgument.testFourOfFour" to 5L, + "DefaultArgument.testOneOfEight" to 5L, + "DefaultArgument.testEightOfEight" to 5L, + "Elvis.testElvis" to 123L, + "Euler.problem1bySequence" to 345L, + "Euler.problem1" to 143L, + "Euler.problem2" to 143L, + "Euler.problem4" to 66281L, + "Euler.problem8" to 14927L, + "Euler.problem9" to 964L, + "Euler.problem14" to 5327L, + "Euler.problem14full" to 22262L, + "Fibonacci.calcClassic" to 48L, + "Fibonacci.calc" to 48L, + "Fibonacci.calcWithProgression" to 184L, + "Fibonacci.calcSquare" to 5225L, + "Inline.calculate" to 47L, + "Inline.calculateInline" to 43L, + "Inline.calculateGeneric" to 36L, + "Inline.calculateGenericInline" to 31L, + "IntArray.copy" to 578L, + "IntArray.copyManual" to 385L, + "IntArray.filterAndCount" to 3497L, + "IntArray.filterSomeAndCount" to 387L, + "IntArray.filterAndMap" to 3709L, + "IntArray.filterAndMapManual" to 3899L, + "IntArray.filter" to 3605L, + "IntArray.filterSome" to 317L, + "IntArray.filterPrime" to 542L, + "IntArray.filterManual" to 3284L, + "IntArray.filterSomeManual" to 327L, + "IntArray.countFilteredManual" to 3871L, + "IntArray.countFilteredSomeManual" to 194L, + "IntArray.countFilteredPrimeManual" to 438L, + "IntArray.countFiltered" to 3120L, + "IntArray.countFilteredSome" to 194L, + "IntArray.countFilteredPrime" to 436L, + "IntArray.countFilteredLocal" to 3425L, + "IntArray.countFilteredSomeLocal" to 208L, + "IntArray.reduce" to 3210L, + "IntBaseline.consume" to 34L, + "IntBaseline.allocateList" to 37L, + "IntBaseline.allocateArray" to 43L, + "IntBaseline.allocateListAndFill" to 335L, + "IntBaseline.allocateArrayAndFill" to 67L, + "IntList.copy" to 38L, + "IntList.copyManual" to 680L, + "IntList.filterAndCount" to 3470L, + "IntList.filterAndMap" to 3829L, + "IntList.filterAndMapManual" to 3775L, + "IntList.filter" to 3726L, + "IntList.filterManual" to 3376L, + "IntList.countFilteredManual" to 3119L, + "IntList.countFiltered" to 3107L, + "IntList.countFilteredLocal" to 3108L, + "IntList.reduce" to 3114L, + "IntStream.copy" to 984L, + "IntStream.copyManual" to 668L, + "IntStream.filterAndCount" to 3532L, + "IntStream.filterAndMap" to 3948L, + "IntStream.filterAndMapManual" to 3581L, + "IntStream.filter" to 3350L, + "IntStream.filterManual" to 3638L, + "IntStream.countFilteredManual" to 3508L, + "IntStream.countFiltered" to 3337L, + "IntStream.countFilteredLocal" to 3215L, + "IntStream.reduce" to 5399L, + "Lambda.noncapturingLambda" to 224L, + "Lambda.noncapturingLambdaNoInline" to 202L, + "Lambda.capturingLambda" to 26L, + "Lambda.capturingLambdaNoInline" to 26L, + "Lambda.mutatingLambda" to 49L, + "Lambda.mutatingLambdaNoInline" to 49L, + "Lambda.methodReference" to 202L, + "Lambda.methodReferenceNoInline" to 203L, + "Loop.arrayLoop" to 191L, + "Loop.arrayIndexLoop" to 209L, + "Loop.rangeLoop" to 34L, + "Loop.arrayListLoop" to 335L, + "Loop.arrayWhileLoop" to 222L, + "Loop.arrayForeachLoop" to 188L, + "Loop.arrayListForeachLoop" to 298L, + "MatrixMap.add" to 8446L, + "ParameterNotNull.invokeOneArgWithNullCheck" to 5L, + "ParameterNotNull.invokeOneArgWithoutNullCheck" to 5L, + "ParameterNotNull.invokeTwoArgsWithNullCheck" to 5L, + "ParameterNotNull.invokeTwoArgsWithoutNullCheck" to 5L, + "ParameterNotNull.invokeEightArgsWithNullCheck" to 5L, + "ParameterNotNull.invokeEightArgsWithoutNullCheck" to 5L, + "PrimeList.calcDirect" to 860L, + "PrimeList.calcEratosthenes" to 3698L, + "String.stringConcat" to 2212L, + "String.stringConcatNullable" to 9354L, + "String.stringBuilderConcat" to 977L, + "String.stringBuilderConcatNullable" to 951L, + "String.summarizeSplittedCsv" to 31226L, + "Switch.testSparseIntSwitch" to 300L, + "Switch.testDenseIntSwitch" to 283L, + "Switch.testConstSwitch" to 276L, + "Switch.testObjConstSwitch" to 282L, + "Switch.testVarSwitch" to 548L, + "Switch.testStringsSwitch" to 1043L, + "Switch.testEnumsSwitch" to 177L, + "Switch.testDenseEnumsSwitch" to 208L, + "Switch.testSealedWhenSwitch" to 172L, + "WithIndicies.withIndicies" to 2303L, + "WithIndicies.withIndiciesManual" to 2256L +)