मैक्रोबेंचमार्क लाइब्रेरी के साथ बेंचमार्क बेसलाइन प्रोफ़ाइल

हमारा सुझाव है कि Jetpack Macrobenchmark का इस्तेमाल करके यह जांच करें कि बेसलाइन प्रोफ़ाइलें चालू होने पर, कोई ऐप्लिकेशन कैसा परफ़ॉर्म करता है. इसके बाद, उन नतीजों की तुलना, बेसलाइन प्रोफ़ाइलें बंद होने पर मिलने वाले बेंचमार्क से करें. इस तरीके से, ऐप्लिकेशन के शुरू होने में लगने वाला समय या रनटाइम रेंडरिंग की परफ़ॉर्मेंस को मेज़र किया जा सकता है. इससे यह पता चलता है कि जनक (ऐप्लिकेशन के फ़्रेम अचानक रुकने या हिलने की समस्या) की वजह से, फ़्रेम जनरेट होने में लगने वाला समय बढ़ता है या नहीं.

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

@RunWith(AndroidJUnit4ClassRunner::class)
class ColdStartupBenchmark {
    @get:Rule
    val benchmarkRule = MacrobenchmarkRule()

    // No ahead-of-time (AOT) compilation at all. Represents performance of a
    // fresh install on a user's device if you don't enable Baseline Profiles—
    // generally the worst case performance.
    @Test
    fun startupNoCompilation() = startup(CompilationMode.None())

    // Partial pre-compilation with Baseline Profiles. Represents performance of
    // a fresh install on a user's device.
    @Test
    fun startupPartialWithBaselineProfiles() =
        startup(CompilationMode.Partial(baselineProfileMode = BaselineProfileMode.Require))

    // Partial pre-compilation with some just-in-time (JIT) compilation.
    // Represents performance after some app usage.
    @Test
    fun startupPartialCompilation() = startup(
        CompilationMode.Partial(
            baselineProfileMode = BaselineProfileMode.Disable,
            warmupIteration = 3
        )
    )

    // Full pre-compilation. Generally not representative of real user
    // experience, but can yield more stable performance metrics by removing
    // noise from JIT compilation within benchmark runs.
    @Test
    fun startupFullCompilation() = startup(CompilationMode.Full())

    private fun startup(compilationMode: CompilationMode) = benchmarkRule.measureRepeated(
        packageName = "com.example.macrobenchmark.target",
        metrics = listOf(StartupTimingMetric()),
        compilationMode = compilationMode,
        iterations = 10,
        startupMode = StartupMode.COLD,
        setupBlock = {
            pressHome()
        }
    ) {
        // Waits for the first rendered frame, which represents time to initial display.
        startActivityAndWait()

        // Waits for content to be visible, which represents time to fully drawn.
        device.wait(Until.hasObject(By.res("my-content")), 5_000)
    }
}

नीचे दिए गए स्क्रीनशॉट में, Google Pixel 7 पर चलाए गए Now in Android sample ऐप्लिकेशन के लिए, सीधे Android Studio में नतीजे देखे जा सकते हैं. नतीजों से पता चलता है कि बेसलाइन प्रोफ़ाइलों (229.0 मिलीसेकंड) का इस्तेमाल करने पर, ऐप्लिकेशन को शुरू होने में कम समय लगता है. वहीं, बिना कंपाइल किए (324.8 मिलीसेकंड) ऐप्लिकेशन को शुरू होने में ज़्यादा समय लगता है.

पिछले उदाहरण में, StartupTimingMetric से कैप्चर किए गए ऐप्लिकेशन के स्टार्टअप के नतीजे दिखाए गए हैं. हालांकि, FrameTimingMetric जैसी अन्य अहम मेट्रिक पर भी ध्यान देने की ज़रूरत है. सभी तरह की मेट्रिक के बारे में ज़्यादा जानकारी के लिए, मैक्रोबेंचमार्क मेट्रिक कैप्चर करना लेख पढ़ें.

फ़ुल स्क्रीन में दिखने में लगने वाला समय

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

हमारा सुझाव है कि आप TTID और TTFD, दोनों के लिए ऑप्टिमाइज़ करें, क्योंकि दोनों ही अहम हैं. कम TTID से उपयोगकर्ता को यह पता चलता है कि ऐप्लिकेशन असल में लॉन्च हो रहा है. TTFD को कम रखना ज़रूरी है, ताकि उपयोगकर्ता ऐप्लिकेशन के साथ तुरंत इंटरैक्ट कर सके.

ऐप्लिकेशन का यूज़र इंटरफ़ेस (यूआई) पूरी तरह से दिखने के समय की रिपोर्टिंग की रणनीतियों के बारे में जानने के लिए, ऐप्लिकेशन के शुरू होने में लगने वाले समय की सटीक जानकारी पाना लेख पढ़ें.