Compose benchmarks that run in attended mode for comparison JVM and K/N (#3297)

1 year ago · 1346feea5a
17 changed files with 977 additions and 0 deletions
--- a/benchmarks/ios/jvm-vs-kotlin-native/.gitignore
+++ b/benchmarks/ios/jvm-vs-kotlin-native/.gitignore
@ -0,0 +1,5 @@
+local.properties
+build
+.gradle
+.idea
+.DS_Store
--- a/benchmarks/ios/jvm-vs-kotlin-native/README.md
+++ b/benchmarks/ios/jvm-vs-kotlin-native/README.md
@ -0,0 +1,8 @@
+# Compose benchmarks for JVM vs Kotlin Native comparison
+
+## Run Desktop
+- `./gradlew :run`
+
+## Run native on MacOS
+ - `./gradlew runReleaseExecutableMacosArm64` (Works on Arm64 processors)
+ - `./gradlew runReleaseExecutableMacosX64` (Works on Intel processors)
--- a/benchmarks/ios/jvm-vs-kotlin-native/build.gradle.kts
+++ b/benchmarks/ios/jvm-vs-kotlin-native/build.gradle.kts
@ -0,0 +1,83 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    kotlin("multiplatform")
+    id("org.jetbrains.compose")
+}
+
+version = "1.0-SNAPSHOT"
+
+repositories {
+    mavenLocal()
+    google()
+    mavenCentral()
+    maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
+}
+
+kotlin {
+    jvm("desktop")
+    macosX64 {
+        binaries {
+            executable {
+                entryPoint = "main"
+                freeCompilerArgs += listOf(
+                    "-linker-option", "-framework", "-linker-option", "Metal"
+                )
+            }
+        }
+    }
+    macosArm64 {
+        binaries {
+            executable {
+                entryPoint = "main"
+                freeCompilerArgs += listOf(
+                    "-linker-option", "-framework", "-linker-option", "Metal"
+                )
+            }
+        }
+    }
+
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                implementation(compose.ui)
+                implementation(compose.foundation)
+                implementation(compose.material)
+                implementation(compose.runtime)
+                @OptIn(org.jetbrains.compose.ExperimentalComposeLibrary::class)
+                implementation(compose.components.resources)
+            }
+        }
+
+        val desktopMain by getting {
+            dependencies {
+                implementation(compose.desktop.currentOs)
+                runtimeOnly("org.jetbrains.kotlinx:kotlinx-coroutines-swing:1.7.1")
+            }
+        }
+
+        val nativeMain by creating {
+            dependsOn(commonMain)
+        }
+        val macosMain by creating {
+            dependsOn(nativeMain)
+        }
+        val macosX64Main by getting {
+            dependsOn(macosMain)
+        }
+        val macosArm64Main by getting {
+            dependsOn(macosMain)
+        }
+    }
+}
+
+compose.desktop {
+    application {
+        mainClass = "Main_desktopKt"
+    }
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions.jvmTarget = "11"
+}
+
--- a/benchmarks/ios/jvm-vs-kotlin-native/gradle.properties
+++ b/benchmarks/ios/jvm-vs-kotlin-native/gradle.properties
@ -0,0 +1,17 @@
+compose.version=1.4.1
+kotlin.version=1.8.20
+agp.version=7.0.4
+org.gradle.jvmargs=-Xmx3g
+kotlin.code.style=official
+kotlin.native.cacheKind=none
+kotlin.native.useEmbeddableCompilerJar=true
+kotlin.native.enableDependencyPropagation=false
+kotlin.mpp.enableGranularSourceSetsMetadata=true
+# Enable kotlin/native experimental memory model
+kotlin.native.binary.memoryModel=experimental
+compose.desktop.verbose=true
+android.useAndroidX=true
+kotlin.js.webpack.major.version=4
+org.jetbrains.compose.experimental.jscanvas.enabled=true
+org.jetbrains.compose.experimental.macos.enabled=true
+org.jetbrains.compose.experimental.uikit.enabled=true
--- a/benchmarks/ios/jvm-vs-kotlin-native/gradle/wrapper/gradle-wrapper.jar
+++ b/benchmarks/ios/jvm-vs-kotlin-native/gradle/wrapper/gradle-wrapper.jar
--- a/benchmarks/ios/jvm-vs-kotlin-native/gradle/wrapper/gradle-wrapper.properties
+++ b/benchmarks/ios/jvm-vs-kotlin-native/gradle/wrapper/gradle-wrapper.properties
@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
--- a/benchmarks/ios/jvm-vs-kotlin-native/gradlew
+++ b/benchmarks/ios/jvm-vs-kotlin-native/gradlew
@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"
--- a/benchmarks/ios/jvm-vs-kotlin-native/gradlew.bat
+++ b/benchmarks/ios/jvm-vs-kotlin-native/gradlew.bat
@ -0,0 +1,91 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
--- a/benchmarks/ios/jvm-vs-kotlin-native/settings.gradle.kts
+++ b/benchmarks/ios/jvm-vs-kotlin-native/settings.gradle.kts
@ -0,0 +1,18 @@
+pluginManagement {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        gradlePluginPortal()
+        maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
+        google()
+    }
+
+    plugins {
+        val kotlinVersion = extra["kotlin.version"] as String
+        kotlin("multiplatform").version(kotlinVersion)
+        val composeVersion = extra["compose.version"] as String
+        id("org.jetbrains.compose").version(composeVersion)
+    }
+}
+
+rootProject.name = "compose-benchmarks"
--- a/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/Benchmarks.kt
+++ b/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/Benchmarks.kt
@ -0,0 +1,14 @@
+import androidx.compose.runtime.Composable
+import benchmarks.animation.AnimatedVisibility
+import benchmarks.lazygrid.LazyGrid
+import benchmarks.visualeffects.NYContent
+
+fun runBenchmark(name: String, frameCount: Int, content: @Composable () -> Unit) {
+    println("$name: " + measureComposable(frameCount, content))
+}
+
+fun runBenchmarks() {
+    runBenchmark("AnimatedVisibility", 1000000) { AnimatedVisibility() }
+    runBenchmark("LazyGrid",2000) { LazyGrid() }
+    runBenchmark("VisualEffects",1000) { NYContent() }
+}
--- a/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/MeasureComposable.kt
+++ b/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/MeasureComposable.kt
@ -0,0 +1,33 @@
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.ComposeScene
+import androidx.compose.ui.unit.Constraints
+import kotlin.time.Duration
+import kotlin.time.ExperimentalTime
+
+const val width = 640
+const val height = 480
+
+const val nanosPerSecond = 1E9.toLong()
+const val nanosPerFrame = (0.16 * nanosPerSecond).toLong()
+
+@OptIn(ExperimentalTime::class)
+fun measureComposable(
+    frameCount: Int = 1000,
+    content: @Composable () -> Unit
+): Duration {
+    val scene = ComposeScene()
+    try {
+        scene.setContent(content)
+        scene.constraints = Constraints.fixed(width, height)
+        val surface = org.jetbrains.skia.Surface.makeNull(width, height)
+        return kotlin.time.measureTime {
+            var nanoTime = 0L
+            repeat(frameCount) {
+                scene.render(surface.canvas, nanoTime)
+                nanoTime += nanosPerFrame
+            }
+        }
+    } finally {
+        scene.close()
+    }
+}
--- a/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/benchmarks/animation/AnimatedVisibility.kt
+++ b/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/benchmarks/animation/AnimatedVisibility.kt
@ -0,0 +1,38 @@
+package benchmarks.animation
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import kotlinx.coroutines.delay
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.painterResource
+
+@OptIn(ExperimentalResourceApi::class)
+@Composable
+fun AnimatedVisibility() {
+    MaterialTheme {
+        var showImage by remember { mutableStateOf(false) }
+        LaunchedEffect(showImage) {
+            delay(200)
+            showImage = !showImage
+        }
+        Column(Modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally) {
+            AnimatedVisibility(showImage) {
+                Image(
+                    painterResource("compose-multiplatform.xml"),
+                    null
+                )
+            }
+        }
+    }
+}
--- a/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/benchmarks/lazygrid/LazyGrid.kt
+++ b/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/benchmarks/lazygrid/LazyGrid.kt
@ -0,0 +1,106 @@
+package benchmarks.lazygrid
+
+import androidx.compose.foundation.gestures.scrollBy
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.foundation.lazy.grid.rememberLazyGridState
+import androidx.compose.material.Card
+import androidx.compose.material.Checkbox
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameMillis
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun LazyGrid() {
+    val itemCount = 12000
+    val entries = remember {List(itemCount) { Entry("$it") }}
+    val state = rememberLazyGridState()
+
+    var smoothScroll by remember { mutableStateOf(false)}
+
+    MaterialTheme {
+        Column {
+            Row {
+                Checkbox(
+                    checked = smoothScroll,
+                    onCheckedChange = { value -> smoothScroll = value}
+                )
+                Text (text = "Smooth scroll", modifier = Modifier.align(Alignment.CenterVertically))
+            }
+
+            LazyVerticalGrid(
+                columns = GridCells.Fixed(4),
+                modifier = Modifier.fillMaxWidth().semantics { contentDescription = "IamLazy" },
+                state = state
+            ) {
+                items(entries) {
+                    ListCell(it)
+                }
+            }
+        }
+
+    }
+
+    var curItem by remember { mutableStateOf(0) }
+    var direct by remember { mutableStateOf(true) }
+    if (smoothScroll) {
+        LaunchedEffect(Unit) {
+            while (smoothScroll) {
+                withFrameMillis { }
+                curItem = state.firstVisibleItemIndex
+                if (curItem == 0) direct = true
+                if (curItem > itemCount - 100) direct = false
+                state.scrollBy(if (direct) 5f else -5f)
+            }
+        }
+    } else {
+        LaunchedEffect(curItem) {
+            withFrameMillis { }
+            curItem += if (direct) 50 else -50
+            if (curItem >= itemCount) {
+                direct = false
+                curItem = itemCount - 1
+            } else if (curItem <= 0) {
+                direct = true
+                curItem = 0
+            }
+            state.scrollToItem(curItem)
+        }
+    }
+
+}
+
+data class Entry(val contents: String)
+
+@Composable
+private fun ListCell(entry: Entry) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(8.dp)
+    ) {
+        Text(
+            text = entry.contents,
+            textAlign = TextAlign.Center,
+            style = MaterialTheme.typography.h5,
+            modifier = Modifier.padding(16.dp)
+        )
+    }
+}
--- a/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/benchmarks/visualeffects/HappyNY.kt
+++ b/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/kotlin/benchmarks/visualeffects/HappyNY.kt
@ -0,0 +1,323 @@
+package benchmarks.visualeffects
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.Surface
+import androidx.compose.runtime.*
+import androidx.compose.runtime.snapshots.SnapshotStateList
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.*
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import height
+import width
+
+import kotlin.math.*
+import kotlin.random.Random
+
+const val snowCount = 80
+const val starCount = 60
+const val rocketPartsCount = 30
+
+data class SnowFlake(
+    var x: Dp,
+    var y: Dp,
+    val scale: Float,
+    var v: Double,
+    var alpha: Float,
+    var angle: Float,
+    var rotate: Int,
+    var phase: Double
+)
+
+data class Star(val x: Dp, val y: Dp, val color: Color, val size: Dp)
+
+val random = Random(123)
+
+fun random(): Float = random.nextFloat()
+
+class DoubleRocket(val particle: Particle) {
+    private val STATE_ROCKET = 0
+    private val STATE_SMALL_ROCKETS = 1
+    var state = STATE_ROCKET
+    var rockets: Array<Rocket> = emptyArray()
+    private fun checkState(time: Long) {
+        if (particle.vy > -3.0 && state == STATE_ROCKET) {
+            explode(time)
+        }
+        if (state == STATE_SMALL_ROCKETS) {
+            var done = true
+            rockets.forEach {
+                if (!it.exploded) {
+                    it.checkExplode(time)
+                }
+                if (!it.checkDone()) {
+                    done = false
+                }
+            }
+            if (done) {
+                reset()
+            }
+        }
+    }
+
+    private fun reset() {
+        state = STATE_ROCKET
+        particle.x = 0.0
+        particle.y = 1000.0
+        particle.vx = 2.1
+        particle.vy = -12.5
+    }
+
+    private fun explode(time: Long) {
+        val colors = arrayOf(Color(0xff, 0, 0), Color(192, 255, 192), Color(192, 212, 255))
+        rockets = Array(7) {
+            val v = 1.2f + 1.0 * random()
+            val angle = 2 * PI * random()
+            Rocket(
+                Particle(
+                    particle.x,
+                    particle.y,
+                    v * sin(angle) + particle.vx,
+                    v * cos(angle) + particle.vy - 0.5f,
+                    colors[it % colors.size]
+                ), colors[it % colors.size], time
+            )
+        }
+        state = STATE_SMALL_ROCKETS
+    }
+
+    fun move(time: Long, prevTime: Long) {
+        if (rocket.state == rocket.STATE_ROCKET) {
+            rocket.particle.move(time, prevTime)
+            rocket.particle.gravity(time, prevTime)
+        } else {
+            rocket.rockets.forEach {
+                it.move(time, prevTime)
+            }
+        }
+        rocket.checkState(time)
+    }
+
+    @Composable
+    fun draw() {
+        if (state == rocket.STATE_ROCKET) {
+            particle.draw()
+        } else {
+            rockets.forEach {
+                it.draw()
+            }
+        }
+    }
+
+}
+
+class Rocket(val particle: Particle, val color: Color, val startTime: Long = 0) {
+    var exploded = false
+    var parts: Array<Particle> = emptyArray()
+
+    fun checkExplode(time: Long) {
+        if (time - startTime > 1200000000) {
+            explode()
+        }
+    }
+
+    private fun explode() {
+        parts = Array(rocketPartsCount) {
+            val v = 0.5f + 1.5 * random()
+            val angle = 2 * PI * random()
+            Particle(particle.x, particle.y, v * sin(angle) + particle.vx, v * cos(angle) + particle.vy, color, 1)
+        }
+        exploded = true
+    }
+
+    fun checkDone(): Boolean {
+        if (!exploded) return false
+        parts.forEach {
+            if (it.y < 800) return false
+        }
+        return true
+    }
+
+    fun move(time: Long, prevTime: Long) {
+        if (!exploded) {
+            particle.move(time, prevTime)
+            particle.gravity(time, prevTime)
+            checkExplode(time)
+        } else {
+            parts.forEach {
+                it.move(time, prevTime)
+                it.gravity(time, prevTime)
+            }
+        }
+    }
+
+    @Composable
+    fun draw() {
+        if (!exploded) {
+            particle.draw()
+        } else {
+            parts.forEach {
+                it.draw()
+            }
+        }
+    }
+}
+
+class Particle(var x: Double, var y: Double, var vx: Double, var vy: Double, val color: Color, val type: Int = 0) {
+    fun move(time: Long, prevTime: Long) {
+        x = (x + vx * (time - prevTime) / 30000000)
+        y = (y + vy * (time - prevTime) / 30000000)
+    }
+
+    fun gravity(time: Long, prevTime: Long) {
+        vy = vy + 1.0f * (time - prevTime) / 300000000
+    }
+
+    @Composable
+    fun draw() {
+        val alphaFactor = if (type == 0) 1.0f else 1 / (1 + abs(vy / 5)).toFloat()
+        Box(Modifier.size(5.dp).offset(x.dp, y.dp).alpha(alphaFactor).clip(CircleShape).background(color))
+        for (i in 1..5) {
+            Box(
+                Modifier.size(4.dp).offset((x - vx / 2 * i).dp, (y - vy / 2 * i).dp)
+                    .alpha(alphaFactor * (1 - 0.18f * i)).clip(CircleShape).background(color)
+            )
+        }
+    }
+}
+
+val rocket = DoubleRocket(Particle(0.0, 1000.0, 2.1, -12.5, Color.White))
+
+fun prepareStarsAndSnowFlakes(stars: SnapshotStateList<Star>, snowFlakes: SnapshotStateList<SnowFlake>) {
+    for (i in 0..snowCount) {
+        snowFlakes.add(
+            SnowFlake(
+                (50 + (width - 50) * random()).dp,
+                (height * random()).dp,
+                0.1f + 0.2f * random(),
+                1.5 + 3 * random(),
+                (0.4f + 0.4 * random()).toFloat(),
+                60 * random(),
+                Random.nextInt(1, 5) - 3,
+                random() * 2 * PI
+            )
+        )
+    }
+    val colors = arrayOf(Color.Red, Color.Yellow, Color.Green, Color.Yellow, Color.Cyan, Color.Magenta, Color.White)
+    for (i in 0..starCount) {
+        stars.add(
+            Star(
+                (width * random()).dp,
+                (height * random()).dp,
+                colors[Random.nextInt(colors.size)],
+                (3 + 5 * random()).dp
+            )
+        )
+    }
+}
+
+@Composable
+fun NYContent() {
+    var time by remember { mutableStateOf(0L) }
+    val startTime = remember { 0L }
+    var prevTime by remember { mutableStateOf(0L) }
+    val snowFlakes = remember { mutableStateListOf<SnowFlake>() }
+    val stars = remember { mutableStateListOf<Star>() }
+    var flickering2 by remember { mutableStateOf(true) }
+    remember { prepareStarsAndSnowFlakes(stars, snowFlakes) }
+
+    Surface(
+        modifier = Modifier.fillMaxSize().padding(5.dp).shadow(3.dp, RoundedCornerShape(20.dp)),
+        color = Color.Black,
+        shape = RoundedCornerShape(20.dp)
+    ) {
+
+        LaunchedEffect(Unit) {
+            while (true) {
+                withFrameNanos {
+                    prevTime = time
+                    time = it
+                }
+            }
+        }
+
+        if (flickering2) {
+            if (time - startTime > 15500000000) { //note, that startTime has been updated above
+                flickering2 = false
+            }
+        }
+
+        rocket.move(time, prevTime)
+
+        Box(Modifier.fillMaxSize()) {
+
+            snow(time, prevTime, snowFlakes, startTime)
+
+            starrySky(stars)
+
+            rocket.draw()
+
+        }
+    }
+}
+
+
+@Composable
+fun starrySky(stars: SnapshotStateList<Star>) {
+    stars.forEach {
+        star(it.x, it.y, it.color, size = it.size)
+    }
+}
+
+@Composable
+fun star(x: Dp, y: Dp, color: Color = Color.White, size: Dp) {
+    Box(Modifier.offset(x, y).scale(1.0f, 0.2f).rotate(45f).size(size).background(color))
+    Box(Modifier.offset(x, y).scale(0.2f, 1.0f).rotate(45f).size(size).background(color))
+}
+
+@Composable
+fun snow(time: Long, prevTime: Long, snowFlakes: SnapshotStateList<SnowFlake>, startTime: Long) {
+    val deltaAngle = (time - startTime) / 100000000
+    with(LocalDensity.current) {
+        snowFlakes.forEach {
+            var y = it.y + ((it.v * (time - prevTime)) / 300000000).dp
+            if (y > (height + 20).dp) {
+                y = -20.dp
+            }
+            it.y = y
+            val x = it.x + (15 * sin(time.toDouble() / 3000000000 + it.phase)).dp
+            snowFlake(Modifier.offset(x, y).scale(it.scale).rotate(it.angle + deltaAngle * it.rotate), it.alpha)
+        }
+    }
+}
+
+@Composable
+fun snowFlake(modifier: Modifier, alpha: Float = 0.8f) {
+    Box(modifier) {
+        snowFlakeInt(0, 0f, 30.dp, 0.dp, alpha)
+        snowFlakeInt(0, 60f, 15.dp, 25.dp, alpha)
+        snowFlakeInt(0, 120f, -15.dp, 25.dp, alpha)
+        snowFlakeInt(0, 180f, -30.dp, 0.dp, alpha)
+        snowFlakeInt(0, 240f, -15.dp, -25.dp, alpha)
+        snowFlakeInt(0, 300f, 15.dp, -25.dp, alpha)
+    }
+
+}
+
+@Composable
+fun snowFlakeInt(level: Int, angle: Float, shiftX: Dp, shiftY: Dp, alpha: Float) {
+    if (level > 3) return
+    Box(
+        Modifier.offset(shiftX, shiftY).rotate(angle).width(100.dp).height(10.dp).scale(0.6f).alpha(1f)
+            .background(Color.White.copy(alpha = alpha))
+    ) {
+        snowFlakeInt(level + 1, 30f, 12.dp, 20.dp, alpha * 0.8f)
+        snowFlakeInt(level + 1, -30f, 12.dp, -20.dp, alpha * 0.8f)
+    }
+}
+
--- a/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/resources/compose-multiplatform.xml
+++ b/benchmarks/ios/jvm-vs-kotlin-native/src/commonMain/resources/compose-multiplatform.xml
@ -0,0 +1,36 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="600dp"
+    android:height="600dp"
+    android:viewportWidth="600"
+    android:viewportHeight="600">
+  <path
+      android:pathData="M301.21,418.53C300.97,418.54 300.73,418.56 300.49,418.56C297.09,418.59 293.74,417.72 290.79,416.05L222.6,377.54C220.63,376.43 219,374.82 217.85,372.88C216.7,370.94 216.09,368.73 216.07,366.47L216.07,288.16C216.06,287.32 216.09,286.49 216.17,285.67C216.38,283.54 216.91,281.5 217.71,279.6L199.29,268.27L177.74,256.19C175.72,260.43 174.73,265.23 174.78,270.22L174.79,387.05C174.85,393.89 178.57,400.2 184.53,403.56L286.26,461.02C290.67,463.51 295.66,464.8 300.73,464.76C300.91,464.76 301.09,464.74 301.27,464.74C301.24,449.84 301.22,439.23 301.22,439.23L301.21,418.53Z"
+      android:fillColor="#041619"
+      android:fillType="nonZero"/>
+  <path
+      android:pathData="M409.45,242.91L312.64,188.23C303.64,183.15 292.58,183.26 283.68,188.51L187.92,245C183.31,247.73 179.93,251.62 177.75,256.17L177.74,256.19L199.29,268.27L217.71,279.6C217.83,279.32 217.92,279.02 218.05,278.74C218.24,278.36 218.43,277.98 218.64,277.62C219.06,276.88 219.52,276.18 220.04,275.51C221.37,273.8 223.01,272.35 224.87,271.25L289.06,233.39C290.42,232.59 291.87,231.96 293.39,231.51C295.53,230.87 297.77,230.6 300,230.72C302.98,230.88 305.88,231.73 308.47,233.2L373.37,269.85C375.54,271.08 377.49,272.68 379.13,274.57C379.68,275.19 380.18,275.85 380.65,276.53C380.86,276.84 381.05,277.15 381.24,277.47L397.79,266.39L420.34,252.93L420.31,252.88C417.55,248.8 413.77,245.35 409.45,242.91Z"
+      android:fillColor="#37BF6E"
+      android:fillType="nonZero"/>
+  <path
+      android:pathData="M381.24,277.47C381.51,277.92 381.77,278.38 382.01,278.84C382.21,279.24 382.39,279.65 382.57,280.06C382.91,280.88 383.19,281.73 383.41,282.59C383.74,283.88 383.92,285.21 383.93,286.57L383.93,361.1C383.96,363.95 383.35,366.77 382.16,369.36C381.93,369.86 381.69,370.35 381.42,370.83C379.75,373.79 377.32,376.27 374.39,378L310.2,415.87C307.47,417.48 304.38,418.39 301.21,418.53L301.22,439.23C301.22,439.23 301.24,449.84 301.27,464.74C306.1,464.61 310.91,463.3 315.21,460.75L410.98,404.25C419.88,399 425.31,389.37 425.22,379.03L425.22,267.85C425.17,262.48 423.34,257.34 420.34,252.93L397.79,266.39L381.24,277.47Z"
+      android:fillColor="#3870B2"
+      android:fillType="nonZero"/>
+  <path
+      android:pathData="M177.75,256.17C179.93,251.62 183.31,247.73 187.92,245L283.68,188.51C292.58,183.26 303.64,183.15 312.64,188.23L409.45,242.91C413.77,245.35 417.55,248.8 420.31,252.88L420.34,252.93L498.59,206.19C494.03,199.46 487.79,193.78 480.67,189.75L320.86,99.49C306.01,91.1 287.75,91.27 273.07,99.95L114.99,193.2C107.39,197.69 101.81,204.11 98.21,211.63L177.74,256.19L177.75,256.17ZM301.27,464.74C301.09,464.74 300.91,464.76 300.73,464.76C295.66,464.8 290.67,463.51 286.26,461.02L184.53,403.56C178.57,400.2 174.85,393.89 174.79,387.05L174.78,270.22C174.73,265.23 175.72,260.43 177.74,256.19L98.21,211.63C94.86,218.63 93.23,226.58 93.31,234.82L93.31,427.67C93.42,438.97 99.54,449.37 109.4,454.92L277.31,549.77C284.6,553.88 292.84,556.01 301.2,555.94L301.2,555.8C301.39,543.78 301.33,495.26 301.27,464.74Z"
+      android:strokeWidth="10"
+      android:fillColor="#00000000"
+      android:strokeColor="#083042"
+      android:fillType="nonZero"/>
+  <path
+      android:pathData="M498.59,206.19L420.34,252.93C423.34,257.34 425.17,262.48 425.22,267.85L425.22,379.03C425.31,389.37 419.88,399 410.98,404.25L315.21,460.75C310.91,463.3 306.1,464.61 301.27,464.74C301.33,495.26 301.39,543.78 301.2,555.8L301.2,555.94C309.48,555.87 317.74,553.68 325.11,549.32L483.18,456.06C497.87,447.39 506.85,431.49 506.69,414.43L506.69,230.91C506.6,222.02 503.57,213.5 498.59,206.19Z"
+      android:strokeWidth="10"
+      android:fillColor="#00000000"
+      android:strokeColor="#083042"
+      android:fillType="nonZero"/>
+  <path
+      android:pathData="M301.2,555.94C292.84,556.01 284.6,553.88 277.31,549.76L109.4,454.92C99.54,449.37 93.42,438.97 93.31,427.67L93.31,234.82C93.23,226.58 94.86,218.63 98.21,211.63C101.81,204.11 107.39,197.69 114.99,193.2L273.07,99.95C287.75,91.27 306.01,91.1 320.86,99.49L480.67,189.75C487.79,193.78 494.03,199.46 498.59,206.19C503.57,213.5 506.6,222.02 506.69,230.91L506.69,414.43C506.85,431.49 497.87,447.39 483.18,456.06L325.11,549.32C317.74,553.68 309.48,555.87 301.2,555.94Z"
+      android:strokeWidth="10"
+      android:fillColor="#00000000"
+      android:strokeColor="#083042"
+      android:fillType="nonZero"/>
+</vector>
--- a/benchmarks/ios/jvm-vs-kotlin-native/src/desktopMain/kotlin/main.desktop.kt
+++ b/benchmarks/ios/jvm-vs-kotlin-native/src/desktopMain/kotlin/main.desktop.kt
@ -0,0 +1,9 @@
+/*
+ * Copyright 2020-2021 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+
+fun main() = runBlocking(Dispatchers.Main) { runBenchmarks() }
--- a/benchmarks/ios/jvm-vs-kotlin-native/src/macosMain/kotlin/main.macos.kt
+++ b/benchmarks/ios/jvm-vs-kotlin-native/src/macosMain/kotlin/main.macos.kt
@ -0,0 +1,6 @@
+/*
+ * Copyright 2020-2021 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+fun main() = runBenchmarks()