मैक्रोबेंचमार्क मेट्रिक कैप्चर करें

मेट्रिक, आपके मानदंड से निकाली गई मुख्य जानकारी होती है. इन्हें measureRepeated फ़ंक्शन में List के तौर पर पास किया जाता है. इससे, मेज़र की गई कई मेट्रिक को एक साथ तय किया जा सकता है. बेंचमार्क चलाने के लिए, कम से कम एक तरह की मेट्रिक ज़रूरी है.

यहां दिया गया कोड स्निपेट, Jetpack Compose के लेज़ी लेआउट इंटरफ़ेस के लिए, फ़्रेम टाइमिंग और कस्टम ट्रेस सेक्शन की मेट्रिक कैप्चर करता है:

@OptIn(ExperimentalMetricApi::class)
    @Test
    fun scrollComposeList() {
        benchmarkRule.measureRepeated(
            // [START_EXCLUDE]
            packageName = TARGET_PACKAGE,
            metrics = listOf(
                FrameTimingMetric(),
                // Measure power usage. This is supported on Pixel 6 and later.
                PowerMetric(PowerMetric.Type.Power(
                    mapOf(
                        PowerCategory.CPU to PowerCategoryDisplayLevel.TOTAL,
                        PowerCategory.DISPLAY to PowerCategoryDisplayLevel.TOTAL,
                        PowerCategory.GPU to PowerCategoryDisplayLevel.TOTAL,
                        PowerCategory.NETWORK to PowerCategoryDisplayLevel.TOTAL,
                    )
                )),
                // Measure custom trace sections by name EntryRow (which is added to the EntryRow composable).
                // Mode.Sum measures combined duration and also how many times it occurred in the trace.
                // This way, you can estimate whether a composable recomposes more than it should.
                TraceSectionMetric("EntryRowCustomTrace", TraceSectionMetric.Mode.Sum),
                // This trace section takes into account the SQL wildcard character %,
                // which can find trace sections without the full name.
                // This way, you can measure composables produced by the composition tracing
                // and measure how long they took and how many times they recomposed.
                // WARNING: This metric only shows results when running with composition tracing, otherwise it won't be visible in the outputs.
                TraceSectionMetric("%EntryRow%", TraceSectionMetric.Mode.Sum),
            ),
            // Try switching to different compilation modes to see the effect
            // it has on frame timing metrics.
            compilationMode = CompilationMode.None(),
            startupMode = StartupMode.WARM, // restarts activity each iteration
            iterations = DEFAULT_ITERATIONS,
            // [END_EXCLUDE]
            setupBlock = {
                uiAutomator {
                    // Before starting to measure, navigate to the UI to be measured.
                    startIntent(Intent("$packageName.COMPOSE_ACTIVITY"))
                }
            }
        ) {
            uiAutomator {
                onElement { isScrollable }.fling(Direction.DOWN)
            }
        }
    }

यहां दिए गए उदाहरण में, EntryRowCustomTrace कस्टम ट्रेस सेक्शन को दिखाता है. इसे स्टैंडर्ड Kotlin trace(sectionName) { ... } ब्लॉक रैपर का इस्तेमाल करके, कंपोज़ किए जा सकने वाले आइटम की लेयर में तय किया गया है. TraceSectionMetric के लिए डेटा उपलब्ध कराने के लिए, आपको अपने ऐप्लिकेशन के प्रोडक्शन कोड बेस में मौजूद टारगेट यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को स्टैंडर्ड Jetpack रनटाइम trace ब्लॉक रैपर के साथ रैप करना होगा:

@Composable
private fun EntryRow(entry: Entry, modifier: Modifier = Modifier) = trace("EntryRowCustomTrace") {
    Card(modifier = modifier) {
        Row(verticalAlignment = Alignment.CenterVertically) {
            Text(
                text = entry.contents,
                modifier = Modifier
                    .padding(16.dp)
                    .wrapContentSize()
            )

            Spacer(modifier = Modifier.weight(1f))

            Checkbox(
                checked = false,
                onCheckedChange = {},
                modifier = Modifier.padding(16.dp)
            )
        }
    }
}

बेंचमार्क टेस्ट के नतीजे, सीधे Android Studio में बेंचमार्क टर्मिनल टैब पर आउटपुट के तौर पर दिखते हैं. जैसा कि इमेज 1 में दिखाया गया है. अगर एक से ज़्यादा मेट्रिक तय की गई हैं, तो उनके कैलकुलेट किए गए सभी डेटा पॉइंट, खास जानकारी वाली विंडो में जोड़ दिए जाते हैं.

TraceSectionMetric और FrameTimingMetric के नतीजे.
पहली इमेज. मॉडर्न Compose लेआउट के लिए, TraceSectionMetric और FrameTimingMetric के कंसोल के नतीजे एक साथ दिखाए गए हैं.

StartupTimingMetric, FrameTimingMetric, TraceSectionMetric, और PowerMetric के बारे में यहां ज़्यादा जानकारी दी गई है. उपलब्ध बेंचमार्क मेट्रिक की पूरी सूची देखने के लिए, एपीआई रेफ़रंस में Metric की सबक्लास देखें.

StartupTimingMetric

StartupTimingMetric, ऐप्लिकेशन के शुरू होने में लगने वाले समय की मेट्रिक को इन वैल्यू के साथ कैप्चर करता है:

  • timeToInitialDisplayMs: सिस्टम को लॉन्च इंटेंट मिलने से लेकर, डेस्टिनेशन स्क्रीन का पहला फ़्रेम रेंडर होने तक लगने वाला समय.
  • timeToFullDisplayMs: सिस्टम को लॉन्च इंटेंट मिलने से लेकर, ऐप्लिकेशन के पूरी तरह से ड्रॉ होने की रिपोर्ट मिलने तक का समय. यह रिपोर्ट, प्लैटफ़ॉर्म के इंटरनल रिपोर्टिंग मैकेनिज़्म का इस्तेमाल करके मिलती है. मेज़रमेंट तब रुक जाता है, जब पूरी तरह से रेंडर किए गए सिग्नल के बाद या उसमें शामिल पहले फ़्रेम की रेंडरिंग पूरी हो जाती है.

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

Compose-first आर्किटेक्चर में, activity.reportFullyDrawn को मैन्युअल तरीके से शुरू करने की कोशिश न करें. इसके बजाय, अपने स्क्रीन कंपोज़ेबल में Compose-safe एसिंक्रोनस यूटिलिटी ReportDrawn, ReportDrawnWhen या ReportDrawnAfter का इस्तेमाल करें. इससे Macrobenchmark को अपने-आप सिग्नल मिल जाता है कि आपके एसिंक्रोनस नेटवर्क डेटा या जटिल यूज़र इंटरफ़ेस (यूआई) की स्थितियों की रेंडरिंग पूरी हो गई है.

ऐप्लिकेशन के शुरू होने की परफ़ॉर्मेंस का विश्लेषण करने और उसे ऑप्टिमाइज़ करने के बारे में ज़्यादा जानने के लिए, ऐप्लिकेशन के स्टार्टअप का समय देखें.

FrameTimingMetric

FrameTimingMetric, बेंचमार्क जर्नी से जनरेट किए गए फ़्रेम से सटीक समय की जानकारी कैप्चर करता है. जैसे, किसी सूची को स्क्रोल करना या यूज़र इंटरफ़ेस (यूआई) के जटिल लेआउट का ऐनिमेशन. साथ ही, यह गड़बड़ी की जानकारी देने वाली ये वैल्यू दिखाता है:

  • frameOverrunMs: वह समय जिसके बाद कोई फ़्रेम अपनी समयसीमा को पार कर जाता है. पॉज़िटिव नंबर, ड्रॉप किए गए फ़्रेम के बारे में बताते हैं. साथ ही, इनमें विज़ुअल जैंक या स्टटर भी शामिल होता है. नेगेटिव नंबर से पता चलता है कि सबसिस्टम हार्डवेयर की समयसीमा के मुकाबले, कोई फ़्रेम कितनी तेज़ी से पूरा हुआ. ध्यान दें: यह मेट्रिक सिर्फ़ Android 12 (एपीआई लेवल 31) और इसके बाद के वर्शन पर उपलब्ध है.
  • frameDurationCpuMs: सीपीयू पर फ़्रेम को रेंडर करने में लगने वाला समय. इसमें मुख्य ऐप्लिकेशन यूज़र इंटरफ़ेस (यूआई) थ्रेड और Compose RenderThread, दोनों शामिल हैं.

ये मेज़रमेंट, 50वें, 90वें, 95वें, और 99वें पर्सेंटाइल के डिस्ट्रिब्यूशन में इकट्ठा किए जाते हैं:

frameDurationCpuMs P50 3.5, P90 6.0, P95 6.4, P99 11.0
frameOverrunMs P50 -11.6, P90 -7.2, P95 -7.1, P99 -1.2

Jetpack Compose के लेआउट की हैरारकी को ऑप्टिमाइज़ करते समय, सबसे खराब परफ़ॉर्म करने वाले फ़्रेम (P95 और P99 बाउंड) देखें. अगर frameOverrunMs, हाई पर्सेंटाइल पर पॉज़िटिव इंटीजर में बदल जाता है, तो इसका मतलब है कि रीकंपोज़िशन की वजह से, स्क्रोल ऐनिमेशन के दौरान मुख्य थ्रेड रुक रहा है.

धीमे फ़्रेम की पहचान करने और उन्हें ठीक करने के बारे में ज़्यादा जानने के लिए, Jetpack Compose की परफ़ॉर्मेंस देखें.

TraceSectionMetric

TraceSectionMetric से यह पता चलता है कि ट्रेस का कोई सेक्शन कितनी बार ट्रिगर हुआ और उसे पूरा होने में कितना समय लगा. समय को ट्रैक करने के लिए, यह मिलीसेकंड में कम से कम, औसत, और ज़्यादा से ज़्यादा समय दिखाता है. टारगेट ट्रेस सेक्शन को फ़ंक्शन कॉल trace(sectionName) या Trace.beginSection(sectionName) और Trace.endSection() या उनके एसिंक्रोनस वैरिएंट के बीच के निचले लेवल के ब्लॉक की सीमाओं से तय किया जाता है.

EntryRowCustomTraceCount min 20.0, median 28.0, max 50.0
EntryRowCustomTraceSumMs min 34.9, median 44.4, max 66.6

डिफ़ॉल्ट रूप से, मेट्रिक सिर्फ़ उन ट्रेस सेक्शन को आउटपुट करती है जो सीधे आपके ऐप्लिकेशन पैकेज बाइनरी से कंपाइल किए गए हैं. अपने ऐप्लिकेशन के पैकेज की सीमा से बाहर की प्रोसेस को शामिल करने के लिए, targetPackageOnly = false प्रॉपर्टी सेट करें.

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

मैन्युअल तरीके से प्रोफ़ाइलर ट्रेस के लिए, अपने टारगेट ऐप्लिकेशन में androidx.compose.runtime:runtime-tracing डिपेंडेंसी जोड़ना काफ़ी है. हालांकि, Macrobenchmark रन के दौरान प्रोग्राम के हिसाब से इन ट्रेस को कैप्चर करने के लिए, आपको अपने मानदंड मॉड्यूल में अतिरिक्त कॉन्फ़िगरेशन करना होगा.

सेटअप करने के पूरे निर्देशों के लिए, Jetpack Macrobenchmark की मदद से ट्रेस कैप्चर करना लेख पढ़ें.

PowerMetric

PowerMetric, मैक्रोबेंचमार्क के चलने के दौरान, पावर या ऊर्जा में होने वाले बदलाव को कैप्चर करता है. चुनी गई हर कैटगरी को उसके मेज़र किए जा सकने वाले हार्डवेयर कॉम्पोनेंट में बांटा जाता है. वहीं, नहीं चुनी गई कैटगरी को "नहीं चुनी गई" बकेट में ग्रुप किया जाता है.

हार्डवेयर से जुड़ी ज़रूरी शर्तें: ये मेट्रिक, हर ऐप्लिकेशन के हिसाब से कैलकुलेशन करने के बजाय, पूरे सिस्टम के हिसाब से खपत को मेज़र करती हैं. इसलिए, डेटा कलेक्शन की सुविधा सिर्फ़ Google Pixel 6, Pixel 6 Pro, और इसके बाद के फ़िज़िकल डिवाइसों तक सीमित है.

यह मेट्रिक, हर कैटगरी के लिए दो मेज़रमेंट दिखाती है:

  • power<category>Uw: इस कैटगरी में, आपके टेस्ट के दौरान खर्च हुई पावर की मात्रा (माइक्रोवॉट में).
  • energy<category>Uws: इस कैटगरी में टेस्ट के दौरान, हर यूनिट समय में ट्रांसफ़र की गई ऊर्जा की कुल मात्रा (माइक्रोवॉट-सेकंड में मेज़र की गई).

कैटगरी में ये शामिल हैं:

  • CPU
  • DISPLAY
  • GPU
  • GPS
  • MEMORY
  • MACHINE_LEARNING
  • NETWORK
  • UNCATEGORIZED

CPU जैसी कुछ कैटगरी में, अन्य प्रोसेस से किए गए काम को आपके ऐप्लिकेशन से किए गए काम से अलग करना मुश्किल हो सकता है. रुकावट को कम करने के लिए, ग़ैर-ज़रूरी ऐप्लिकेशन और खातों को हटाएं या उन पर पाबंदी लगाएं.

powerCategoryCpuUw min 300.2, median 346.1, max 519.6
powerCategoryDisplayUw min 319.8, median 325.8, max 329.7
powerCategoryGpuUw min 18.8, median 23.3, max 36.9
powerCategoryNetworkUw min 97.3, median 123.3, max 681.3
powerTotalUw min 1234.8, median 1316.6, max 2112.4
powerUnselectedUw       min  483.3,  median  512.6,  max  561.7

मुख्य सबसिस्टम का विश्लेषण करना

PowerMetric, दी गई पावर कैटगरी के लिए, टेस्ट के दौरान पावर या एनर्जी में हुए बदलाव को कैप्चर करता है. चुनी गई हर कैटगरी को उसके मेज़र किए जा सकने वाले सब-कॉम्पोनेंट में बांटा जाता है. साथ ही, नहीं चुनी गई कैटगरी को "नहीं चुनी गई" मेट्रिक में जोड़ा जाता है.

टर्मिनल के आउटपुट, आपके अनुरोध किए गए कॉन्फ़िगरेशन के हिसाब से मैप होते हैं:

  • powerCategoryCpuUw: टेस्ट के दौरान, सीपीयू ने कितनी बिजली खर्च की.
  • powerCategoryGpuUw: टेस्ट के दौरान, जीपीयू ने कितनी बिजली खर्च की.
  • powerUnselectedUw: हार्डवेयर की उन सभी उपलब्ध कैटगरी से खर्च की गई कुल बैटरी जिनके लिए, आपके इनिशलाइज़ेशन मैप में साफ़ तौर पर अनुरोध नहीं किया गया था.

रन के दौरान हार्डवेयर रेल पर डेटा में अचानक होने वाली बढ़ोतरी को रोकने के लिए, स्क्रीन की रोशनी को एक तय वैल्यू पर लॉक करें. साथ ही, डिवाइस के तापमान को सामान्य बनाए रखें. इसके अलावा, Macrobenchmark लूप शुरू करने से पहले, बैकग्राउंड में चल रही ऐसी प्रोसेस बंद करें जो एक-दूसरे के साथ काम नहीं करतीं.

अन्य संसाधन

कॉन्टेंट देखना

पीछे जाएं
मानदंड लिखना
आगे बढ़ें
अपना ऐप्लिकेशन कंट्रोल करें