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

हमारा सुझाव है कि बेसलाइन प्रोफ़ाइलें चालू होने पर, ऐप्लिकेशन की परफ़ॉर्मेंस की जांच करने के लिए, 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()
        }
    ) {
        uiAutomator {
            startApp(packageName)
            onElement(5_000) { viewIdResourceName == "my-content"}
        }
    }
}

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

ColdstartupBenchmark के नतीजे
पहली इमेज. ColdStartupBenchmark के नतीजे, जिनमें पहली बार दिखने में लगने वाला समय दिखाया गया है. इसमें, कंपाइलेशन न होने पर (324 मि॰से॰), पूरा कंपाइलेशन होने पर (315 मि॰से॰), कुछ कंपाइलेशन होने पर (312 मि॰से॰), और बेसलाइन प्रोफ़ाइल होने पर (229 मि॰से॰) लगने वाला समय दिखाया गया है.

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

पूरा डिसप्ले दिखने में लगने वाला समय

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

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

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

  • ध्यान दें: JavaScript बंद होने पर, लिंक टेक्स्ट दिखता है
  • [Write a Macrobenchmark][11]
  • [Macrobenchmark मेट्रिक कैप्चर करना][12]
  • UI Automator की मदद से ऑटोमेटेड टेस्ट लिखना
  • [ऐप्लिकेशन के स्टार्टअप का विश्लेषण और ऑप्टिमाइज़ेशन {:#app-startup-analysis-optimization}][14]