refactoring + removing binaryen gufa flag for now

alex28sh · alex28sh · commit 0fdf2ac38d41 · 2026-03-06T10:17:32.000+01:00
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -109,6 +109,8 @@ tasks.withType<org.jetbrains.kotlin.gradle.targets.wasm.d8.D8Exec>().configureEa
 }
 
 tasks.withType<org.jetbrains.kotlin.gradle.targets.wasm.binaryen.BinaryenExec>().configureEach {
+    val filteredArgs = binaryenArgs.filter { it != "--gufa" }
+    binaryenArgs = filteredArgs.toMutableList()
     binaryenArgs.add("--enable-stack-switching")
     binaryenArgs.add("--enable-multivalue")
 }
diff --git a/src/commonMain/kotlin/macroBenchmarks/MacroBenchmarks.kt b/src/commonMain/kotlin/macroBenchmarks/MacroBenchmarks.kt
@@ -17,8 +17,7 @@
 package macroBenchmarks
 
 import kotlinx.benchmark.*
-import macroBenchmarks.coroutinesFastBenchmarks.SharedFlowBaseline
-import macroBenchmarks.coroutinesFastBenchmarks.SimpleChannelBenchmark
+import macroBenchmarks.coroutinesSlowBenchmarks.Coroutines
 
 open class MacroBenchmarksBase {
     protected fun runBenchmark(macroBenchmark: MacroBenchmark) {
@@ -102,24 +101,4 @@ class MacroBenchmarksFast : MacroBenchmarksBase() {
     fun towers() {
         runBenchmark(Towers())
     }
-
-    @Benchmark
-    fun cancellableChannelBenchmark() {
-        runBenchmark(SimpleChannelBenchmark.CancellableChannelBenchmark())
-    }
-
-    @Benchmark
-    fun cancellableReusableChannelBenchmark() {
-        runBenchmark(SimpleChannelBenchmark.CancellableReusableChannelBenchmark())
-    }
-
-    @Benchmark
-    fun nonCancellableChannelBenchmark() {
-        runBenchmark(SimpleChannelBenchmark.NonCancellableChannelBenchmark())
-    }
-
-    @Benchmark
-    fun sharedFlowBaseline() {
-        runBenchmark(SharedFlowBaseline())
-    }
 }
diff --git a/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/Coroutines.kt b/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/Coroutines.kt
@@ -1,5 +1,6 @@
-package macroBenchmarks
+package macroBenchmarks.coroutinesSlowBenchmarks
 
+import macroBenchmarks.MacroBenchmark
 import macroBenchmarks.coroutines.AbstractGenerator
 import macroBenchmarks.coroutines.ClosedRangeGenerator
 import macroBenchmarks.coroutines.CoroutineStub
diff --git a/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/LaunchBenchmark.kt b/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/LaunchBenchmark.kt
@@ -7,6 +7,13 @@ import macroBenchmarks.coroutines.ParametrizedDispatcherBase
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.startCoroutine
 
+/*
+ * Adapted benchmark from kotlinx.coroutines
+ * https://github.com/Kotlin/kotlinx.coroutines/blob/master/benchmarks/src/jmh/kotlin/benchmarks/scheduler/LaunchBenchmark.kt
+ * Probably, no need of FJP-like adaptation, cause in K/Wasm no multithreading?
+ *
+ * Used CyclicBarrier from arrow-kt as an alternative to java CyclicBarrier
+ */
 @State(Scope.Benchmark)
 open class LaunchBenchmark : ParametrizedDispatcherBase() {
 
diff --git a/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/SelectBenchmark.kt b/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/SelectBenchmark.kt
@@ -9,6 +9,10 @@ import kotlinx.benchmark.*
 import macroBenchmarks.coroutines.ParametrizedDispatcherBase
 import kotlin.concurrent.Volatile
 
+/*
+ * Adapted benchmark from kotlinx.coroutines
+ * https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/benchmarks/jvm/kotlin/kotlinx/coroutines/channels/SelectBenchmark.kt
+ */
 @State(Scope.Benchmark)
 open class SelectBenchmark: ParametrizedDispatcherBase() {
     // 450
diff --git a/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/SemaphoreBenchmark.kt b/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/SemaphoreBenchmark.kt
@@ -17,18 +17,22 @@ private fun doGeomDistrWork(work: Int) {
     // are distributed geometrically, see https://github.com/Kotlin/kotlinx.coroutines/pull/1464#discussion_r355705325
     val p = 1.0 / work
 
-//    used to have ThreadLocal to avoid contention, but there is no multithreading in K/Wasm?
+//    Used to have ThreadLocal to avoid contention, but there is no multithreading in K/Wasm?
 //    val r = ThreadLocalRandom.current()
     val r = Random
     while (true) {
         if (r.nextDouble() < p) break
     }
 }
 
+/*
+ * Adapted benchmark from kotlinx.coroutines
+ * https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/benchmarks/jvm/kotlin/kotlinx/coroutines/SemaphoreBenchmark.kt
+ */
 @State(Scope.Benchmark)
 open class SemaphoreBenchmark: ParametrizedDispatcherBase() {
 
-    // with params both stack-switching and non-stack-switching versions fail
+// With params both stack-switching and non-stack-switching versions fail
 //    @Param("0", "1000")
     var coroutines: Int = 1000
 
diff --git a/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/SharedFlowBaseline.kt b/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/SharedFlowBaseline.kt
@@ -1,20 +1,24 @@
-package macroBenchmarks.coroutinesFastBenchmarks
+package macroBenchmarks.coroutinesSlowBenchmarks
 
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.launch
-import macroBenchmarks.coroutines.ParametrizedDispatcherBaseSlow
+import macroBenchmarks.coroutines.ParametrizedDispatcherBase
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.startCoroutine
+import kotlinx.benchmark.*
 
-// Stresses out 'synchronized' codepath in MutableSharedFlow
-open class SharedFlowBaseline : ParametrizedDispatcherBaseSlow() {
+/* Adapted benchmark from kotlinx.coroutines
+ * https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/benchmarks/main/kotlin/SharedFlowBaseline.kt
+ * Stresses out 'synchronized' codepath in MutableSharedFlow
+ */
+@State(Scope.Benchmark)
+open class SharedFlowBaseline : ParametrizedDispatcherBase() {
 
     private var size: Int = 10_000
 
-    override fun verifyResult(result: Any) = (result is Int) && result == size * (size - 1) / 2
-
-    override fun benchmark(): Any {
+    @Benchmark
+    fun baseline() {
         var sum = 0
         var done = false
         suspend {
@@ -27,6 +31,6 @@ open class SharedFlowBaseline : ParametrizedDispatcherBaseSlow() {
         }.startCoroutine(Continuation(coroutineContext) { it.getOrThrow() })
         coroutineContext.drain()
         check(done) { "benchmark did not complete" }
-        return sum
+        check(sum == size * (size - 1) / 2) { "benchmark did not complete $sum" }
     }
-}
+}
diff --git a/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/SimpleChannelBenchmark.kt b/src/commonMain/kotlin/macroBenchmarks/coroutinesSlowBenchmarks/SimpleChannelBenchmark.kt
@@ -1,4 +1,4 @@
-package macroBenchmarks.coroutinesFastBenchmarks
+package macroBenchmarks.coroutinesSlowBenchmarks
 
 import kotlinx.coroutines.launch
 import macroBenchmarks.coroutines.CancellableChannel
@@ -9,9 +9,13 @@ import macroBenchmarks.coroutines.SimpleChannel
 import kotlin.concurrent.Volatile
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.startCoroutine
+import kotlinx.benchmark.*
 
-// Stresses out 'synchronized' codepath in MutableSharedFlow
-sealed class SimpleChannelBenchmark : ParametrizedDispatcherBaseSlow() {
+/*
+ * Adapted benchmark from kotlinx.coroutines
+ * https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/benchmarks/jvm/kotlin/kotlinx/coroutines/channels/SimpleChannelBenchmark.kt
+ */
+abstract class SimpleChannelBenchmark : ParametrizedDispatcherBaseSlow() {
 
     private val iterations = 10_000
     protected abstract fun makeChannel(): SimpleChannel
@@ -39,16 +43,28 @@ sealed class SimpleChannelBenchmark : ParametrizedDispatcherBaseSlow() {
         check(done) { "benchmark did not complete" }
         return sink
     }
+}
 
-    class CancellableChannelBenchmark: SimpleChannelBenchmark() {
-        override fun makeChannel() = CancellableChannel()
-    }
+@State(Scope.Benchmark)
+class CancellableChannelBenchmark: SimpleChannelBenchmark() {
+    override fun makeChannel() = CancellableChannel()
 
-    class CancellableReusableChannelBenchmark: SimpleChannelBenchmark() {
-        override fun makeChannel() = CancellableReusableChannel()
-    }
+    @Benchmark
+    fun cancellable() = benchmark()
+}
 
-    class NonCancellableChannelBenchmark: SimpleChannelBenchmark() {
-        override fun makeChannel() = NonCancellableChannel()
-    }
+@State(Scope.Benchmark)
+class CancellableReusableChannelBenchmark: SimpleChannelBenchmark() {
+    override fun makeChannel() = CancellableReusableChannel()
+
+    @Benchmark
+    fun cancellableReusable() = benchmark()
 }
+
+@State(Scope.Benchmark)
+class NonCancellableChannelBenchmark: SimpleChannelBenchmark() {
+    override fun makeChannel() = NonCancellableChannel()
+
+    @Benchmark
+    fun nonCancellable() = benchmark()
+}

Original file line number	Diff line number	Diff line change
`@@ -109,6 +109,8 @@ tasks.withType<org.jetbrains.kotlin.gradle.targets.wasm.d8.D8Exec>().configureEa`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`tasks.withType<org.jetbrains.kotlin.gradle.targets.wasm.binaryen.BinaryenExec>().configureEach {`
	`112`	`+ val filteredArgs = binaryenArgs.filter { it != "--gufa" }`
	`113`	`+ binaryenArgs = filteredArgs.toMutableList()`
`112`	`114`	`binaryenArgs.add("--enable-stack-switching")`
`113`	`115`	`binaryenArgs.add("--enable-multivalue")`
`114`	`116`	`}`