Handle benchmarks that return Promise as defer benchmark in JsBenchmarkSuite

Author: qwwdfsad

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

@@ -0,0 +1,49 @@
+package test
+
+import org.jetbrains.gradle.benchmarks.*
+import kotlin.js.*
+
+@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

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,27 @@ 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: () -> Promise<*>, setup: () -> Unit, teardown: () -> Unit) {
+        suite.add(name) { deferred: Promise<Unit> ->
+            // Mind asDynamic: this is **not** a regular promise
+            function().then { (deferred.asDynamic()).resolve() }
+        }
+
+        configureBenchmark(setup, teardown, isAsynchronous = true)
     }
 
     fun add(name: String, function: () -> Any?, setup: () -> Unit, teardown: () -> Unit) {
         suite.add(name, function)
+        configureBenchmark(setup, teardown, isAsynchronous = false)
+    }
+
+    private fun configureBenchmark(setup: () -> Unit, teardown: () -> Unit, isAsynchronous: Boolean) {
         val benchmark = suite[suite.length - 1] // take back last added benchmark and subscribe to events
 
         // TODO: Configure properly
@@ -49,6 +65,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 +105,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)
         }
     }