2012-03-21 20 views
36

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.¿Cómo optimizar el rendimiento de compilación de gradle con respecto a la duración de compilación y el uso de RAM?

Los problemas: pasan varios minutos antes de que aparezca el primer compileJava, e incluso si no ha cambiado nada en las fuentes, el proceso se está ejecutando al menos 7 minutos hasta que se bloquea a mitad de camino a través :testClasses (a diferentes subproyectos) con el siguiente mensaje :

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

el proyecto consiste de aproximadamente 30 (en parte interdependientes) subproyectos, la build.gradle de ellos siendo más o menos lo 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 { 
} 

Me trataron de resolver el problema de espacio de almacenamiento dinámico por el aumento gradual de tamaño máximo de memoria a 1024M, pero no sirvió de nada. Mi archivo principal build.gradle 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' 
      } 
+1

hace suceder que ser la sustitución de fichas? He encontrado que esta es la única causa de que la compilación de proyectos múltiples de Gradle sea un orden de magnitud más lenta porque estábamos reemplazando los tokens por la caché de .gradle. –

+0

Gracias por su sugerencia. Sin embargo, no hubo reemplazos involucrados. La respuesta de Peter Niederwieser a continuación hizo el truco :) – peterp

Respuesta

52

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

+3

Gracias, establecer GRADLE_OPTS en -Xmx512m como se sugiere no solo eliminó el error de Heap Space, sino que también aceleró el proceso enormemente. Todavía lleva bastante tiempo hacer la compilación y en algunos momentos no estoy seguro de lo que Gradle está haciendo en segundo plano, pero puedo seguir utilizando el generador de perfiles desde aquí :) – peterp

+0

Cuando lo configuro en 512, obtengo el mismo error de nuevo; Pero cuando lo configuré para, por ejemplo, 2048, aparece "No se pudo reservar suficiente espacio para 2097152" –

23

Si se utiliza el Gradle Wrapper se puede establecer en DEFAULT_JVM_OPTSgradlew así:

DEFAULT_JVM_OPTS="-Xmx512m" 

Conjunto que de una manera similar en gradlew.bat si estás en Windows:

set DEFAULT_JVM_OPTS=-Xmx512m 

La tarea Gradle Envoltura también se puede modificar para incluir esto automáticamente. Así es como el Gradle developers 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") 
    } 
} 
+0

Modificación de la tarea de envoltura a partir de Gradle 2.9 así como – nerdherd

+0

Sugiero que cuando proporcione fragmentos de código también debe indicar la preocupación de los archivos y sus rutas de archivos. –

+0

Esto se puede colocar en cualquier archivo de construcción de Gradle, por lo que recuerdo. –

5

que acaba de encontrar una muy buena manera 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 va a usar su parámetro para el tamaño máximo de la memoria.

gradle build --info 
4

En los gradle.properties archivo Agregue la línea siguiente:

org.gradle.daemon = true

Esto aumentará la acumulación - tomado de

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

+0

Parece que sobrecarga el tamaño del montón de Java en el punto, después de un tiempo lo quitó, pensando en el disco SSD por ahora como la siguiente etapa de rendimiento –

+0

daemon gradle está habilitado de forma predeterminada –

1

Ninguna de las respuestas anteriores trabajado para mí, entonces me encontré con esto:

Mi configuración del sistema -

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

opciones de JVM para ejecutar Gradle se pueden establecer a través de 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.

que añade las dos variables de entorno se mencionan a continuación y resolvieron este problema-

Variable Name: GRADLE_OPTS 
Variable Value: -Xmx512m 

Variable Name: JAVA_OPTS 
Variable Value: -Xmx512m 

Espero que esto ayude a los tipos como yo.

3

estoy usando siguiente versión de gradle.properties para hacer el rendimiento Gradle mejor en Android proyecta

# 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 
1

ponga el siguiente contenido a ~/.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 
+0

Encender el daemon gradle funciona bien para acelerar gradle, en general. Cada vez que invocas gradle, tiene que cargar y analizar el archivo de compilación, y luego puede comenzar a ejecutarse. El daemon cargará/analizará y almacenará en caché los datos analizados. Siguiente invocación, si el archivo de compilación no ha cambiado, va MUCHO más rápido. Sin embargo, falla si alguna vez haces "gradle --debug " porque estás tratando de ver el classpath, qué valores tienen las variables, etc. Debes desactivar el daemon en la configuración, kill -9 el proceso ENTONCES haga el --debug ENTONCES, después de completar la depuración, vuelva a encenderlo en la configuración. – Meower68

2

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

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

  1. Ir al panel de control (búsqueda de Java en Windows 10)
  2. encontrar la aplicación java
  3. doble clic en java y luego ver.
  4. En los parámetros de tiempo de ejecución añade:

    -Xmx 2048m 
    
+0

Para cualquiera que busque "parámetros de tiempo de ejecución", en W7 esto se encuentra debajo de la pestaña "Java" una vez que haga el paso 3, luego haga clic en "Ver". A partir de ahí, los "parámetros de tiempo de ejecución" se verán como una de las celdas en la cuadrícula. – user1863152

+0

¡Gracias! Tenía Java de 32 bits y 64 bits instalados y Gradle usaba 32 bits en lugar de 64 bits. – blk0ut

Cuestiones relacionadas