Support for AppCDS

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/dsl/AppCdsSettings.kt

@@ -0,0 +1,181 @@
+package org.jetbrains.compose.desktop.application.dsl
+
+import org.gradle.api.file.Directory
+import org.gradle.api.file.RegularFile
+import org.jetbrains.compose.desktop.application.internal.JvmApplicationContext
+import org.jetbrains.compose.internal.utils.packagedAppJarFilesDir
+import java.io.Serializable
+
+/**
+ * The configuration of AppCDS for the native distribution.
+ */
+abstract class AppCdsConfiguration {
+    /**
+     * The AppCDS mode to use.
+     */
+    var mode: AppCdsMode = AppCdsMode.None
+
+    /**
+     * Whether to fail running the app if unable to load the AppCDS archive.
+     */
+    var exitAppOnCdsFailure: Boolean = false
+}
+
+/**
+ * Returns the AppCDS-related arguments to pass the JVM when running the app.
+ */
+internal fun AppCdsConfiguration.runtimeJvmArgs(context: JvmApplicationContext) = buildList {
+    addAll(mode.runtimeJvmArgs())
+    if (exitAppOnCdsFailure) {
+        add("-Xshare:on")
+    }
+    if (context.buildType.cdsLogging.get()) {
+        add("-Xlog:cds")
+    }
+}
+
+/**
+ * The mode of use of AppCDS.
+ */
+abstract class AppCdsMode(val name: String) : Serializable {
+
+    /**
+     * Whether to generate a classes.jsa archive for the JRE classes.
+     */
+    internal abstract val generateJreClassesArchive: Boolean
+
+    /**
+     * Returns whether this mode creates an archive of app classes at build time.
+     */
+    internal open val generateAppClassesArchive: Boolean get() = false
+
+    /**
+     * The arguments to pass to the JVM when running the app to create
+     * the archive for the app's class files.
+     *
+     * This will only be called if [generateAppClassesArchive] is `true`.
+     */
+    internal open fun appClassesArchiveCreationJvmArgs(): List<String> =
+        error("AppCdsMode '$this' does not create an archive")
+
+    /**
+     * Returns the app's classes archive file, given the root directory of
+     * the packaged app.
+     */
+    internal open fun appClassesArchiveFile(packagedAppRootDir: Directory): RegularFile =
+        error("AppCdsMode '$this' does not create an archive")
+
+    /**
+     * The arguments to pass to the JVM when running the final app.
+     */
+    internal abstract fun runtimeJvmArgs(): List<String>
+
+    /**
+     * Checks whether this mode is compatible with the given JDK major version.
+     * Throws an exception if not.
+     */
+    internal open fun checkJdkCompatibility(jdkMajorVersion: Int) = Unit
+
+    override fun toString() = name
+
+    companion object {
+
+        /**
+         * The name of the AppCDS archive file.
+         */
+        private const val ARCHIVE_NAME = "app.jsa"
+
+        /**
+         * The AppCDS archive file.
+         */
+        internal const val ARCHIVE_FILE_ARGUMENT = "\$APPDIR/$ARCHIVE_NAME"
+
+        /**
+         * AppCDS is not used.
+         */
+        val None = object : AppCdsMode("None") {
+            override val generateJreClassesArchive: Boolean get() = false
+            override fun runtimeJvmArgs() = emptyList<String>()
+        }
+
+        /**
+         * AppCDS is used via a dynamic shared archive created automatically
+         * when the app is run (using `-XX:+AutoCreateSharedArchive`).
+         * Due to the drawbacks below, this mode is mostly recommended only
+         * to experiment and see how fast your app starts up with AppCDS.
+         * In production, we recomment [Prebuild] mode.
+         *
+         * Advantages:
+         * - Simplest - no additional step is needed to build the archive.
+         * - Creates a smaller distributable.
+         *
+         * Drawbacks:
+         * - Requires JDK 19 or later.
+         * - The archive is not available at the first execution of the app,
+         *   so it is slower (and possibly even slower than regular execution),
+         *   The archive is created when at shutdown time of the first execution,
+         *   which also takes a little longer.
+         * - Some OSes may block writing the archive file to the application's
+         *   directory at runtime.
+         */
+        @Suppress("unused")
+        val Auto = object : AppCdsMode("Auto") {
+            private val MIN_JDK_VERSION = 19
+            override val generateJreClassesArchive: Boolean get() = true
+            override fun runtimeJvmArgs() =
+                listOf(
+                    "-XX:SharedArchiveFile=$ARCHIVE_FILE_ARGUMENT",
+                    "-XX:+AutoCreateSharedArchive"
+                )
+            override fun checkJdkCompatibility(jdkMajorVersion: Int) {
+                if (jdkMajorVersion < MIN_JDK_VERSION) {
+                    error(
+                        "AppCdsMode '$this' is not supported on JDK earlier than" +
+                                " $MIN_JDK_VERSION; current is $jdkMajorVersion"
+                    )
+                }
+            }
+        }
+
+        /**
+         * AppCDS is used via a dynamic shared archive created by executing
+         * the app before packaging (using `-XX:ArchiveClassesAtExit`).
+         *
+         * When using this mode, the app will be run during the creation of
+         * the distributable. In this run, a system property
+         * `compose.appcds.create-archive` will be set to the value `true`.
+         * The app should "exercise" itself and cause the loading of all
+         * the classes that should be written into the AppCDS archive. It
+         * should then shut down in order to let the build process continue.
+         *
+         * Advantages:
+         * - Can be used with JDKs earlier than 19.
+         * - The first run of the distributed app is fast too.
+         *
+         * Drawbacks:
+         * - Requires an additional step of running the app when building the
+         *   distributable.
+         * - The distributable is larger because it includes the archive of
+         *   the app's classes.
+         */
+        @Suppress("unused")
+        val Prebuild = object : AppCdsMode("Prebuild") {
+            override val generateJreClassesArchive: Boolean get() = true
+            override val generateAppClassesArchive: Boolean get() = true
+            override fun appClassesArchiveCreationJvmArgs() =
+                listOf(
+                    "-XX:ArchiveClassesAtExit=$ARCHIVE_FILE_ARGUMENT",
+                    "-Dcompose.appcds.create-archive=true",
+                    "-Xlog:cds"
+                )
+            override fun appClassesArchiveFile(packagedAppRootDir: Directory): RegularFile {
+                val appDir = packagedAppJarFilesDir(packagedAppRootDir)
+                return appDir.file(ARCHIVE_NAME)
+            }
+            override fun runtimeJvmArgs() =
+                listOf(
+                    "-XX:SharedArchiveFile=$ARCHIVE_FILE_ARGUMENT",
+                )
+        }
+    }
+}

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/dsl/JvmApplicationBuildTypes.kt

@@ -7,7 +7,9 @@ package org.jetbrains.compose.desktop.application.dsl
 
 import org.gradle.api.Action
 import org.gradle.api.model.ObjectFactory
+import org.gradle.api.provider.Property
 import org.jetbrains.compose.internal.utils.new
+import org.jetbrains.compose.internal.utils.notNullProperty
 import javax.inject.Inject
 
 abstract class JvmApplicationBuildTypes @Inject constructor(
@@ -25,6 +27,7 @@ abstract class JvmApplicationBuildTypes @Inject constructor(
 
     val release: JvmApplicationBuildType = objects.new<JvmApplicationBuildType>("release").apply {
         proguard.isEnabled.set(true)
+        cdsLogging.set(false)
     }
     fun release(fn: Action<JvmApplicationBuildType>) {
         fn.execute(release)
@@ -43,4 +46,6 @@ abstract class JvmApplicationBuildType @Inject constructor(
     fun proguard(fn: Action<ProguardSettings>) {
         fn.execute(proguard)
     }
+
+    val cdsLogging: Property<Boolean> = objects.notNullProperty(true)
 }

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/dsl/JvmApplicationDistributions.kt

@@ -43,4 +43,10 @@ abstract class JvmApplicationDistributions : AbstractDistributions() {
         windows.fileAssociation(mimeType, extension, description, windowsIconFile)
         macOS.fileAssociation(mimeType, extension, description, macOSIconFile)
     }
+
+    val appCds: AppCdsConfiguration = objects.newInstance(AppCdsConfiguration::class.java)
+    fun appCds(fn: Action<AppCdsConfiguration>) {
+        fn.execute(appCds)
+    }
+
 }

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/internal/JvmTasks.kt

@@ -29,23 +29,31 @@ internal class JvmTasks(
         taskNameAction: String,
         taskNameObject: String = "",
         args: List<Any> = emptyList(),
+        isHidden: Boolean = false,
         noinline configureFn: T.() -> Unit = {}
     ): TaskProvider<T> {
         val buildTypeClassifier = buildType.classifier.uppercaseFirstChar()
         val objectClassifier = taskNameObject.uppercaseFirstChar()
         val taskName = "$taskNameAction$buildTypeClassifier$objectClassifier"
-        return register(taskName, klass = T::class.java, args = args, configureFn = configureFn)
+        return register(
+            name = taskName,
+            klass = T::class.java,
+            args = args,
+            isHidden = isHidden,
+            configureFn = configureFn
+        )
     }
 
     fun <T : Task> register(
         name: String,
         klass: Class<T>,
         args: List<Any>,
+        isHidden: Boolean = false,
         configureFn: T.() -> Unit
     ): TaskProvider<T> =
         project.tasks.register(name, klass, *args.toTypedArray()).apply {
             configure { task ->
-                task.group = taskGroup
+                task.group = if (isHidden) null else taskGroup
                 task.configureFn()
             }
         }