Detect benchmarks that return promise and handle them as deferred benchmarks

Author: qwwdfsad

examples/kotlin-multiplatform/src/jsMain/kotlin/JsAsyncBenchmarks.kt

@@ -0,0 +1,50 @@
+package test
+
+import org.jetbrains.gradle.benchmarks.*
+import kotlin.js.*
+import kotlin.math.*
+
+@State(Scope.Benchmark)
+class JsAsyncBenchmarks {
+
+    private var data = 0.0
+
+    @Setup
+    fun setUp() {
+        data = 42.0
+    }
+
+    @Benchmark
+    fun baseline(): Double {
+        // This benchmarks shows that benchmarks.js fails a baseline test :)
+        return data
+    }
+
+    @Benchmark
+    fun promiseResolve(): Promise<Double> {
+        return Promise.resolve(data)
+    }
+
+    @Benchmark
+    fun promiseResolveDoubleChain(): Promise<Double> {
+        return Promise.resolve(Unit).then { data }
+    }
+
+    @Benchmark
+    fun promiseResolveTripleChain(): Promise<Double> {
+        return Promise.resolve(Unit).then { Unit }.then { data }
+    }
+
+    @Benchmark
+    fun promiseDelayedBaseline(): Promise<Double> {
+        // Score of this benchmark cannot be greater than 10 ops/sec
+        return Promise { resolve, reject ->
+            setTimeout({
+                resolve(data)
+            }, 100)
+        }
+    }
+
+}
+
+private external fun setTimeout(handler: dynamic, timeout: Int = definedExternally): Int

plugin/main/src/org/jetbrains/gradle/benchmarks/SuiteSourceGenerator.kt

@@ -121,9 +121,10 @@ class SuiteSourceGenerator(val title: String, val module: ModuleDescriptor, val
                 function(addFunctionName) {
                     addParameter("suite", suiteType)
                     for (fn in benchmarkFunctions) {
+                        val returnsPromise = fn.returnsPromise()
                         val functionName = fn.name.toString()
                         addStatement(
-                            "suite.add(%P, _instance::%N, this::$setupFunctionName, this::$teardownFunctionName)",
+                            "suite.add(%P, _instance::%N, this::$setupFunctionName, this::$teardownFunctionName, $returnsPromise)",
                             "${originalClass.canonicalName}.$functionName",
                             functionName
                         )
@@ -136,6 +137,9 @@ class SuiteSourceGenerator(val title: String, val module: ModuleDescriptor, val
 
         file.writeTo(output)
     }
+
+    private fun FunctionDescriptor.returnsPromise() =
+        returnType?.constructor?.declarationDescriptor?.fqNameOrNull()?.asString() == "kotlin.js.Promise"
 }
 
 inline fun codeBlock(builderAction: CodeBlock.Builder.() -> Unit): CodeBlock {

runtime/jsMain/src/org/jetbrains/gradle/benchmarks/js/JsBenchmarkSuite.kt

@@ -2,12 +2,13 @@ package org.jetbrains.gradle.benchmarks.js
 
 import kotlinx.cli.*
 import org.jetbrains.gradle.benchmarks.*
+import kotlin.js.*
 import kotlin.math.*
 
 external fun require(module: String): dynamic
 private val benchmarkJs: dynamic = require("benchmark")
-private val fs = require("fs");
-private val process = require("process");
+private val fs = require("fs")
+private val process = require("process")
 
 class Suite(val title: String, @Suppress("UNUSED_PARAMETER") dummy_args: Array<out String>) {
     private val args = RunnerCommandLine().also { it.parse((process["argv"] as Array<String>).drop(2)) }
@@ -34,12 +35,26 @@ class Suite(val title: String, @Suppress("UNUSED_PARAMETER") dummy_args: Array<o
             }
             else -> throw UnsupportedOperationException("Format ${args.traceFormat} is not supported.")
         }
-        suite.run()
-        fs.writeFile(args.reportFile, results.toJson()) { err -> if (err) throw err }
+
+        suite.run().on("complete") {
+            fs.writeFile(args.reportFile, results.toJson()) { err -> if (err != null) throw err }
+        }
     }
 
-    fun add(name: String, function: () -> Any?, setup: () -> Unit, teardown: () -> Unit) {
-        suite.add(name, function)
+    fun add(name: String, function: () -> Any?, setup: () -> Unit, teardown: () -> Unit, isAsynchronous: Boolean = false) {
+        /*
+         * `isAsynchronous` is set to true iff benchmark return type is `Promise`.
+         * In that case, special treatment by benchmark.js is required
+         */
+        if (isAsynchronous) {
+            suite.add(name) { deferred: Promise<Unit> ->
+                // Mind asDynamic: this is **not** a regular promise
+                (function() as Promise<*>).then { (deferred.asDynamic()).resolve() }
+            }
+        } else {
+            suite.add(name, function)
+        }
+
         val benchmark = suite[suite.length - 1] // take back last added benchmark and subscribe to events
 
         // TODO: Configure properly
@@ -49,6 +64,8 @@ class Suite(val title: String, @Suppress("UNUSED_PARAMETER") dummy_args: Array<o
 
         benchmark.options.minTime = args.iterationTime / 1000.0
         benchmark.options.maxTime = args.iterationTime * args.iterations / 1000.0
+        benchmark.options.async = isAsynchronous
+        benchmark.options.defer = isAsynchronous
 
         benchmark.on("start") { event ->
             val benchmarkFQN = event.target.name
@@ -87,7 +104,6 @@ class Suite(val title: String, @Suppress("UNUSED_PARAMETER") dummy_args: Array<o
                 else -> throw UnsupportedOperationException("Format ${args.traceFormat} is not supported.")
             }
 
-
             results.add(result)
         }
     }