कंपोज़िशन ट्रेसिंग

परफ़ॉर्मेंस से जुड़ी किसी समस्या की जांच करते समय, ट्रेस अक्सर जानकारी का सबसे अच्छा सोर्स होते हैं. इनकी मदद से, यह अनुमान लगाया जा सकता है कि समस्या क्या है और उसे कहां से ढूंढना शुरू करना है.

Android पर दो तरह से ट्रेस किया जा सकता है: सिस्टम ट्रेस करने की प्रक्रिया और तरीकों की सूची.

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

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

डिफ़ॉल्ट रूप से, सिस्टम ट्रेस करने की प्रक्रिया में, अलग-अलग कंपोज़ेबल फ़ंक्शन शामिल नहीं होते हैं. ये तरीकों की सूची में उपलब्ध होते हैं.

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

कंपोज़िशन ट्रेसिंग सेटअप

अपने प्रोजेक्ट में कंपोज़िशन ट्रेसिंग की सुविधा आज़माने के लिए, आपको कम से कम इन वर्शन पर अपडेट करना होगा:

  • Android Studio Flamingo
  • Compose UI: 1.3.0
  • Compose Compiler: 1.3.0

जिस डिवाइस या एम्युलेटर पर ट्रेस चलाया जा रहा है उसका एपीआई लेवल कम से कम 30 होना चाहिए.

इसके अलावा, आपको Compose रनटाइम ट्रेसिंग पर एक नई डिपेंडेंसी जोड़नी होगी:

implementation("androidx.compose.runtime:runtime-tracing:1.12.1")

अगर Compose बीओएम का इस्तेमाल किया जा रहा है, तो आपको वर्शन की जानकारी देने की ज़रूरत नहीं है:

val composeBom = platform("androidx.compose:compose-bom:2026.09.00")
implementation(composeBom)
// ...

// dependency without a version
implementation("androidx.compose.runtime:runtime-tracing")

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

सिस्टम ट्रेस करने की प्रक्रिया शुरू करना

सिस्टम ट्रेस करने और कंपोज़िशन ट्रेस करने की नई सुविधा को काम करते हुए देखने के लिए, यह तरीका अपनाएं:

  1. प्रोफ़ाइलर खोलें:

    Android Studio - प्रोफ़ाइलिंग शुरू करें
    दूसरी इमेज. Android Studio - प्रोफ़ाइल बनाना शुरू करें

  2. सीपीयू टाइमलाइन पर क्लिक करें

    Android Studio प्रोफ़ाइलर - सीपीयू टाइमलाइन
    तीसरी इमेज. Android Studio प्रोफ़ाइलर - सीपीयू टाइमलाइन

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

    ट्रेस करने के विकल्प - सिस्टम ट्रेस करने की प्रक्रिया
    चौथी इमेज. ट्रेस करने के विकल्प - सिस्टम ट्रेस करने की प्रक्रिया

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

    Android Studio में सिस्टम ट्रेस करने की प्रक्रिया के विज़ुअलाइज़ेशन का उदाहरण.
    पांचवीं इमेज. सिस्टम ट्रेस करने की प्रक्रिया

    चार्ट में किसी कंपोज़ेबल पर दो बार क्लिक करने से, आपको उसके सोर्स कोड पर ले जाया जाता है.

  5. फ़्लेम चार्ट में, कंपोज़ेबल के साथ-साथ फ़ाइल और लाइन नंबर भी देखा जा सकता है:

    ऐप्लिकेशन बनाने की सुविधा दिखाने वाले फ़्लेम चार्ट का उदाहरण.
    छठी इमेज. फ़्लेम चार्ट

सीमाएं

कंपोज़िशन ट्रेसिंग का इस्तेमाल करते समय, APK के साइज़ और परफ़ॉर्मेंस से जुड़ी इन चेतावनियों को ध्यान में रखें.

APK साइज़ ओवरहेड

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

ट्रेसिंग स्ट्रिंग को अपने प्रोडक्शन बिल्ड से हटाया जा सकता है. इसके लिए, Proguard का यह नियम जोड़ें:

-assumenosideeffects public class androidx.compose.runtime.ComposerKt {

   boolean isTraceInProgress();

   void traceEventStart(int,int,int,java.lang.String);

   void traceEventStart(int,java.lang.String);

   void traceEventEnd();

}

आने वाले समय में, इन फ़ंक्शन में बदलाव हो सकता है. हालांकि, किसी भी बदलाव की जानकारी Compose के रिलीज़ नोट में दी जाएगी.

ध्यान दें कि फ़ंक्शन को बनाए रखने से, APK का साइज़ कुछ बढ़ जाता है. हालांकि, इससे यह पक्का होता है कि प्रोफ़ाइल किया जा रहा APK वही है जिसे ऐप्लिकेशन के उपयोगकर्ता इस्तेमाल करते हैं.

सटीक समय

परफ़ॉर्मेंस की जांच करने की तरह ही, सटीक प्रोफ़ाइलिंग के लिए आपको प्रोफ़ाइल किए जा सकने वाले ऐप्लिकेशन के मुताबिक, ऐप्लिकेशन को profileable और non-debuggable बनाना होगा.

टर्मिनल से ट्रेस कैप्चर करना

टर्मिनल से कंपोज़िशन ट्रेस को कैप्चर किया जा सकता है. इसके लिए, आपको वे चरण पूरे करने होंगे जो Android Studio आम तौर पर आपके लिए अपने-आप पूरे करता है.

डिपेंडेंसी जोड़ें

सबसे पहले, अपने ऐप्लिकेशन में अतिरिक्त डिपेंडेंसी जोड़ें.

implementation("androidx.tracing:tracing-perfetto:1.0.0")
implementation("androidx.tracing:tracing-perfetto-binary:1.0.0")

रिकॉर्ड करने का निर्देश जनरेट करना

  1. Perfetto में रिकॉर्ड कमांड जनरेट करना.

  2. यहां दिए गए उदाहरण के मुताबिक, track_event डेटा सोर्स सेक्शन को मैन्युअल तरीके से जोड़ें:

    adb shell perfetto \
  -c - --txt \
  -o /data/misc/perfetto-traces/trace \
<<EOF
buffers: {
    size_kb: 63488
    fill_policy: RING_BUFFER
}
buffers: {
    size_kb: 2048
    fill_policy: RING_BUFFER
}
data_sources: {
    config {
        name: "track_event"
    }
}
duration_ms: 10000
flush_period_ms: 30000
incremental_state_config {
    clear_period_ms: 5000
}
EOF

ट्रेस कैप्चर करना

  1. ऐप्लिकेशन लॉन्च करें और वह सेक्शन तैयार करें जिसे आपको ट्रेस करना है.

  2. ब्रॉडकास्ट जारी करके, ऐप्लिकेशन में ट्रेसिंग की सुविधा चालू करें.

    # set app package variable, e.g. com.google.samples.apps.nowinandroid.debug
# can be found through `adb shell ps -ef` or `adb shell cmd package list packages`
package=<your app process>

# issue a broadcast to enable tracing
adb shell am broadcast \
-a androidx.tracing.perfetto.action.ENABLE_TRACING \
$package/androidx.tracing.perfetto.TracingReceiver

  3. पहले से बनाए गए रिकॉर्डिंग कमांड का इस्तेमाल करें.

ट्रेस खोलें

  1. adb pull <location> डिवाइस से ट्रेस (रिकॉर्ड कमांड में बताई गई जगह).

  2. Perfetto में खोलें.

Jetpack Macrobenchmark की मदद से ट्रेस कैप्चर करना

Jetpack Macrobenchmark की मदद से परफ़ॉर्मेंस को मेज़र किया जा सकता है. यह नतीजों के तौर पर ट्रेस उपलब्ध कराता है. मैक्रोबेंचमार्क के साथ कंपोज़िशन ट्रेसिंग की सुविधा चालू करने के लिए, आपको ये काम करने होंगे:

  1. Macrobenchmark टेस्ट मॉड्यूल में ये अतिरिक्त डिपेंडेंसी जोड़ें:

    implementation("androidx.tracing:tracing-perfetto:1.0.0")
implementation("androidx.tracing:tracing-perfetto-binary:1.0.0")

  2. बेंचमार्क चलाने से पहले, androidx.benchmark.fullTracing.enable=true इंस्ट्रुमेंटेशन आर्ग्युमेंट जोड़ें. Macrobenchmark इंस्ट्रुमेंटेशन आर्ग्युमेंट के बारे में ज़्यादा जानने के लिए, Macrobenchmark इंस्ट्रुमेंटेशन आर्ग्युमेंट देखें.

रिकंपोज़िशन ट्रेसिंग

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

रीकंपोज़िशन ट्रेसिंग में, कंपोज़िशन ट्रेसिंग की तुलना में ज़्यादा ओवरहेड होता है. इसलिए, इसका इस्तेमाल रीकंपोज़िशन को डीबग करने के लिए करें, न कि परफ़ॉर्मेंस को मेज़र करने के लिए.

रीकंपोज़िशन ट्रेसिंग सेटअप

अपने ऐप्लिकेशन मॉड्यूल में, Compose Runtime Tracing 1.13.0 या इसके बाद के वर्शन पर डिपेंडेंसी जोड़ें:

// Compose BOM 2026.11.00+ (runtime-tracing 1.13.0+)
implementation("androidx.compose.runtime:runtime-tracing")

जिस डिवाइस या एम्युलेटर पर ट्रेस चलाया जा रहा है वह एपीआई लेवल 29 या इसके बाद के लेवल पर होना चाहिए.

रीकंपोज़िशन ट्रेस कैप्चर करना

टर्मिनल से रीकंपोज़िशन ट्रेस कैप्चर करने के लिए, record_recomposition_trace.py स्क्रिप्ट का इस्तेमाल करें.

  1. ऐप्लिकेशन लॉन्च करें और वह सेक्शन तैयार करें जिसे आपको ट्रेस करना है.

  2. रिकॉर्डिंग शुरू करना:

    ./record_recomposition_trace.py -p <your app package>

  3. रीकंपोज़िशन को ट्रिगर करने के लिए, अपने ऐप्लिकेशन का इस्तेमाल करें. इसके बाद, रिकॉर्डिंग बंद करने के लिए Control+C दबाएं. अगर आपको किसी तय अवधि के लिए रिकॉर्डिंग करनी है, तो -t के साथ सेकंड में अवधि डालें. उदाहरण के लिए, -t 10.

यह स्क्रिप्ट, ऐप्लिकेशन में कंपोज़िशन और रीकंपोज़िशन को ट्रेस करने की सुविधा चालू करती है. साथ ही, सिस्टम ट्रेस को रिकॉर्ड करती है. इसके बाद, ट्रेस करने की सुविधा को बंद कर देती है और सभी ट्रेस को मौजूदा डायरेक्ट्री में मौजूद एक <package>-recompose-<timestamp>.zip फ़ाइल में सेव कर देती है. फ़ाइल को Perfetto में खोलें.

स्टेट राइट को चुनने पर, वह कॉल स्टैक दिखता है जिसने स्टेट को बदला है. साथ ही, एक फ़्लो ऐरो दिखता है जो उस रीकंपोज़िशन की ओर इशारा करता है जो इसकी वजह से हुआ है:

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

सभी विकल्प देखने के लिए, --help के साथ स्क्रिप्ट चलाएं. जैसे, कस्टम Perfetto कॉन्फ़िगरेशन या ट्रेस बफ़र साइज़.

सुझाव/राय दें या शिकायत करें

हमें इस सुविधा के बारे में आपके सुझाव, शिकायत या राय जानकर खुशी होगी. साथ ही, अगर आपको इसमें कोई गड़बड़ी मिलती है, तो हमें बताएं. इसके अलावा, अगर आपको कोई अनुरोध करना है, तो वह भी करें. समस्याओं को ट्रैक करने वाले टूल का इस्तेमाल करके, हमें सुझाव/राय दी जा सकती है या शिकायत की जा सकती है.

पीछे जाएं
खास जानकारी
आगे बढ़ें
स्‍टैक ट्रेस