[Gradle] Add Gradle & task property to set compiler execution strategy

#KT-49299 Fixed
2021-10-14 20:23:57 +03:00
parent b4cb7f3610
commit e9c8135dfa
11 changed files with 137 additions and 54 deletions
@@ -7,8 +7,48 @@ package org.jetbrains.kotlin.gradle.tasks

 import org.gradle.api.Task
 import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Internal

+enum class KotlinCompilerExecutionStrategy(
+    /**
+     * Value that should be passed for `kotlin.compiler.execution.strategy` Gradle or system property to choose the strategy
+     */
+    val propertyValue: String
+) {
+    /**
+     * Execute Kotlin compiler in its own daemon. Default strategy.
+     *
+     * Daemon may be shared across multiple compile tasks if it's considered compatible
+     */
+    DAEMON("daemon"),
+
+    /**
+     * Execute Kotlin compiler inside the Gradle process
+     *
+     * Note: currently this strategy doesn't support incremental compilation
+     */
+    IN_PROCESS("in-process"),
+
+    /**
+     * Execute Kotlin compiler in a new forked process for each compilation
+     *
+     * Note: currently this strategy doesn't support incremental compilation
+     */
+    OUT_OF_PROCESS("out-of-process"),
+    ;
+
+    companion object {
+        fun fromProperty(value: String?) =
+            if (value == null) {
+                DAEMON
+            } else {
+                values().find { it.propertyValue.equals(value, ignoreCase = true) }
+                    ?: error("Unknown value '$value' is passed for Kotlin compiler execution strategy")
+            }
+    }
+}
+
 /**
 * Task is using Kotlin daemon to run compilation.
 */
@@ -18,4 +58,10 @@ interface CompileUsingKotlinDaemon : Task {
     */
    @get:Internal
    val kotlinDaemonJvmArguments: ListProperty<String>
+
+    /**
+     * Defines compiler execution strategy, see docs for [KotlinCompilerExecutionStrategy] for more details
+     */
+    @get:Internal
+    val compilerExecutionStrategy: Property<KotlinCompilerExecutionStrategy>
 }
@@ -1,5 +1,6 @@
 package org.jetbrains.kotlin.gradle

+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.util.checkedReplace
 import org.jetbrains.kotlin.gradle.util.getFileByName
 import org.jetbrains.kotlin.gradle.util.modify
@@ -45,46 +46,67 @@ class ExecutionStrategyJvmIT : ExecutionStrategyIT() {
 abstract class ExecutionStrategyIT : BaseGradleIT() {
    @Test
    fun testDaemon() {
-        doTestExecutionStrategy("daemon", addHeapDumpOptions = false)
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.DAEMON, addHeapDumpOptions = false)
+    }
+
+    @Test
+    fun testDaemonViaSystemProperty() {
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.DAEMON, addHeapDumpOptions = false, viaSystemProperty = true)
    }

    @Test
    fun testInProcess() {
-        doTestExecutionStrategy("in-process")
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.IN_PROCESS)
+    }
+
+    @Test
+    fun testInProcessViaSystemProperty() {
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.IN_PROCESS, viaSystemProperty = true)
    }

    @Test
    fun testOutOfProcess() {
-        doTestExecutionStrategy("out-of-process")
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.OUT_OF_PROCESS)
    }

-    private fun doTestExecutionStrategy(executionStrategy: String, addHeapDumpOptions: Boolean = true) {
-        val project = Project("kotlinBuiltins", addHeapDumpOptions = addHeapDumpOptions)
-        setupProject(project)
+    @Test
+    fun testOutOfProcessViaSystemProperty() {
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.OUT_OF_PROCESS, viaSystemProperty = true)
+    }

-        val strategyCLIArg = "-Dkotlin.compiler.execution.strategy=$executionStrategy"
-        val finishMessage = "Finished executing kotlin compiler using $executionStrategy strategy"
+    private fun doTestExecutionStrategy(
+        executionStrategy: KotlinCompilerExecutionStrategy,
+        addHeapDumpOptions: Boolean = true,
+        viaSystemProperty: Boolean = false
+    ) {
+        with(Project("kotlinBuiltins", addHeapDumpOptions = addHeapDumpOptions)) {
+            setupProject(this)

-        project.build("build", strategyCLIArg) {
-            assertSuccessful()
-            assertContains(finishMessage)
-            checkOutput()
-            assertNoWarnings()
+            val cliArgPrefix = if (viaSystemProperty) "-D" else "-P"
+            val strategyCLIArg = "${cliArgPrefix}kotlin.compiler.execution.strategy=${executionStrategy.propertyValue}"
+            val finishMessage = "Finished executing kotlin compiler using $executionStrategy strategy"

-            if (executionStrategy == "daemon") {
-                checkCompileDaemon()
+            build("build", strategyCLIArg) {
+                assertSuccessful()
+                assertContains(finishMessage)
+                checkOutput()
+                assertNoWarnings()
+
+                if (executionStrategy == KotlinCompilerExecutionStrategy.DAEMON) {
+                    checkCompileDaemon()
+                }
            }
-        }

-        val classesKt = project.projectDir.getFileByName("classes.kt")
-        classesKt.modify {
-            it.checkedReplace("class B", "//class B")
-        }
-        project.build("build", strategyCLIArg) {
-            assertSuccessful()
-            assertContains(finishMessage)
-            checkOutputAfterChange()
-            assertNoWarnings()
+            val classesKt = projectDir.getFileByName("classes.kt")
+            classesKt.modify {
+                it.checkedReplace("class B", "//class B")
+            }
+            build("build", strategyCLIArg) {
+                assertSuccessful()
+                assertContains(finishMessage)
+                checkOutputAfterChange()
+                assertNoWarnings()
+            }
        }
    }

@@ -3,6 +3,7 @@ package org.jetbrains.kotlin.gradle
 import org.gradle.api.logging.LogLevel
 import org.gradle.api.logging.configuration.WarningMode
 import org.gradle.util.GradleVersion
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.testbase.*
 import org.junit.jupiter.api.DisplayName

@@ -19,7 +20,7 @@ class SimpleKotlinGradleIT : KGPBaseTest() {
            buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.DEBUG),
        ) {
            build("compileDeployKotlin", "build") {
-                assertOutputContains("Finished executing kotlin compiler using daemon strategy")
+                assertOutputContains("Finished executing kotlin compiler using ${KotlinCompilerExecutionStrategy.DAEMON} strategy")
                assertFileInProjectExists("build/reports/tests/test/classes/demo.TestSource.html")
                assertTasksExecuted(":compileKotlin", ":compileTestKotlin", ":compileDeployKotlin")
            }
@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.build.report.metrics.BuildMetricsReporter
 import org.jetbrains.kotlin.build.report.metrics.BuildTime
 import org.jetbrains.kotlin.build.report.metrics.measure
 import org.jetbrains.kotlin.gradle.tasks.GradleCompileTaskProvider
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.tasks.TaskOutputsBackup
 import java.io.File
 import javax.inject.Inject
@@ -29,8 +30,9 @@ internal class GradleCompilerRunnerWithWorkers(
    jdkToolsJar: File?,
    kotlinDaemonJvmArgs: List<String>?,
    buildMetrics: BuildMetricsReporter,
+    compilerExecutionStrategy: KotlinCompilerExecutionStrategy,
    private val workerExecutor: WorkerExecutor
-) : GradleCompilerRunner(taskProvider, jdkToolsJar, kotlinDaemonJvmArgs, buildMetrics) {
+) : GradleCompilerRunner(taskProvider, jdkToolsJar, kotlinDaemonJvmArgs, buildMetrics, compilerExecutionStrategy) {
    override fun runCompilerAsync(
        workArgs: GradleKotlinCompilerWorkArguments,
        taskOutputsBackup: TaskOutputsBackup?
@@ -16,6 +16,7 @@ import org.gradle.workers.WorkQueue
 import org.jetbrains.kotlin.build.report.metrics.BuildMetricsReporter
 import org.jetbrains.kotlin.build.report.metrics.BuildTime
 import org.jetbrains.kotlin.build.report.metrics.measure
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.arguments.*
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.daemon.client.CompileServiceSession
@@ -43,10 +44,6 @@ import org.jetbrains.kotlin.statistics.metrics.StringMetrics
 import java.io.File
 import java.lang.ref.WeakReference

-internal const val KOTLIN_COMPILER_EXECUTION_STRATEGY_PROPERTY = "kotlin.compiler.execution.strategy"
-internal const val DAEMON_EXECUTION_STRATEGY = "daemon"
-internal const val IN_PROCESS_EXECUTION_STRATEGY = "in-process"
-internal const val OUT_OF_PROCESS_EXECUTION_STRATEGY = "out-of-process"
 const val CREATED_CLIENT_FILE_PREFIX = "Created client-is-alive flag file: "
 const val EXISTING_CLIENT_FILE_PREFIX = "Existing client-is-alive flag file: "
 const val CREATED_SESSION_FILE_PREFIX = "Created session-is-alive flag file: "
@@ -54,9 +51,6 @@ const val EXISTING_SESSION_FILE_PREFIX = "Existing session-is-alive flag file: "
 const val DELETED_SESSION_FILE_PREFIX = "Deleted session-is-alive flag file: "
 const val COULD_NOT_CONNECT_TO_DAEMON_MESSAGE = "Could not connect to Kotlin compile daemon"

-internal fun kotlinCompilerExecutionStrategy(): String =
-    System.getProperty(KOTLIN_COMPILER_EXECUTION_STRATEGY_PROPERTY) ?: DAEMON_EXECUTION_STRATEGY
-
 /*
 Using real taskProvider cause "field 'taskProvider' from type 'org.jetbrains.kotlin.compilerRunner.GradleCompilerRunner':
 value 'fixed(class org.jetbrains.kotlin.gradle.tasks.KotlinCompile_Decorated, task ':compileKotlin')'
@@ -66,7 +60,8 @@ internal open class GradleCompilerRunner(
    protected val taskProvider: GradleCompileTaskProvider,
    protected val jdkToolsJar: File?,
    protected val kotlinDaemonJvmArgs: List<String>?,
-    protected val buildMetrics: BuildMetricsReporter
+    protected val buildMetrics: BuildMetricsReporter,
+    protected val compilerExecutionStrategy: KotlinCompilerExecutionStrategy,
 ) {

    internal val pathProvider = taskProvider.path.get()
@@ -196,7 +191,8 @@ internal open class GradleCompilerRunner(
            reportingSettings = environment.reportingSettings,
            kotlinScriptExtensions = environment.kotlinScriptExtensions,
            allWarningsAsErrors = compilerArgs.allWarningsAsErrors,
-            daemonJvmArgs = kotlinDaemonJvmArgs
+            daemonJvmArgs = kotlinDaemonJvmArgs,
+            compilerExecutionStrategy = compilerExecutionStrategy,
        )
        TaskLoggers.put(pathProvider, loggerProvider)
        return runCompilerAsync(
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.gradle.report.*
 import org.jetbrains.kotlin.gradle.report.TaskExecutionInfo
 import org.jetbrains.kotlin.gradle.report.TaskExecutionProperties.ABI_SNAPSHOT
 import org.jetbrains.kotlin.gradle.report.TaskExecutionResult
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.tasks.clearLocalState
 import org.jetbrains.kotlin.gradle.tasks.throwGradleExceptionIfError
 import org.jetbrains.kotlin.gradle.utils.stackTraceAsString
@@ -68,7 +69,8 @@ internal class GradleKotlinCompilerWorkArguments(
    val reportingSettings: ReportingSettings,
    val kotlinScriptExtensions: Array<String>,
    val allWarningsAsErrors: Boolean,
-    val daemonJvmArgs: List<String>?
+    val daemonJvmArgs: List<String>?,
+    val compilerExecutionStrategy: KotlinCompilerExecutionStrategy,
 ) : Serializable {
    companion object {
        const val serialVersionUID: Long = 0
@@ -104,6 +106,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
    private val metrics = if (reportingSettings.reportMetrics) BuildMetricsReporterImpl() else DoNothingBuildMetricsReporter
    private var icLogLines: List<String> = emptyList()
    private val daemonJvmArgs = config.daemonJvmArgs
+    private val compilerExecutionStrategy = config.compilerExecutionStrategy

    private val log: KotlinLogger =
        TaskLoggers.get(taskPath)?.let { GradleKotlinLogger(it).apply { debug("Using '$taskPath' logger") } }
@@ -155,8 +158,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
            kotlinDebug { "$taskPath Kotlin compiler args: ${compilerArgs.joinToString(" ")}" }
        }

-        val executionStrategy = kotlinCompilerExecutionStrategy()
-        if (executionStrategy == DAEMON_EXECUTION_STRATEGY) {
+        if (compilerExecutionStrategy == KotlinCompilerExecutionStrategy.DAEMON) {
            val daemonExitCode = compileWithDaemon(messageCollector)

            if (daemonExitCode != null) {
@@ -167,7 +169,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
        }

        val isGradleDaemonUsed = System.getProperty("org.gradle.daemon")?.let(String::toBoolean)
-        return if (executionStrategy == IN_PROCESS_EXECUTION_STRATEGY || isGradleDaemonUsed == false) {
+        return if (compilerExecutionStrategy == KotlinCompilerExecutionStrategy.IN_PROCESS || isGradleDaemonUsed == false) {
            compileInProcess(messageCollector)
        } else {
            compileOutOfProcess()
@@ -242,7 +244,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
        } catch (e: RemoteException) {
            log.warn("Unable to clear jar cache after compilation, maybe daemon is already down: $e")
        }
-        log.logFinish(DAEMON_EXECUTION_STRATEGY)
+        log.logFinish(KotlinCompilerExecutionStrategy.DAEMON)
        return exitCode
    }

@@ -364,7 +366,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
            stream,
            exitCode
        )
-        log.logFinish(IN_PROCESS_EXECUTION_STRATEGY)
+        log.logFinish(KotlinCompilerExecutionStrategy.IN_PROCESS)
        return exitCode
    }

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.daemon.client.DaemonReportingTargets
 import org.jetbrains.kotlin.daemon.client.launchProcessWithFallback
 import org.jetbrains.kotlin.gradle.logging.GradleKotlinLogger
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.org.objectweb.asm.ClassReader
 import org.jetbrains.org.objectweb.asm.ClassVisitor
 import org.jetbrains.org.objectweb.asm.FieldVisitor
@@ -129,7 +130,7 @@ internal fun runToolInSeparateProcess(
    readErrThread.join()

    val exitCode = process.waitFor()
-    logger.logFinish(OUT_OF_PROCESS_EXECUTION_STRATEGY)
+    logger.logFinish(KotlinCompilerExecutionStrategy.OUT_OF_PROCESS)
    return exitCodeFromProcessExitCode(logger, exitCode)
 }

@@ -171,7 +172,7 @@ private fun createLoggingMessageCollector(log: KotlinLogger): MessageCollector =
    }
 }

-internal fun KotlinLogger.logFinish(strategy: String) {
+internal fun KotlinLogger.logFinish(strategy: KotlinCompilerExecutionStrategy) {
    debug("Finished executing kotlin compiler using $strategy strategy")
 }

@@ -122,7 +122,8 @@ abstract class KaptWithKotlincTask @Inject constructor(
            taskProvider.get(),
            defaultKotlinJavaToolchain.get().currentJvmJdkToolsJar.orNull,
            normalizedKotlinDaemonJvmArguments.orNull,
-            metrics.get()
+            metrics.get(),
+            compilerExecutionStrategy.get(),
        )
        compilerRunner.runJvmCompilerAsync(
            sourcesToCompile = emptyList(),
@@ -23,10 +23,7 @@ import org.jetbrains.kotlin.gradle.targets.js.dukat.ExternalsOutputFormat
 import org.jetbrains.kotlin.gradle.targets.js.dukat.ExternalsOutputFormat.Companion.externalsOutputFormatProperty
 import org.jetbrains.kotlin.gradle.targets.js.webpack.WebpackMajorVersion
 import org.jetbrains.kotlin.gradle.targets.native.DisabledNativeTargetsReporter
-import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
-import org.jetbrains.kotlin.gradle.tasks.CompileUsingKotlinDaemon
-import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.tasks.*
 import org.jetbrains.kotlin.gradle.utils.SingleWarningPerBuild
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.konan.target.presetName
@@ -59,9 +56,12 @@ internal fun PropertiesProvider.mapKotlinDaemonProperties(task: CompileUsingKotl
    kotlinDaemonJvmArgs?.let {
        task.kotlinDaemonJvmArguments.set(it.split("\\s+".toRegex()))
    }
+    if (!task.compilerExecutionStrategy.isPresent) {
+        task.compilerExecutionStrategy.set(kotlinCompilerExecutionStrategy)
+    }
 }

- internal class PropertiesProvider private constructor(private val project: Project) {
+internal class PropertiesProvider private constructor(private val project: Project) {
    private val localProperties: Properties by lazy {
        Properties().apply {
            val localPropertiesFile = project.rootProject.file("local.properties")
@@ -159,10 +159,10 @@ internal fun PropertiesProvider.mapKotlinDaemonProperties(task: CompileUsingKotl
    val mppStabilityNoWarn: Boolean?
        get() = booleanProperty(KotlinMultiplatformPlugin.STABILITY_NOWARN_FLAG)

-     val wasmStabilityNoWarn: Boolean
-         get() = booleanProperty("kotlin.wasm.stability.nowarn") ?: false
+    val wasmStabilityNoWarn: Boolean
+        get() = booleanProperty("kotlin.wasm.stability.nowarn") ?: false

-     val ignoreDisabledNativeTargets: Boolean?
+    val ignoreDisabledNativeTargets: Boolean?
        get() = booleanProperty(DisabledNativeTargetsReporter.DISABLE_WARNING_PROPERTY_NAME)

    val ignoreIncorrectNativeDependencies: Boolean?
@@ -358,6 +358,14 @@ internal fun PropertiesProvider.mapKotlinDaemonProperties(task: CompileUsingKotl
    val kotlinDaemonJvmArgs: String?
        get() = property("kotlin.daemon.jvmargs")

+    val kotlinCompilerExecutionStrategy: KotlinCompilerExecutionStrategy
+        get() {
+            val gradleProperty = property("kotlin.compiler.execution.strategy")
+            // system property is for backward compatibility
+            val value = (gradleProperty ?: System.getProperty("kotlin.compiler.execution.strategy"))?.toLowerCase()
+            return KotlinCompilerExecutionStrategy.fromProperty(value)
+        }
+
    private fun propertyWithDeprecatedVariant(propName: String, deprecatedPropName: String): String? {
        val deprecatedProperty = property(deprecatedPropName)
        if (deprecatedProperty != null) {
@@ -90,6 +90,7 @@ abstract class KotlinCompileCommon @Inject constructor(
                    null,
                    normalizedKotlinDaemonJvmArguments.orNull,
                    metrics.get(),
+                    compilerExecutionStrategy.get(),
                    workerExecutor
                )
            }
@@ -322,7 +322,8 @@ abstract class AbstractKotlinCompile<T : CommonCompilerArguments> : AbstractKotl
                    it,
                    null,
                    normalizedKotlinDaemonJvmArguments.orNull,
-                    metrics.get()
+                    metrics.get(),
+                    compilerExecutionStrategy.get(),
                )
            }
        )
@@ -665,6 +666,7 @@ abstract class KotlinCompile @Inject constructor(
                    toolchain.currentJvmJdkToolsJar.orNull,
                    normalizedKotlinDaemonJvmArguments.orNull,
                    metrics.get(),
+                    compilerExecutionStrategy.get(),
                    workerExecutor
                )
            })
@@ -993,6 +995,7 @@ abstract class Kotlin2JsCompile @Inject constructor(
                    null,
                    normalizedKotlinDaemonJvmArguments.orNull,
                    metrics.get(),
+                    compilerExecutionStrategy.get(),
                    workerExecutor
                )
            }