मैन्युअल तरीके से बेसलाइन प्रोफ़ाइल बनाएं और उन्हें मेज़र करें

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

प्रोफ़ाइल के लिए मैन्युअल तरीके से नियम तय करना

किसी ऐप्लिकेशन या लाइब्रेरी मॉड्यूल में, प्रोफ़ाइल के नियम मैन्युअल तरीके से तय किए जा सकते हैं. इसके लिए, src/main डायरेक्ट्री में baseline-prof.txt नाम की फ़ाइल बनाएं. यह वही फ़ोल्डर है जिसमें AndroidManifest.xml फ़ाइल मौजूद है.

फ़ाइल में हर लाइन के लिए एक नियम तय किया जाता है. हर नियम, ऐप्लिकेशन या लाइब्रेरी में मौजूद उन तरीकों या क्लास से मैच करने वाले पैटर्न को दिखाता है जिन्हें ऑप्टिमाइज़ करना ज़रूरी है.

adb shell profman --dump-classes-and-methods का इस्तेमाल करते समय, इन नियमों का सिंटैक्स, किसी व्यक्ति के लिए आसानी से पढ़े जा सकने वाले एआरटी प्रोफ़ाइल फ़ॉर्मैट (एचआरएफ़) का सुपरसेट होता है. इसका सिंटैक्स, डिस्क्रिप्टर और सिग्नेचर के सिंटैक्स जैसा ही होता है. हालांकि, इसमें वाइल्डकार्ड का इस्तेमाल किया जा सकता है, ताकि नियम लिखने की प्रोसेस को आसान बनाया जा सके.

यहां दिए गए उदाहरण में, Jetpack Compose लाइब्रेरी में शामिल कुछ बेसलाइन प्रोफ़ाइल के नियम दिखाए गए हैं:

HSPLandroidx/compose/runtime/ComposerImpl;->updateValue(Ljava/lang/Object;)V
HSPLandroidx/compose/runtime/ComposerImpl;->updatedNodeCount(I)I
HLandroidx/compose/runtime/ComposerImpl;->validateNodeExpected()V
PLandroidx/compose/runtime/CompositionImpl;->applyChanges()V
HLandroidx/compose/runtime/ComposerKt;->findLocation(Ljava/util/List;I)I
Landroidx/compose/runtime/ComposerImpl;

इस सैंपल कंपाइलर एक्सप्लोरर प्रोजेक्ट में, प्रोफ़ाइल के नियमों में बदलाव करके देखें. ध्यान दें कि Compiler Explorer, सिर्फ़ किसी व्यक्ति के लिए आसानी से पढ़े जा सकने वाले ART प्रोफ़ाइल फ़ॉर्मैट (एचआरएफ़) के साथ काम करता है. इसलिए, वाइल्डकार्ड का इस्तेमाल नहीं किया जा सकता.

नियम का सिंटैक्स

ये नियम, तरीकों या क्लास को टारगेट करने के लिए, इनमें से कोई एक फ़ॉर्मैट इस्तेमाल करते हैं:

[FLAGS][CLASS_DESCRIPTOR]->[METHOD_SIGNATURE]

क्लास रूल में इस पैटर्न का इस्तेमाल किया जाता है:

[CLASS_DESCRIPTOR]

ज़्यादा जानकारी के लिए, यहां दी गई टेबल देखें:

इन पैटर्न में वाइल्डकार्ड हो सकते हैं, ताकि एक ही नियम कई तरीकों या क्लास पर लागू हो सके. Android Studio में नियम के सिंटैक्स का इस्तेमाल करके लिखते समय मदद पाने के लिए, Android बेसलाइन प्रोफ़ाइल प्लगिन देखें.

वाइल्डकार्ड नियम का एक उदाहरण कुछ ऐसा दिख सकता है:

HSPLandroidx/compose/ui/layout/**->**(**)**

बेसलाइन प्रोफ़ाइल के नियमों में इस्तेमाल किए जा सकने वाले टाइप

बेसलाइन प्रोफ़ाइल के नियम, इन टाइप के साथ काम करते हैं. इन टाइप के बारे में ज़्यादा जानने के लिए, Dalvik Executable (DEX) फ़ॉर्मैट देखें.

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

जब APK का इस्तेमाल डिवाइसों पर किया जाता है, तब एआरटी इस प्रोफ़ाइल का इस्तेमाल करता है. ऐसा, Android 9 (एपीआई लेवल 28) पर इंस्टॉल करते समय, ऐप्लिकेशन के किसी खास सबसेट को एओटी कंपाइल करने के लिए किया जाता है. इसके अलावा, ProfileInstaller का इस्तेमाल करते समय, Android 7 (एपीआई लेवल 24) पर भी ऐसा किया जाता है.

मैन्युअल तरीके से बेसलाइन प्रोफ़ाइलें इकट्ठा करना

Macrobenchmark लाइब्रेरी को सेट अप किए बिना, मैन्युअल तरीके से बेसलाइन प्रोफ़ाइल जनरेट की जा सकती है. साथ ही, क्रिटिकल यूज़र जर्नी के लिए यूज़र इंटरफ़ेस (यूआई) ऑटोमेशन बनाए जा सकते हैं. हमारा सुझाव है कि आप Macrobenchmark का इस्तेमाल करें. हालांकि, ऐसा करना हमेशा मुमकिन नहीं होता. उदाहरण के लिए, अगर Gradle के अलावा किसी अन्य बिल्ड सिस्टम का इस्तेमाल किया जा रहा है, तो बेसलाइन प्रोफ़ाइल Gradle प्लगिन का इस्तेमाल नहीं किया जा सकता. ऐसे मामलों में, बेसलाइन प्रोफ़ाइल के नियमों को मैन्युअल तरीके से इकट्ठा किया जा सकता है. एपीआई 34 और इसके बाद के वर्शन वाले डिवाइस या एम्युलेटर का इस्तेमाल करने पर, यह प्रोसेस काफ़ी आसान हो जाती है. हालांकि, कम एपीआई लेवल पर भी ऐसा किया जा सकता है, लेकिन इसके लिए रूट ऐक्सेस की ज़रूरत होती है. साथ ही, आपको एओएसपी इमेज वाले एम्युलेटर का इस्तेमाल करना होगा. नियमों को सीधे तौर पर इकट्ठा करने के लिए, यह तरीका अपनाएं:

1. टेस्ट डिवाइस पर अपने ऐप्लिकेशन का रिलीज़ के लिए तैयार वर्शन इंस्टॉल करें. ऐप्लिकेशन का बिल्ड टाइप, R8-ऑप्टिमाइज़्ड नहीं होना चाहिए. साथ ही, बिल्ड सिस्टम के इस्तेमाल की जा सकने वाली प्रोफ़ाइल को कैप्चर करने के लिए, उसे डीबग करने लायक नहीं होना चाहिए.
2. प्रोफ़ाइल इंस्टॉल करने की सुविधा बंद करें और ऐप्लिकेशन को बंद करें.

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

   adb shell am broadcast -a androidx.profileinstaller.action.SKIP_FILE WRITE_SKIP_FILE $PACKAGE_NAME/androidx.profileinstaller.ProfileInstallReceiver

3. ऐप्लिकेशन कंपाइलेशन को रीसेट करें और सभी प्रोफ़ाइलें मिटाएं.

   एपीआई लेवल 34 और इसके बाद के वर्शन

   adb shell cmd package compile -f -m verify $PACKAGE_NAME
   adb shell pm art clear-app-profiles $PACKAGE_NAME

   एपीआई लेवल 33 और इससे पहले के लेवल

   adb root
   adb shell cmd package compile --reset $PACKAGE_NAME

4. ऐप्लिकेशन चलाएं और मैन्युअल तरीके से उन क्रिटिकल यूज़र जर्नी पर जाएं जिनके लिए आपको प्रोफ़ाइल इकट्ठा करनी है.

5. प्रोफ़ाइलें लोड होने के लिए, कम से कम पांच सेकंड इंतज़ार करें.

6. सेव करने की कार्रवाई करें और सेव होने की प्रोसेस पूरी होने तक इंतज़ार करें. अगर आपका APK, Jetpack Profile Installer लाइब्रेरी पर निर्भर है, तो प्रोफ़ाइलों को डंप करने के लिए इसका इस्तेमाल करें:

   adb shell am broadcast -a androidx.profileinstaller.action.SAVE_PROFILE $PACKAGE_NAME/androidx.profileinstaller.ProfileInstallReceiver
   sleep 1 # wait 1 second
   adb shell am force-stop $PACKAGE_NAME

   अगर प्रोफ़ाइल इंस्टॉलर का इस्तेमाल नहीं किया जा रहा है, तो इस कमांड का इस्तेमाल करके, एम्युलेटर पर प्रोफ़ाइलों को मैन्युअल तरीके से डंप करें:

   adb root
   adb shell killall -s SIGUSR1 $PACKAGE_NAME
   sleep 1 # wait 1 second
   adb shell am force-stop $PACKAGE_NAME

7. जनरेट की गई बाइनरी प्रोफ़ाइलों को टेक्स्ट में बदलें:

   एपीआई लेवल 34 और इसके बाद के वर्शन

   adb shell pm dump-profiles --dump-classes-and-methods $PACKAGE_NAME

   एपीआई लेवल 33 और इससे पहले के लेवल

   यह तय करना कि कोई रेफ़रंस प्रोफ़ाइल या मौजूदा प्रोफ़ाइल बनाई गई है या नहीं. रेफ़रंस प्रोफ़ाइल इस जगह पर मौजूद है:

   /data/misc/profiles/ref/$$PACKAGE_NAME/primary.prof

   मौजूदा प्रोफ़ाइल इस जगह पर मौजूद है:

   /data/misc/profiles/cur/0/$PACKAGE_NAME/primary.prof

   APK की जगह की जानकारी का पता लगाएं:

   adb root
   adb shell pm path $PACKAGE_NAME

   कन्वर्ज़न की प्रोसेस पूरी करना:

   adb root
   adb shell profman --dump-classes-and-methods --profile-file=$PROFILE_PATH --apk=$APK_PATH > /data/misc/profman/$PACKAGE_NAME-primary.prof.txt

8. डिवाइस से डंप की गई प्रोफ़ाइल को वापस पाने के लिए, adb का इस्तेमाल करें:

   adb pull /data/misc/profman/$PACKAGE_NAME-primary.prof.txt PATH_TO_APP_MODULE/src/main/

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

ऐप्लिकेशन में हुए सुधारों को मैन्युअल तरीके से मेज़र करना

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

PACKAGE_NAME=com.example.app
# Force Stop App
adb shell am force-stop $PACKAGE_NAME
# Reset compiled state
adb shell cmd package compile --reset $PACKAGE_NAME
# Measure App startup
# This corresponds to `Time to initial display` metric.
adb shell am start-activity -W -n $PACKAGE_NAME/.ExampleActivity \
 | grep "TotalTime"

इसके बाद, बेसलाइन प्रोफ़ाइल को अनजान सोर्स से इंस्टॉल करें.

# Unzip the Release APK first.
unzip release.apk
# Create a ZIP archive.
# The name should match the name of the APK.
# Copy `baseline.prof{m}` and rename it `primary.prof{m}`.
cp assets/dexopt/baseline.prof primary.prof
cp assets/dexopt/baseline.profm primary.profm
# Create an archive.
zip -r release.dm primary.prof primary.profm
# Confirm that release.dm only contains the two profile files:
unzip -l release.dm
# Archive:  release.dm
#   Length      Date    Time    Name
# ---------  ---------- -----   ----
#      3885  1980-12-31 17:01   primary.prof
#      1024  1980-12-31 17:01   primary.profm
# ---------                     -------
#                               2 files
# Install APK + Profile together.
adb install-multiple release.apk release.dm

यह पुष्टि करने के लिए कि पैकेज को इंस्टॉल करते समय ऑप्टिमाइज़ किया गया था, यह कमांड चलाएं:

# Check dexopt state.
adb shell dumpsys package dexopt | grep -A 1 $PACKAGE_NAME

आउटपुट में यह बताना ज़रूरी है कि पैकेज को कंपाइल कर लिया गया है:

[com.example.app]
  path: /data/app/~~YvNxUxuP2e5xA6EGtM5i9A==/com.example.app-zQ0tkJN8tDrEZXTlrDUSBg==/base.apk
  arm64: [status=speed-profile] [reason=install-dm]

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

# Force stop app
adb shell am force-stop $PACKAGE_NAME
# Measure app startup
adb shell am start-activity -W -n $PACKAGE_NAME/.ExampleActivity \
 | grep "TotalTime"

बेसलाइन प्रोफ़ाइल और profgen

इस सेक्शन में बताया गया है कि बेसलाइन प्रोफ़ाइल का छोटा बाइनरी वर्शन बनाते समय, profgen टूल क्या करता है.

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

Profgen-cli एक सीएलआई है, जो बेसलाइन प्रोफ़ाइल के एचआरएफ़ को उसके कंपाइल किए गए फ़ॉर्मैट में कंपाइल करता है. सीएलआई, Android SDK के हिस्से के तौर पर cmdline-tools रिपॉज़िटरी में भी उपलब्ध है.

ये सुविधाएं studio-main ब्रांच में उपलब्ध हैं:

➜ ../cmdline-tools/latest/bin
apkanalyzer
avdmanager
lint
profgen
retrace
screenshot2
sdkmanager

Profgen-cli की मदद से, कॉम्पैक्ट बाइनरी प्रोफ़ाइलें बनाना

Profgen-cli के साथ उपलब्ध कमांड bin, validate, और dumpProfile हैं. उपलब्ध कमांड देखने के लिए, profgen --help का इस्तेमाल करें:

➜  profgen --help
Usage: profgen options_list
Subcommands:
    bin - Generate Binary Profile
    validate - Validate Profile
    dumpProfile - Dump a binary profile to a HRF

Options:
    --help, -h -> Usage info

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

profgen bin ./baseline-prof.txt \
  --apk ./release.apk \
  --map ./obfuscation-map.txt \
  --profile-format v0_1_0_p \
  --output ./baseline.prof \

उपलब्ध विकल्प देखने के लिए, profgen bin options_list का इस्तेमाल करें:

Usage: profgen bin options_list
Arguments:
    profile -> File path to Human Readable profile { String }
Options:
    --apk, -a -> File path to apk (always required) { String }
    --output, -o -> File path to generated binary profile (always required)
    --map, -m -> File path to name obfuscation map { String }
    --output-meta, -om -> File path to generated metadata output { String }
    --profile-format, -pf [V0_1_0_P] -> The ART profile format version
      { Value should be one of [
         v0_1_5_s, v0_1_0_p, v0_0_9_omr1, v0_0_5_o, v0_0_1_n
        ]
      }
    --help, -h -> Usage info

पहला आर्ग्युमेंट, baseline-prof.txt एचआरएफ़ का पाथ दिखाता है.

Profgen-cli को APK के रिलीज़ के लिए तैयार बिल्ड का पाथ और ऑब्फ़स्केशन मैप भी चाहिए. इसका इस्तेमाल, R8 या Proguard का इस्तेमाल करते समय APK को ऑब्फ़स्केट करने के लिए किया जाता है. इस तरह, कंपाइल की गई प्रोफ़ाइल बनाते समय, profgen एचआरएफ़ में मौजूद सोर्स सिंबल को उनके मिलते-जुलते अस्पष्ट नामों में अनुवाद कर सकता है.

ART प्रोफ़ाइल के फ़ॉर्मैट, पुराने या नए सिस्टम के साथ काम नहीं करते. इसलिए, प्रोफ़ाइल का ऐसा फ़ॉर्मैट उपलब्ध कराएं जिससे profgen, प्रोफ़ाइल के मेटाडेटा (profm) को पैकेज कर सके. इससे, ज़रूरत पड़ने पर ART प्रोफ़ाइल के एक फ़ॉर्मैट को दूसरे फ़ॉर्मैट में ट्रांसकोड किया जा सकता है.

प्रोफ़ाइल फ़ॉर्मैट और प्लैटफ़ॉर्म के वर्शन

प्रोफ़ाइल फ़ॉर्मैट चुनते समय, ये विकल्प उपलब्ध होते हैं:

baseline.prof और baseline.profm आउटपुट फ़ाइलों को APK में मौजूद assets या dexopt फ़ोल्डर में कॉपी करें.

ऑब्फ़स्केशन मैप

अगर एचआरएफ़, सोर्स सिंबल का इस्तेमाल करता है, तो आपको सिर्फ़ कोड को छिपाने वाला मैप उपलब्ध कराना होगा. अगर HRF को रिलीज़ के लिए तैयार ऐसे बिल्ड से जनरेट किया गया है जो पहले से ही अस्पष्ट है और किसी मैपिंग की ज़रूरत नहीं है, तो उस विकल्प को अनदेखा किया जा सकता है. साथ ही, आउटपुट को assets या dexopt फ़ोल्डर में कॉपी किया जा सकता है.

बेसलाइन प्रोफ़ाइलों को इंस्टॉल करने का पारंपरिक तरीका

आम तौर पर, बेसलाइन प्रोफ़ाइलें किसी डिवाइस पर दो में से किसी एक तरीके से डिलीवर की जाती हैं.

DexMetadata के साथ install-multiple का इस्तेमाल करना

एपीआई 28 और इसके बाद के वर्शन वाले डिवाइसों पर, Play क्लाइंट इंस्टॉल किए जा रहे APK वर्शन के लिए, APK और DexMetadata (DM) पेलोड डाउनलोड करता है. डीएम में प्रोफ़ाइल की जानकारी होती है, जिसे डिवाइस पर पैकेज मैनेजर को भेजा जाता है.

APK और डीएम को एक ही इंस्टॉल सेशन के हिस्से के तौर पर इंस्टॉल किया जाता है. इसके लिए, इस तरह के किसी तरीके का इस्तेमाल किया जाता है:

adb install-multiple base.apk base.dm

Jetpack ProfileInstaller

एपीआई लेवल 29 और इसके बाद के वर्शन वाले डिवाइसों पर, Jetpack ProfileInstaller लाइब्रेरी, डिवाइस पर APK इंस्टॉल होने के बाद, assets या dexopt में पैकेज की गई प्रोफ़ाइल को इंस्टॉल करने का एक दूसरा तरीका उपलब्ध कराती है. ProfileInstaller को ProfileInstallReceiver या सीधे तौर पर ऐप्लिकेशन से शुरू किया जाता है.

ProfileInstaller लाइब्रेरी, टारगेट डिवाइस के एसडीके वर्शन के आधार पर प्रोफ़ाइल को ट्रांसकोड करती है. साथ ही, प्रोफ़ाइल को डिवाइस पर मौजूद cur डायरेक्ट्री में कॉपी करती है. यह डिवाइस पर Android रनटाइम प्रोफ़ाइलों के लिए, पैकेज के हिसाब से बनाई गई स्टेजिंग डायरेक्ट्री होती है.

डिवाइस के इस्तेमाल में न होने पर, प्रोफ़ाइल को डिवाइस पर bg-dexopt नाम की प्रोसेस से चुना जाता है.

बेसलाइन प्रोफ़ाइल को साइडलोड करना

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

androidx.profileinstaller से ब्रॉडकास्ट करें

एपीआई 24 और इसके बाद के वर्शन वाले डिवाइसों पर, प्रोफ़ाइल इंस्टॉल करने के लिए कोई निर्देश ब्रॉडकास्ट किया जा सकता है:

# Broadcast the install profile command - moves binary profile from assets
#     to a location where ART uses it for the next compile.
#     When successful, the following command prints "1":
adb shell am broadcast \
    -a androidx.profileinstaller.action.INSTALL_PROFILE \
    <pkg>/androidx.profileinstaller.ProfileInstallReceiver

# Kill the process
am force-stop <pkg>

# Compile the package based on profile
adb shell cmd package compile -f -m speed-profile <pkg>

ProfileInstaller, बेसलाइन प्रोफ़ाइल वाले ज़्यादातर APK में मौजूद नहीं होता है. यह Play पर मौजूद 4.5 लाख ऐप्लिकेशन में से करीब 77 हज़ार ऐप्लिकेशन में मौजूद होता है. हालांकि, यह Compose का इस्तेमाल करने वाले हर APK में मौजूद होता है. ऐसा इसलिए होता है, क्योंकि लाइब्रेरी, ProfileInstaller पर डिपेंडेंसी का एलान किए बिना प्रोफ़ाइलें उपलब्ध करा सकती हैं. प्रोफ़ाइल वाली हर लाइब्रेरी में डिपेंडेंसी जोड़ने की सुविधा, Jetpack से शुरू होती है.

profgen या DexMetaData के साथ install-multiple का इस्तेमाल करना

एपीआई 28 और इसके बाद के वर्शन वाले डिवाइसों पर, ऐप्लिकेशन में ProfileInstaller लाइब्रेरी के बिना भी बेसलाइन प्रोफ़ाइल को अनजान सोर्स से इंस्टॉल किया जा सकता है.

इसके लिए, Profgen-cli का इस्तेमाल करें:

profgen extractProfile \
        --apk app-release.apk \
        --output-dex-metadata app-release.dm \
        --profile-format V0_1_5_S # Select based on device and the preceding table.

# Install APK and the profile together
adb install-multiple appname-release.apk appname-release.dm

APK स्प्लिट की सुविधा का इस्तेमाल करने के लिए, हर APK के लिए प्रोफ़ाइल एक्सट्रैक्ट करने के ऊपर बताए गए चरणों को एक बार चलाएं. इंस्टॉल करते समय, हर APK और उससे जुड़ी .dm फ़ाइल को पास करें. साथ ही, पक्का करें कि APK और .dm के नाम मेल खाते हों:

adb install-multiple appname-base.apk appname-base.dm \
appname-split1.apk appname-split1.dm

पुष्टि

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

बाइनरी प्रोफ़ाइल का कॉन्टेंट डंप करें

बेसलाइन प्रोफ़ाइल के कॉम्पैक्ट बाइनरी वर्शन के कॉन्टेंट की जांच करने के लिए, Profgen-cli dumpProfile विकल्प का इस्तेमाल करें:

Usage: profgen dumpProfile options_list
Options:
    --profile, -p -> File path to the binary profile (always required)
    --apk, -a -> File path to apk (always required) { String }
    --map, -m -> File path to name obfuscation map { String }
    --strict, -s [true] -> Strict mode
    --output, -o -> File path for the HRF (always required) { String }
    --help, -h -> Usage info

dumpProfile को APK की ज़रूरत होती है, क्योंकि कॉम्पैक्ट बाइनरी रिप्रज़ेंटेशन सिर्फ़ DEX ऑफ़सेट को सेव करता है. इसलिए, क्लास और मेथड के नाम फिर से बनाने के लिए, इसे APK की ज़रूरत होती है.

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

ऑब्फ़स्केशन मैप ज़रूरी नहीं है. हालांकि, इसे उपलब्ध कराने पर, ऑब्फ़स्केट किए गए सिंबल को आसानी से पढ़े जा सकने वाले वर्शन में फिर से मैप करने में मदद मिलती है. इससे, उन्हें इस्तेमाल करना आसान हो जाता है.