כתיבת נתוני מיקרובנצ'מרק

כדי ללמוד איך להשתמש בספריית Microbenchmark על ידי הוספת שינויים לקוד האפליקציה, אפשר לעיין בקטע מדריך למתחילים. כדי ללמוד איך להשלים הגדרה מלאה עם שינויים מורכבים יותר בבסיס הקוד, אפשר לעיין בקטע הגדרה מלאה של פרויקט.

מדריך למתחילים

בקטע הזה מוסבר איך לנסות את ההשוואה לשוק ולהריץ מדידות חד-פעמיות בלי להעביר קוד למודולים. כדי לקבל תוצאות מדויקות של הביצועים, צריך להשבית את ניפוי הבאגים באפליקציה. לכן, מומלץ לבצע את השלבים האלה בעותק עבודה מקומי בלי לבצע את השינויים במערכת בקרת המקור.

כדי לבצע השוואה חד-פעמית לשוק:

  1. מוסיפים את הספרייה לקובץ build.gradle או build.gradle.kts של המודול:

    Kotlin

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

    Groovy

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

    במקום להשתמש בתלות androidTestImplementation, צריך להשתמש בתלות implementation. אם משתמשים ב-androidTestImplementation, ההשוואות לא יפעלו כי המניפסט של הספרייה לא מוזג עם המניפסט של האפליקציה.

  2. מעדכנים את סוג ה-build‏ debug כך שלא ניתן יהיה לבצע בו ניפוי באגים:

    Kotlin

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

    Groovy

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

  3. משנים את הערך של testInstrumentationRunner ל-AndroidBenchmarkRunner:

    Kotlin

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

    Groovy

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

  4. כדי להוסיף את המדד, מוסיפים מופע של BenchmarkRule בקובץ בדיקה בספרייה androidTest. מידע נוסף על כתיבת נקודות השוואה זמין במאמר בנושא יצירת מחלקה של מיקרו-מדד.

    בקטע הקוד הבא מוצג איך מוסיפים מדד השוואה לבדיקה עם מכשור:

    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()
            );
       }
    }
}

כדי ללמוד איך לכתוב מדד השוואה, אפשר לדלג אל יצירת מחלקה של מיקרו-מדד השוואה.

הגדרה מלאה של הפרויקט

כדי להגדיר בנצ'מרקינג רגיל במקום בנצ'מרקינג חד-פעמי, צריך לבודד את הבנצ'מרקים למודול משלהם. כך תוכלו לוודא שההגדרה שלהם, כמו הגדרת debuggable לערך false, נפרדת מבדיקות רגילות.

הספרייה Microbenchmark מריצה את הקוד שלכם ישירות, ולכן צריך להציב את הקוד שרוצים לבצע לו בנצ'מרק במודול Gradle נפרד ולהגדיר תלות במודול הזה כמו שמוצג באיור 1.

מבנה האפליקציה
איור 1. מבנה האפליקציה עם מודולים של :app,‏ :microbenchmark ו-:benchmarkable Gradle, שמאפשרים ל-Microbenchmarks לבצע בנצ'מרקינג של קוד במודול :benchmarkable.

כדי להוסיף מודול חדש של Gradle, אפשר להשתמש באשף המודולים ב-Android Studio. אשף יוצר מודול שמוגדר מראש להשוואה לשוק, עם ספריית השוואה לשוק שנוספה ועם debuggable שמוגדר ל-false.

  1. לוחצים לחיצה ימנית על הפרויקט או המודול בחלונית Project (פרויקט) ב-Android Studio ולוחצים על New > Module (חדש > מודול).

  2. לוחצים על השוואה לשוק בחלונית תבניות.

  3. בוחרים באפשרות Microbenchmark (מיקרו-מדד השוואה) כסוג מודול מדד ההשוואה.

  4. מקלידים microbenchmark בשם המודול.

  5. לוחצים על סיום.

הגדרת מודול חדש של ספרייה
איור 2. הוספת מודול Gradle חדש ב-Android Studio Bumblebee

אחרי שיוצרים את המודול, משנים את הקובץ build.gradle או build.gradle.kts ומוסיפים את androidTestImplementation למודול שמכיל קוד להשוואה:

Kotlin

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

Groovy

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

יצירת מחלקה של מיקרו-בנצ'מרק

בדיקות השוואה הן בדיקות אינסטרומנטציה רגילות. כדי ליצור מדד השוואה, משתמשים במחלקה BenchmarkRule שסופקה על ידי הספרייה. כדי להשוות פעילויות לנקודת השוואה, משתמשים בפונקציות ActivityScenario או ActivityScenarioRule. כדי להשוות בין קוד ממשק משתמש לבין קוד אחר, משתמשים בפונקציה @UiThreadTest.

הקוד הבא מציג מדד השוואה לדוגמה:

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() {
        final BenchmarkState state = benchmarkRule.getState();
        while (state.keepRunning()) {
            doSomeWork();
        }
    }
}

השבתת התזמון של ההגדרה

אפשר להשבית את התזמון של קטעי קוד שלא רוצים למדוד באמצעות הבלוק runWithTimingDisabled{}. הקטעים האלה בדרך כלל מייצגים קוד שצריך להפעיל בכל איטרציה של ההשוואה לשוק.

Kotlin

// 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

Java

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

כדאי לצמצם את כמות העבודה שמתבצעת בתוך הבלוק measureRepeated ובתוך runWithTimingDisabled. הבלוק measureRepeated מופעל כמה פעמים, והוא יכול להשפיע על הזמן הכולל שנדרש להפעלת ההשוואה לשוק. אם צריך לאמת חלק מהתוצאות של בדיקת ההשוואה, אפשר לאמת את התוצאה האחרונה במקום לעשות זאת בכל איטרציה של בדיקת ההשוואה.

הפעלת ההשוואה לשוק

ב-Android Studio, מריצים את הבדיקה כמו שמריצים כל @Test באמצעות הפעולה בסרגל הצידי שליד מחלקת הבדיקה או המתודה, כמו שמוצג באיור 3.

הרצת Microbenchmark
איור 3. מריצים בדיקת Microbenchmark באמצעות הפעולה בסרגל הניווט לצד מחלקת בדיקה.

לחלופין, משורת הפקודה, מריצים את connectedCheck כדי להריץ את כל הבדיקות ממודול Gradle שצוין:

./gradlew benchmark:connectedCheck

או בדיקה אחת:

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

תוצאות ההשוואה לשוק

אחרי הרצה מוצלחת של Microbenchmark, המדדים מוצגים ישירות ב-Android Studio, ודוח השוואה (benchmark) מלא עם מדדים נוספים ופרטי המכשיר זמין בפורמט JSON.

תוצאות של מיקרו-בנצ&#39;מרק
איור 4. תוצאות של Microbenchmark.

גם דוחות JSON ועקבות של תיעוד מועתקים אוטומטית מהמכשיר למארח. הן נכתבות במכונת המארח במיקום הבא:

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

כברירת מחדל, דוח ה-JSON נכתב לדיסק במכשיר בתיקיית המדיה החיצונית המשותפת של קובץ ה-APK של הבדיקה, שבדרך כלל נמצאת ב-/storage/emulated/0/Android/media/**app_id**/**app_id**-benchmarkData.json.

שגיאות בהגדרות

הספרייה מזהה את התנאים הבאים כדי לוודא שהפרויקט והסביבה מוגדרים לביצועים מדויקים של הגרסה:

  • האפשרות Debuggable מוגדרת ל-false.
  • נעשה שימוש במכשיר פיזי – אין תמיכה באמולטורים.
  • השעונים נעולים אם המכשיר עבר תהליך רוט (Root).
  • רמת הטעינה של הסוללה במכשיר מספיקה, לפחות 25%.

אם אחת מהבדיקות הקודמות נכשלת, בדוח ההשוואה לשוק מוצגת שגיאה כדי למנוע מדידות לא מדויקות.

כדי להגדיר שסוגי שגיאות ספציפיים יוצגו כאזהרות ולא יגרמו להפסקת הבדיקה, צריך להעביר את סוג השגיאה ברשימה מופרדת בפסיקים לארגומנט של המדידה androidx.benchmark.suppressErrors.

אפשר להגדיר את זה באמצעות סקריפט Gradle, כמו בדוגמה הבאה:

Kotlin

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

Groovy

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

אפשר גם להשבית את השגיאות משורת הפקודה:

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

הסתרת השגיאות מאפשרת להריץ את ההשוואה למדד במצב לא מוגדר, והפלט של ההשוואה למדד משנה את השם בכוונה על ידי הוספת השגיאה לשמות הבדיקה. לדוגמה, הפעלת מדד השוואה שאפשר לנפות בו באגים עם ההשבתה בקטע הקוד הקודם מוסיפה את הקידומת DEBUGGABLE_ לשמות הבדיקות.

הקודם
מידע על Microbenchmark
הבא
יצירת פרופיל של נקודת השוואה