इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

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

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

नीचे दिए गए उदाहरण में, 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 के सैंपल प्रोजेक्ट में, प्रोफ़ाइल के नियमों में बदलाव करने की कोशिश की जा सकती है. ध्यान दें कि Compiler Explorer सिर्फ़ ऐसे ART प्रोफ़ाइल फ़ॉर्मैट (एचआरएफ़) के साथ काम करता है जिसे इंसान पढ़ सकता है. इसलिए, इसमें वाइल्डकार्ड का इस्तेमाल नहीं किया जा सकता.

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

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

[FLAGS][CLASS_DESCRIPTOR]->[METHOD_SIGNATURE]

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

[CLASS_DESCRIPTOR]

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

वाक्य-विन्यास	ब्यौरा
`FLAGS`	इसमें एक या उससे ज़्यादा वर्ण `H`, `S`, और `P` होते हैं. इनसे यह पता चलता है कि स्टार्टअप टाइप के हिसाब से, इस तरीके को `Hot`, `Startup` या `Post Startup` के तौर पर फ़्लैग किया जाना चाहिए या नहीं. `H` फ़्लैग वाला कोई मैथड, "हॉट" मैथड होता है. इसका मतलब है कि ऐप्लिकेशन के लाइफ़टाइम के दौरान, इसे कई बार कॉल किया जाता है. `S` फ़्लैग वाला कोई मैथड, स्टार्टअप के दौरान कॉल किया जाने वाला मैथड होता है. `P` फ़्लैग वाला तरीका, स्टार्टअप के बाद कॉल किया जाने वाला तरीका होता है. इस फ़ाइल में मौजूद किसी क्लास का मतलब है कि उसका इस्तेमाल स्टार्टअप के दौरान किया जाता है. साथ ही, क्लास लोड होने में लगने वाले समय से बचने के लिए, उसे पहले से ही ढेर में जोड़ना ज़रूरी है. ART कंपाइलर, ऑप्टिमाइज़ेशन की अलग-अलग रणनीतियों का इस्तेमाल करता है. जैसे, इन तरीकों को AOT कंपाइल करना और जनरेट की गई AOT फ़ाइल में लेआउट ऑप्टिमाइज़ेशन करना.
`CLASS_DESCRIPTOR`	टारगेट किए गए तरीके की क्लास के लिए डिस्क्रिप्टर. उदाहरण के लिए, `androidx.compose.runtime.SlotTable` का डिस्क्रिप्टर `Landroidx/compose/runtime/SlotTable;` है. Dalvik Executable (DEX) फ़ॉर्मैट के मुताबिक, यहां L को पहले रखा गया है.
`METHOD_SIGNATURE`	मेथड का सिग्नेचर, जिसमें मेथड का नाम, पैरामीटर टाइप, और रिटर्न टाइप शामिल होते हैं. उदाहरण के लिए: `// LayoutNode.kt` `fun isPlaced():Boolean {` `// ...` `}` पर `LayoutNode` का हस्ताक्षर `isPlaced()Z` है.

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

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

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

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

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

वर्ण	टाइप	ब्यौरा
`B`	बाइट	साइन किया गया बाइट
`C`	char	UTF-16 में एन्कोड किया गया यूनिकोड कैरेक्टर कोड पॉइंट
`D`	डबल	डबल-प्रिसिशन फ़्लोटिंग पॉइंट वैल्यू
`F`	फ़्लोट	सिंगल-प्रिसिशन फ़्लोटिंग पॉइंट वैल्यू
`I`	आईएनटी	पूर्णांक
`J`	लंबा	लंबा इंटीजर
`S`	छोटा	हस्ताक्षर वाला शॉर्ट वीडियो
`V`	अमान्य	अमान्य
`Z`	बूलियन	सही या गलत
`L` (क्लास का नाम)	संदर्भ	क्लास के नाम का कोई इंस्टेंस

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

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

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

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

टेस्ट डिवाइस पर, अपने ऐप्लिकेशन का रिलीज़ वर्शन इंस्टॉल करें. सटीक प्रोफ़ाइल के लिए, ऐप्लिकेशन का बिल्ड टाइप R8-ऑप्टिमाइज़ किया गया होना चाहिए और उसे डीबग नहीं किया जा सकता.
पक्का करें कि प्रोफ़ाइलें पहले से कंपाइल न की गई हों.
एपीआई 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
```
अगर आपके APK में Jetpack Profile Installer लाइब्रेरी पर डिपेंडेंसी है, तो लाइब्रेरी आपके APK के पहले लॉन्च पर प्रोफ़ाइल को बूटस्ट्रैप करती है. इससे प्रोफ़ाइल जनरेट करने की प्रोसेस में रुकावट आ सकती है. इसलिए, इसे इस कमांड की मदद से बंद करें:
```
adb shell am broadcast -a androidx.profileinstaller.action.SKIP_FILE $PACKAGE_NAME/androidx.profileinstaller.ProfileInstallReceiver
```
ऐप्लिकेशन चलाएं और उन क्रिटिकल यूज़र जर्नी पर मैन्युअल रूप से जाएं जिनके लिए आपको प्रोफ़ाइल इकट्ठा करनी है.
प्रोफ़ाइलों को डंप करने के लिए, ART को प्रॉम्प्ट करें. अगर आपके APK में Jetpack Profile Installer लाइब्रेरी पर निर्भरता है, तो प्रोफ़ाइलों को डंप करने के लिए उसका इस्तेमाल करें:
```
adb shell am broadcast -a androidx.profileinstaller.action.SAVE_FILE $PACKAGE_NAME/androidx.profileinstaller.ProfileInstallReceiver
adb shell am force-stop $PACKAGE_NAME
```
अगर प्रोफ़ाइल इंस्टॉलर का इस्तेमाल नहीं किया जा रहा है, तो नीचे दिए गए कमांड का इस्तेमाल करके, प्रोफ़ाइलों को एमुलेटर पर मैन्युअल तरीके से डंप करें:
```
adb root
adb shell killall -s SIGUSR1 $PACKAGE_NAME
adb shell am force-stop $PACKAGE_NAME
```
प्रोफ़ाइल जनरेट होने के लिए, कम से कम पांच सेकंड इंतज़ार करें.
जनरेट की गई बाइनरी प्रोफ़ाइलों को टेक्स्ट में बदलें:
एपीआई 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
```
डिवाइस से डंप की गई प्रोफ़ाइल वापस पाने के लिए, adb का इस्तेमाल करें:
```
adb pull /data/misc/profman/$PACKAGE_NAME-primary.prof.txt PATH_TO_APP_MODULE/src/main/
```

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

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

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

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

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"

ध्यान दें: परफ़ॉर्मेंस पर असर को मेज़र करने के लिए, Macrobenchmark का इस्तेमाल करने का सुझाव दिया जाता है. इससे, परफ़ॉर्मेंस को बेहतर और सटीक तरीके से मेज़र किया जा सकता है. साथ ही, यह एक लूप में बार-बार मेज़र कर सकता है, परफ़ॉर्मेंस की गड़बड़ी को ठीक करने के लिए ट्रेस कैप्चर कर सकता है, और ऑपरेटिंग सिस्टम के डिस्क कैश मेमोरी को मिटाकर, भरोसे को बढ़ा सकता है. उदाहरण के लिए,

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

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

Profgen-cli, प्रोफ़ाइल को कंपाइल करने, खुद की जांच करने, और ART प्रोफ़ाइलों को ट्रांसपाइल करने में मदद करता है. इससे, टारगेट किए गए SDK टूल के वर्शन के बावजूद, 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 प्रोफ़ाइल फ़ॉर्मैट को दूसरे में ट्रांसकोड करने के लिए किया जा सकता है.

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

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

प्रोफ़ाइल का फ़ॉर्मैट	प्लेटफ़ॉर्म वर्शन	API स्तर
v0_1_5_s	Android S+	31 से ज़्यादा
v0_1_0_p	Android P, Q, और R	28-30
v0_0_9_omr1	Android O MR1	27
v0_0_5_o	Android O	26
v0_0_1_n	Android N	24-25

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

डेटा को छिपाने वाले मैप

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

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

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

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

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

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

adb install-multiple base.apk base.dm

Jetpack ProfileInstaller

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

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

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

का एलान करना ज़रूरी है.

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

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

`androidx.profileinstaller` के साथ ब्रॉडकास्ट करना

API 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,50,000 ऐप्लिकेशन में से करीब 77,000 ऐप्लिकेशन में मौजूद है. हालांकि, यह 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 में मौजूद DEX फ़ाइलों के साथ प्रोफ़ाइल की कम्पैटिबिलिटी की जांच करता है. अगर किसी दूसरे टूल से जनरेट की गई प्रोफ़ाइलों को डीबग करने की कोशिश की जा रही है, तो आपको काम न करने की गड़बड़ियां मिल सकती हैं. इन गड़बड़ियों की वजह से, जांच के लिए डेटा को डंप नहीं किया जा सकता. ऐसे मामलों में, --strict false का इस्तेमाल करके स्ट्रिक्ट मोड को बंद किया जा सकता है. हालांकि, ज़्यादातर मामलों में आपको स्ट्रिक्ट मोड चालू रखना चाहिए.

डेटा को छिपाने वाला मैप देना ज़रूरी नहीं है. हालांकि, अगर यह दिया जाता है, तो डेटा को छिपाने वाले सिंबल को आसानी से पढ़े जा सकने वाले वर्शन में रीमैप करने में मदद मिलती है.

आपके लिए सुझाव

ध्यान दें: JavaScript बंद होने पर लिंक टेक्स्ट दिखता है
SQLite की परफ़ॉर्मेंस को बेहतर बनाने के सबसे सही तरीके
बेसलाइन प्रोफ़ाइलें {:#baseline-profiles}
अटके हुए पार्शियल वेक लॉक