Mikro-Benchmark schreiben

Um zu erfahren, wie Sie die MicroBenchmark-Bibliothek verwenden können, indem Sie Änderungen an Ihrem finden Sie im Abschnitt Kurzanleitung. Wenn Sie mehr darüber erfahren möchten, wie Sie eine vollständige Einrichtung mit komplizierteren Änderungen an Ihrer Codebasis durchführen, siehe Abschnitt Vollständige Projekteinrichtung.

Kurzanleitung

In diesem Abschnitt erfahren Sie, wie Sie Benchmarking ausprobieren und einmalige Messungen ausführen, ohne Code in Module verschieben zu müssen. Um genaue Leistungsergebnisse zu erhalten, Dazu muss die Fehlerbehebung in Ihrer App deaktiviert werden. ohne die Änderungen in Ihr Versionsverwaltungssystem zu übernehmen.

So führen Sie einen einmaligen Benchmark aus:

1. Fügen Sie die Bibliothek der Datei build.gradle oder build.gradle.kts Ihres Moduls hinzu:

   Kotlin

   dependencies {
       implementation("androidx.benchmark:benchmark-junit4:1.2.4")
   }
   

   Cool

   dependencies {
       implementation 'androidx.benchmark:benchmark-junit4:1.2.4'
   }
   

   Verwenden Sie eine implementation-Abhängigkeit anstelle einer androidTestImplementation-Abhängigkeit. Wenn Sie androidTestImplementation verwenden, entsprechen die Benchmarks ausgeführt, da das Bibliotheksmanifest nicht mit der App zusammengeführt wurde Manifests.

2. Aktualisieren Sie den Buildtyp von debug, damit er nicht debugbar ist:

   Kotlin

   android {
       ...
       buildTypes {
           debug {
               isDebuggable = false
           }
       }
   }
   

   Cool

   android {
       ...
       buildTypes {
           debug {
               debuggable false
           }
       }
   }
   

3. Ändern Sie testInstrumentationRunner in AndroidBenchmarkRunner:

   Kotlin

   android {
       ...
       defaultConfig {
           testInstrumentationRunner = "androidx.benchmark.junit4.AndroidBenchmarkRunner"
       }
   }
   

   Cool

   android {
       ...
       defaultConfig {
           testInstrumentationRunner "androidx.benchmark.junit4.AndroidBenchmarkRunner"
       }
   }
   

4. Fügen Sie eine Instanz von BenchmarkRule in einer Testdatei im androidTest, um die Benchmark hinzuzufügen. Weitere Informationen zum Erstellen von Benchmarks finden Sie unter Microbenchmark-Klasse erstellen.

   Im folgenden Code-Snippet sehen Sie, wie Sie einer instrumentierten Test:

   Kotlin

   @RunWith(AndroidJUnit4::class)
   class SampleBenchmark {
       @get:Rule
       val benchmarkRule = BenchmarkRule()
   
       @Test
       fun benchmarkSomeWork() {
           benchmarkRule.measureRepeated {
               doSomeWork()
           }
       }
   }
   SampleBenchmark.kt
   

   Java

   @RunWith(AndroidJUnit4.class)
   class SampleBenchmark {
       @Rule
       public BenchmarkRule benchmarkRule = new BenchmarkRule();
   
       @Test
       public void benchmarkSomeWork() {
               BenchmarkRuleKt.measureRepeated(
                   (Function1<BenchmarkRule.Scope, Unit>) scope -> doSomeWork()
               );
          }
       }
   }
   

Informationen zum Erstellen eines Benchmarks finden Sie unter Microbenchmark-Klasse erstellen.

Vollständige Projekteinrichtung

Um ein regelmäßiges Benchmarking anstelle einmaliger Benchmarking einzurichten, isolieren Sie die Benchmarks in einem eigenen Modul an. So wird sichergestellt, dass ihre Konfiguration, wie das Festlegen von debuggable auf false, unterscheidet sich von regulären Tests.

Da MicroBenchmark Ihren Code direkt ausführt, platzieren Sie den Code, den Sie Benchmark in einem separaten Gradle-Modul und setze die Abhängigkeit von diesem Modul als wie in Abbildung 1 dargestellt.

Mit dem Modulassistenten in Android Studio können Sie ein neues Gradle-Modul hinzufügen. Die ein für das Benchmarking vorkonfiguriertes Modul mit einem Benchmark-Verzeichnis hinzugefügt und debuggable auf false festgelegt.

1. Klicken Sie in Android im Bereich Project (Projekt) mit der rechten Maustaste auf Ihr Projekt oder Modul. Studio an und klicken Sie auf Neu > Modul.

2. Wählen Sie im Bereich Vorlagen die Option Benchmark aus.

3. Wählen Sie als Typ des Benchmark-Moduls MicroBenchmark aus.

4. Geben Sie „MicroBenchmark“ ein. als Modulnamen.

5. Klicken Sie auf Fertig.

Nachdem das Modul erstellt wurde, ändern Sie build.gradle oder build.gradle.kts und fügen Sie androidTestImplementation in das Modul ein, das den Code enthält, Benchmark:

dependencies {
    // The module name might be different.
    androidTestImplementation(project(":benchmarkable"))
}

dependencies {
    // The module name might be different.
    androidTestImplementation project(':benchmarkable')
}

Microbenchmark-Klasse erstellen

Benchmarks sind standardmäßige Instrumentierungstests. Verwenden Sie zum Erstellen eines Benchmarks die von der Bibliothek bereitgestellte Klasse BenchmarkRule. Verwenden Sie ActivityScenario oder ActivityScenarioRule, um Aktivitäten zu vergleichen. Um den UI-Code zu vergleichen, Verwenden Sie @UiThreadTest.

Der folgende Code zeigt einen Beispiel-Benchmark:

@RunWith(AndroidJUnit4::class)
class SampleBenchmark {
    @get:Rule
    val benchmarkRule = BenchmarkRule()

    @Test
    fun benchmarkSomeWork() {
        benchmarkRule.measureRepeated {
            doSomeWork()
        }
    }
}
SampleBenchmark.kt
    

@RunWith(AndroidJUnit4.class)
class SampleBenchmark {
    @Rule
    public BenchmarkRule benchmarkRule = new BenchmarkRule();

    @Test
    public void benchmarkSomeWork() {
        final BenchmarkState state = benchmarkRule.getState();
        while (state.keepRunning()) {
            doSomeWork();
        }
    }
}
    

Zeitplan für die Einrichtung deaktivieren

Sie können das Timing für Code-Abschnitte deaktivieren, die Sie nicht mit der Funktion runWithTimingDisabled{}-Block Diese Abschnitte stehen in der Regel den Sie bei jeder Iteration der Benchmark ausführen müssen.

// using random with the same seed, so that it generates the same data every run
private val random = Random(0)

// create the array once and just copy it in benchmarks
private val unsorted = IntArray(10_000) { random.nextInt() }

@Test
fun benchmark_quickSort() {
    // ...
    benchmarkRule.measureRepeated {
        // copy the array with timing disabled to measure only the algorithm itself
        listToSort = runWithTimingDisabled { unsorted.copyOf() }

        // sort the array in place and measure how long it takes
        SortingAlgorithms.quickSort(listToSort)
    }

    // assert only once not to add overhead to the benchmarks
    assertTrue(listToSort.isSorted)
}
SortingBenchmarks.kt
    

private final int[] unsorted = new int[10000];

public SampleBenchmark() {
    // Use random with the same seed, so that it generates the same data every
    // run.
    Random random = new Random(0);

    // Create the array once and copy it in benchmarks.
    Arrays.setAll(unsorted, (index) -> random.nextInt());
}

@Test
public void benchmark_quickSort() {
    final BenchmarkState state = benchmarkRule.getState();

    int[] listToSort = new int[0];

    while (state.keepRunning()) {
        
        // Copy the array with timing disabled to measure only the algorithm
        // itself.
        state.pauseTiming();
        listToSort = Arrays.copyOf(unsorted, 10000);
        state.resumeTiming();
        
        // Sort the array in place and measure how long it takes.
        SortingAlgorithms.quickSort(listToSort);
    }

    // Assert only once, not to add overhead to the benchmarks.
    assertTrue(SortingAlgorithmsKt.isSorted(listToSort));
}
    

Versuchen Sie, den Arbeitsaufwand innerhalb des measureRepeated-Blocks zu minimieren. und innerhalb von runWithTimingDisabled. Der Block measureRepeated wird mehrfach ausgeführt und kann sich auf die Gesamtzeit auswirken, die zum Ausführen der Benchmark benötigt wird. Wenn Sie Ergebnisse einer Benchmark überprüfen müssen, können Sie anstatt bei jeder Iteration des Benchmarks.

Benchmark ausführen

Führen Sie in Android Studio Ihren Benchmark wie bei jeder @Test aus, indem Sie die Aktion in der Leiste neben Ihrer Testklasse oder ‑methode ausführen, wie in Abbildung 3 dargestellt.

Alternativ können Sie über die Befehlszeile connectedCheck ausführen, um alle der Tests aus dem angegebenen Gradle-Modul:

./gradlew benchmark:connectedCheck

Oder einen einzelnen Test:

./gradlew benchmark:connectedCheck -P android.testInstrumentationRunnerArguments.class=com.example.benchmark.SampleBenchmark#benchmarkSomeWork

Benchmarkergebnisse

Nach einem erfolgreichen Microbenchmark-Lauf werden die Messwerte direkt in Android Studio angezeigt und ein vollständiger Benchmarkbericht mit zusätzlichen Messwerten und Geräteinformationen ist im JSON-Format verfügbar.

JSON-Berichte und alle Profiling-Traces werden ebenfalls automatisch vom Gerät auf den Host kopiert. Sie werden an folgendem Ort auf dem Hostcomputer geschrieben:

project_root/module/build/outputs/connected_android_test_additional_output/debugAndroidTest/connected/device_id/

Standardmäßig wird der JSON-Bericht im extern freigegebener Medienordner, der sich in der Regel in /storage/emulated/0/Android/media/**app_id**/**app_id**-benchmarkData.json

Konfigurationsfehler

Die Bibliothek erkennt die folgenden Bedingungen, damit Ihr Projekt und -Umgebung für Release-genaue Leistung eingerichtet sind:

• „Debuggable“ ist auf false festgelegt.
• Ein physisches Gerät wird verwendet – Emulatoren werden nicht unterstützt.
• Die Uhr wird gesperrt, wenn das Gerät gerootet ist.
• Der Akkustand des Geräts muss mindestens 25 % betragen.

Wenn eine der vorherigen Prüfungen fehlschlägt, meldet die Benchmark einen Fehler an ungenaue Messungen vermeiden.

Wenn Sie bestimmte Fehlertypen als Warnungen unterdrücken und verhindern möchten, dass der Benchmark dadurch beendet wird, übergeben Sie den Fehlertyp in einer durch Kommas getrennten Liste an das Instrumentierungsargument androidx.benchmark.suppressErrors.

Sie können dies in Ihrem Gradle-Script festlegen, wie im folgenden Beispiel gezeigt:

android {
    defaultConfig {
       …
      testInstrumentationRunnerArguments["androidx.benchmark.suppressErrors"] = "DEBUGGABLE,LOW-BATTERY"
    }
}

android {
    defaultConfig {
       …
      testInstrumentationRunnerArguments["androidx.benchmark.suppressErrors"] = "DEBUGGABLE,LOW-BATTERY"
    }
}

Sie können Fehler auch über die Befehlszeile unterdrücken:

$ ./gradlew :benchmark:connectedCheck -P andoidtestInstrumentationRunnerArguments.androidx.benchmark.supperssErrors=DEBUGGABLE,LOW-BATTERY

Wenn Sie Fehler unterdrücken, wird die Benchmark in einem falsch konfigurierten Zustand ausgeführt. und das Ergebnis der Benchmark wird durch das Voranstellen des Tests absichtlich umbenannt. Namen mit dem Fehler. Wenn Sie z. B. eine debugfähige Benchmark mit dem Durch die Unterdrückung im vorherigen Snippet wird Testnamen das Zeichen DEBUGGABLE_ vorangestellt.