From 087f7e3b31829f0fced2f6c99a6939c15af3077e Mon Sep 17 00:00:00 2001 From: Elena Lepilkina Date: Fri, 1 Apr 2022 18:30:24 +0300 Subject: [PATCH] [K/N] Added possibility to run only base part of benchmarks --- .../jetbrains/kotlin/RunKotlinNativeTask.kt | 9 +- .../cinterop/src/main/kotlin/main.kt | 25 ++-- kotlin-native/performance/gradle.properties | 2 +- .../numerical/src/main/kotlin-jvm/launcher.kt | 7 +- .../src/main/kotlin-native/launcher.kt | 9 +- .../objcinterop/src/main/kotlin/main.kt | 24 ++-- .../performance/ring/src/main/kotlin/main.kt | 125 +++++++++--------- .../benchmarksLauncher/SwiftLauncher.kt | 6 +- .../jetbrains/benchmarksLauncher/launcher.kt | 25 ++-- .../startup/src/main/kotlin/main.kt | 9 +- .../swiftinterop/swiftSrc/main.swift | 2 +- .../kotlin/network/aws/AWSNetworkUtils.kt | 2 +- .../ui/src/main/kotlin/main.kt | 2 +- 13 files changed, 131 insertions(+), 116 deletions(-) diff --git a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/RunKotlinNativeTask.kt b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/RunKotlinNativeTask.kt index d4c843ce05b..07bd20d5106 100644 --- a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/RunKotlinNativeTask.kt +++ b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/RunKotlinNativeTask.kt @@ -34,6 +34,9 @@ open class RunKotlinNativeTask @Inject constructor(private val linkTask: Task, @Option(option = "verbose", description = "Verbose mode of running benchmarks") var verbose: Boolean = false @Input + @Option(option = "baseOnly", description = "Run only set of base benchmarks") + var baseOnly: Boolean = false + @Input var warmupCount: Int = 0 @Input var repeatCount: Int = 0 @@ -131,7 +134,11 @@ open class RunKotlinNativeTask @Inject constructor(private val linkTask: Task, } else { executable = this@RunKotlinNativeTask.executable } - args("list") + if (baseOnly) { + args("baseOnlyList") + } else { + args("list") + } standardOutput = output } val benchmarks = output.toString().lines() diff --git a/kotlin-native/performance/cinterop/src/main/kotlin/main.kt b/kotlin-native/performance/cinterop/src/main/kotlin/main.kt index e1b55452128..c39a537bd82 100644 --- a/kotlin-native/performance/cinterop/src/main/kotlin/main.kt +++ b/kotlin-native/performance/cinterop/src/main/kotlin/main.kt @@ -22,19 +22,20 @@ import org.jetbrains.typesBenchmarks.* import kotlinx.cli.* class CinteropLauncher : Launcher() { - override val benchmarks = BenchmarksCollection( - mutableMapOf( - "macros" to BenchmarkEntry(::macrosBenchmark), - "struct" to BenchmarkEntry(::structBenchmark), - "union" to BenchmarkEntry(::unionBenchmark), - "enum" to BenchmarkEntry(::enumBenchmark), - "stringToC" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringToCBenchmark() }), - "stringToKotlin" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringToKotlinBenchmark() }), - "intMatrix" to BenchmarkEntryWithInit.create(::IntMatrixBenchmark, { intMatrixBenchmark() }), - "int" to BenchmarkEntryWithInit.create(::IntBenchmark, { intBenchmark() }), - "boxedInt" to BenchmarkEntryWithInit.create(::BoxedIntBenchmark, { boxedIntBenchmark() }) - ) + override val baseBenchmarksSet: MutableMap = mutableMapOf( + "stringToC" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringToCBenchmark() }), + "stringToKotlin" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringToKotlinBenchmark() }), + "intMatrix" to BenchmarkEntryWithInit.create(::IntMatrixBenchmark, { intMatrixBenchmark() }) ) + override val extendedBenchmarksSet: MutableMap = mutableMapOf( + "macros" to BenchmarkEntry(::macrosBenchmark), + "struct" to BenchmarkEntry(::structBenchmark), + "union" to BenchmarkEntry(::unionBenchmark), + "enum" to BenchmarkEntry(::enumBenchmark), + "int" to BenchmarkEntryWithInit.create(::IntBenchmark, { intBenchmark() }), + "boxedInt" to BenchmarkEntryWithInit.create(::BoxedIntBenchmark, { boxedIntBenchmark() }) + ) + } fun main(args: Array) { diff --git a/kotlin-native/performance/gradle.properties b/kotlin-native/performance/gradle.properties index 92e2d6be8a1..ed1877a4ab1 100644 --- a/kotlin-native/performance/gradle.properties +++ b/kotlin-native/performance/gradle.properties @@ -3,7 +3,7 @@ org.jetbrains.kotlin.native.jvmArgs=-Xmx6G org.gradle.jvmargs=-Xmx3g jvmWarmup = 1000 nativeWarmup = 10 -attempts = 30 +attempts = 20 jvmBenchResults = jvmBenchResults.json nativeBenchResults = nativeBenchResults.json nativeTextReport = nativeReport.txt diff --git a/kotlin-native/performance/numerical/src/main/kotlin-jvm/launcher.kt b/kotlin-native/performance/numerical/src/main/kotlin-jvm/launcher.kt index 1938943c781..9c32b0b74ba 100644 --- a/kotlin-native/performance/numerical/src/main/kotlin-jvm/launcher.kt +++ b/kotlin-native/performance/numerical/src/main/kotlin-jvm/launcher.kt @@ -6,11 +6,10 @@ import org.jetbrains.benchmarksLauncher.* actual class NumericalLauncher : Launcher() { - override val benchmarks = BenchmarksCollection( - mutableMapOf( - "BellardPi" to BenchmarkEntry(::jvmBellardPi) - ) + override val baseBenchmarksSet = mutableMapOf( + "BellardPi" to BenchmarkEntry(::jvmBellardPi) ) + } fun jvmBellardPi() { diff --git a/kotlin-native/performance/numerical/src/main/kotlin-native/launcher.kt b/kotlin-native/performance/numerical/src/main/kotlin-native/launcher.kt index 245d06d1025..031f2f41dd6 100644 --- a/kotlin-native/performance/numerical/src/main/kotlin-native/launcher.kt +++ b/kotlin-native/performance/numerical/src/main/kotlin-native/launcher.kt @@ -6,12 +6,11 @@ import org.jetbrains.benchmarksLauncher.* actual class NumericalLauncher : Launcher() { - override val benchmarks = BenchmarksCollection( - mutableMapOf( - "BellardPi" to BenchmarkEntry(::konanBellardPi), - "BellardPiCinterop" to BenchmarkEntry(::clangBellardPi) - ) + override val baseBenchmarksSet: MutableMap = mutableMapOf( + "BellardPi" to BenchmarkEntry(::konanBellardPi), + "BellardPiCinterop" to BenchmarkEntry(::clangBellardPi) ) + } fun konanBellardPi() { diff --git a/kotlin-native/performance/objcinterop/src/main/kotlin/main.kt b/kotlin-native/performance/objcinterop/src/main/kotlin/main.kt index b37ea14bbe2..13df58c10f1 100644 --- a/kotlin-native/performance/objcinterop/src/main/kotlin/main.kt +++ b/kotlin-native/performance/objcinterop/src/main/kotlin/main.kt @@ -9,18 +9,18 @@ import org.jetbrains.complexNumbers.* import kotlinx.cli.* class ObjCInteropLauncher: Launcher() { - override val benchmarks = BenchmarksCollection( - mutableMapOf( - "generateNumbersSequence" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { generateNumbersSequence() }), - "sumComplex" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { sumComplex() }), - "subComplex" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { subComplex() }), - "classInheritance" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { classInheritance() }), - "categoryMethods" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { categoryMethods() }), - "stringToObjC" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { stringToObjC() }), - "stringFromObjC" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { stringFromObjC() }), - "fft" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { fft() }), - "invertFft" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { invertFft() }) - ) + override val baseBenchmarksSet: MutableMap = mutableMapOf( + "sumComplex" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { sumComplex() }), + "stringToObjC" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { stringToObjC() }), + "stringFromObjC" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { stringFromObjC() }), + "fft" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { fft() }) + ) + override val extendedBenchmarksSet: MutableMap = mutableMapOf( + "generateNumbersSequence" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { generateNumbersSequence() }), + "subComplex" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { subComplex() }), + "classInheritance" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { classInheritance() }), + "categoryMethods" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { categoryMethods() }), + "invertFft" to BenchmarkEntryWithInit.create(::ComplexNumbersBenchmark, { invertFft() }) ) } diff --git a/kotlin-native/performance/ring/src/main/kotlin/main.kt b/kotlin-native/performance/ring/src/main/kotlin/main.kt index 2c4997cbdf9..1554cc25554 100644 --- a/kotlin-native/performance/ring/src/main/kotlin/main.kt +++ b/kotlin-native/performance/ring/src/main/kotlin/main.kt @@ -21,55 +21,103 @@ import org.jetbrains.benchmarksLauncher.* import kotlinx.cli.* class RingLauncher : Launcher() { - - override val benchmarks = BenchmarksCollection( + override val baseBenchmarksSet = mutableMapOf( "AbstractMethod.sortStrings" to BenchmarkEntryWithInit.create(::AbstractMethodBenchmark, { sortStrings() }), + "ClassArray.copy" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { copy() }), + "ClassArray.filter" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { filter() }), + "ClassArray.countFiltered" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { countFiltered() }), + "ClassBaseline.consume" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { consume() }), + "ClassBaseline.consumeField" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { consumeField() }), + "ClassBaseline.allocateListAndFill" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { allocateListAndFill() }), + "ClassList.copy" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { copy() }), + "ClassList.mapWithLambda" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { mapWithLambda() }), + "ClassList.filter" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filter() }), + "ClassList.reduce" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { reduce() }), + "ClassStream.copy" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { copy() }), + "ClassStream.filter" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { filter() }), + "ClassStream.reduce" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { reduce() }), + "Elvis.testElvis" to BenchmarkEntryWithInit.create(::ElvisBenchmark, { testElvis() }), + "Euler.problem1bySequence" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem1bySequence() }), + "Euler.problem9" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem9() }), + "Euler.problem14" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem14() }), + "Fibonacci.calcClassic" to BenchmarkEntryWithInit.create(::FibonacciBenchmark, { calcClassic() }), + "Fibonacci.calc" to BenchmarkEntryWithInit.create(::FibonacciBenchmark, { calc() }), + "ForLoops.arrayLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { arrayLoop() }), + "ForLoops.arrayIndicesLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { arrayIndicesLoop() }), + "Inline.calculateInline" to BenchmarkEntryWithInit.create(::InlineBenchmark, { calculateInline() }), + "Lambda.noncapturingLambda" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { noncapturingLambda() }), + "Lambda.capturingLambda" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { capturingLambda() }), + "Lambda.methodReference" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { methodReference() }), + "Loop.arrayLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayLoop() }), + "Loop.rangeLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { rangeLoop() }), + "Loop.arrayWhileLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayWhileLoop() }), + "Loop.arrayForeachLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayForeachLoop() }), + "Loop.arrayListForeachLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayListForeachLoop() }), + "MatrixMap.add" to BenchmarkEntryWithInit.create(::MatrixMapBenchmark, { add() }), + "PrimeList.calcDirect" to BenchmarkEntryWithInit.create(::PrimeListBenchmark, { calcDirect() }), + "PrimeList.calcEratosthenes" to BenchmarkEntryWithInit.create(::PrimeListBenchmark, { calcEratosthenes() }), + "Singleton.access" to BenchmarkEntryWithInit.create(::SingletonBenchmark, { access() }), + "String.stringConcat" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringConcat() }), + "String.stringBuilderConcat" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringBuilderConcat() }), + "String.stringBuilderConcatNullable" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringBuilderConcatNullable() }), + "String.summarizeSplittedCsv" to BenchmarkEntryWithInit.create(::StringBenchmark, { summarizeSplittedCsv() }), + "Switch.testStringsSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testStringsSwitch() }), + "Switch.testEnumsSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testEnumsSwitch() }), + "Switch.testSealedWhenSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testSealedWhenSwitch() }), + "WithIndicies.withIndicies" to BenchmarkEntryWithInit.create(::WithIndiciesBenchmark, { withIndicies() }), + "OctoTest" to BenchmarkEntry(::octoTest), + "Calls.finalMethod" to BenchmarkEntryWithInit.create(::CallsBenchmark, { finalMethodCall() }), + "Calls.openMethodMonomorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { classOpenMethodCall_MonomorphicCallsite() }), + "Calls.interfaceMethodMonomorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { interfaceMethodCall_MonomorphicCallsite() }), + "Calls.returnBoxUnboxFolding" to BenchmarkEntryWithInit.create(::CallsBenchmark, { returnBoxUnboxFolding() }), + "Calls.parameterBoxUnboxFolding" to BenchmarkEntryWithInit.create(::CallsBenchmark, { parameterBoxUnboxFolding() }), + "CoordinatesSolver.solve" to BenchmarkEntryWithInit.create(::CoordinatesSolverBenchmark, { solve() }), + "GraphSolver.solve" to BenchmarkEntryWithInit.create(::GraphSolverBenchmark, { solve() }), + "Casts.classCast" to BenchmarkEntryWithInit.create(::CastsBenchmark, { classCast() }), + "Casts.interfaceCast" to BenchmarkEntryWithInit.create(::CastsBenchmark, { interfaceCast() }), + "LinkedListWithAtomicsBenchmark" to BenchmarkEntryWithInit.create(::LinkedListWithAtomicsBenchmark, { ensureNext() }), + "Inheritance.baseCalls" to BenchmarkEntryWithInit.create(::InheritanceBenchmark, { baseCalls() }), + "ChainableBenchmark.testChainable" to BenchmarkEntryWithInit.create(::ChainableBenchmark, { testChainable() }), + "BunnymarkBenchmark.testBunnymark" to BenchmarkEntryWithInit.create(::BunnymarkBenchmark, { testBunnymark() }), + "ArrayCopyBenchmark.copyInSameArray" to BenchmarkEntryWithInit.create(::ArrayCopyBenchmark, { copyInSameArray() }) + ) + + + override val extendedBenchmarksSet: MutableMap = + mutableMapOf( "AbstractMethod.sortStringsWithComparator" to BenchmarkEntryWithInit.create(::AbstractMethodBenchmark, { sortStringsWithComparator() }), "AllocationBenchmark.allocateObjects" to BenchmarkEntryWithInit.create(::AllocationBenchmark, { allocateObjects() }), - "ClassArray.copy" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { copy() }), "ClassArray.copyManual" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { copyManual() }), "ClassArray.filterAndCount" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { filterAndCount() }), "ClassArray.filterAndMap" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { filterAndMap() }), "ClassArray.filterAndMapManual" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { filterAndMapManual() }), - "ClassArray.filter" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { filter() }), "ClassArray.filterManual" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { filterManual() }), "ClassArray.countFilteredManual" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { countFilteredManual() }), - "ClassArray.countFiltered" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { countFiltered() }), "ClassArray.countFilteredLocal" to BenchmarkEntryWithInit.create(::ClassArrayBenchmark, { countFilteredLocal() }), - "ClassBaseline.consume" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { consume() }), - "ClassBaseline.consumeField" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { consumeField() }), "ClassBaseline.allocateList" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { allocateList() }), "ClassBaseline.allocateArray" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { allocateArray() }), - "ClassBaseline.allocateListAndFill" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { allocateListAndFill() }), "ClassBaseline.allocateListAndWrite" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { allocateListAndWrite() }), "ClassBaseline.allocateArrayAndFill" to BenchmarkEntryWithInit.create(::ClassBaselineBenchmark, { allocateArrayAndFill() }), - "ClassList.copy" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { copy() }), "ClassList.copyManual" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { copyManual() }), "ClassList.filterAndCount" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filterAndCount() }), "ClassList.filterAndCountWithLambda" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filterAndCountWithLambda() }), "ClassList.filterWithLambda" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filterWithLambda() }), - "ClassList.mapWithLambda" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { mapWithLambda() }), "ClassList.countWithLambda" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { countWithLambda() }), "ClassList.filterAndMapWithLambda" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filterAndMapWithLambda() }), "ClassList.filterAndMapWithLambdaAsSequence" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filterAndMapWithLambdaAsSequence() }), "ClassList.filterAndMap" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filterAndMap() }), "ClassList.filterAndMapManual" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filterAndMapManual() }), - "ClassList.filter" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filter() }), "ClassList.filterManual" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { filterManual() }), "ClassList.countFilteredManual" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { countFilteredManual() }), "ClassList.countFiltered" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { countFiltered() }), - "ClassList.reduce" to BenchmarkEntryWithInit.create(::ClassListBenchmark, { reduce() }), - "ClassStream.copy" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { copy() }), "ClassStream.copyManual" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { copyManual() }), "ClassStream.filterAndCount" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { filterAndCount() }), "ClassStream.filterAndMap" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { filterAndMap() }), "ClassStream.filterAndMapManual" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { filterAndMapManual() }), - "ClassStream.filter" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { filter() }), "ClassStream.filterManual" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { filterManual() }), "ClassStream.countFilteredManual" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { countFilteredManual() }), "ClassStream.countFiltered" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { countFiltered() }), - "ClassStream.reduce" to BenchmarkEntryWithInit.create(::ClassStreamBenchmark, { reduce() }), "CompanionObject.invokeRegularFunction" to BenchmarkEntryWithInit.create(::CompanionObjectBenchmark, { invokeRegularFunction() }), "DefaultArgument.testOneOfTwo" to BenchmarkEntryWithInit.create(::DefaultArgumentBenchmark, { testOneOfTwo() }), "DefaultArgument.testTwoOfTwo" to BenchmarkEntryWithInit.create(::DefaultArgumentBenchmark, { testTwoOfTwo() }), @@ -77,21 +125,14 @@ class RingLauncher : Launcher() { "DefaultArgument.testFourOfFour" to BenchmarkEntryWithInit.create(::DefaultArgumentBenchmark, { testFourOfFour() }), "DefaultArgument.testOneOfEight" to BenchmarkEntryWithInit.create(::DefaultArgumentBenchmark, { testOneOfEight() }), "DefaultArgument.testEightOfEight" to BenchmarkEntryWithInit.create(::DefaultArgumentBenchmark, { testEightOfEight() }), - "Elvis.testElvis" to BenchmarkEntryWithInit.create(::ElvisBenchmark, { testElvis() }), "Elvis.testCompositeElvis" to BenchmarkEntryWithInit.create(::ElvisBenchmark, { testCompositeElvis() }), - "Euler.problem1bySequence" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem1bySequence() }), "Euler.problem1" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem1() }), "Euler.problem2" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem2() }), "Euler.problem4" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem4() }), "Euler.problem8" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem8() }), - "Euler.problem9" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem9() }), - "Euler.problem14" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem14() }), "Euler.problem14full" to BenchmarkEntryWithInit.create(::EulerBenchmark, { problem14full() }), - "Fibonacci.calcClassic" to BenchmarkEntryWithInit.create(::FibonacciBenchmark, { calcClassic() }), - "Fibonacci.calc" to BenchmarkEntryWithInit.create(::FibonacciBenchmark, { calc() }), "Fibonacci.calcWithProgression" to BenchmarkEntryWithInit.create(::FibonacciBenchmark, { calcWithProgression() }), "Fibonacci.calcSquare" to BenchmarkEntryWithInit.create(::FibonacciBenchmark, { calcSquare() }), - "ForLoops.arrayLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { arrayLoop() }), "ForLoops.intArrayLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { intArrayLoop() }), "ForLoops.floatArrayLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { floatArrayLoop() }), "ForLoops.charArrayLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { charArrayLoop() }), @@ -99,7 +140,6 @@ class RingLauncher : Launcher() { "ForLoops.uIntArrayLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { uIntArrayLoop() }), "ForLoops.uShortArrayLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { uShortArrayLoop() }), "ForLoops.uLongArrayLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { uLongArrayLoop() }), - "ForLoops.arrayIndicesLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { arrayIndicesLoop() }), "ForLoops.intArrayIndicesLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { intArrayIndicesLoop() }), "ForLoops.floatArrayIndicesLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { floatArrayIndicesLoop() }), "ForLoops.charArrayIndicesLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { charArrayIndicesLoop() }), @@ -108,7 +148,6 @@ class RingLauncher : Launcher() { "ForLoops.uShortArrayIndicesLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { uShortArrayIndicesLoop() }), "ForLoops.uLongArrayIndicesLoop" to BenchmarkEntryWithInit.create(::ForLoopsBenchmark, { uLongArrayIndicesLoop() }), "Inline.calculate" to BenchmarkEntryWithInit.create(::InlineBenchmark, { calculate() }), - "Inline.calculateInline" to BenchmarkEntryWithInit.create(::InlineBenchmark, { calculateInline() }), "Inline.calculateGeneric" to BenchmarkEntryWithInit.create(::InlineBenchmark, { calculateGeneric() }), "Inline.calculateGenericInline" to BenchmarkEntryWithInit.create(::InlineBenchmark, { calculateGenericInline() }), "IntArray.copy" to BenchmarkEntryWithInit.create(::IntArrayBenchmark, { copy() }), @@ -158,70 +197,34 @@ class RingLauncher : Launcher() { "IntStream.countFiltered" to BenchmarkEntryWithInit.create(::IntStreamBenchmark, { countFiltered() }), "IntStream.countFilteredLocal" to BenchmarkEntryWithInit.create(::IntStreamBenchmark, { countFilteredLocal() }), "IntStream.reduce" to BenchmarkEntryWithInit.create(::IntStreamBenchmark, { reduce() }), - "Lambda.noncapturingLambda" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { noncapturingLambda() }), "Lambda.noncapturingLambdaNoInline" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { noncapturingLambdaNoInline() }), - "Lambda.capturingLambda" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { capturingLambda() }), "Lambda.capturingLambdaNoInline" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { capturingLambdaNoInline() }), "Lambda.mutatingLambda" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { mutatingLambda() }), "Lambda.mutatingLambdaNoInline" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { mutatingLambdaNoInline() }), - "Lambda.methodReference" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { methodReference() }), "Lambda.methodReferenceNoInline" to BenchmarkEntryWithInit.create(::LambdaBenchmark, { methodReferenceNoInline() }), - "Loop.arrayLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayLoop() }), "Loop.arrayIndexLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayIndexLoop() }), - "Loop.rangeLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { rangeLoop() }), "Loop.arrayListLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayListLoop() }), - "Loop.arrayWhileLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayWhileLoop() }), - "Loop.arrayForeachLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayForeachLoop() }), - "Loop.arrayListForeachLoop" to BenchmarkEntryWithInit.create(::LoopBenchmark, { arrayListForeachLoop() }), - "MatrixMap.add" to BenchmarkEntryWithInit.create(::MatrixMapBenchmark, { add() }), "ParameterNotNull.invokeOneArgWithNullCheck" to BenchmarkEntryWithInit.create(::ParameterNotNullAssertionBenchmark, { invokeOneArgWithNullCheck() }), "ParameterNotNull.invokeOneArgWithoutNullCheck" to BenchmarkEntryWithInit.create(::ParameterNotNullAssertionBenchmark, { invokeOneArgWithoutNullCheck() }), "ParameterNotNull.invokeTwoArgsWithNullCheck" to BenchmarkEntryWithInit.create(::ParameterNotNullAssertionBenchmark, { invokeTwoArgsWithNullCheck() }), "ParameterNotNull.invokeTwoArgsWithoutNullCheck" to BenchmarkEntryWithInit.create(::ParameterNotNullAssertionBenchmark, { invokeTwoArgsWithoutNullCheck() }), "ParameterNotNull.invokeEightArgsWithNullCheck" to BenchmarkEntryWithInit.create(::ParameterNotNullAssertionBenchmark, { invokeEightArgsWithNullCheck() }), "ParameterNotNull.invokeEightArgsWithoutNullCheck" to BenchmarkEntryWithInit.create(::ParameterNotNullAssertionBenchmark, { invokeEightArgsWithoutNullCheck() }), - "PrimeList.calcDirect" to BenchmarkEntryWithInit.create(::PrimeListBenchmark, { calcDirect() }), - "PrimeList.calcEratosthenes" to BenchmarkEntryWithInit.create(::PrimeListBenchmark, { calcEratosthenes() }), - "Singleton.access" to BenchmarkEntryWithInit.create(::SingletonBenchmark, { access() }), - "String.stringConcat" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringConcat() }), "String.stringConcatNullable" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringConcatNullable() }), - "String.stringBuilderConcat" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringBuilderConcat() }), - "String.stringBuilderConcatNullable" to BenchmarkEntryWithInit.create(::StringBenchmark, { stringBuilderConcatNullable() }), - "String.summarizeSplittedCsv" to BenchmarkEntryWithInit.create(::StringBenchmark, { summarizeSplittedCsv() }), "Switch.testSparseIntSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testSparseIntSwitch() }), "Switch.testDenseIntSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testDenseIntSwitch() }), "Switch.testConstSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testConstSwitch() }), "Switch.testObjConstSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testObjConstSwitch() }), "Switch.testVarSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testVarSwitch() }), - "Switch.testStringsSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testStringsSwitch() }), - "Switch.testEnumsSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testEnumsSwitch() }), "Switch.testDenseEnumsSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testDenseEnumsSwitch() }), - "Switch.testSealedWhenSwitch" to BenchmarkEntryWithInit.create(::SwitchBenchmark, { testSealedWhenSwitch() }), - "WithIndicies.withIndicies" to BenchmarkEntryWithInit.create(::WithIndiciesBenchmark, { withIndicies() }), "WithIndicies.withIndiciesManual" to BenchmarkEntryWithInit.create(::WithIndiciesBenchmark, { withIndiciesManual() }), - "OctoTest" to BenchmarkEntry(::octoTest), - "Calls.finalMethod" to BenchmarkEntryWithInit.create(::CallsBenchmark, { finalMethodCall() }), - "Calls.openMethodMonomorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { classOpenMethodCall_MonomorphicCallsite() }), "Calls.openMethodBimorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { classOpenMethodCall_BimorphicCallsite() }), "Calls.openMethodTrimorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { classOpenMethodCall_TrimorphicCallsite() }), - "Calls.interfaceMethodMonomorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { interfaceMethodCall_MonomorphicCallsite() }), "Calls.interfaceMethodBimorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { interfaceMethodCall_BimorphicCallsite() }), "Calls.interfaceMethodTrimorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { interfaceMethodCall_TrimorphicCallsite() }), "Calls.interfaceMethodHexamorphic" to BenchmarkEntryWithInit.create(::CallsBenchmark, { interfaceMethodCall_HexamorphicCallsite() }), - "Calls.returnBoxUnboxFolding" to BenchmarkEntryWithInit.create(::CallsBenchmark, { returnBoxUnboxFolding() }), - "Calls.parameterBoxUnboxFolding" to BenchmarkEntryWithInit.create(::CallsBenchmark, { parameterBoxUnboxFolding() }), - "CoordinatesSolver.solve" to BenchmarkEntryWithInit.create(::CoordinatesSolverBenchmark, { solve() }), - "GraphSolver.solve" to BenchmarkEntryWithInit.create(::GraphSolverBenchmark, { solve() }), - "Casts.classCast" to BenchmarkEntryWithInit.create(::CastsBenchmark, { classCast() }), - "Casts.interfaceCast" to BenchmarkEntryWithInit.create(::CastsBenchmark, { interfaceCast() }), - "LocalObjects.localArray" to BenchmarkEntryWithInit.create(::LocalObjectsBenchmark, { localArray() }), - "LinkedListWithAtomicsBenchmark" to BenchmarkEntryWithInit.create(::LinkedListWithAtomicsBenchmark, { ensureNext() }), - "Inheritance.baseCalls" to BenchmarkEntryWithInit.create(::InheritanceBenchmark, { baseCalls() }), - "ChainableBenchmark.testChainable" to BenchmarkEntryWithInit.create(::ChainableBenchmark, { testChainable() }), - "BunnymarkBenchmark.testBunnymark" to BenchmarkEntryWithInit.create(::BunnymarkBenchmark, { testBunnymark() }), - "ArrayCopyBenchmark.copyInSameArray" to BenchmarkEntryWithInit.create(::ArrayCopyBenchmark, { copyInSameArray() }) + "LocalObjects.localArray" to BenchmarkEntryWithInit.create(::LocalObjectsBenchmark, { localArray() }) ) - ) } fun main(args: Array) { diff --git a/kotlin-native/performance/shared/src/main/kotlin/org/jetbrains/benchmarksLauncher/SwiftLauncher.kt b/kotlin-native/performance/shared/src/main/kotlin/org/jetbrains/benchmarksLauncher/SwiftLauncher.kt index 15bd7099b54..3da103d31c9 100644 --- a/kotlin-native/performance/shared/src/main/kotlin/org/jetbrains/benchmarksLauncher/SwiftLauncher.kt +++ b/kotlin-native/performance/shared/src/main/kotlin/org/jetbrains/benchmarksLauncher/SwiftLauncher.kt @@ -7,8 +7,6 @@ import org.jetbrains.benchmarksLauncher.* import kotlinx.cli.* class SwiftLauncher: Launcher() { - override val benchmarks = BenchmarksCollection( - mutableMapOf( - ) - ) + override val baseBenchmarksSet: MutableMap = mutableMapOf() + override val extendedBenchmarksSet: MutableMap = mutableMapOf() } \ No newline at end of file diff --git a/kotlin-native/performance/shared/src/main/kotlin/org/jetbrains/benchmarksLauncher/launcher.kt b/kotlin-native/performance/shared/src/main/kotlin/org/jetbrains/benchmarksLauncher/launcher.kt index 000b810c4aa..ccdd0c29df1 100644 --- a/kotlin-native/performance/shared/src/main/kotlin/org/jetbrains/benchmarksLauncher/launcher.kt +++ b/kotlin-native/performance/shared/src/main/kotlin/org/jetbrains/benchmarksLauncher/launcher.kt @@ -26,7 +26,9 @@ data class RecordTimeMeasurement( val durationNs: Double) abstract class Launcher { - abstract val benchmarks: BenchmarksCollection + abstract val baseBenchmarksSet: MutableMap + open val extendedBenchmarksSet: MutableMap = mutableMapOf() + val benchmarks: BenchmarksCollection by lazy { BenchmarksCollection((baseBenchmarksSet + extendedBenchmarksSet).toMutableMap()) } fun add(name: String, benchmark: AbstractBenchmarkEntry) { benchmarks[name] = benchmark @@ -140,8 +142,9 @@ abstract class Launcher { return benchmarkResults } - fun benchmarksListAction() { - benchmarks.keys.forEach { + fun benchmarksListAction(baseOnly: Boolean) { + val benchmarksNames = if (baseOnly) baseBenchmarksSet.keys else benchmarks.keys + benchmarksNames.forEach { println(it) } } @@ -165,16 +168,22 @@ class BaseBenchmarkArguments(argParser: ArgParser): BenchmarkArguments(argParser } object BenchmarksRunner { - fun parse(args: Array, benchmarksListAction: ()->Unit): BenchmarkArguments? { + fun parse(args: Array, benchmarksListAction: (Boolean)->Unit): BenchmarkArguments? { class List: Subcommand("list", "Show list of benchmarks") { override fun execute() { - benchmarksListAction() + benchmarksListAction(false) + } + } + + class BaseBenchmarksList: Subcommand("baseOnlyList", "Show list of base benchmarks") { + override fun execute() { + benchmarksListAction(true) } } // Parse args. val argParser = ArgParser("benchmark") - argParser.subcommands(List()) + argParser.subcommands(List(), BaseBenchmarksList()) val argumentsValues = BaseBenchmarkArguments(argParser) return if (argParser.parse(args).commandName == "benchmark") argumentsValues else null } @@ -187,9 +196,9 @@ object BenchmarksRunner { fun runBenchmarks(args: Array, run: (parser: BenchmarkArguments) -> List, - parseArgs: (args: Array, benchmarksListAction: ()->Unit) -> BenchmarkArguments? = this::parse, + parseArgs: (args: Array, benchmarksListAction: (Boolean)->Unit) -> BenchmarkArguments? = this::parse, collect: (results: List, arguments: BenchmarkArguments) -> Unit = this::collect, - benchmarksListAction: ()->Unit) { + benchmarksListAction: (Boolean)->Unit) { val arguments = parseArgs(args, benchmarksListAction) arguments?.let { val results = run(arguments) diff --git a/kotlin-native/performance/startup/src/main/kotlin/main.kt b/kotlin-native/performance/startup/src/main/kotlin/main.kt index 223c44fe7b6..df4a5b7b9b9 100644 --- a/kotlin-native/performance/startup/src/main/kotlin/main.kt +++ b/kotlin-native/performance/startup/src/main/kotlin/main.kt @@ -8,12 +8,11 @@ import org.jetbrains.benchmarksLauncher.* import kotlinx.cli.* class StartupLauncher : Launcher() { - override val benchmarks = BenchmarksCollection( - mutableMapOf( - "Singleton.initialize" to BenchmarkEntryManual(::singletonInitialize), - "Singleton.initializeNested" to BenchmarkEntryManual(::singletonInitializeNested), - ) + override val baseBenchmarksSet: MutableMap = mutableMapOf( + "Singleton.initialize" to BenchmarkEntryManual(::singletonInitialize), + "Singleton.initializeNested" to BenchmarkEntryManual(::singletonInitializeNested), ) + } fun main(args: Array) { diff --git a/kotlin-native/performance/swiftinterop/swiftSrc/main.swift b/kotlin-native/performance/swiftinterop/swiftSrc/main.swift index 9e8116de78e..f6df59b862b 100644 --- a/kotlin-native/performance/swiftinterop/swiftSrc/main.swift +++ b/kotlin-native/performance/swiftinterop/swiftSrc/main.swift @@ -46,7 +46,7 @@ runner.runBenchmarks(args: args, run: { (arguments: BenchmarkArguments) -> [Benc verbose: argumentsList.verbose) } return [BenchmarkResult]() -}, parseArgs: { (args: KotlinArray, benchmarksListAction: (() -> KotlinUnit)) -> BenchmarkArguments? in +}, parseArgs: { (args: KotlinArray, benchmarksListAction: ((KotlinBoolean) -> KotlinUnit)) -> BenchmarkArguments? in return runner.parse(args: args, benchmarksListAction: swiftLauncher.benchmarksListAction) }, collect: { (benchmarks: [BenchmarkResult], arguments: BenchmarkArguments) -> Void in runner.collect(results: benchmarks, arguments: arguments) diff --git a/kotlin-native/tools/performance-server/src/main/kotlin/network/aws/AWSNetworkUtils.kt b/kotlin-native/tools/performance-server/src/main/kotlin/network/aws/AWSNetworkUtils.kt index d07750d49ae..debe4cd266b 100644 --- a/kotlin-native/tools/performance-server/src/main/kotlin/network/aws/AWSNetworkUtils.kt +++ b/kotlin-native/tools/performance-server/src/main/kotlin/network/aws/AWSNetworkUtils.kt @@ -64,7 +64,7 @@ class AWSNetworkConnector : NetworkConnector() { override fun sendBaseRequest(method: RequestMethod, path: String, user: String?, password: String?, acceptJsonContentType: Boolean, body: String?, errorHandler: (url: String, response: dynamic) -> Nothing?): Promise { - val useEnvironmentCredentials = true // For easy test on localhost change to false. + val useEnvironmentCredentials = false val AWSEndpoint = AWSInstance.Endpoint(AWSDomain) var request = AWSInstance.HttpRequest(AWSEndpoint, AWSRegion) request.method = method.toString() diff --git a/kotlin-native/tools/performance-server/ui/src/main/kotlin/main.kt b/kotlin-native/tools/performance-server/ui/src/main/kotlin/main.kt index 6be5212ecb6..5859117a72a 100644 --- a/kotlin-native/tools/performance-server/ui/src/main/kotlin/main.kt +++ b/kotlin-native/tools/performance-server/ui/src/main/kotlin/main.kt @@ -190,7 +190,7 @@ fun getDatesComponents() = "${beforeDate?.let {"&before=${encodeURIComponent(it) "${afterDate?.let {"&after=${encodeURIComponent(it)}"} ?: ""}" fun main(args: Array) { - val serverUrl = "https://kotlin-native-perf-summary.labs.jb.gg" // use "http://localhost:3000" for local debug. + val serverUrl = "http://localhost:3000" val zoomRatio = 2 // Get parameters from request.