web-dev-qa-db-fra.com

Comment optimiser les performances de construction gradle en ce qui concerne la durée de construction et RAM utilisation?

Je suis actuellement en train de passer de ant à gradle pour mon application Web multi-modules et pour le moment, il semble que la version actuelle de Gradle (M9) puisse se heurter à ses limites. Mais peut-être (espérons-le) que c'est juste un problème de ne pas comprendre assez bien les concepts de Gradle ou de ne pas connaître le "commutateur de boost de performance magique". Je serais heureux de savoir comment les performances de construction pourraient être optimisées.

Les problèmes: plusieurs minutes s'écoulent avant que le premier compileJava ne s'affiche, et même si rien n'a changé dans les sources, le processus s'exécute au moins 7 minutes jusqu'à ce qu'il se bloque à mi-chemin de :testClasses (à différents sous-projets) avec le message suivant:

* What went wrong:
Could not resolve all dependencies for configuration ':mysubproject_X:testRuntime'.
> Java heap space

Le projet se compose d'environ 30 sous-projets (partiellement interdépendants), le build.gradle d'entre eux étant plus ou moins le même et sont utilisés pour créer un fichier jar à partir de chaque sous-projet, par ex.

sourceSets {

    main {
        Java {
            srcDirs 'src'
        }
    }
}

dependencies {

    compile project(':mysubproject_A')
    compile project(':mysubproject_B')
    compile project(':mysubproject_E')

    compile group: 'commons-lang', name: 'commons-lang', version: '2.2'

}

// copy all non-Java files from src
copy {
    from sourceSets.main.Java.srcDirs
    into "$buildDir/classes/main"
    exclude '**/*.Java'
}

jar {
}

J'ai essayé de résoudre le problème d'espace de tas en augmentant la taille maximale de la mémoire à 1024 Mo, mais cela n'a pas aidé. Mon fichier build.gradle principal ressemble à ceci:

            sourceCompatibility = 1.6
            version = 0.5

            useFindBugs = false

            apply plugin: 'Java'

            configurations {
            }

            repositories {
                mavenCentral()
                mavenRepo url:"http://repository.jboss.org/maven2", artifactUrls: ["https://repository.jboss.org/nexus/content/repositories/public","http://opensource.55minutes.com/maven-releases"]
            }


            dependencies {
            }

            buildscript {
                repositories {
                    mavenRepo url: 'http://gradle.artifactoryonline.com/gradle/plugins'
                    flatDir(dirs: "$projectDir/lib")
                }

                dependencies {
                    classpath "org.gradle.plugins:gradle-idea-plugin:0.3.1"
                }
            }

            subprojects {
                apply plugin: 'Java'
                apply plugin: 'idea'

                repositories {
                    mavenCentral()
                    mavenRepo url:"http://repository.jboss.org/maven2", artifactUrls: ["https://repository.jboss.org/nexus/content/repositories/public","http://opensource.55minutes.com/maven-releases"]
                }

                dependencies {
                    testCompile 'junit:junit:4.8.2'
                }

                compileJava {
                    options.encoding = 'UTF-8'
                    options.fork (memoryMaximumSize: '1024m') 
                }

                javadoc {
                    options.encoding = 'UTF-8'
                }

                test {
                    testReportDir = file(rootProject.testReportDir)
                    forkEvery = 1
                    jvmArgs = ['-ea', '-Xmx1024m']
                }
            }


            dependsOnChildren()

            task wrapper(type: Wrapper) {
                gradleVersion = '1.0-milestone-9'
            }
performancebuildheapgradle
39
peterp

Vous devez donner plus de mémoire à la JVM Gradle, pas à la tâche de compilation/JVM. Une façon de le faire est via le GRADLE_OPTS variable d'environnement (GRADLE_OPTS=-Xmx512m).

58
Peter Niederwieser

Si vous utilisez Gradle Wrapper vous pouvez définir DEFAULT_JVM_OPTS dans gradlew comme ceci:

DEFAULT_JVM_OPTS="-Xmx512m"

Réglez-le de manière similaire dans gradlew.bat si vous êtes sous Windows:

set DEFAULT_JVM_OPTS=-Xmx512m

La tâche Gradle Wrapper peut également être modifiée pour l'inclure automatiquement. C'est ainsi que les développeurs Gradle l'ont résolu:

wrapper {
    gradleVersion = '1.8'

    def jvmOpts = "-Xmx512m"
    inputs.property("jvmOpts", jvmOpts)
    doLast {
        def optsEnvVar = "DEFAULT_JVM_OPTS"
        scriptFile.write scriptFile.text.replace("$optsEnvVar=\"\"", "$optsEnvVar=\"$jvmOpts\"")
        batchScript.write batchScript.text.replace("set $optsEnvVar=", "set $optsEnvVar=$jvmOpts")
    }
}
25
David Pärsson

Je viens de trouver un très bon moyen de gérer ce problème. Pas besoin de wrapper gradle personnalisé ou GRADLE_OPTIONS.

compileJava {
    options.fork = true  // Fork your compilation into a child process
    options.forkOptions.setMemoryMaximumSize("4g") // Set maximum memory to 4g
}

Exécutez Gradle avec l'option --info pour voir où il va utiliser votre paramètre pour la taille de mémoire maximale.

gradle build --info
7
Dusan Jovanovic

J'utilise la version suivante de gradle.properties pour améliorer les performances de Gradle dans les projets Android

# The Gradle daemon aims to improve the startup and execution time of Gradle.
# When set to true the Gradle daemon is to run the build.
org.gradle.daemon=true

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
org.gradle.parallel=true

# Enables new incubating mode that makes Gradle selective when configuring projects.
# Only relevant projects are configured which results in faster builds for large multi-projects.
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:configuration_on_demand
org.gradle.configureondemand=true
5
silwar

Dans le fichier gradle.properties , ajoutez la ligne suivante:

org.gradle.daemon = true

Cela stimulera la construction - tiré de

https://www.timroes.de/2013/09/12/speed-up-gradle/

4
shimi_tap

Mettez le contenu suivant dans ~/.gradle en tant que gradle.properties

# Project-wide Gradle settings.
# IDE (e.g. Android Studio) users:
# Settings specified in this file will override any Gradle settings
# configured through the IDE.
# For more details on how to configure your build environment visit
# http://www.gradle.org/docs/current/userguide/build_environment.html
# The Gradle daemon aims to improve the startup and execution time of Gradle.
# When set to true the Gradle daemon is to run the build.
# TODO: disable daemon on CI, since builds should be clean and reliable on servers
org.gradle.daemon=true
# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
org.gradle.jvmargs=-Xmx6g -Xms4g -XX:MaxPermSize=8g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
org.gradle.parallel=true
# Enables new incubating mode that makes Gradle selective when configuring projects.
# Only relevant projects are configured which results in faster builds for large multi-projects.
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:configuration_on_demand
org.gradle.configureondemand=true
3
wukong

J'ai personnellement parcouru tous les articles ici mais faire ces étapes l'a corrigé.

Si vous utilisez jvm 32 bits, cela peut être le problème, installez un jvm 64 bits.

  1. Accédez au panneau de configuration (recherche Java dans Windows 10)
  2. trouver l'application Java
  3. Double-cliquez sur Java puis visualisez.

  4. Dans les paramètres d'exécution, ajoutez:

    -Xmx 2048m
2
Ashwin Bn

Aucune des réponses ci-dessus n'a fonctionné pour moi, alors j'ai trouvé cela-

Ma configuration système -

Windows x64 - JDK 32 bit - Cordova 5.4.1 - Ionic 1.7.12

Les options JVM pour exécuter Gradle peuvent être définies via des variables d'environnement. Vous pouvez utiliser GRADLE_OPTS ou Java_OPTS, ou les deux. Java_OPTS est par convention une variable d'environnement partagée par de nombreuses applications Java. Un cas d'utilisation typique serait de définir le proxy HTTP dans Java_OPTS et les options de mémoire dans GRADLE_OPTS. Ces variables peuvent également être définies à la début du script gradle ou gradlew.

J'ai ajouté les deux variables d'environnement mentionnées ci-dessous et résolu ce problème.

Variable Name: GRADLE_OPTS
Variable Value: -Xmx512m

Variable Name: Java_OPTS
Variable Value: -Xmx512m

J'espère que cela aide des gars comme moi.

1
Manik Arora