प्रदर्शन मापना
प्रोफ़ाइलर, ट्रेस और बेंचमार्क।
प्रदर्शन मापना, CoddyKit पर Android Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Android Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Android Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
अनुकूलन से पहले मापें
प्रदर्शन संबंधी काम का स्वर्णिम नियम है: पहले मापें, कभी अनुमान न लगाएँ। क्या धीमा है, इस बारे में मनुष्य का सहज अनुमान लगभग हमेशा गलत होता है।
इस पाठ में आप Android द्वारा दिए गए प्रदर्शन को देखने वाले टूल सीखेंगे: प्रोफ़ाइलर, सिस्टम ट्रेस और सूक्ष्म-बेंचमार्क। जब आप माप सकेंगे, तो हर अनुकूलन अंदाज़े के बजाय डेटा पर आधारित निर्णय बन जाएगा।
- प्रोफ़ाइलर CPU, मेमोरी और ऊर्जा को वास्तविक समय में दिखाते हैं।
- सिस्टम ट्रेस ठीक-ठीक बताते हैं कि हर फ़्रेम का समय कहाँ खर्च होता है।
- बेंचमार्क दोहराए जा सकने वाले आँकड़े देते हैं, जिनकी अलग-अलग निर्माणों के बीच तुलना की जा सकती है।
16ms का फ़्रेम बजट
60Hz स्क्रीन पर सिस्टम हर 16.67ms में एक नया फ़्रेम बनाता है। यदि आपका ऐप इस समय-सीमा में फ़्रेम तैयार नहीं कर पाता, तो फ़्रेम छूट जाता है और उपयोगकर्ताओं को रुकावट (अटकना) महसूस होती है। 120Hz डिवाइसों पर यह बजट घटकर लगभग 8ms रह जाता है।
प्रदर्शन पर काम करने का वास्तविक अर्थ इसी बजट के भीतर बने रहना है। नीचे दी गई टिप्पणी वह गणना दिखाती है जिसे आपको ध्यान में रखना होता है।
// Frame budget math
// 60 Hz -> 1000ms / 60 = 16.67ms per frame
// 90 Hz -> 1000ms / 90 = 11.11ms per frame
// 120 Hz -> 1000ms / 120 = 8.33ms per frame
//
// Exceed the budget on the UI thread = a dropped frame = visible jank.
fun frameBudgetMs(refreshHz: Int): Double = 1000.0 / refreshHz
fun main() {
println("60Hz -> %.2f ms".format(frameBudgetMs(60)))
println("120Hz -> %.2f ms".format(frameBudgetMs(120)))
}एंड्रॉइड स्टूडियो प्रोफाइलर
एंड्रॉइड स्टूडियो प्रोफाइलर (दृश्य > टूल विंडो > प्रोफाइलर) चलते हुए ऐप से जुड़ता है और CPU, मेमोरी, ऊर्जा तथा नेटवर्क की लाइव समय-रेखाएँ दिखाता है।
- CPU: गर्म कोड-पथ खोजने के लिए विधि और सिस्टम ट्रेस रिकॉर्ड करें।
- मेमोरी: आवंटनों पर नज़र रखें और मेमोरी-लीक खोजने के लिए हीप डंप लें।
- ऊर्जा: बैटरी ख़त्म करने वाले वेकलॉक और अत्यधिक कार्यों का पता लगाएँ।
हमेशा किसी रिलीज़-जैसे बिल्ड को वास्तविक डिवाइस पर प्रोफाइल करें। डिबग बिल्ड और एमुलेटर भ्रामक आँकड़े देते हैं, क्योंकि उनमें ऑप्टिमाइज़ेशन बंद होते हैं।
वास्तविक परिस्थितियों के लिए मैक्रोबेंचमार्क
जेटपैक मैक्रोबेंचमार्क लाइब्रेरी वास्तविक डिवाइस पर उपयोगकर्ता की पूरी यात्राओं (शुरुआत, स्क्रॉलिंग, नेविगेशन) को मापती है और फ़्रेम समय तथा शुरुआती समय जैसे स्थिर मेट्रिक देती है।
आप ऐसा परीक्षण लिखते हैं जो आपका ऐप शुरू करके किसी कार्य-प्रवाह को चलाता है; लाइब्रेरी उसे कई बार चलाकर माध्यिका और 99वें प्रतिशतक के आँकड़े देती है।
@RunWith(AndroidJUnit4::class)
class StartupBenchmark {
@get:Rule val rule = MacrobenchmarkRule()
@Test
fun coldStartup() = rule.measureRepeated(
packageName = "com.example.app",
metrics = listOf(StartupTimingMetric()),
iterations = 5,
startupMode = StartupMode.COLD
) {
pressHome()
startActivityAndWait()
}
}गर्म कोड के लिए माइक्रोबेंचमार्क
जब आपको यह जानना हो कि कोई एक फ़ंक्शन कितनी तेज़ी से चलता है, तो माइक्रोबेंचमार्क लाइब्रेरी का उपयोग करें। यह आपके कोड को एक कसी हुई लूप में चलाती है, JIT को गर्म करती है और अतिरिक्त शोर हटाकर प्रति ऑपरेशन नैनोसेकंड की रिपोर्ट देती है।
इसका उपयोग पार्सर, सीरियलाइज़र, सॉर्टिंग या बार-बार कॉल किए जाने वाले किसी भी CPU-आधारित सहायक के लिए करें।
@RunWith(AndroidJUnit4::class)
class JsonParseBenchmark {
@get:Rule val benchmarkRule = BenchmarkRule()
@Test
fun parseLargePayload() {
val raw = loadSampleJson()
benchmarkRule.measureRepeated {
val parsed = parseUsers(raw) // code under test
// assertEquals avoids the compiler dropping the result
assertTrue(parsed.isNotEmpty())
}
}
}Perfetto के साथ सिस्टम ट्रेसिंग
सिस्टम ट्रेसिंग फ़्रेम-दर-फ़्रेम यह रिकॉर्ड करती है कि हर थ्रेड और सिस्टम ने क्या किया। एंड्रॉइड स्टूडियो का CPU प्रोफाइलर इसे रिकॉर्ड कर सकता है। आप adb से भी इसे कैप्चर करके Perfetto (ui.perfetto.dev) में खोल सकते हैं।
ट्रेस में डरावने लाल फ़्रेम, मुख्य थ्रेड पर हो रहा काम और GPU में लगा समय दिखाई देता है। रुकावट का निदान करने के लिए यह सबसे उपयोगी एकल टूल है।
# Record a 5-second system trace from the command line
adb shell perfetto -o /data/misc/perfetto-traces/trace.perfetto-trace \
-t 5s sched freq idle am wm gfx view
# Pull it to your machine, then open in https://ui.perfetto.dev
adb pull /data/misc/perfetto-traces/trace.perfetto-traceकस्टम ट्रेस सेक्शन
डिफ़ॉल्ट रूप से ट्रेस फ़्रेमवर्क का काम दिखाते हैं। अपने कोड को लेबल करने के लिए उसे नाम वाले ट्रेस सेक्शन में लपेटें। ये नाम Perfetto में लेबल किए गए ब्लॉक के रूप में दिखाई देते हैं, जिससे आपके धीमे हिस्सों को पहचानना आसान हो जाता है।
androidx.tracing API का उपयोग करें, ताकि सेक्शन डिबग और बेंचमार्क—दोनों ट्रेस में दिखाई दें।
import androidx.tracing.trace
fun loadDashboard(repo: Repo): Dashboard {
return trace("loadDashboard") {
val user = trace("fetchUser") { repo.user() }
val feed = trace("fetchFeed") { repo.feed() }
Dashboard(user, feed)
}
}
// In Perfetto you will now see named slices:
// loadDashboard > fetchUser, fetchFeedरनटाइम पर छूटे हुए फ़्रेम ट्रैक करना
आपके साथ हमेशा प्रोफाइलर जुड़ा नहीं होता। JankStats एक जेटपैक लाइब्रेरी है जो चलते हुए ऐप के भीतर से रुकावट वाले फ़्रेम की रिपोर्ट देती है, ताकि आप उन्हें लॉग कर सकें या उनके समेकित आँकड़े एनालिटिक्स को भेज सकें।
यह विंडो से जुड़ती है और जब भी कोई फ़्रेम अपने बजट से अधिक समय लेता है, आपको वापस कॉल करती है।
val jankStats = JankStats.createAndTrack(window) { frameData ->
if (frameData.isJank) {
Log.w("Jank", "Janky frame: ${frameData.frameDurationUiNanos} ns")
analytics.logJank(frameData.frameDurationUiNanos)
}
}
// Pause/resume with your screen lifecycle
override fun onResume() { super.onResume(); jankStats.isTrackingEnabled = true }
override fun onPause() { super.onPause(); jankStats.isTrackingEnabled = false }आँकड़े पढ़ना: प्रतिशतक
केवल एक औसत वास्तविक समस्या छिपा देता है। यदि आपके फ़्रेम का औसत समय 10ms है, लेकिन 99वाँ प्रतिशतक 40ms है, तो 1% फ़्रेम में रुकावट है और उपयोगकर्ताओं को यह महसूस होती है। केवल माध्य नहीं, हमेशा P50, P90, P99 देखें।
बेंचमार्क आपके लिए ये आँकड़े देते हैं। नीचे दिया गया सहायक कच्चे फ़्रेम नमूनों पर इसका विचार दिखाता है।
fun percentile(samplesMs: List<Double>, p: Int): Double {
val sorted = samplesMs.sorted()
val index = ((p / 100.0) * (sorted.size - 1)).toInt()
return sorted[index]
}
fun main() {
val frames = listOf(8.0, 9.0, 10.0, 9.5, 11.0, 40.0, 9.0, 10.5)
println("P50 = %.1f ms".format(percentile(frames, 50)))
println("P99 = %.1f ms".format(percentile(frames, 99)))
}दोहराए जा सकने वाले मापन की कार्यप्रणाली
विश्वसनीय आँकड़े एक अनुशासित प्रक्रिया से मिलते हैं। हर बार यह जाँच-सूची अपनाएँ:
- रिलीज़ / डिबग-न किए जा सकने वाला बिल्ड (R8 सक्षम) उपयोग करें।
- स्थिर तापीय स्थिति वाले, चार्जर से जुड़े भौतिक डिवाइस पर चलाएँ।
- परिस्थिति को कई बार दोहराएँ और माध्यिका की रिपोर्ट दें।
- एक बार में एक ही चीज़ बदलें और फिर से मापें।
- सुधार साबित करने के लिए किसी सहेजे गए आधार-मान से तुलना करें।
यदि आप ये चरण छोड़ देते हैं, तो वास्तविक समस्याएँ ठीक करने के बजाय शोर के पीछे भागते रहेंगे।
समय वास्तव में कहाँ जाता है
एंड्रॉइड में अधिकांश रुकावटें कुछ ही कारणों से आती हैं। उन्हें जानने पर आपको पता चलता है कि अपने टूल्स का रुख कहाँ करना है:
- मुख्य थ्रेड का काम: UI थ्रेड पर डिस्क/नेटवर्क/JSON का काम।
- अत्यधिक री-कम्पोज़िशन: Compose का आवश्यकता से बहुत अधिक दोबारा चित्रण करना।
- आवंटन की लगातार हलचल: कचरा-संग्रह के विराम।
- लेआउट पास: बहुत गहराई तक नेस्ट किए गए या बार-बार मापे जाने वाले लेआउट।
इस पाठ्यक्रम के अगले पाठ री-कम्पोज़िशन, मेमोरी-लीक और शुरुआत की समस्याओं पर सीधे काम करेंगे। सबसे पहले किसे ठीक करना है, यह मापन ही बताता है।
त्वरित जाँच
आप वास्तविक डिवाइस पर कई बार चलाकर यह स्थिर और दोहराए जा सकने वाला मापन चाहते हैं कि आपके ऐप की ठंडी शुरुआत में कितना समय लगता है। इसके लिए कौन-सा टूल सबसे उपयुक्त है?
पुनरावलोकन: अब आप माप सकते हैं
आपने कुछ भी बदलने से पहले प्रदर्शन को दृश्यमान बनाना सीखा:
- 16ms का फ़्रेम बजट सहज और रुकावट वाले प्रदर्शन के बीच की सीमा तय करता है।
- एंड्रॉइड स्टूडियो प्रोफाइलर लाइव CPU, मेमोरी और ऊर्जा दिखाता है।
- मैक्रो- और माइक्रोबेंचमार्क दोहराए जा सकने वाले आँकड़े देते हैं।
- Perfetto ट्रेस और कस्टम
trace()सेक्शन बताते हैं कि समय कहाँ जा रहा है। - JankStats चलते हुए ऐप के भीतर से रुकावट की रिपोर्ट देता है।
- P50/P90/P99 पढ़ें, वास्तविक डिवाइसों पर रिलीज़ बिल्ड प्रोफाइल करें और एक बार में एक ही चीज़ बदलें।
अगले पाठ में हम इसे Compose में रुकावट के सबसे बड़े स्रोतों में से एक—री-कम्पोज़िशन—पर लागू करेंगे।
एआई शिक्षक के साथ Kotlin सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 36
- पाठ
- 152
अक्सर पूछे जाने वाले प्रश्न
क्या “प्रदर्शन मापना” पाठ निःशुल्क है?
हाँ — Android Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “प्रदर्शन मापना” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Android Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“प्रदर्शन मापना” में मैं क्या सीखूँगा?
प्रोफ़ाइलर, ट्रेस और बेंचमार्क। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Android Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Android Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Android Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“प्रदर्शन मापना” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Android Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Android Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।