Wasm implementation

Author: igoriakovlev

examples/kotlin-multiplatform/build.gradle

@@ -16,6 +16,7 @@ kotlin {
     jvm()
     js('jsIr', IR) { nodejs() }
     js { nodejs() }
+    wasm { d8() }
     if (HostManager.host == KonanTarget.MACOS_X64.INSTANCE) macosX64('native')
     if (HostManager.host == KonanTarget.MACOS_ARM64.INSTANCE) macosArm64('native')
     if (HostManager.hostIsLinux) linuxX64('native')
@@ -36,6 +37,8 @@ kotlin {
 
         jvmMain {}
 
+        wasmMain {}
+
         jsMain {
             jsIrMain.dependsOn(it)
         }
@@ -101,6 +104,7 @@ benchmark {
         }
         register("jsIr")
         register("js")
+        register("wasm")
         register("native")
     }
 }

examples/kotlin-multiplatform/src/wasmMain/kotlin/WasmTestBenchmark.kt

@@ -0,0 +1,26 @@
+package test
+
+import kotlinx.benchmark.*
+import kotlin.math.*
+
+@State(Scope.Benchmark)
+class WasmTestBenchmark {
+    private var data = 0.0
+
+    @Setup
+    fun setUp() {
+        data = 3.0
+    }
+
+    @Benchmark
+    fun sqrtBenchmark(): Double {
+        return sqrt(data)
+    }
+
+    @Benchmark
+    fun cosBenchmark(): Double {
+        return cos(data)
+    }
+}
+
+

integration/build.gradle.kts

@@ -54,6 +54,7 @@ val createClasspathManifest by tasks.registering {
     dependsOn(artifactsTask("jvm"))
     dependsOn(artifactsTask("jsIr"))
     dependsOn(artifactsTask("jsLegacy"))
+    dependsOn(artifactsTask("wasm"))
     dependsOn(artifactsTask("metadata"))
     dependsOn(artifactsTaskNativeKlibs())
 
@@ -67,6 +68,7 @@ val createClasspathManifest by tasks.registering {
             resolve("runtime-jvm.txt").writeText(artifactsTask("jvm").archiveFilePath)
             resolve("runtime-jsIr.txt").writeText(artifactsTask("jsIr").archiveFilePath)
             resolve("runtime-js.txt").writeText(artifactsTask("jsLegacy").archiveFilePath)
+            resolve("runtime-wasm.txt").writeText(artifactsTask("wasm").archiveFilePath)
             resolve("runtime-native.txt").writeText(artifactsTaskNativeKlibs().klibs())
         }
     }

integration/src/main/kotlin/kotlinx/benchmark/integration/ProjectBuilder.kt

@@ -37,12 +37,14 @@ private val buildScript = run {
     
     repositories {
         mavenCentral()
+        maven { url 'https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap' }
     }
     
     def benchmarkRuntimeMetadata = files(${readFileList("runtime-metadata.txt")})
     def benchmarkRuntimeJvm = files(${readFileList("runtime-jvm.txt")})
     def benchmarkRuntimeJsIr = files(${readFileList("runtime-jsIr.txt")})
     def benchmarkRuntimeJs = files(${readFileList("runtime-js.txt")})
+    def benchmarkRuntimeWasm = files(${readFileList("runtime-wasm.txt")})
     def benchmarkRuntimeNative = files(${readFileList("runtime-native.txt")})
     """.trimIndent()
 }

integration/src/test/kotlin/kotlinx/benchmark/integration/ReportFormatTest.kt

@@ -8,7 +8,7 @@ class ReportFormatTest : GradleTest() {
     @Test
     fun testReportFormatFileNames() {
         val formats = listOf(null, "json", "csv", "scsv", "text")
-        val targets = listOf("jsIr", "js", "jvm", "native")
+        val targets = listOf("jsIr", "js", "wasm", "jvm", "native")
 
         val runner = project("kotlin-multiplatform", true) {
             formats.forEach { format ->

integration/src/test/resources/templates/kotlin-multiplatform/build.gradle

@@ -5,6 +5,7 @@ kotlin {
     jvm()
     js('jsIr', IR) { nodejs() }
     js { nodejs() }
+    wasm { d8() }
 
     if (HostManager.hostIsLinux) linuxX64('native')
     if (HostManager.hostIsMingw) mingwX64('native')
@@ -32,6 +33,11 @@ kotlin {
                 implementation(benchmarkRuntimeJs)
             }
         }
+        wasmMain {
+            dependencies {
+                implementation(benchmarkRuntimeWasm)
+            }
+        }
         nativeMain {
             dependsOn(commonMain)
             dependencies {
@@ -46,6 +52,7 @@ benchmark {
         register("jvm")
         register("jsIr")
         register("js")
+        register("wasm")
         register("native")
     }
 }

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

@@ -2,6 +2,7 @@ package kotlinx.benchmark.gradle
 
 import org.gradle.api.tasks.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrCompilation
 
 open class BenchmarkConfiguration(val extension: BenchmarksExtension, val name: String) {
     var iterations: Int? = null
@@ -50,7 +51,7 @@ abstract class JvmBenchmarkTarget(
     extension: BenchmarksExtension,
     name: String
 ) : BenchmarkTarget(extension, name) {
-    var jmhVersion = (extension.project.findProperty("benchmarks_jmh_version") as? String) ?: "1.21"
+    var jmhVersion: String = (extension.project.findProperty("benchmarks_jmh_version") as? String) ?: "1.21"
 }
 
 class JavaBenchmarkTarget(
@@ -65,18 +66,27 @@ open class KotlinJvmBenchmarkTarget(
     val compilation: KotlinJvmCompilation
 ) : JvmBenchmarkTarget(extension, name)
 
+enum class JsBenchmarksExecutor {
+    BenchmarkJs,
+    BuiltIn
+}
+
 class JsBenchmarkTarget(
     extension: BenchmarksExtension,
     name: String,
     val compilation: KotlinJsCompilation
 ) : BenchmarkTarget(extension, name) {
-
+    var jsBenchmarksExecutor: JsBenchmarksExecutor = JsBenchmarksExecutor.BenchmarkJs
 }
 
+class WasmBenchmarkTarget(
+    extension: BenchmarksExtension,
+    name: String,
+    val compilation: KotlinJsIrCompilation
+) : BenchmarkTarget(extension, name)
+
 class NativeBenchmarkTarget(
     extension: BenchmarksExtension,
     name: String,
     val compilation: KotlinNativeCompilation
-) : BenchmarkTarget(extension, name) {
-
-}
+) : BenchmarkTarget(extension, name)

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

@@ -4,7 +4,9 @@ import groovy.lang.*
 import org.gradle.api.*
 import org.gradle.api.plugins.*
 import org.jetbrains.kotlin.gradle.dsl.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
+import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrCompilation
 
 fun Project.benchmark(configure: Action<BenchmarksExtension>) {
     configure.execute(extensions.getByType(BenchmarksExtension::class.java))
@@ -58,7 +60,12 @@ open class BenchmarksExtension(val project: Project) {
                             KotlinJvmBenchmarkTarget(this, name, compilation)
                         }
                         is KotlinJsCompilation -> {
-                            JsBenchmarkTarget(this, name, compilation)
+                            if (compilation.target.platformType != KotlinPlatformType.wasm) {
+                                JsBenchmarkTarget(this, name, compilation)
+                            } else {
+                                check(compilation is KotlinJsIrCompilation)
+                                WasmBenchmarkTarget(this, name, compilation)
+                            }
                         }
                         is KotlinNativeCompilation -> {
                             NativeBenchmarkTarget(this, name, compilation)

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

@@ -79,6 +79,7 @@ class BenchmarksPlugin : Plugin<Project> {
                 is JavaBenchmarkTarget -> processJavaSourceSet(config)
                 is KotlinJvmBenchmarkTarget -> processJvmCompilation(config)
                 is JsBenchmarkTarget -> processJsCompilation(config)
+                is WasmBenchmarkTarget -> processWasmCompilation(config)
                 is NativeBenchmarkTarget -> processNativeCompilation(config)
             }
         }

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

@@ -0,0 +1,68 @@
+package kotlinx.benchmark.gradle
+
+import java.io.ByteArrayOutputStream
+import java.io.FileOutputStream
+import java.io.OutputStream
+
+internal class ConsoleAndFilesOutputStream : OutputStream() {
+    private val buffer = ByteArrayOutputStream()
+    private var currentStream: OutputStream = System.out
+    private val fileTag = "<FILE:"
+    private val endFileTag = "<ENDFILE>"
+    private val openTag = '<'.toInt()
+    private val closeTag = '>'.toInt()
+    private var tagOpened = false
+
+    private fun processTag(tag: String) {
+        if (tag.startsWith(fileTag)) {
+            check(currentStream !is FileOutputStream) { "$endFileTag not found" }
+            val fileName = tag.substring(fileTag.length, tag.lastIndex)
+            currentStream = FileOutputStream(fileName)
+        } else if (tag == endFileTag) {
+            val currentFile = currentStream as? FileOutputStream
+            check(currentFile != null) { "$fileTag not found" }
+            currentFile.flush()
+            currentFile.close()
+            currentStream = System.out
+        } else {
+            buffer.writeTo(currentStream)
+        }
+        buffer.reset()
+    }
+
+    override fun write(b: Int) {
+        when (b) {
+            openTag -> {
+                buffer.writeTo(currentStream)
+                buffer.reset()
+                buffer.write(b)
+                tagOpened = true
+            }
+            closeTag -> {
+                if (tagOpened) {
+                    buffer.write(b)
+                    processTag(buffer.toString())
+                    tagOpened = false
+                } else {
+                    buffer.write(b)
+                }
+            }
+            else -> {
+                buffer.write(b)
+            }
+        }
+    }
+
+    override fun flush() {
+        buffer.flush()
+        buffer.writeTo(currentStream)
+        buffer.reset()
+        currentStream.flush()
+    }
+
+    override fun close() {
+        flush()
+        buffer.close()
+        currentStream.close()
+    }
+}