Merge remote-tracking branch 'origin/master' into fzhinkin/kc-dev-rebase-jun-18

fzhinkin · fzhinkin · commit 8b5837505b94 · 2025-06-18T11:13:57.000-04:00
diff --git a/.teamcity/utils.kt b/.teamcity/utils.kt
@@ -12,17 +12,12 @@ const val releaseVersionParameter = "releaseVersion"
 const val libraryStagingRepoDescription = "kotlinx-benchmark"
 
 val platforms = Platform.values()
-const val jdk = "JDK_18_x64"
+const val jdk = "JDK_17_0"
 
 enum class Platform {
     Windows, Linux, MacOS;
 }
 
-fun Platform.nativeTaskPrefix(): String = when(this) {
-    Platform.Windows -> "mingwX64"
-    Platform.Linux -> "linuxX64"
-    Platform.MacOS -> "macosX64"
-}
 fun Platform.buildTypeName(): String = when (this) {
     Platform.Windows, Platform.Linux -> name
     Platform.MacOS -> "Mac OS X"
@@ -117,4 +112,4 @@ fun BuildType.dependsOnSnapshot(build: IdOwner, onFailure: FailureAction = Failu
             onDependencyCancel = FailureAction.CANCEL
         }
     }
-}
+}
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 0.4.14
+
+- Fixed various issues specific to Kotlin/JS projects [#292](https://github.com/Kotlin/kotlinx-benchmark/pull/292)
+- Added benchmark name validation for JVM [#304](https://github.com/Kotlin/kotlinx-benchmark/pull/304)
+- Various build infrastructure updates
+
 ## 0.4.13
 
 - Support Kotlin 2.0.0 and newer [#255](https://github.com/Kotlin/kotlinx-benchmark/pull/255)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -0,0 +1,46 @@
+# Contributing Guidelines
+
+One can contribute to the project by reporting issues or submitting changes via pull request.
+
+## Reporting issues
+
+Please use [GitHub issues](https://github.com/Kotlin/kotlinx-benchmark/issues) for filing feature requests and bug reports.
+
+Questions about usage and general inquiries are better suited for StackOverflow or the #benchmarks channel in KotlinLang Slack.
+
+## Submitting changes
+
+Submit pull requests [here](https://github.com/Kotlin/kotlinx-benchmark/pulls).
+However, please keep in mind that maintainers will have to support the resulting code of the project,
+so do familiarize yourself with the following guidelines.
+
+* All development (both new features and bug fixes) is performed in the `master` branch.
+    * Base your PRs against the `master` branch.
+* If you make any code changes:
+    * Follow the [Kotlin Coding Conventions](https://kotlinlang.org/docs/reference/coding-conventions.html).
+        * Use 4 spaces for indentation.
+        * Use imports with '*'.
+    * [Build the project](#building) to make sure it all works and passes the tests.
+* If you fix a bug:
+    * Write the test that reproduces the bug.
+        * Depending on a particular bug, it may require either a unit or an integration test. For the latter, please check [integration module](integration/src/test) for examples.
+    * Fixes without tests are accepted only in exceptional circumstances if it can be shown that writing the
+      corresponding test is too hard or otherwise impractical.
+    * Follow the style of writing tests that is used in this project:
+      name test functions as `testXxx`. Don't use backticks in test names.
+* Comment on the existing issue if you want to work on it. Ensure that the issue not only describes a problem, but also describes a solution that has received positive feedback. Propose a solution if none has been suggested.
+
+## Building
+
+This project is built with Gradle.
+
+* Run `./gradlew build` to build. It also runs all the tests.
+
+You can import this project into IDEA, but you have to delegate build actions
+to Gradle (in Preferences -> Build, Execution, Deployment -> Build Tools -> Gradle -> Build and run).
+
+### Updating the public API dump
+
+* Use the [Binary Compatibility Validator](https://github.com/Kotlin/binary-compatibility-validator/blob/master/README.md) for updates to public API:
+    * Run `./gradlew apiDump` to update API index files.
+    * Commit the updated API indexes together with other changes.
diff --git a/README.md b/README.md
@@ -59,7 +59,7 @@ dedicated to setting up benchmarking in those specific project types.
     ```kotlin
     // build.gradle.kts
     plugins {
-        id("org.jetbrains.kotlinx.benchmark") version "0.4.13"
+        id("org.jetbrains.kotlinx.benchmark") version "0.4.14"
     }
     ```
 
@@ -82,7 +82,7 @@ dedicated to setting up benchmarking in those specific project types.
         sourceSets {
             commonMain {
                 dependencies {
-                    implementation("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.13")
+                    implementation("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.14")
                 }
             }
         }
@@ -107,7 +107,7 @@ dedicated to setting up benchmarking in those specific project types.
     ```groovy
     // build.gradle
     plugins {
-        id 'org.jetbrains.kotlinx.benchmark' version '0.4.13'
+        id 'org.jetbrains.kotlinx.benchmark' version '0.4.14'
     }
     ```
 
@@ -130,7 +130,7 @@ dedicated to setting up benchmarking in those specific project types.
         sourceSets {
             commonMain {
                 dependencies {
-                    implementation 'org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.13'
+                    implementation 'org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.14'
                 }
             }
         }
diff --git a/docs/configuration-options.md b/docs/configuration-options.md
@@ -84,21 +84,29 @@ benchmark {
 - **"definedByJmh"** – Let JMH determine the amount, using the value in the [`@Fork` annotation](https://javadoc.io/doc/org.openjdk.jmh/jmh-core/latest/org/openjdk/jmh/annotations/Fork.html) for the benchmark function or its enclosing class. If not specified by `@Fork`, it defaults to [Defaults.MEASUREMENT_FORKS (`5`)](https://javadoc.io/doc/org.openjdk.jmh/jmh-core/latest/org/openjdk/jmh/runner/Defaults.html#MEASUREMENT_FORKS).
 
 The library offers the flexibility to specify the version of the Java Microbenchmark Harness (JMH) to use when running benchmarks on the JVM.
-The default version is set to `1.21`, but you can customize it while registering a JVM target for benchmarking:
+The default version is set to `1.37`, but you can customize it while registering a JVM target for benchmarking:
 
 ```kotlin
 benchmark {
     targets {
         register("jvmBenchmarks") {
             this as JvmBenchmarkTarget
-            jmhVersion = "1.36"
+            jmhVersion = "1.38"
         }
     }
 }
 ```
 
 Alternatively, you can utilize the project property `benchmarks_jmh_version` to achieve the same effect.
 
+> [!WARNING]
+> While it is possible to register multiple JVM benchmark targets with different JMH versions,
+> such configurations are not supported. Using such configurations may result in runtime errors.
+
+> [!NOTE]
+> It is recommended to change JMH version only when a new JMH version was released,
+> but `kotlinx-benchmark` plugin applied to a project is still using an older version.
+
 ### Kotlin/JS & Kotlin/Wasm
 | Option                                        | Description                                                                                           | Possible Values | Default Value |
 |-----------------------------------------------|-------------------------------------------------------------------------------------------------------|-----------------|---------------|
diff --git a/examples/java/build.gradle.kts b/examples/java/build.gradle.kts
@@ -25,7 +25,7 @@ benchmark {
     targets {
         register("main") {
             this as JvmBenchmarkTarget
-            jmhVersion = "1.21"
+            jmhVersion = "1.37"
         }
     }
 }
diff --git a/examples/kotlin-jvm-separate-benchmark-source-set/build.gradle.kts b/examples/kotlin-jvm-separate-benchmark-source-set/build.gradle.kts
@@ -43,7 +43,7 @@ benchmark {
     targets {
         register("benchmarks") {
             if (this is JvmBenchmarkTarget) {
-                jmhVersion = "1.21"
+                jmhVersion = "1.37"
             }
         }
     }
diff --git a/examples/kotlin-jvm/build.gradle.kts b/examples/kotlin-jvm/build.gradle.kts
@@ -36,9 +36,6 @@ benchmark {
         }
     }
     targets {
-        register("main") {
-            this as JvmBenchmarkTarget
-            jmhVersion = "1.21"
-        }
+        register("main")
     }
-}
+}
diff --git a/examples/kotlin-multiplatform/build.gradle b/examples/kotlin-multiplatform/build.gradle
@@ -103,12 +103,12 @@ benchmark {
         // This one matches target name, e.g. 'jvm', 'js',
         // and registers its 'main' compilation, so 'jvm' registers 'jvmMain'
         register("jvm") {
-            jmhVersion = "1.21"
+            jmhVersion = "1.37"
         }
         // This one matches source set name, e.g. 'jvmMain', 'jvmTest', etc
         // and register the corresponding compilation (here the 'benchmark' compilation declared in the 'jvm' target)
         register("jvmBenchmark") {
-            jmhVersion = "1.21"
+            jmhVersion = "1.37"
         }
         register("jsDefaultExecutor")
         register("jsBuiltInExecutor") {
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -6,7 +6,7 @@ kotlin-for-gradle-plugin = "2.0.20" # Kotlin 2.1 removes support for the used la
 kotlinx-binaryCompatibilityValidator = "0.16.2"
 kotlinx-teamInfra = "0.4.0-dev-85"
 squareup-kotlinpoet = "1.3.0"
-jmh = "1.21"
+jmh = "1.37"
 gradle-pluginPublish = "0.21.0"
 
 # Note: This version can be overridden by passing `-Pmin_supported_gradle_version=<version>`
diff --git a/integration/src/test/kotlin/kotlinx/benchmark/integration/BenchmarkFunctionNameValidationTest.kt b/integration/src/test/kotlin/kotlinx/benchmark/integration/BenchmarkFunctionNameValidationTest.kt
@@ -0,0 +1,26 @@
+package kotlinx.benchmark.integration
+
+import kotlin.test.*
+
+class BenchmarkFunctionNameValidationTest : GradleTest() {
+    @Test
+    fun jvmNamesValidations() {
+        project("funny-names").apply {
+            runAndFail("jvmBenchmarkCompile") {
+                assertOutputContains("One or more benchmark functions are invalid and could not be processed by JMH. See logs for details.")
+                assertOutputDoesNotContain("Group name should be the legal Java identifier")
+
+                assertOutputContains("""Benchmark function name is a reserved Java keyword and cannot be used: "test.CommonBenchmark.assert" (declared as "test.CommonBenchmark.assert")""")
+
+                assertOutputContains("""Benchmark function name is not a valid Java identifier: "test.BenchmarkBase.-illegal base name" (declared as "test.BenchmarkBase.base")""")
+                val firstOccurrence = output.indexOf(""""test.BenchmarkBase.-illegal base name"""")
+                assertEquals(-1, output.indexOf(""""test.BenchmarkBase.-illegal base name"""", firstOccurrence + 1),
+                    "\"test.BenchmarkBase.-illegal base name\" is expected to be reported only once")
+
+                assertOutputContains("""Benchmark function name is not a valid Java identifier: "test.CommonBenchmark.wrapString-gu_FwkY" (declared as "test.CommonBenchmark.wrapString")""")
+                assertOutputContains("""Benchmark function name is not a valid Java identifier: "test.CommonBenchmark.-explicitlyRenamed" (declared as "test.CommonBenchmark.explicitlyRenamed")""")
+                assertOutputContains("""Benchmark function name is not a valid Java identifier: "test.CommonBenchmark.backticked name" (declared as "test.CommonBenchmark.backticked name")""")
+            }
+        }
+    }
+}
diff --git a/integration/src/test/kotlin/kotlinx/benchmark/integration/ConfigurationCacheTest.kt b/integration/src/test/kotlin/kotlinx/benchmark/integration/ConfigurationCacheTest.kt
@@ -40,11 +40,10 @@ class ConfigurationCacheTest : GradleTest() {
     )
 
     @Test
-    @Ignore("https://youtrack.jetbrains.com/issue/KT-58250")
     fun testConfigurationCacheJs() = runConfigurationCacheTest(
         "kotlin-multiplatform",
-        listOf(":jsIrBenchmark"),
-        listOf(":compileKotlinJsIr", ":jsIrBenchmarkGenerate", ":compileJsIrBenchmarkProductionExecutableKotlinJsIr")
+        listOf(":jsBenchmark"),
+        listOf(":compileKotlinJs", ":jsBenchmarkGenerate", ":compileJsBenchmarkProductionExecutableKotlinJs")
     )
 
     @Test
@@ -55,11 +54,10 @@ class ConfigurationCacheTest : GradleTest() {
     )
 
     @Test
-    @Ignore("https://youtrack.jetbrains.com/issue/KT-58256")
     fun testConfigurationCacheWasm() = runConfigurationCacheTest(
         "kotlin-multiplatform",
         listOf(":wasmJsBenchmark"),
-        listOf(":compileKotlinWasmJs", ":wasmBenchmarkGenerate", ":compileWasmBenchmarkProductionExecutableKotlinWasmJs")
+        listOf(":compileKotlinWasmJs", ":wasmJsBenchmarkGenerate", ":compileWasmJsBenchmarkProductionExecutableKotlinWasmJs")
     )
 }
 
diff --git a/integration/src/test/kotlin/kotlinx/benchmark/integration/JmhVersionValidationTest.kt b/integration/src/test/kotlin/kotlinx/benchmark/integration/JmhVersionValidationTest.kt
@@ -0,0 +1,19 @@
+package kotlinx.benchmark.integration
+
+import kotlin.test.Test
+
+class JmhVersionValidationTest : GradleTest() {
+    @Test
+    fun verifyWarningsAboutJmhVersions() {
+        val runner = project("conflicting-jmh-versions", true) {}
+
+        runner.runAndSucceed("assembleBenchmarks") {
+            assertOutputContains("configures several JVM benchmarking targets that use different " +
+                    "JMH versions (1.21 is used by jvmFirst; 1.22 is used by jvmSecond, jvmThird). " +
+                    "Such configuration is not supported and may lead to runtime errors. " +
+                    "Consider using the same JMH version across all benchmarking targets.")
+            assertOutputContains("Configured JMH version (1.22) is older than a default version supplied by the benchmarking plugin")
+            assertOutputContains("Configured JMH version (1.21) is older than a default version supplied by the benchmarking plugin")
+        }
+    }
+}
diff --git a/integration/src/test/resources/templates/conflicting-jmh-versions/build.gradle b/integration/src/test/resources/templates/conflicting-jmh-versions/build.gradle
@@ -0,0 +1,15 @@
+kotlin {
+    jvm {
+        compilations.create('first') { associateWith(compilations.main) }
+        compilations.create('second') { associateWith(compilations.main) }
+        compilations.create('third') { associateWith(compilations.main) }
+    }
+}
+
+benchmark {
+    targets {
+        register("jvmFirst") { jmhVersion = "1.21" }
+        register("jvmSecond") { jmhVersion = "1.22" }
+        register("jvmThird") { jmhVersion = "1.22" }
+    }
+}
diff --git a/integration/src/test/resources/templates/conflicting-jmh-versions/gradle.properties b/integration/src/test/resources/templates/conflicting-jmh-versions/gradle.properties
@@ -0,0 +1 @@
+org.gradle.jvmargs=-Xmx2g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
diff --git a/integration/src/test/resources/templates/funny-names/build.gradle b/integration/src/test/resources/templates/funny-names/build.gradle
@@ -0,0 +1,9 @@
+kotlin {
+    jvm { }
+}
+
+benchmark {
+    targets {
+        register("jvm")
+    }
+}
diff --git a/integration/src/test/resources/templates/funny-names/gradle.properties b/integration/src/test/resources/templates/funny-names/gradle.properties
@@ -0,0 +1 @@
+org.gradle.jvmargs=-Xmx2g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
diff --git a/integration/src/test/resources/templates/funny-names/src/commonMain/kotlin/CommonBenchmark.kt b/integration/src/test/resources/templates/funny-names/src/commonMain/kotlin/CommonBenchmark.kt
@@ -0,0 +1,40 @@
+package test
+
+import kotlinx.benchmark.*
+import kotlin.jvm.*
+
+@JvmInline
+value class StringWrapper(val value: String)
+
+@State(Scope.Benchmark)
+@Measurement(iterations = 1, time = 1, timeUnit = BenchmarkTimeUnit.SECONDS)
+@Warmup(iterations = 1, time = 500, timeUnit = BenchmarkTimeUnit.MILLISECONDS)
+@OutputTimeUnit(BenchmarkTimeUnit.MILLISECONDS)
+@BenchmarkMode(Mode.Throughput)
+open class CommonBenchmark {
+    @Benchmark // will be wrapString-something on JVM
+    fun wrapString() = StringWrapper("Hello World!")
+
+    @Benchmark
+    @JvmName("-explicitlyRenamed")
+    fun explicitlyRenamed() = 0
+
+    @Benchmark
+    fun `backticked name`() = 0
+
+    @Benchmark
+    fun `assert`() = 0
+}
+
+abstract class BenchmarkBase {
+    @Benchmark
+    @JvmName("-illegal base name")
+    fun base() = 0
+}
+
+@State(Scope.Benchmark)
+@Measurement(iterations = 1, time = 1, timeUnit = BenchmarkTimeUnit.SECONDS)
+@Warmup(iterations = 1, time = 500, timeUnit = BenchmarkTimeUnit.MILLISECONDS)
+@OutputTimeUnit(BenchmarkTimeUnit.MILLISECONDS)
+@BenchmarkMode(Mode.Throughput)
+open class ConcreteBenchmark : BenchmarkBase()
diff --git a/plugin/build.gradle.kts b/plugin/build.gradle.kts
@@ -141,6 +141,9 @@ val generatePluginConstants by tasks.registering {
     val kotlinCompilerVersion = libs.versions.kotlin.asProvider()
     inputs.property("kotlinCompilerVersion", kotlinCompilerVersion)
 
+    val defaultJvmVersion = libs.versions.jmh
+    inputs.property("defaultJmhVersion", defaultJvmVersion)
+
     doLast {
         constantsKtFile.writeText(
                 """|package kotlinx.benchmark.gradle.internal
@@ -150,6 +153,7 @@ val generatePluginConstants by tasks.registering {
                 |  const val MIN_SUPPORTED_GRADLE_VERSION = "${minSupportedGradleVersion.get()}"
                 |  const val MIN_SUPPORTED_KOTLIN_VERSION = "${minSupportedKotlinVersion.get()}"
                 |  const val DEFAULT_KOTLIN_COMPILER_VERSION = "${kotlinCompilerVersion.get()}"
+                |  const val DEFAULT_JMH_VERSION = "${defaultJvmVersion.get()}"
                 |}
                 |""".trimMargin()
         )
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/BenchmarkConfiguration.kt b/plugin/main/src/kotlinx/benchmark/gradle/BenchmarkConfiguration.kt
@@ -1,5 +1,6 @@
 package kotlinx.benchmark.gradle
 
+import kotlinx.benchmark.gradle.internal.BenchmarksPluginConstants
 import kotlinx.benchmark.gradle.internal.KotlinxBenchmarkPluginInternalApi
 import org.gradle.api.tasks.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmCompilation
@@ -70,7 +71,8 @@ constructor(
     extension: BenchmarksExtension,
     name: String
 ) : BenchmarkTarget(extension, name) {
-    var jmhVersion: String = (extension.project.findProperty("benchmarks_jmh_version") as? String) ?: "1.21"
+    var jmhVersion: String = (extension.project.findProperty("benchmarks_jmh_version") as? String)
+        ?: BenchmarksPluginConstants.DEFAULT_JMH_VERSION
 }
 
 class JavaBenchmarkTarget
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/BenchmarksPlugin.kt b/plugin/main/src/kotlinx/benchmark/gradle/BenchmarksPlugin.kt
@@ -120,6 +120,7 @@ constructor(
                 is NativeBenchmarkTarget -> processNativeCompilation(config)
             }
         }
+        extension.checkConflictingJmhVersions()
     }
 
     private fun configureBenchmarkTaskConventions(
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/JmhBytecodeGeneratorWorker.kt b/plugin/main/src/kotlinx/benchmark/gradle/JmhBytecodeGeneratorWorker.kt
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/JsEngineExecTasks.kt b/plugin/main/src/kotlinx/benchmark/gradle/JsEngineExecTasks.kt
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/JvmJavaTasks.kt b/plugin/main/src/kotlinx/benchmark/gradle/JvmJavaTasks.kt
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/JvmMultiplatformTasks.kt b/plugin/main/src/kotlinx/benchmark/gradle/JvmMultiplatformTasks.kt
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/Utils.kt b/plugin/main/src/kotlinx/benchmark/gradle/Utils.kt

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ dedicated to setting up benchmarking in those specific project types.`
`59`	`59`	```kotlin
`60`	`60`	`// build.gradle.kts`
`61`	`61`	`plugins {`
`62`		`- id("org.jetbrains.kotlinx.benchmark") version "0.4.13"`
	`62`	`+ id("org.jetbrains.kotlinx.benchmark") version "0.4.14"`
`63`	`63`	`}`
`64`	`64`	```
`65`	`65`
`@@ -82,7 +82,7 @@ dedicated to setting up benchmarking in those specific project types.`
`82`	`82`	`sourceSets {`
`83`	`83`	`commonMain {`
`84`	`84`	`dependencies {`
`85`		`- implementation("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.13")`
	`85`	`+ implementation("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.14")`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`	`}`
`@@ -107,7 +107,7 @@ dedicated to setting up benchmarking in those specific project types.`
`107`	`107`	```groovy
`108`	`108`	`// build.gradle`
`109`	`109`	`plugins {`
`110`		`- id 'org.jetbrains.kotlinx.benchmark' version '0.4.13'`
	`110`	`+ id 'org.jetbrains.kotlinx.benchmark' version '0.4.14'`
`111`	`111`	`}`
`112`	`112`	```
`113`	`113`
`@@ -130,7 +130,7 @@ dedicated to setting up benchmarking in those specific project types.`
`130`	`130`	`sourceSets {`
`131`	`131`	`commonMain {`
`132`	`132`	`dependencies {`
`133`		`- implementation 'org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.13'`
	`133`	`+ implementation 'org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.14'`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ benchmark {`
`25`	`25`	`targets {`
`26`	`26`	`register("main") {`
`27`	`27`	`this as JvmBenchmarkTarget`
`28`		`- jmhVersion = "1.21"`
	`28`	`+ jmhVersion = "1.37"`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ benchmark {`
`43`	`43`	`targets {`
`44`	`44`	`register("benchmarks") {`
`45`	`45`	`if (this is JvmBenchmarkTarget) {`
`46`		`- jmhVersion = "1.21"`
	`46`	`+ jmhVersion = "1.37"`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,9 +36,6 @@ benchmark {`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`targets {`
`39`		`- register("main") {`
`40`		`- this as JvmBenchmarkTarget`
`41`		`- jmhVersion = "1.21"`
`42`		`- }`
	`39`	`+ register("main")`
`43`	`40`	`}`
`44`		`-}`
	`41`	`+}`