performance - rendimiento - optimizar aplicacion android studio

¿Cómo optimizar el rendimiento de compilación de Gradle con respecto a la duración de compilación y el uso de RAM?

Question

Actualmente estoy cambiando de hormiga a gradle para mi aplicación web de varios módulos y, en este momento, parece que la versión actual de Gradle (M9) podría estar funcionando contra sus límites. Pero tal vez (con suerte) es solo un problema que no entienda los conceptos de Gradle lo suficientemente bien o que no conozca el "interruptor de aumento de rendimiento mágico". Estaría feliz por cualquier pista sobre cómo se podría optimizar el rendimiento de la construcción.

Los problemas: pasan varios minutos antes de que se muestre la primera compileJava , e incluso si nada ha cambiado en las fuentes, el proceso se ejecuta al menos 7 minutos hasta que se bloquea a la mitad :testClasses (en varios subproyectos) con el siguiente mensaje:

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

El proyecto consiste en aproximadamente 30 subproyectos (parcialmente interdependientes), el build.gradle de ellos es más o menos el mismo y se utilizan para construir un archivo jar de cada subproyecto, por ejemplo

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 {
}

Traté de resolver el problema del espacio de montón aumentando el tamaño máximo de la memoria a 1024M, pero no ayudó. Mi archivo build.gradle principal se ve así:

            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''
            }

Answer 1

Acabo de encontrar una forma muy agradable de manejar este problema. No es necesario usar un envoltorio gradle personalizado ni GRADLE_OPTIONS.

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

Ejecute Gradle con la opción --info para ver dónde usará su parámetro para el tamaño máximo de la memoria.

gradle build --info

Answer 2

Coloque el siguiente contenido en ~ / .gradle como 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

Answer 3

En el archivo gradle.properties , agregue la siguiente línea:

org.gradle.daemon = true

Esto impulsará la construcción, tomado de

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

Answer 4

Estoy usando la siguiente versión de gradle.properties para mejorar el rendimiento de Gradle en proyectos de 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

Answer 5

Necesita dar más memoria a la JVM de Gradle, no a la tarea de compilación / JVM. Una forma de hacerlo es a través de la variable de entorno GRADLE_OPTS=-Xmx512m ( GRADLE_OPTS=-Xmx512m ).

Answer 6

Ninguna de las respuestas anteriores funcionó para mí, entonces encontré esto-

Mi configuración del sistema-

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

Las opciones de JVM para ejecutar Gradle se pueden configurar mediante variables de entorno. Puede usar GRADLE_OPTS o JAVA_OPTS, o ambos. JAVA_OPTS es, por convención, una variable de entorno compartida por muchas aplicaciones Java. Un caso de uso típico sería establecer el proxy HTTP en JAVA_OPTS y las opciones de memoria en GRADLE_OPTS. Esas variables también se pueden establecer al comienzo de la secuencia de comandos gradle o gradlew.

Agregué las dos variables de entorno mencionadas más abajo y resolví este problema:

Variable Name: GRADLE_OPTS
Variable Value: -Xmx512m

Variable Name: JAVA_OPTS
Variable Value: -Xmx512m

Espero que esto ayude a chicos como yo.

Answer 7

Personalmente revisé todos los artículos aquí, pero al seguir estos pasos lo solucioné.

Si está utilizando jvm de 32 bits que puede ser el problema instale un jvm de 64 bits.

1. Vaya al panel de control (busque Java en Windows 10)
2. encuentra la aplicación java
3. Haga doble clic en java y luego vea.

4. En los parámetros de tiempo de ejecución, agregue:

   -Xmx 2048m

Answer 8

Si usa Gradle Wrapper , puede establecer DEFAULT_JVM_OPTS en gradlew como este:

DEFAULT_JVM_OPTS="-Xmx512m"

gradlew.bat forma similar en gradlew.bat si está en Windows:

set DEFAULT_JVM_OPTS=-Xmx512m

La tarea Gradle Wrapper también se puede modificar para incluir esto automáticamente. Así es como los desarrolladores de Gradle lo han resuelto:

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")
    }
}