माइक्रोबैंचमार्क लिखें

अपने ऐप्लिकेशन कोड के लिए, क्विकस्टार्ट सेक्शन देखें. यह जानने के लिए कि अपने कोड बेस में ज़्यादा जटिल बदलावों के साथ एक पूरा सेटअप पूरा करें, तो प्रोजेक्ट का पूरा सेटअप सेक्शन.

क्विकस्टार्ट

इस सेक्शन में, मानदंड को इस्तेमाल करने और सिर्फ़ एक बार मापे जाने वाले आंकड़े देखने का तरीका बताया गया है इसके लिए, कोड को मॉड्यूल में ले जाने की ज़रूरत नहीं होती. परफ़ॉर्मेंस के सटीक नतीजे पाने के लिए, इन चरणों में, आपके ऐप्लिकेशन में डीबग करने की सुविधा को बंद करना शामिल है. इसलिए, इसे अपने सोर्स कंट्रोल सिस्टम में बदलाव किए बिना ही कॉपी काम करना.

एक-बार का मानदंड करने के लिए, ये काम करें:

  1. लाइब्रेरी को अपने मॉड्यूल की build.gradle या build.gradle.kts फ़ाइल में जोड़ें:

    Kotlin

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

    ग्रूवी

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

    androidTestImplementation के बजाय, implementation डिपेंडेंसी का इस्तेमाल करें निर्भर है. अगर androidTestImplementation का इस्तेमाल किया जाता है, तो मानदंड चलाएं, क्योंकि लाइब्रेरी मेनिफ़ेस्ट को ऐप्लिकेशन में मर्ज नहीं किया गया है मेनिफ़ेस्ट.

  2. 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 डायरेक्ट्री. Reader Revenue Manager को सेट अप करने के बारे में मानदंड लिखने के बारे में जानने के लिए, माइक्रोबेंचमार्क क्लास बनाना लेख पढ़ें.

    नीचे दिया गया कोड स्निपेट, किसी अहमियत वाले इंस्ट्रुमेंट में बेंचमार्क जोड़ने का तरीका बताता है परीक्षण:

    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 पर सेट करना, सामान्य टेस्ट से अलग होता है.

माइक्रोबेंचमार्क आपके कोड को सीधे तौर पर चलाता है, इसलिए अपनी पसंद का कोड डालें एक अलग Gradle मॉड्यूल में बेंचमार्क और उस मॉड्यूल पर डिपेंडेंसी को इस तरह सेट करना पहली इमेज में दिखाया गया है.

ऐप्लिकेशन का स्ट्रक्चर
पहली इमेज. :app वाला ऐप्लिकेशन स्ट्रक्चर, :microbenchmark और :benchmarkable Gradle मॉड्यूल की मदद से, Microsoft में :benchmarkable मॉड्यूल.

नया Gradle मॉड्यूल जोड़ने के लिए, Android Studio में मॉड्यूल विज़र्ड का इस्तेमाल किया जा सकता है. कॉन्टेंट बनाने विज़र्ड एक ऐसा मॉड्यूल बनाता है जो मानदंड के लिए पहले से कॉन्फ़िगर होता है, जिसमें मानदंड डायरेक्ट्री जोड़ी गई और debuggable को false पर सेट किया गया.

  1. Android के प्रोजेक्ट पैनल में, अपने प्रोजेक्ट या मॉड्यूल पर राइट क्लिक करें स्टूडियो में वापस जाएं और नया > मॉड्यूल.

  2. टेंप्लेट पैनल में मानदंड चुनें.

  3. मानदंड मॉड्यूल टाइप के तौर पर, माइक्रोबेंचमार्क चुनें.

  4. "माइक्रोबेंचमार्क" लिखें मॉड्यूल का नाम डालें.

  5. पूरा करें पर क्लिक करें.

नया लाइब्रेरी मॉड्यूल कॉन्फ़िगर करें
दूसरी इमेज. Android Studio में नया Gradle मॉड्यूल जोड़ना भौंरा.

मॉड्यूल बनने के बाद, उसका 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 के साथ किए जाने वाले मानदंड को गटर ऐक्शन का इस्तेमाल करें, जैसा कि तीसरी इमेज में दिखाया गया है.

माइक्रोबेंचमार्क चलाएं
तीसरी इमेज. गटर ऐक्शन का इस्तेमाल करके माइक्रोबेंचमार्क टेस्ट करें दिख सकता है.

इसके अलावा, कमांड लाइन से, सभी को चलाने के लिए connectedCheck को चलाएं Gradle मॉड्यूल से कितनी जांच की जा सकती हैं:

./gradlew benchmark:connectedCheck

या एक टेस्ट से:

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

बेंचमार्क नतीजे

माइक्रोबेंचमार्क चलाने के बाद, मेट्रिक सीधे Android पर दिखती हैं Studio और अतिरिक्त मेट्रिक और डिवाइस के साथ पूरी मानदंड वाली रिपोर्ट जानकारी JSON फ़ॉर्मैट में उपलब्ध है.

माइक्रोबेंचमार्क के नतीजे
चौथी इमेज. माइक्रोबेंचमार्क के नतीजे.

JSON रिपोर्ट और प्रोफ़ाइलिंग ट्रेस भी डिवाइस से अपने-आप कॉपी हो जाती हैं को होस्ट करना है. ये कोड, होस्ट मशीन पर नीचे दी गई जगह पर लिखे जाते हैं:

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

डिफ़ॉल्ट रूप से, JSON रिपोर्ट को डिवाइस पर मौजूद डिस्क में सेव किया जाता है. इसके लिए, शेयर किया गया बाहरी मीडिया फ़ोल्डर है, जो आम तौर पर /storage/emulated/0/Android/media/**app_id**/**app_id**-benchmarkData.json.

कॉन्फ़िगरेशन से जुड़ी गड़बड़ियां हैं

लाइब्रेरी इन शर्तों का पता लगाती है, ताकि आपके प्रोजेक्ट और एनवायरमेंट को रिलीज़ के हिसाब से सटीक परफ़ॉर्मेंस के लिए सेट अप किया जाता है:

  • डीबग करने लायक, false पर सेट है.
  • किसी फ़िज़िकल डिवाइस का इस्तेमाल किया जा रहा है. एम्युलेटर का इस्तेमाल नहीं किया जा सकता.
  • अगर डिवाइस रूट किया गया है, तो घड़ी लॉक होती है.
  • डिवाइस की बैटरी कम से कम 25% होनी चाहिए.

अगर कोई भी पिछली जांच पूरी नहीं हो पाती है, तो बेंचमार्क गलत मेज़रमेंट को बढ़ावा न दें.

किसी खास तरह की गड़बड़ी को चेतावनी के तौर पर छिपाने और उसे रोकने के लिए बेंचमार्क, इंस्ट्रुमेंटेशन में गड़बड़ी के टाइप को कॉमा लगाकर अलग की गई सूची में पास करें आर्ग्युमेंट androidx.benchmark.suppressErrors.

इसे अपनी ग्रेडल स्क्रिप्ट से सेट किया जा सकता है, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

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_ को जोड़ देता है.

पीछे जाएं
माइक्रोबेंचमार्क के बारे में जानकारी
आगे बढ़ें
मानदंड की पहचान करना