WIP added some actual benchmarks

Author: zach-klippenstein

benchmarks/compose-workflow/build.gradle.kts

@@ -1,7 +1,8 @@
 plugins {
-  id("com.android.library")
+  id("com.android.application")
   id("kotlin-android")
   id("android-defaults")
+  alias(libs.plugins.compose.compiler)
 }
 
 // Note: We are not including our defaults from .buildscript as we do not need the base Workflow
@@ -15,8 +16,7 @@ android {
 
   buildTypes {
     debug {
-      // TODO why isn't this available?
-      // isDebuggable = false
+      isDebuggable = false
     }
   }
 
@@ -30,4 +30,6 @@ dependencies {
   androidTestImplementation(libs.androidx.test.espresso.core)
   androidTestImplementation(libs.androidx.test.junit)
   androidTestImplementation(libs.androidx.test.uiautomator)
+  androidTestImplementation(libs.kotlin.test.jdk)
+  androidTestImplementation(libs.kotlinx.coroutines.test)
 }

benchmarks/compose-workflow/src/androidTest/java/com/squareup/benchmark/composeworkflow/benchmark/ComposeWorkflowMicroBenchmark.kt

@@ -1,20 +1,140 @@
+@file:OptIn(WorkflowExperimentalApi::class)
+
 package com.squareup.benchmark.composeworkflow.benchmark
 
 import androidx.benchmark.junit4.BenchmarkRule
 import androidx.benchmark.junit4.measureRepeated
+import androidx.compose.runtime.Composable
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.squareup.workflow1.RuntimeConfigOptions
+import com.squareup.workflow1.Workflow
+import com.squareup.workflow1.WorkflowExperimentalApi
+import com.squareup.workflow1.WorkflowExperimentalRuntime
+import com.squareup.workflow1.compose.ComposeWorkflow
+import com.squareup.workflow1.compose.composable
+import com.squareup.workflow1.compose.renderChild
+import com.squareup.workflow1.renderChild
+import com.squareup.workflow1.renderWorkflowIn
+import com.squareup.workflow1.stateless
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.job
+import kotlinx.coroutines.plus
+import kotlinx.coroutines.test.runTest
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import kotlin.test.assertEquals
 
+@OptIn(WorkflowExperimentalRuntime::class)
 @RunWith(AndroidJUnit4::class)
 class ComposeWorkflowMicroBenchmark {
 
   @get:Rule val benchmarkRule = BenchmarkRule()
 
-  @Test fun foo() {
+  @Test fun tradRoot_tradChildren_initialRender() {
+    benchmarkSimpleTreeInitialRender(
+      maxChildCount = 100,
+      composeRoot = false,
+      composeChildren = false
+    )
+  }
+
+  @Test fun tradRoot_composeChildren_initialRender() {
+    benchmarkSimpleTreeInitialRender(
+      maxChildCount = 100,
+      composeRoot = false,
+      composeChildren = true
+    )
+  }
+
+  @Test fun composeRoot_tradChildren_initialRender() {
+    benchmarkSimpleTreeInitialRender(
+      maxChildCount = 100,
+      composeRoot = true,
+      composeChildren = false
+    )
+  }
+
+  @Test fun composeRoot_composeChildren_initialRender() {
+    benchmarkSimpleTreeInitialRender(
+      maxChildCount = 100,
+      composeRoot = true,
+      composeChildren = true
+    )
+  }
+
+  private fun benchmarkSimpleTreeInitialRender(
+    maxChildCount: Int,
+    composeRoot: Boolean,
+    composeChildren: Boolean
+  ) = runTest {
+    val props =
+      MutableStateFlow(RootWorkflowProps(childCount = 0, composeChildren = composeChildren))
+    val workflowJob = Job(parent = coroutineContext.job)
+    val renderings = renderWorkflowIn(
+      workflow = if (composeRoot) {
+        composeSimpleRoot
+      } else {
+        traditionalSimpleRoot
+      },
+      props = props,
+      scope = this + workflowJob,
+      runtimeConfig = RuntimeConfigOptions.ALL,
+      onOutput = {}
+    )
+
     benchmarkRule.measureRepeated {
-      Thread.sleep(100)
+      runWithTimingDisabled {
+        props.value = RootWorkflowProps(childCount = 0, composeChildren = composeChildren)
+        testScheduler.runCurrent()
+        assertEquals(0, renderings.value.rendering)
+      }
+
+      props.value = RootWorkflowProps(childCount = maxChildCount, composeChildren = composeChildren)
+      testScheduler.runCurrent()
+      assertEquals(maxChildCount, renderings.value.rendering)
     }
+
+    workflowJob.cancel()
+  }
+}
+
+private data class RootWorkflowProps(
+  val childCount: Int,
+  val composeChildren: Boolean
+)
+
+private val traditionalSimpleRoot = Workflow.stateless<RootWorkflowProps, Nothing, Int> { props ->
+  var rendering = 0
+  repeat(props.childCount) { child ->
+    rendering += renderChild(
+      key = child.toString(),
+      child = if (props.composeChildren) {
+        composeSimpleLeaf
+      } else {
+        traditionalSimpleLeaf
+      }
+    )
   }
+  rendering
 }
+
+private val composeSimpleRoot = Workflow.composable<RootWorkflowProps, Nothing, Int> { props, _ ->
+  var rendering = 0
+  repeat(props.childCount) {
+    rendering += renderChild(
+      workflow = if (props.composeChildren) {
+        composeSimpleLeaf
+      } else {
+        traditionalSimpleLeaf
+      },
+      props = Unit,
+      onOutput = null
+    )
+  }
+  rendering
+}
+
+private val traditionalSimpleLeaf = Workflow.stateless<Unit, Nothing, Int> { 1 }
+private val composeSimpleLeaf = Workflow.composable<Unit, Nothing, Int> { _, _ -> 1 }

benchmarks/compose-workflow/src/main/AndroidManifest.xml

@@ -1,3 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+  <uses-permission
+      android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+      tools:ignore="ScopedStorage"/>
 </manifest>

workflow-core/src/commonMain/kotlin/com/squareup/workflow1/compose/ComposeWorkflow.kt

@@ -304,3 +304,17 @@ private fun <PropsT, OutputT, RenderingT> ChildWorkflowRecomposeIsolator(
 ) {
   renderingHolder.value = renderChild(workflow, props, onOutput)
 }
+
+@WorkflowExperimentalApi
+public inline fun <PropsT, OutputT, RenderingT> Workflow.Companion.composable(
+  crossinline produceRendering: @Composable (
+    props: PropsT,
+    emitOutput: (OutputT) -> Unit
+  ) -> RenderingT
+): Workflow<PropsT, OutputT, RenderingT> = object : ComposeWorkflow<PropsT, OutputT, RenderingT>() {
+  @Composable
+  override fun produceRendering(
+    props: PropsT,
+    emitOutput: (OutputT) -> Unit
+  ): RenderingT = produceRendering(props, emitOutput)
+}

workflow-runtime/src/commonMain/kotlin/com/squareup/workflow1/internal/compose/runtime/SynchronizedMolecule.kt

@@ -186,7 +186,15 @@ private class RealSynchronizedMolecule(
     } else {
       // Hard-code unchanging frame time since there's no actual frame time code shouldn't rely on
       // this value.
-      frameRequest.execute(0L)
+      val frameResult = frameRequest.execute(0L)
+
+      // If the composition threw an exception, re-throw it ourselves now instead of waiting for the
+      // scope to get it, since lastResult may have not been initialized in this case and we'd throw
+      // below and get supppressed.
+      frameResult.exceptionOrNull()?.let {
+        throw RuntimeException("ComposeWorkflow composition threw an exception", it)
+      }
+
       // If the composition threw an exception, we want it to cancel the coroutine scope before
       // getOrThrow below does so.
       dispatcher.advanceUntilIdle()
@@ -284,9 +292,10 @@ private class RealSynchronizedMolecule(
     private val onFrame: (frameTimeNanos: Long) -> R,
     private val continuation: CancellableContinuation<R>
   ) {
-    fun execute(frameTimeNanos: Long) {
+    fun execute(frameTimeNanos: Long): Result<R> {
       val frameResult = runCatching { onFrame(frameTimeNanos) }
       continuation.resumeWith(frameResult)
+      return frameResult
     }
   }
 }