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

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

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

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

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

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

    Kotlin

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

    מגניב

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

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

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

    Kotlin

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

    מגניב

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

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

    Kotlin

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

    מגניב

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

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

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

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

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

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

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

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

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

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

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

  2. בחלונית Templates (תבניות), בוחרים באפשרות Benchmark (השוואה לשוק).

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

מגניב

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, ודוח מלא של השוואת ביצועים עם מדדים נוספים ופרטי המכשיר זמין בפורמט 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"
    }
}

מגניב

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

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

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

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

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