Track Ausführungszeit pro Aufgabe in gradle-Skript?

Was ist der eleganteste Weg, um die Ausführung mal auf, wie lange eine Aufgabe fand in einem gradle-build-Skript? Im optimalen Fall melden die Zeit unmittelbar gleichen oder nächsten Zeile, um den Namen der Aufgabe

:buildSrc:testClasses (0.518 secs)
:fooBar (28.652 secs)

Wenn Sie ausführen von gradle mit der --profile parameter, erzeugt es einen Bericht in build/reports/profile mit der Ausführung der Aufgabe mal drin... Ist das gut genug?
Das ist ein schöner Bericht, aber das erfordert einen zusätzlichen Schritt in der Erhebung alle build-bezogene Informationen, optimal die person, die Analyse unserer gradle Jenkins-jobs sehen können, die Ausführungszeit direkt inline. Thx trotzdem!

InformationsquelleAutor ngeek | 2012-10-23

17

Die sauberste Lösung ist die Umsetzung eines TaskExecutionListener (ich bin mir sicher, dass Sie behandeln können, das Teil) und registrieren Sie es mit gradle.taskGraph.addTaskExecutionListener.
- Vielen Dank, das klingt wie eine gute Passform, das einzige, was ich vermisse immer noch ist, wie Sie den listener für alle Aufgaben.
- Sie brauchen nur zu registrieren, einen einzelnen listener, einmal.
- Dies ist das snippet landete ich mit: gist.github.com/3939407
InformationsquelleAutor Peter Niederwieser

Nur zu erarbeiten, auf die andere Antwort: Wir wollten die gleiche Sache zu tun, sowie einen Bericht timings am Ende der
bauen, so langsam weicht offensichtlich sind (und die entsprechenden Parteien fühlen sich ein kleiner, aber gesund bisschen Scham, wenn Sie verlangsamen den bauen!).

BUILD SUCCESSFUL

Total time: 1 mins 37.973 secs
Task timings:
    579ms  :myproject-foo:clean
  15184ms  :myproject-bar:clean
   2839ms  :myproject-bar:compileJava
  10157ms  :myproject-bar:jar
    456ms  :myproject-foo:compileJava
    391ms  :myproject-foo:libs
    101ms  :myproject-foo:jar
    316ms  :myproject-bar:compileTestJava
    364ms  :myproject-foo:compileTestJava
  53353ms  :myproject-foo:test
   2146ms  :myproject-bar:test
   8348ms  :www/node:npmInstall
    687ms  :www/node:npmTest

Etwas wie den folgenden code kann gelöscht werden, in Ihrer top-level - build.gradle zu berichten Timing während der Ausführung oder nach Fertigstellung.

//Log timings per task.
class TimingsListener implements TaskExecutionListener, BuildListener {
    private Clock clock
    private timings = []

    @Override
    void beforeExecute(Task task) {
        clock = new org.gradle.util.Clock()
    }

    @Override
    void afterExecute(Task task, TaskState taskState) {
        def ms = clock.timeInMs
        timings.add([ms, task.path])
        task.project.logger.warn "${task.path} took ${ms}ms"
    }

    @Override
    void buildFinished(BuildResult result) {
        println "Task timings:"
        for (timing in timings) {
            if (timing[0] >= 50) {
                printf "%7sms  %s\n", timing
            }
        }
    }

    @Override
    void buildStarted(Gradle gradle) {}

    @Override
    void projectsEvaluated(Gradle gradle) {}

    @Override
    void projectsLoaded(Gradle gradle) {}

    @Override
    void settingsEvaluated(Settings settings) {}
}

gradle.addListener new TimingsListener()

Thx, das ist eine tolle Antwort. Super nützlich out of the box.
Gibt es eine Möglichkeit, dies könnte wie ein plugin oder so etwas, ich könnte leicht hinzufügen, um ein build-Skript ohne das verschmutzen der script? Oder gibt es andere Möglichkeiten, dies zu tun-timing in einer mehr clean-Mode? Danke!!!
Kann es irgendwie zeigen die gesamte Zeit, einschließlich der Zeit bei der installation (auf dem Gerät/emulator) der app?
timing[0] >= 50 gibt mir eine lästige Warnung 'getAt' in 'org.codehaus.groovig.- Laufzeit.DefaultGroovyMethods' nicht angewandt werden kann '(java.lang.Integer)' also ich habe ein ignorieren //noinspection GroovyAssignabilityCheck über die bedingte

InformationsquelleAutor jlevy

16

Ich weiß, das ist eine alte Frage, aber ich habe ein cooles plugin, das bedeutet das task-timing. Es ist wie @jlevy Antwort, aber mit etwas mehr Optionen zur Verfügung: https://github.com/passy/build-time-tracker-plugin

Dieses plugin von Pascal Hartig kontinuierlich protokolliert Ihre build-Zeiten und bietet CSV-und bar-chart-Zusammenfassungen. Der Entwickler empfiehlt es für die überwachung Ihres build-Zeiten im Laufe der Zeit, im Vergleich zu --profile die Ihnen eine Momentaufnahme für den aktuellen build.

Dies ist, wie ich bin derzeit mit es:
```
buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "net.rdrei.android.buildtimetracker:gradle-plugin:0.7.+"
    }
}

apply plugin: "build-time-tracker"

buildtimetracker {
    reporters {
        summary {
            ordered false
            threshold 50
            barstyle 'unicode'
        }
    }
}
```
- Funktioniert sogar bei neuen DSL-Zeug!
InformationsquelleAutor André Gil

Dies ist eine variation von jlevy Antwort oben, die geändert wurde, zu löschen, die Nutzung des öffentlich zugänglichen gradle Clock Klasse, die veraltet ist.

BUILD SUCCESSFUL

Total time: 1 mins 37.973 secs
Task timings:
    579ms  :myproject-foo:clean
  15184ms  :myproject-bar:clean
   2839ms  :myproject-bar:compileJava
  10157ms  :myproject-bar:jar
    456ms  :myproject-foo:compileJava
    391ms  :myproject-foo:libs
    101ms  :myproject-foo:jar
    316ms  :myproject-bar:compileTestJava
    364ms  :myproject-foo:compileTestJava
  53353ms  :myproject-foo:test
   2146ms  :myproject-bar:test
   8348ms  :www/node:npmInstall
    687ms  :www/node:npmTest

Etwas wie den folgenden code kann gelöscht werden, in Ihrer top-level - build.gradle zu berichten Timing während der Ausführung oder nach Fertigstellung.

import java.util.concurrent.TimeUnit
//Log timings per task.
class TimingsListener implements TaskExecutionListener, BuildListener {
    private long startTime
    private timings = []

    @Override
    void beforeExecute(Task task) {
        startTime = System.nanoTime()
    }

    @Override
    void afterExecute(Task task, TaskState taskState) {
        def ms = TimeUnit.MILLISECONDS.convert(System.nanoTime() - startTime, TimeUnit.NANOSECONDS);
        timings.add([ms, task.path])
        task.project.logger.warn "${task.path} took ${ms}ms"
    }

    @Override
    void buildFinished(BuildResult result) {
        println "Task timings:"
        for (timing in timings) {
            if (timing[0] >= 50) {
                printf "%7sms  %s\n", timing
            }
        }
    }

    @Override
    void buildStarted(Gradle gradle) {}

    @Override
    void projectsEvaluated(Gradle gradle) {}

    @Override
    void projectsLoaded(Gradle gradle) {}

    @Override
    void settingsEvaluated(Settings settings) {}
}

gradle.addListener new TimingsListener()

InformationsquelleAutor Jon

Einfachen Sortierung machen würde @jlevy die Lösung sogar noch besser.

Auch für eine typische Produktion-Anwendungen, ich denke, die Schwelle von 50ms ist zu niedrig.

Wir in der Regel kümmern-Aufgaben, die mehr als 1 Sekunde.

Projekt/bauen.gradle

import java.util.concurrent.TimeUnit

//Log timings per task.
class TimingsListener implements TaskExecutionListener, BuildListener {
    private long startTime
    private timings = []

    @Override
    void beforeExecute(Task task) {
        startTime = System.nanoTime()
    }

    @Override
    void afterExecute(Task task, TaskState taskState) {
        def ms = TimeUnit.MILLISECONDS.convert(System.nanoTime() - startTime, TimeUnit.NANOSECONDS)
        timings.add(new Tuple2<Integer, String>(ms, task.path))
        task.project.logger.warn "${task.path} took ${ms}ms"
    }

    @Override
    void buildFinished(BuildResult result) {
        println "Task timings:"
        def tmp = timings.toSorted(new Comparator<Tuple2<Integer, String>>() {
            @Override
            int compare(Tuple2<Integer, String> o, Tuple2<Integer, String> t1) {
                return o.first - t1.first
            }
        })
        for (timing in tmp) {
            if (timing.first >= 1000) {
                printf "%ss  %s\n", timing.first / 1000, timing.second
            }
        }
    }

    @Override
    void buildStarted(Gradle gradle) {}

    @Override
    void projectsEvaluated(Gradle gradle) {}

    @Override
    void projectsLoaded(Gradle gradle) {}

    @Override
    void settingsEvaluated(Settings settings) {}
}

gradle.addListener new TimingsListener()

Terminal-Ausgabe:

BUILD SUCCESSFUL in 14m 33s
948 actionable tasks: 419 executed, 476 from cache, 53 up-to-date
Task timings:
1.036s  :cbl-config:mergeMyAppDebugResources
1.187s  :express:bundleMyAppDebug
1.199s  :country:testMyAppDebugUnitTest
1.214s  :core-for-test:extractMyAppDebugAnnotations
1.242s  :analytics:testMyAppDebugUnitTest
1.308s  :express:extractMyAppDebugAnnotations
1.33s  :availability:dataBindingExportBuildInfoMyAppDebug
1.357s  :app:transformNativeLibsWithStripDebugSymbolForMyAppDebug
1.405s  :hermes:generateMyAppDebugBuildConfig
1.56s  :availability:testMyAppDebugUnitTest
1.65s  :app:javaPreCompileMyAppDebugUnitTest
1.749s  :chat:compileMyAppDebugJavaWithJavac
1.858s  :cbl-config-for-test:compileMyAppDebugJavaWithJavac
2.027s  :cbl-config:compileMyAppDebugJavaWithJavac
2.056s  :analytics-for-test:compileMyAppDebugJavaWithJavac
2.447s  :crypto:compileMyAppDebugJavaWithJavac
2.45s  :crypto:testMyAppDebugUnitTest
2.47s  :chat:javaPreCompileMyAppDebugUnitTest
2.639s  :crypto-for-test:dataBindingExportBuildInfoMyAppDebug
2.683s  :test-utils:compileMyAppDebugJavaWithJavac
3.056s  :crypto:lintMyAppDebug
3.227s  :app:transformNativeLibsWithMergeJniLibsForMyAppDebug
3.272s  :express:testMyAppDebugUnitTest
3.394s  :crypto:mergeMyAppDebugResources
3.426s  :core:testMyAppDebugUnitTest
4.299s  :multicity:testMyAppDebugUnitTest
4.333s  :app:packageMyAppDebug
4.584s  :availability-for-test:compileMyAppDebugJavaWithJavac
4.672s  :app:transformResourcesWithMergeJavaResForMyAppDebug
4.786s  :map:lintMyAppDebug
5.309s  :country:lintMyAppDebug
5.332s  :job:lintMyAppDebug
5.389s  :map:testMyAppDebugUnitTest
6.04s  :express:lintMyAppDebug
6.584s  :hermes:lintMyAppDebug
6.707s  :app:transformClassesWithMultidexlistForMyAppDebug
7.052s  :multicity:lintMyAppDebug
8.044s  :multicity:compileMyAppDebugJavaWithJavac
8.87s  :app:transformDexArchiveWithDexMergerForMyAppDebug
9.371s  :uikit:testMyAppDebugUnitTest
9.429s  :availability:lintMyAppDebug
13.12s  :app:compileMyAppDebugUnitTestKotlin
16.276s  :hermes:testMyAppDebugUnitTest
16.898s  :chat:testMyAppDebugUnitTest
17.174s  :job:testMyAppDebugUnitTest
36.008s  :grab-junior:testMyAppDebugUnitTest
96.88s  :app:compileMyAppDebugJavaWithJavac
125.693s  :app:lintMyAppDebug
145.538s  :app:transformClassesWithDexBuilderForMyAppDebug
182.752s  :app:testMyAppDebugUnitTest

InformationsquelleAutor ericn

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.