Fixed internal mode after rebase

Author: Elena Lepilkina

plugin/main/src/kotlinx/benchmark/gradle/NativeMultiplatformTasks.kt

@@ -176,6 +176,7 @@ open class NativeBenchmarkExec() : DefaultTask() {
         execute(listOf(configFile.absolutePath, "--list", benchsDescriptionDir.absolutePath))
         val detailedConfigFiles = project.fileTree(benchsDescriptionDir).files.sortedBy { it.absolutePath }
         val jsonReportParts = mutableListOf<File>()
+        val runResults = mutableMapOf<String, String>()
 
         detailedConfigFiles.forEach { runConfig ->
             val runConfigPath = runConfig.absolutePath
@@ -185,9 +186,11 @@ open class NativeBenchmarkExec() : DefaultTask() {
 
             // Execute benchmark
             if (config.nativeIterationMode == "internal") {
-                val jsonFile = createTempFile("bench", ".json").toFile()
-                jsonReportParts.add(jsonFile)
-                execute(listOf(configFile.absolutePath, "--internal", runConfigPath, jsonFile.absolutePath))
+                val suiteResultsFile = createTempFile("bench", ".txt").toFile()
+                execute(listOf(configFile.absolutePath, "--internal", runConfigPath, suiteResultsFile.absolutePath))
+                val suiteResults = suiteResultsFile.readText()
+                if (suiteResults.isNotEmpty())
+                    runResults[runConfigPath] = suiteResults
             } else {
                 val iterations = currentConfigDescription.substringAfter("iterations=")
                     .substringBefore(',').toInt()
@@ -209,7 +212,7 @@ open class NativeBenchmarkExec() : DefaultTask() {
                 var iteration = 0
                 while (!exceptionDuringExecution && iteration in 0 until iterations) {
                     val textResult = createTempFile("bench", ".txt").toFile()
-                    execute(listOf(configFile.absolutePath, runConfigPath, iteration.toString(), textResult.absolutePath))
+                    execute(listOf(configFile.absolutePath, "--iteration", runConfigPath, iteration.toString(), textResult.absolutePath))
                     val result = textResult.readLines()[0]
                     if (result == "null")
                         exceptionDuringExecution = true
@@ -218,23 +221,15 @@ open class NativeBenchmarkExec() : DefaultTask() {
                 }
                 // Store results
                 if (iterationResults.size == iterations) {
-                    val samplesFile = createTempFile("bench_results").toFile()
-                    samplesFile.printWriter().use { out ->
-                        out.write(iterationResults.joinToString { it.toString() })
-                    }
-                    execute(listOf(configFile.absolutePath, runConfigPath, samplesFile.absolutePath))
-                    jsonReportParts.add(samplesFile)
+                    runResults[runConfigPath] = iterationResults.joinToString()
                 }
             }
         }
-        // Complete
-        execute(listOf(configFile.absolutePath, "--complete"))
-        // Merge reports
-        val fullResults = jsonReportParts.map {
-            it.readText()
-        }.joinToString(",", prefix = "[", postfix = "\n]")
-        reportFile.printWriter().use {
-            it.print(fullResults)
+        // Merge results
+        val samplesFile = createTempFile("bench_results").toFile()
+        samplesFile.printWriter().use { out ->
+            out.write(runResults.toList().joinToString("\n") { "${it.first}: ${it.second}"})
         }
+        execute(listOf(configFile.absolutePath, "--store-results", samplesFile.absolutePath))
     }
 }

runtime/nativeMain/src/kotlinx/benchmark/Utils.kt

@@ -62,7 +62,7 @@ internal fun String.parseBenchmarkConfig(): NativeExecutor.BenchmarkRun {
 
     val content = readFile()
     val lines = content.lines().filter { it.isNotEmpty() }
-    require(lines.size == 3, { "Wrong fromat of detailed benchmark configuration file. "})
+    require(lines.size == 3, { "Wrong format of detailed benchmark configuration file. "})
     val name = lines[0].getElement("benchmark")
     val configuration = BenchmarkConfiguration.parse(lines[1].getElement("configuration"))
     val parameters = lines[2].getElement("parameters").parseMap()

runtime/nativeMain/src/kotlinx/benchmark/native/NativeExecutor.kt

@@ -72,7 +72,8 @@ class NativeExecutor(name: String, args: Array<out String>) : SuiteExecutor(name
         reporter.startBenchmark(executionName, id)
         val samples = run(benchmark, benchmarkRun)
         if (samples != null) {
-            saveBenchmarkResults(benchmark, benchmarkRun, samples, resultsFile)
+            writeFile(resultsFile, samples.joinToString())
+            saveBenchmarkResults(benchmark, benchmarkRun, samples)
         }
     }
 
@@ -107,16 +108,17 @@ class NativeExecutor(name: String, args: Array<out String>) : SuiteExecutor(name
         } finally {
             benchmark.suite.teardown(instance)
         }
-        exception?.let {
+        if (exception != null) {
             val error = exception.toString()
             val stacktrace = exception.stacktrace()
             reporter.endBenchmarkException(executionName, id, error, stacktrace)
             return null
-        } ?: return samples
+        }
+        return samples
     }
 
     private fun saveBenchmarkResults(benchmark: BenchmarkDescriptor<Any?>, benchmarkRun: BenchmarkRun,
-                              samples: DoubleArray, fileName: String? = null) {
+                              samples: DoubleArray) {
         val id = id(benchmark.name, benchmarkRun.parameters)
         val result = ReportBenchmarksStatistics.createResult(benchmark, benchmarkRun.parameters, benchmarkRun.config, samples)
         val message = with(result) {
@@ -136,15 +138,20 @@ class NativeExecutor(name: String, args: Array<out String>) : SuiteExecutor(name
             message
         )
         result(result)
-        fileName?.let { writeFile(it, JsonBenchmarkReportFormatter.format(result)) }
     }
 
-    fun storeResults(benchmarks: List<BenchmarkDescriptor<Any?>>) {
-        val (configFileName, fileName) = additionalArguments
-        val benchmarkRun = configFileName.parseBenchmarkConfig()
-        val benchmark = benchmarks.getBenchmark(benchmarkRun.benchmarkName)
-        val samples = fileName.readFile().split(", ").map { it.toDouble() }.toDoubleArray()
-        saveBenchmarkResults(benchmark, benchmarkRun, samples, fileName)
+    private fun storeResults(benchmarks: List<BenchmarkDescriptor<Any?>>, complete: () -> Unit) {
+        val (_, resultsFileName) = additionalArguments
+        resultsFileName.readFile().split("\n").filter { it.isNotEmpty() }.forEach {
+            val (configFileName, samplesList) = it.split(": ")
+            val samples = samplesList.split(", ").map { it.toDouble() }.toDoubleArray()
+            val benchmarkRun = configFileName.parseBenchmarkConfig()
+            val benchmark = benchmarks.getBenchmark(benchmarkRun.benchmarkName)
+            val result = ReportBenchmarksStatistics.createResult(benchmark, benchmarkRun.parameters,
+                benchmarkRun.config, samples)
+            result(result)
+        }
+        complete()
     }
 
     override fun run(
@@ -154,18 +161,24 @@ class NativeExecutor(name: String, args: Array<out String>) : SuiteExecutor(name
         start: () -> Unit,
         complete: () -> Unit
     ) {
-        when(additionalArguments.size) {
-            1 -> complete()
-            2 -> when (additionalArguments.first()) {
-                "--list" -> outputBenchmarks(runnerConfiguration, benchmarks, start)
-                else -> storeResults(benchmarks)
-            }
-            3 -> when (additionalArguments.first()) {
-                "--internal" -> runBenchmark(benchmarks)
-                else -> runBenchmarkIteration(benchmarks)
-            }
-            4 -> runBenchmarkWarmup(benchmarks)
+        val knownActions = mapOf(
+            "--list" to 2,
+            "--store-results" to 2,
+            "--internal" to 3,
+            "--iteration" to 4,
+            "--warmup" to 5
+        )
 
+        val action = additionalArguments.first()
+        if (action !in knownActions.keys)
+            throw NoSuchElementException("Action $action isn't found in the list of possible actions ${knownActions.keys}.")
+        require(knownActions[action] == additionalArguments.size)
+        when (action) {
+            "--list" -> outputBenchmarks(runnerConfiguration, benchmarks, start)
+            "--store-results" -> storeResults(benchmarks, complete)
+            "--internal" -> runBenchmark(benchmarks)
+            "--iteration" -> runBenchmarkIteration(benchmarks)
+            "--warmup" -> runBenchmarkWarmup(benchmarks)
         }
     }