Merge pull request #118 from Kotlin/qurbonzoda/fix-build

Opt-in for ExperimentalNativeApi to fix aggregate build

Author: woainikk

gradle.properties

@@ -7,7 +7,6 @@ infra_version=0.3.0-dev-73
 kotlin.code.style=official
 kotlin.incremental.multiplatform=true
 kotlin.mpp.enableGranularSourceSetsMetadata=true
-kotlin.mpp.enableCompatibilityMetadataVariant=true
 kotlin.native.distribution.type=prebuilt
 
 org.gradle.jvmargs=-Xmx4g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

integration/build.gradle.kts

@@ -54,7 +54,7 @@ val createClasspathManifest by tasks.registering {
     dependsOn(artifactsTask("jvm"))
     dependsOn(artifactsTask("jsIr"))
     dependsOn(artifactsTask("wasm"))
-    dependsOn(artifactsTask("metadata"))
+    dependsOn(artifactsTask("allMetadata"))
     dependsOn(artifactsTaskNativeKlibs())
 
     val outputDir = file("$buildDir/$name")
@@ -63,7 +63,7 @@ val createClasspathManifest by tasks.registering {
         outputDir.apply {
             mkdirs()
             resolve("plugin-classpath.txt").writeText(plugin.classpath().resolve("plugin-classpath.txt").readText())
-            resolve("runtime-metadata.txt").writeText(artifactsTask("metadata").archiveFilePath)
+            resolve("runtime-metadata.txt").writeText(artifactsTask("allMetadata").archiveFilePath)
             resolve("runtime-jvm.txt").writeText(artifactsTask("jvm").archiveFilePath)
             resolve("runtime-jsIr.txt").writeText(artifactsTask("jsIr").archiveFilePath)
             resolve("runtime-wasm.txt").writeText(artifactsTask("wasm").archiveFilePath)

runtime/build.gradle

@@ -8,24 +8,40 @@ repositories {
 
 kotlin {
     infra {
-        target('linuxX64')
-        target('mingwX64')
+        // According to https://kotlinlang.org/docs/native-target-support.html
+
+        // Tier 1
+        target("linuxX64")
+
+        // Tier 2
+        target("linuxArm64")
+
+        // Tier 3
+        target("androidNativeArm32")
+        target("androidNativeArm64")
+        target("androidNativeX86")
+        target("androidNativeX64")
+        target("mingwX64")
 
         common("darwin") {
+            // Tier 1
             target("macosX64")
             target("macosArm64")
-            target("iosX64")
-            target("iosArm64")
-            target("iosArm32")
             target("iosSimulatorArm64")
+            target("iosX64")
+
+            // Tier 2
+            target("watchosSimulatorArm64")
+            target("watchosX64")
             target("watchosArm32")
             target("watchosArm64")
-            target("watchosX86")
-            target("watchosX64")
-            target("watchosSimulatorArm64")
-            target("tvosArm64")
-            target("tvosX64")
             target("tvosSimulatorArm64")
+            target("tvosX64")
+            target("tvosArm64")
+            target("iosArm64")
+
+            // Tier 3
+            target("watchosDeviceArm64")
         }
     }
 
@@ -38,6 +54,7 @@ kotlin {
         resources.srcDirs = ["$it.name/resources"]
         languageSettings {
             progressiveMode = true
+            optIn('kotlin.experimental.ExperimentalNativeApi')
             optIn("kotlinx.cinterop.ExperimentalForeignApi")
         }
     }

runtime/nativeMain/src/kotlinx/benchmark/native/NativeExecutor.kt

@@ -2,7 +2,7 @@ package kotlinx.benchmark.native
 
 import kotlinx.benchmark.*
 import kotlin.native.internal.GC
-import kotlin.system.*
+import kotlin.time.*
 
 class NativeExecutor(
     name: String,
@@ -218,25 +218,28 @@ class NativeExecutor(
         return getStackTrace().joinToString("\n") + "\nCause: ${nested.message}\n" + nested.stacktrace()
     }
 
+    @OptIn(ExperimentalTime::class)
     private inline fun measure(
         cycles: Int,
         nativeGCAfterIteration: Boolean,
         body: () -> Unit,
     ): Double {
-        var counter = cycles
         if (nativeGCAfterIteration)
             GC.collect()
-        val startTime = getTimeNanos()
-        while (counter-- > 0) {
-            body()
+
+        val duration = measureTime {
+            var counter = cycles
+            while (counter-- > 0) {
+                body()
+            }
+            if (nativeGCAfterIteration)
+                GC.collect()
         }
-        if (nativeGCAfterIteration)
-            GC.collect()
-        val endTime = getTimeNanos()
-        val time = endTime - startTime
-        return time.toDouble() / cycles
+
+        return duration.toDouble(DurationUnit.NANOSECONDS) / cycles
     }
 
+    @OptIn(ExperimentalTime::class)
     private inline fun <T> measureWarmup(
         name: String,
         config: BenchmarkConfiguration,
@@ -256,19 +259,18 @@ class NativeExecutor(
 
             if (config.nativeGCAfterIteration)
                 GC.collect()
-            val startTime = getTimeNanos()
-            var endTime = startTime
+            val startTime = TimeSource.Monotonic.markNow()
+            var duration = Duration.ZERO
             iterations = 0
-            while (endTime - startTime < benchmarkNanos) {
+            while (duration.inWholeNanoseconds < benchmarkNanos) {
                 body()
-                endTime = getTimeNanos()
+                duration = startTime.elapsedNow()
                 iterations++
             }
             if (config.nativeGCAfterIteration)
                 GC.collect()
 
-            val time = endTime - startTime
-            val metric = time.toDouble() / iterations // TODO: metric
+            val metric = duration.toDouble(DurationUnit.NANOSECONDS) / iterations // TODO: metric
             val sample = metric.nanosToText(config.mode, config.outputTimeUnit)
             val iterationNumber = currentIteration ?: iteration
             reporter.output(name, benchmark.name, "Warm-up #$iterationNumber: $sample")