Android पर, अब तक सिर्फ़ 4 केबी मेमोरी वाले पेज साइज़ का इस्तेमाल किया जा सकता था. इससे, Android डिवाइसों में आम तौर पर मौजूद कुल मेमोरी के लिए, सिस्टम मेमोरी की परफ़ॉर्मेंस को ऑप्टिमाइज़ किया जाता था. Android 15 से, AOSP उन डिवाइसों के साथ काम करता है जिन्हें 16 केबी (16 केबी डिवाइस) के पेज साइज़ का इस्तेमाल करने के लिए कॉन्फ़िगर किया गया है. अगर आपका ऐप्लिकेशन, सीधे तौर पर या किसी SDK टूल के ज़रिए, NDK लाइब्रेरी का इस्तेमाल करता है, तो आपको अपने ऐप्लिकेशन को फिर से बनाना होगा, ताकि वह 16 केबी वाले डिवाइसों पर काम कर सके.
डिवाइस बनाने वाली कंपनियां, ज़्यादा फ़िज़िकल मेमोरी (रैम) वाले डिवाइस बना रही हैं. इसलिए, इनमें से कई डिवाइसों पर 16 केबी (और बाद में ज़्यादा) पेज साइज़ का इस्तेमाल किया जाएगा, ताकि डिवाइस की परफ़ॉर्मेंस को ऑप्टिमाइज़ किया जा सके. 16 केबी वाले पेज साइज़ वाले डिवाइसों के लिए, ऐप्लिकेशन को चलाने की सुविधा जोड़ने पर, आपका ऐप्लिकेशन इन डिवाइसों पर चल पाएगा. साथ ही, इससे आपके ऐप्लिकेशन की परफ़ॉर्मेंस में हुई सुधारों का फ़ायदा भी मिलेगा. फिर से कंपाइल किए बिना, ऐप्लिकेशन Android के आने वाले वर्शन में 16 KB वाले डिवाइसों पर काम नहीं करेंगे.
अपने ऐप्लिकेशन के लिए सहायता जोड़ने में आपकी मदद करने के लिए, हमने यह देखने का तरीका बताया है कि आपके ऐप्लिकेशन पर असर पड़ा है या नहीं. साथ ही, अगर लागू हो, तो अपने ऐप्लिकेशन को फिर से बनाने का तरीका और 16 केबी वाले एनवायरमेंट में अपने ऐप्लिकेशन की जांच करने का तरीका भी बताया है. इसके लिए, हमने Android 15 के सिस्टम इमेज वाले Android एमुलेटर का इस्तेमाल करने का तरीका भी बताया है.
Google Play के साथ काम करने की ज़रूरी शर्त
Android के नए वर्शन पर आपका ऐप्लिकेशन ठीक से काम करे, इसके लिए Google Play पर मौजूद, Android 15 (एपीआई लेवल 35) और इसके बाद के वर्शन को टारगेट करने वाले सभी ऐप्लिकेशन को 64-बिट वाले डिवाइसों पर 16 केबी मेमोरी वाले पेज साइज़ के साथ काम करना होगा. अगर 1 फ़रवरी, 2027 से आपके ऐप्लिकेशन के अपडेट, 16 केबी मेमोरी वाले पेज साइज़ के साथ काम नहीं करते हैं, तो इन अपडेट को रिलीज़ नहीं किया जा सकेगा.
फ़ायदे और परफ़ॉर्मेंस में सुधार
16 केबी वाले पेज साइज़ के साथ कॉन्फ़िगर किए गए डिवाइस औसतन थोड़ी ज़्यादा मेमोरी का इस्तेमाल करते हैं, लेकिन इससे सिस्टम और ऐप्लिकेशन, दोनों के लिए परफ़ॉर्मेंस में कई सुधार भी होते हैं:
- सिस्टम में मेमोरी कम होने पर, ऐप्लिकेशन लॉन्च होने में लगने वाला समय कम हो गया है: औसतन 3.16% कम, जिन ऐप्लिकेशन की हमने जांच की है उनमें 30% तक का सुधार हुआ है
- ऐप्लिकेशन के लॉन्च के दौरान, पावर सप्लाई में कमी: औसतन 4.56% की कमी
- कैमरे को तेज़ी से लॉन्च करने की सुविधा: औसतन 4.48% ज़्यादा तेज़ी से हॉट स्टार्ट और 6.60% ज़्यादा तेज़ी से कोल्ड स्टार्ट
- सिस्टम बूट होने का समय बेहतर हुआ: औसतन 8% (करीब 950 मिलीसेकंड) की बढ़ोतरी हुई
ये सुधार, हमारी शुरुआती जांच पर आधारित हैं. इसलिए, हो सकता है कि असल डिवाइसों पर नतीजे अलग हों. जैसे-जैसे हम अपनी टेस्टिंग को जारी रखेंगे, वैसे-वैसे हम ऐप्लिकेशन को मिलने वाले संभावित फ़ायदों का अतिरिक्त विश्लेषण देंगे.
यह देखना कि आपके ऐप्लिकेशन पर असर पड़ा है या नहीं
अगर आपका ऐप्लिकेशन किसी नेटिव कोड का इस्तेमाल करता है, तो आपको अपने ऐप्लिकेशन को 16 केबी वाले डिवाइसों के लिए फिर से बनाना होगा. अगर आपको नहीं पता कि आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है या नहीं, तो APK विश्लेषक का इस्तेमाल करके यह पता लगाया जा सकता है कि कोई नेटिव कोड मौजूद है या नहीं. इसके बाद, आपको जो शेयर की गई लाइब्रेरी मिलती हैं उनके ELF सेगमेंट के अलाइनमेंट की जांच करें. Android Studio में ऐसी सुविधाएं भी होती हैं जिनकी मदद से, अलाइनमेंट से जुड़ी समस्याओं का पता अपने-आप चल जाता है.
अगर आपका ऐप्लिकेशन सिर्फ़ Java प्रोग्रामिंग भाषा या Kotlin में लिखे गए कोड का इस्तेमाल करता है, तो इसका मतलब है कि आपका ऐप्लिकेशन पहले से ही 16 केबी वाले डिवाइसों पर काम करता है. इसमें सभी लाइब्रेरी या SDK टूल भी शामिल हैं. इसके बावजूद, हमारा सुझाव है कि आप अपने ऐप्लिकेशन को 16 केबी वाले एनवायरमेंट में टेस्ट करें. इससे यह पक्का किया जा सकेगा कि ऐप्लिकेशन के काम करने के तरीके में कोई अनचाहा बदलाव नहीं हुआ है.
क्या आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है?
अगर इनमें से कोई भी स्थिति लागू होती है, तो आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है:
- आपका ऐप्लिकेशन, किसी C/C++ (नेटिव) कोड का इस्तेमाल करता है. अगर आपका ऐप्लिकेशन Android NDK का इस्तेमाल करता है, तो इसका मतलब है कि वह नेटिव कोड का इस्तेमाल करता है.
- आपका ऐप्लिकेशन, तीसरे पक्ष की किसी ऐसी नेटिव लाइब्रेरी या डिपेंडेंसी (जैसे, एसडीके) से लिंक हो जो इन एपीआई का इस्तेमाल करती है.
- आपका ऐप्लिकेशन, तीसरे पक्ष के किसी ऐसे ऐप्लिकेशन बिल्डर ने बनाया है जो डिवाइस पर नेटिव लाइब्रेरी का इस्तेमाल करता है.
APK ऐनालाइज़र का इस्तेमाल करके नेटिव लाइब्रेरी की पहचान करना
APK ऐनालाइज़र एक ऐसा टूल है जिसकी मदद से, बनाए गए APK के अलग-अलग पहलुओं का आकलन किया जा सकता है. यह देखने के लिए कि आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है या नहीं (चाहे वह 16 केबी वाले पेजों के साथ काम करता हो या नहीं):
- Android Studio खोलें. इसके बाद, File > Open पर क्लिक करें और कोई प्रोजेक्ट चुनें.
मेन्यू बार में जाकर, Build > Analyze APK... पर क्लिक करें
वह APK चुनें जिसका विश्लेषण करना है.
libफ़ोल्डर में देखें. इसमें शेयर किए गए ऑब्जेक्ट (.so) की फ़ाइलें होती हैं, अगर कोई फ़ाइल मौजूद हो. अगर कोई शेयर की गई ऑब्जेक्ट फ़ाइल मौजूद है, तो आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है. अलाइनमेंट कॉलम में, उन सभी फ़ाइलों के लिए चेतावनी वाले मैसेज दिखते हैं जिनमें अलाइनमेंट से जुड़ी समस्याएं हैं. अगर शेयर की गई कोई ऑब्जेक्ट फ़ाइल मौजूद नहीं है याlibफ़ोल्डर नहीं है, तो इसका मतलब है कि आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल नहीं करता.
अपने-आप होने वाली जांचों की मदद से, अलाइनमेंट से जुड़ी समस्याओं का पता लगाना
अगर आपकी पहले से बनाई गई लाइब्रेरी या APK, 16 केबी के साथ काम नहीं करते हैं, तो Android Studio आपको पहले से चेतावनी देता है. APK ऐनालाइज़र टूल का इस्तेमाल करके देखें कि किन लाइब्रेरी को अपडेट करने की ज़रूरत है या कोड में कोई बदलाव करने की ज़रूरत है या नहीं.
Android Studio में Lint, उन नेटिव लाइब्रेरी को भी हाइलाइट करता है जो 16 केबी पेज साइज़ के साथ काम नहीं करती हैं.
शेयर की गई लाइब्रेरी के लिए, ईएलएफ़ सेगमेंट के अलाइनमेंट की जांच करना
शेयर की गई किसी भी लाइब्रेरी के लिए, पुष्टि करें कि शेयर की गई लाइब्रेरी के ईएलएफ़ सेगमेंट, 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके सही तरीके से अलाइन किए गए हों.
APK ऐनालाइज़र का इस्तेमाल करना (सुझाया गया)
शेयर की गई लाइब्रेरी के अलाइनमेंट की पुष्टि करने का सबसे आसान तरीका, Android Studio में APK ऐनालाइज़र का इस्तेमाल करना है. अगर शेयर की गई कोई ऑब्जेक्ट फ़ाइल 16 केबी के हिसाब से अलाइन नहीं है, तो अलाइनमेंट कॉलम में चेतावनी वाला मैसेज दिखेगा.
check_elf_alignment.sh स्क्रिप्ट (Linux या macOS) का इस्तेमाल करना
अगर Linux या macOS पर ऐप्लिकेशन डेवलप किया जा रहा है और आपको स्क्रिप्ट का इस्तेमाल करना है, तो check_elf_alignment.sh स्क्रिप्ट का इस्तेमाल किया जा सकता है:
check_elf_alignment.shस्क्रिप्ट को किसी फ़ाइल में सेव करें.अपने ऐप्लिकेशन की APK फ़ाइल पर स्क्रिप्ट चलाएं:
check_elf_alignment.sh APK_NAME.apkस्क्रिप्ट, शेयर की गई सभी
arm64-v8aलाइब्रेरी के लिए,ALIGNEDयाUNALIGNEDआउटपुट देती है.अगर कोई
arm64-v8aयाx86_64शेयर की गई लाइब्रेरीUNALIGNEDहै, तो आपको उन लाइब्रेरी की पैकेजिंग अपडेट करनी होगी. इसके बाद, अपने ऐप्लिकेशन को फिर से कंपाइल करें और इस सेक्शन में दिया गया तरीका अपनाकर, फिर से जांच करें.
कमांड-लाइन टूल का सीधे तौर पर इस्तेमाल करना
कमांड-लाइन टूल का इस्तेमाल करके, ईएलएफ़ सेगमेंट के अलाइनमेंट की जांच करने के लिए, यह तरीका अपनाएं:
- पक्का करें कि Android SDK बिल्ड-टूल का वर्शन 35.0.0 या इसके बाद का वर्शन और Android एनडीके, दोनों इंस्टॉल हों. इसके लिए, Android Studio में एसडीके मैनेजर या
sdkmanagerकमांड-लाइन टूल का इस्तेमाल करें. अपने ऐप्लिकेशन की APK फ़ाइल को एक्सट्रैक्ट करें:
Linux या macOS
unzip APK_NAME.apk -d /tmp/my_apk_outWindows (PowerShell)
Expand-Archive -Path .\APK_NAME.apk -DestinationPath ~\tmp\my_apk_outजिस अस्थायी डायरेक्ट्री में आपने APK फ़ाइल को एक्सट्रैक्ट किया है उसमें शेयर किए गए ऑब्जेक्ट (
.so) की फ़ाइलों के लिए,libडायरेक्ट्री का कॉन्टेंट देखें. ये वही शेयर की गई ऑब्जेक्ट फ़ाइलें हैं जो आपको APK ऐनालाइज़र का इस्तेमाल करके नेटिव लाइब्रेरी की पहचान करने के दौरान दिखती हैं. शेयर की गई हर ऑब्जेक्ट फ़ाइल पर यह कमांड चलाएं:Linux या macOS
SDK_ROOT_LOCATION/Android/sdk/ndk/NDK_VERSION/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-objdump -p SHARED_OBJECT_FILE.so | grep LOADWindows (PowerShell)
SDK_ROOT_LOCATION\Android\sdk\ndk\NDK_VERSION\toolchains\llvm\prebuilt\windows-x86_64\bin\llvm-objdump.exe -p SHARED_OBJECT_FILE.so | Select-String -Pattern "LOAD"जहां
SDK_ROOT_LOCATIONउस डायरेक्ट्री का पाथ है जहां आपने Android SDK टूल इंस्टॉल किया है,SHARED_OBJECT_FILEउस शेयर की गई ऑब्जेक्ट फ़ाइल का नाम है जिसकी जांच की जा रही है, औरNDK_VERSIONआपके इंस्टॉल किए गए Android NDK का वर्शन है (उदाहरण के लिए,28.0.12433566). जांच की जाने वाली हर फ़ाइल के लिए, आउटपुट कुछ इस तरह दिखेगा:LOAD off 0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**14 LOAD off 0x0000000000042a90 vaddr 0x0000000000043a90 paddr 0x0000000000043a90 align 2**14 LOAD off 0x0000000000046230 vaddr 0x0000000000048230 paddr 0x0000000000048230 align 2**14आउटपुट लाइनों की जांच करके पक्का करें कि लोड सेगमेंट की वैल्यू
2**14से कम न हों. अगर किसी लोड सेगमेंट की वैल्यू2**13,2**12या इससे कम है, तो आपको उन लाइब्रेरी की पैकेजिंग अपडेट करनी होगी. इसके बाद, अपने ऐप्लिकेशन को फिर से कंपाइल करें और इस सेक्शन में दिया गया तरीका अपनाकर, फिर से जांच करें.इसके बाद, अपने ऐप्लिकेशन की APK फ़ाइल पर
zipalignकमांड-लाइन टूल चलाएं:Linux या macOS
SDK_ROOT_LOCATION/Android/sdk/build-tools/35.0.0/zipalign -v -c -P 16 4 APK_NAME.apkWindows (PowerShell)
SDK_ROOT_LOCATION\Android\sdk\build-tools\35.0.0\zipalign.exe -v -c -P 16 4 APK_NAME.apkजहां
SDK_ROOT_LOCATIONउस डायरेक्ट्री का पाथ है जहां आपने Android SDK इंस्टॉल किया है औरAPK_NAMEआपके ऐप्लिकेशन की APK फ़ाइल का नाम है. अगर शेयर की गई सभी लाइब्रेरी सही तरीके से अलाइन की गई हैं, तो आउटपुट की आखिरी लाइन में "पुष्टि हो गई" दिखेगा.अगर पुष्टि नहीं हो पाती है, तो शेयर की गई कुछ लाइब्रेरी को फिर से अलाइन करना होगा. इसके लिए, आपको उन लाइब्रेरी की पैकेजिंग को अपडेट करना होगा. इसके बाद, अपने ऐप्लिकेशन को फिर से कंपाइल करें और इस सेक्शन में दिया गया तरीका अपनाकर, फिर से जांच करें.
RELRO के सुरक्षा फ़्लैग की जांच करना
सुरक्षा से जुड़े जोखिमों को कम करने के लिए, मॉडर्न लिंकर रीलोकेशन रीड-ओनली (RELRO) फ़्लैग का इस्तेमाल करते हैं. इससे डाइनैमिक रीलोकेशन पूरा होने के बाद, शेयर की गई ऑब्जेक्ट फ़ाइल के रीलोकेशन टारगेट सेक्शन (जैसे, .got और .data.rel.ro) रीड-ओनली हो जाते हैं.
अपने बिल्ड में RELRO फ़्लैग चालू करें.
जब GNU_RELRO, बदलाव किए जा सकने वाले LOAD सेगमेंट को बदलाव किए जा सकने वाले डेटा (जैसे, .data या .bss) के साथ शेयर करता है, तो GNU_RELRO सेगमेंट का आखिरी पता (VirtAddr + MemSiz) 16 केबी अलाइन (0x4000) होना चाहिए. ऐसा न होने पर, जब Android लिंकर, GNU_RELRO के आखिरी हिस्से वाले 16 केबी पेज को रीड-ओनली के तौर पर मार्क करता है, तो उसी 16 केबी पेज के बाकी हिस्से में मौजूद, बदलाव किए जा सकने वाले डेटा को भी रीड-ओनली के तौर पर मार्क कर दिया जाता है. इससे, डेटा लिखे जाने पर, सेगमेंटेशन फ़ॉल्ट (SIGSEGV) की वजह से ऐप्लिकेशन क्रैश हो जाता है.
आम तौर पर, ऐसा तब होता है, जब .so फ़ाइल को एनडीके टूल चेन r27 और इससे पहले के वर्शन का इस्तेमाल करके बनाया गया हो. साथ ही, ज़रूरी फ़्लैग चालू न किए गए हों.
APK ऐनालाइज़र का इस्तेमाल करना (सुझाया गया)
Android Studio में APK ऐनालाइज़र का इस्तेमाल करके, शेयर की गई ऑब्जेक्ट फ़ाइलों के RELRO अलाइनमेंट की स्थिति सीधे तौर पर देखी जा सकती है.
कमांड-लाइन टूल इस्तेमाल करना
अगर आपको मैन्युअल तरीके से अलाइनमेंट की जांच करनी है या इस प्रोसेस को ऑटोमेट करना है, तो यह तरीका अपनाएं:
पहला चरण: प्रोग्राम हेडर की जांच करना
शेयर की गई हर ऑब्जेक्ट फ़ाइल पर यह कमांड चलाएं (Linux पर, darwin-x86_64 को linux-x86_64 से बदलें):
Linux या macOS
SDK_ROOT_LOCATION/Android/sdk/ndk/NDK_VERSION/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-readelf -Wl SHARED_OBJECT_FILE.so | grep 'LOAD\|RELRO\|Type'
Windows (PowerShell)
SDK_ROOT_LOCATION\Android\sdk\ndk\NDK_VERSION\toolchains\llvm\prebuilt\windows-x86_64\bin\llvm-readelf.exe -Wl SHARED_OBJECT_FILE.so | Select-String -Pattern 'LOAD|RELRO|Type'
अगर कोई RELRO सेगमेंट है, तो GNU_RELRO स्ट्रिंग प्रिंट की जाती है.
दूसरा चरण: पुष्टि करें कि RELRO, 16 केबी के साथ काम करता है या नहीं
शेयर की गई ऑब्जेक्ट फ़ाइल, RELRO के हिसाब से 16 केबी के साथ काम करती है, अगर इनमें से कोई भी शर्त पूरी होती है:
- प्रोग्राम के हेडर में कोई
GNU_RELROसेगमेंट मौजूद नहीं है. GNU_RELROका आखिरी पता 16 केबी के हिसाब से अलाइन किया गया है: इसके वर्चुअल पते (VirtAddr) और मेमोरी साइज़ (MemSiz) के योग को 16 केबी (0x4000) से भाग देने पर, शेषफल (मॉड्यूलो) शून्य बचता है:(VirtAddr + MemSiz) % 0x4000 == 0.GNU_RELROके बाद, उसीLOADसेगमेंट में ऐसा कोई डेटा नहीं है जिसमें बदलाव किया जा सके:GNU_RELRO, अपनेLOADसेगमेंट के बाकी बचे पूरे हिस्से को घेरता है (इसका मतलब हैLOAD.VirtAddr + LOAD.MemSiz == RELRO.VirtAddr + RELRO.MemSiz). इसलिए, बदलाव किए जा सकने वाले.dataया.bssसेक्शन, ट्रेलिंग पेज को शेयर नहीं करते.
उदाहरण
यहां दिए गए उदाहरणों से पता चलता है कि अलग-अलग GNU_RELRO कॉन्फ़िगरेशन के लिए, llvm-readelf आउटपुट का आकलन कैसे किया जाता है.
उदाहरण 1: अलाइन न की गई .so फ़ाइल (शर्तों का पालन न करने वाली)
इस उदाहरण में, GNU_RELRO, RW LOAD सेगमेंट को बाद के राइटेबल डेटा के साथ शेयर करता है. साथ ही, इसका एंड अड्रेस 0x4000 का मल्टीपल नहीं है:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x0cfaf0 0x0cfaf0 R E 0x4000
LOAD 0x0cfaf0 0x00000000000dfaf0 0x00000000000dfaf0 0x02510 0x04510 RW 0x4000
GNU_RELRO 0x0cfaf0 0x00000000000dfaf0 0x00000000000dfaf0 0x01510 0x01510 R 0x1
- फ़ॉर्मूला:
(VirtAddr + MemSiz) % 0x4000 == 0 - नतीजा:
(0xdfaf0 + 0x01510) % 0x4000 = 0xE1000 % 0x4000 == 0x1000
0x1000 शून्य नहीं है और इसमें मौजूद LOAD सेगमेंट, 0xE1000 के बाद भी जारी रहता है (0xdfaf0 + 0x04510 = 0xE4000 पर खत्म होता है). इसलिए, यह .so फ़ाइल 16 केबी के मुताबिक नहीं है. 16 केबी वाले डिवाइस पर, लिंकर RELRO सुरक्षा रेंज को 16 केबी वाले पेज की सीमाओं तक राउंड करता है. साथ ही, 0xDC000 (पिछले पेज ब्रेक) से लेकर 0xE4000 तक को रीड-ओनली के तौर पर मार्क करता है. हालांकि, .so फ़ाइल के राइटेबल .data और .bss सेक्शन, 0xE1000 से 0xE4000 की सब-रेंज में मौजूद होते हैं. इस वजह से, रनटाइम के दौरान बदलाव करने पर, सेगमेंटेशन फ़ॉल्ट होता है. 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके अपना ऐप्लिकेशन कंपाइल करें सेक्शन में बताए गए तरीके से, इस .so फ़ाइल को फिर से बनाएं.
दूसरा उदाहरण: RELRO सेगमेंट के साथ अलाइन की गई .so फ़ाइल (शर्तों के मुताबिक)
इस उदाहरण में, GNU_RELRO सेगमेंट का आखिरी हिस्सा 16 केबी वाले पेज की सीमा पर आता है:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x0cfaf0 0x0cfaf0 R E 0x4000
LOAD 0x0cfaf0 0x00000000000dfaf0 0x00000000000dfaf0 0x01510 0x03510 RW 0x4000
GNU_RELRO 0x0cfaf0 0x00000000000dfaf0 0x00000000000dfaf0 0x00510 0x00510 R 0x1
- फ़ॉर्मूला:
(VirtAddr + MemSiz) % 0x4000 == 0 - नतीजा:
(0xdfaf0 + 0x00510) % 0x4000 = 0xE0000 % 0x4000 == 0
शेष 0 है, इसलिए RELRO सुरक्षा 0xE0000 पेज की सीमा पर खत्म हो जाती है. इससे 0xE0000 से शुरू होने वाले किसी भी डेटा पर कोई असर नहीं पड़ता.
तीसरा उदाहरण: RELRO सेगमेंट के बिना .so फ़ाइल (नीति का पालन करने वाली)
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x000680 0x000680 R E 0x4000
LOAD 0x000680 0x0000000000004680 0x0000000000004680 0x0001d8 0x0001d8 RW 0x4000
इस .so फ़ाइल में कोई GNU_RELRO सेगमेंट नहीं है. इसलिए, RELRO पेज-बाउंड्री से जुड़ी समस्याएं लागू नहीं होती हैं. हालांकि, सुरक्षा के लिए RELRO को चालू करने का सुझाव अब भी दिया जाता है.
उदाहरण 4: GNU_RELRO अपने LOAD सेगमेंट में है (नीति के मुताबिक है)
इस उदाहरण में, GNU_RELRO 16 केबी की सीमा पर खत्म नहीं होता है. हालांकि, यह अब भी ज़रूरी शर्तों को पूरा करता है, क्योंकि उसी LOAD सेगमेंट में इसके बाद कोई ऐसा डेटा नहीं है जिसमें बदलाव किया जा सके:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x000680 0x000680 R E 0x4000
LOAD 0x000680 0x0000000000004680 0x0000000000004680 0x0001d8 0x000980 RW 0x4000
GNU_RELRO 0x000680 0x0000000000004680 0x0000000000004680 0x0001d8 0x000980 R 0x1
- फ़ॉर्मूला:
(VirtAddr + MemSiz) % 0x4000 == 0 - नतीजा:
(0x4680 + 0x0980) % 0x4000 = 0x5000 % 0x4000 == 0x1000
0x1000 शून्य नहीं है. इसके बावजूद, यह .so फ़ाइल 16 केबी वाले पेज साइज़ के साथ काम करती है.
GNU_RELRO की तुलना, इसमें शामिल LOAD सेगमेंट (दूसरी LOAD एंट्री) से करने पर पता चलता है कि दोनों VirtAddr 0x4680 पर शुरू होते हैं और एक ही पते (0x4680 + 0x0980 = 0x5000) पर खत्म होते हैं.
पूरे LOAD सेगमेंट में सिर्फ़ RELRO डेटा होता है. इसलिए, 0x5000 से 0x8000 तक की सब-रेंज में, .data या .bss का ऐसा डेटा मौजूद नहीं होता जिसमें बदलाव किया जा सके. ऐसा इसलिए होता है, क्योंकि लाइब्रेरी में ऐसा कोई डेटा मौजूद नहीं होता जिसमें बदलाव किया जा सके और जो RELRO डेटा न हो. इसके अलावा, ऐसा भी हो सकता है कि LOAD सेगमेंट के बाद मौजूद, बदलाव किए जा सकने वाले किसी सेगमेंट की शुरुआत, 0x8000 या इसके बाद, 16 केबी के किसी अलग पेज की सीमा से होती हो. लिंकर की रीड-ओनली सुरक्षा, किसी भी ऐसे डेटा को ओवरलैप नहीं करेगी जिसमें बदलाव किया जा सकता है. इसलिए, सेगमेंटेशन से जुड़ी कोई गड़बड़ी नहीं होती.
अपने ऐप्लिकेशन को 16 केबी मेमोरी वाले डिवाइसों के साथ काम करने के लिए बनाएं
अगर आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है, तो यहां दिए गए सेक्शन में बताया गया तरीका अपनाएं. इससे यह पक्का किया जा सकेगा कि आपका ऐप्लिकेशन, 16 केबी मेमोरी वाले डिवाइसों पर काम करे:
- शेयर की गई लाइब्रेरी की पैकेजिंग अपडेट करना
- 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके, अपने ऐप्लिकेशन को कंपाइल करना
- कोड को ठीक करना और रनटाइम से जुड़ी समस्याएं हल करना
- कस्टम मेमोरी एलोकेटर को ऑप्टिमाइज़ करना (अगर लागू हो)
- यह देखना कि एसडीके, 16 केबी वाले पेज साइज़ के साथ काम करते हैं या नहीं
शेयर की गई लाइब्रेरी की पैकेजिंग अपडेट करना
Android Gradle प्लगिन के वर्शन 8.5.1 या इसके बाद वाले वर्शन पर अपग्रेड करें और कंप्रेस नहीं की गई शेयर की गई लाइब्रेरी का इस्तेमाल करें.
ज़िप अलाइनमेंट की पुष्टि करने के लिए, bundletool का इस्तेमाल करना
अपने बंडल का अलाइनमेंट देखने के लिए, इसका इस्तेमाल करें:
bundletool dump config --bundle=<my .aab> | grep alignment
अगर आपको PAGE_ALIGNMENT_16K दिखता है, तो इसका मतलब है कि आपका बंडल 16 केबी ज़िप अलाइनमेंट का अनुरोध करता है. अगर आपको PAGE_ALIGNMENT_4K दिखता है, तो इसका मतलब है कि इस AAB से बने APK में, zip फ़ाइल में 4 केबी अलाइन की गई .so फ़ाइलें होनी चाहिए.
Android Gradle प्लगिन का वर्शन 8.5.1 या इसके बाद का वर्शन
16 केबी वाले डिवाइसों पर, कंप्रेस न की गई शेयर की गई लाइब्रेरी वाले ऐप्लिकेशन को 16 केबी की ज़िप-अलाइन की गई बाउंड्री पर अलाइन करना ज़रूरी है. इसके लिए, आपको Android Gradle प्लगिन (एजीपी) को 8.5.1 या इसके बाद के वर्शन पर अपग्रेड करना होगा. अपग्रेड की प्रोसेस के बारे में जानकारी पाने के लिए, Android Gradle प्लग-इन अपग्रेड असिस्टेंट सेक्शन देखें.
AGP का वर्शन 8.5 या इससे पहले का वर्शन
अगर एजीपी को 8.5.1 या इसके बाद के वर्शन पर अपग्रेड नहीं किया जा सकता, तो कंप्रेस की गई शेयर की गई लाइब्रेरी का इस्तेमाल करें. अपने Gradle कॉन्फ़िगरेशन को अपडेट करें, ताकि ऐप्लिकेशन को पैकेज करते समय Gradle आपकी शेयर की गई लाइब्रेरी को कंप्रेस कर सके. इससे, शेयर की गई लाइब्रेरी के अलाइन न होने की वजह से, ऐप्लिकेशन इंस्टॉल करने से जुड़ी समस्याओं से बचा जा सकता है.
Groovy
अपनी build.gradle फ़ाइल में, यह विकल्प जोड़ें:
android {
...
packagingOptions {
jniLibs {
useLegacyPackaging true
}
}
}
Kotlin
अपनी build.gradle.kts फ़ाइल में, यह विकल्प जोड़ें:
android {
...
packagingOptions {
jniLibs {
useLegacyPackaging = true
}
}
}
Android Gradle प्लगिन का वर्शन 8.0 या इससे पहले का वर्शन
अगर एजीपी के 8.0 या इससे पहले के वर्शन का इस्तेमाल किया जा रहा है, तो आपको अपनी gradle.properties फ़ाइल में, ऐप्लिकेशन बंडल के लिए कंप्रेस न की गई नेटिव लाइब्रेरी का विकल्प भी बंद करना होगा:
android.bundle.enableUncompressedNativeLibs=false
16 केबी वाले ईएलएफ़ अलाइनमेंट का इस्तेमाल करके, अपने ऐप्लिकेशन को कंपाइल करना
16 केबी वाले डिवाइसों पर आपका ऐप्लिकेशन सही तरीके से काम करे, इसके लिए ज़रूरी है कि शेयर की गई लाइब्रेरी के ईएलएफ़ सेगमेंट को 16 केबी वाले ईएलएफ़ अलाइनमेंट का इस्तेमाल करके सही तरीके से अलाइन किया गया हो.
अगर आपका गेम Unity गेम इंजन पर चलता है, तो Unity गाइड देखें. अगर आपका गेम Unreal गेम इंजन पर चलता है, तो Unreal गाइड देखें. नेटिव गेम इंजन के लिए, इस गाइड को पढ़ना जारी रखें.
16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके अपने ऐप्लिकेशन को कंपाइल करने के लिए, यहां दिए गए किसी एक सेक्शन में बताया गया तरीका अपनाएं. यह इस बात पर निर्भर करता है कि Android एनडीके (NDK) के किस वर्शन का इस्तेमाल किया जा रहा है.
Android NDK r28 और इसके बाद के वर्शन
NDK के r28 और इसके बाद के वर्शन, डिफ़ॉल्ट रूप से 16 केबी पेज साइज़ के साथ काम करने वाले ऐप्लिकेशन कंपाइल करते हैं.
Android NDK r27 और इससे पहले के वर्शन
Android एनडीके (NDK) के r27 या इससे पहले के वर्शन के साथ, 16 केबी पेज साइज़ के हिसाब से अलाइन की गई शेयर की गई लाइब्रेरी को कंपाइल करने के लिए, इन लिंकर फ़्लैग का इस्तेमाल करें:
-Wl,-z,max-page-size=16384
-Wl,-z,common-page-size=16384
अपनी बिल्ड सिस्टम कॉन्फ़िगरेशन फ़ाइलों को अपडेट करने का तरीका यहां बताया गया है:
ndk-build
अगर ndk-build का इस्तेमाल किया जा रहा है, तो 16 केबी ईएलएफ़ अलाइनमेंट को चालू करने के लिए, अपने Android.mk को अपडेट करें:
LOCAL_LDFLAGS += -Wl,-z,max-page-size=16384 -Wl,-z,common-page-size=16384
CMake
अगर CMake का इस्तेमाल किया जा रहा है, तो 16 केबी ईएलएफ़ अलाइनमेंट को चालू करने के लिए, अपने CMakeLists.txt को अपडेट करें:
target_link_options(${CMAKE_PROJECT_NAME} PRIVATE
"-Wl,-z,max-page-size=16384"
"-Wl,-z,common-page-size=16384"
)
कोड को ठीक करना और रनटाइम से जुड़ी समस्याएं हल करना
भले ही, आपका ऐप्लिकेशन 16 केबी वाले पेज साइज़ के साथ काम करता हो, लेकिन अगर आपके कोड में यह अनुमान लगाया गया है कि डिवाइस में किसी खास साइज़ का पेज इस्तेमाल किया जा रहा है, तो आपके ऐप्लिकेशन में गड़बड़ियां हो सकती हैं. इससे बचने के लिए, यह तरीका अपनाएं:
अपने कोड लॉजिक में, हार्ड-कोड की गई ऐसी सभी डिपेंडेंसी हटाएं जो
PAGE_SIZEकॉन्सटेंट या इंस्टेंस को रेफ़र करती हैं. साथ ही, यह मानती हैं कि डिवाइस का पेज साइज़ 4 केबी (4096) है.इसके बजाय,
getpagesize()याsysconf(_SC_PAGESIZE)का इस्तेमाल करें.mmap()और अन्य एपीआई के इस्तेमाल की जांच करें. इन एपीआई के लिए, पेज-अलाइन किए गए आर्ग्युमेंट की ज़रूरत होती है. साथ ही, ज़रूरत पड़ने पर इन्हें अन्य विकल्पों से बदलें.
कुछ मामलों में, अगर आपका ऐप्लिकेशन PAGE_SIZE का इस्तेमाल ऐसी वैल्यू के तौर पर करता है जो पेज साइज़ से जुड़ी नहीं है, तो 16 केबी वाले मोड में इस्तेमाल किए जाने पर आपका ऐप्लिकेशन क्रैश नहीं होगा. हालांकि, अगर इस वैल्यू को mmap के साथ कर्नेल को पास किया जाता है, लेकिन MAP_FIXED के बिना, तो कर्नेल अब भी पूरे पेज का इस्तेमाल करता है. इससे कुछ मेमोरी बर्बाद होती है. इन वजहों से, एनडीके r27 और इसके बाद के वर्शन पर 16 केबी मोड चालू होने पर, PAGE_SIZE को तय नहीं किया जाता.
अगर आपका ऐप्लिकेशन PAGE_SIZE का इस्तेमाल इस तरह करता है और इस वैल्यू को कभी भी सीधे तौर पर कर्नेल को पास नहीं करता है, तो PAGE_SIZE का इस्तेमाल करने के बजाय, नए नाम के साथ एक नया वैरिएबल बनाएं. इससे यह पता चलेगा कि इसका इस्तेमाल अन्य कामों के लिए किया जाता है और यह असल मेमोरी पेज को नहीं दिखाता है.
कस्टम मेमोरी ऐलोकेटर को ऑप्टिमाइज़ करना
16 केबी वाले सिस्टम पर, फ़िज़िकल मेमोरी की सबसे छोटी यूनिट, 4 केबी वाले सिस्टम की तुलना में चार गुना बड़ी होती है. फ़िज़िकल मेमोरी की यह यूनिट, ऑपरेटिंग सिस्टम तय करता है. अगर कस्टम ऐलोकेटर को 4 केबी के हिसाब से डिज़ाइन किया गया है, तो यह छोटे ऑब्जेक्ट को 16 केबी के कई पेजों में बांट सकता है. साथ ही, बेवजह खाली मेमोरी को बनाए रख सकता है. इससे, फ़िज़िकल मेमोरी के इस्तेमाल (आरएसएस) में काफ़ी बढ़ोतरी हो सकती है. साथ ही, कंप्रेस की गई स्वैप मेमोरी (ZRAM) की परफ़ॉर्मेंस में गिरावट आ सकती है.
अगर आपका कोड अपने मेमोरी पूल को मैनेज करता है, तो ये सुझाव अपनाएं:
1. मेमोरी खाली करने के लिए, हार्ड कोड किए गए बाइट थ्रेशोल्ड का इस्तेमाल करने से बचें
कई ऐलोकेटर, बाइट की तय सीमा का इस्तेमाल करके यह तय करते हैं कि madvise(MADV_DONTNEED) का इस्तेमाल करके, ओएस को मेमोरी कब वापस करनी है. उदाहरण के लिए, मेमोरी सिर्फ़ तब रिलीज़ करें, जब ऐक्टिव ऑब्जेक्ट 8 केबी से कम जगह लेते हों.
16 केबी वाले सिस्टम पर, 16 बाइट का एक लाइव ऑब्जेक्ट भी पूरे 16 केबी वाले पेज को पिन करता है. यह 8 केबी से ज़्यादा होता है. इस वजह से, रिलीज़ थ्रेशोल्ड कभी पूरा नहीं होता और ऐलोकेटर, इस्तेमाल नहीं की गई मेमोरी को कर्नेल को कभी वापस नहीं करता.
क्या करें: पेज-रिलीज़ ह्यूरिस्टिक के लिए, हार्ड-कोड किए गए बाइट कॉन्सटेंट का इस्तेमाल कभी न करें.
sysconf(_SC_PAGESIZE) का इस्तेमाल करके, पेज के असल साइज़ के आधार पर रनटाइम के दौरान, रिलीज़ थ्रेशोल्ड को डाइनैमिक तौर पर स्केल करें.
2. पहले से इस्तेमाल किए जा रहे पेजों को पहले भरें (डेंस-फ़र्स्ट ऐलोकेशन)
अगर कोई ऐलोकेटर, फ़र्स्ट-इन-फ़र्स्ट-आउट (एफ़आईएफ़ओ) या राउंड-रॉबिन ऑर्डर में मेमोरी देता है, तो नए ऐलोकेशन, आंशिक रूप से भरे हुए कई 16 केबी पेजों में बिखर जाते हैं. पेज पर मौजूद एक ऑब्जेक्ट, फ़िज़िकल रैम में मौजूद सभी 16 केबी को सेव रखता है.
क्या करें: खाली या कम इस्तेमाल किए गए पेजों को छूने से पहले, हमेशा सबसे ज़्यादा भरे हुए (सबसे ज़्यादा डेंसिटी वाले) पेज या स्लैब से नए ऑब्जेक्ट असाइन करें. पहले से इस्तेमाल किए जा रहे पेजों पर नए ऐलोकेशन को कंसंट्रेट करने से, कम इस्तेमाल किए जा रहे पेजों को नैचुरल तरीके से ड्रेन किया जा सकता है. इससे, ऐक्टिव ऑब्जेक्ट की संख्या शून्य हो जाती है. इस तरह, पूरे 16 केबी पेज को ओएस के लिए रिलीज़ किया जा सकता है.
3. मेमोरी पूल को 16 केबी पर अलाइन करें और पूल के साइज़ को मॉडरेट रखें
4 केबी वाले सिस्टम के लिए डिज़ाइन किए गए मल्टी-पेज स्पैन, 16 केबी वाले कर्नेल पर ज़्यादा मेमोरी इस्तेमाल कर सकते हैं. इसके अलावा, साइज़ की ऐसी क्लास जो 16 केबी में बराबर नहीं बंटती हैं, उनकी वजह से हर पेज के आखिर में फ़्रैगमेंटेशन होता है.
क्या करें:
- पक्का करें कि सभी मेमोरी पूल, स्लैब बाउंड्री, और बफ़र अलाइनमेंट, रनटाइम पेज साइज़ के सटीक मल्टीपल हों.
- छोटे ऑब्जेक्ट वाली क्लास के लिए, कई पेजों के स्पैन साइज़ का फिर से आकलन करें, ताकि बहुत बड़े स्लैब को असाइन करने से बचा जा सके. इससे, इस्तेमाल न की जा रही मेमोरी को ट्रैप होने से बचाया जा सकता है.
4. कैश मेमोरी में सेव किए गए बड़े बफ़र के लिए, फ़िज़िकल मेमोरी को तुरंत खाली करें
कस्टम ऐलोकेटर अक्सर इन-मेमोरी पूल में बड़े बफ़र (> 64 केबी) को कैश मेमोरी में सेव करते हैं, ताकि उन्हें mmap या munmap सिस्टम कॉल के ओवरहेड का भुगतान किए बिना फिर से इस्तेमाल किया जा सके. हालांकि, मेमोरी में इन डर्टी बफ़र को बनाए रखने से, फ़िज़िकल रैम के मेगाबाइट बर्बाद होते हैं. ऐसा तब होता है, जब इविक्शन टाइमर का इंतज़ार किया जा रहा हो.
क्या करें: वर्चुअल मेमोरी के अड्रेस की रेंज को रिज़र्व रखें, ताकि उसे तुरंत फिर से इस्तेमाल किया जा सके. हालांकि, बफ़र को कैश मेमोरी में वापस भेजते समय, madvise(..., MADV_DONTNEED) या madvise(..., MADV_FREE) को तुरंत कॉल करें. ऑपरेटिंग सिस्टम, फ़िज़िकल रैम को तुरंत वापस ले लेता है. हालांकि, आपका ऐप्लिकेशन वर्चुअल पते को फिर से असाइन किए बिना, तुरंत इस्तेमाल कर सकता है.
5. ZRAM कंप्रेशन के लिए, मेमोरी को ऐलोकेट करने के बजाय, खाली होने पर उसे ज़ीरो आउट करें
Android, बैकग्राउंड में चल रहे ऐप्लिकेशन को मेमोरी में रखने के लिए, कंप्रेस किए गए स्वैप (ZRAM) का इस्तेमाल करता है. 16 केबी वाले डिवाइसों पर, अगर किसी पेज में एक भी लाइव ऑब्जेक्ट मौजूद है, तो पूरा 16 केबी वाला पेज मेमोरी में बना रहता है या उसे ZRAM में स्वैप कर दिया जाता है. पेज के पहले से खाली किए गए हिस्सों में मौजूद, बचा हुआ बेकार डेटा (जैसे, पुराने पॉइंटर और स्ट्रिंग) ठीक से कंप्रेस नहीं होता.
अगर आपका ऐलोकेटर, मेमोरी को ज़ीरो करता है (जैसे कि सुरक्षा या ज़ीरो-इनिशलाइज़ किए गए ऐलोकेशन के लिए), तो ऐलोकेशन के बजाय डीऐलोकेशन (free()) पर ज़ीरो करने पर विचार करें:
- पिन किए गए पेजों के लिए कम मेमोरी की ज़रूरत होती है: 16 केबी के जिन पेजों में कुछ जगह खाली होती है उनकी खाली मेमोरी, ZRAM में कंप्रेस होकर न के बराबर हो जाती है. इसलिए, पिन किए गए पेजों के लिए फ़िज़िकल स्वैप स्पेस बर्बाद नहीं होता.
- कैश मेमोरी का कम से कम ओवरहेड:
free()को कॉल करने के समय, सीपीयू कैश मेमोरी में डेटा पहले से ही मौजूद होता है. इससे बाद में कैश मेमोरी में डेटा न मिलने की समस्या से बचा जा सकता है.
सुझावों की खास जानकारी
| जगह | सुझाव | अनुमानित असर |
|---|---|---|
| डेटा मिटाने के लिए थ्रेशोल्ड | sysconf(_SC_PAGESIZE) का इस्तेमाल करके, रिलीज़ थ्रेशोल्ड को डाइनैमिक तरीके से स्केल करें. |
रिलीज़ लॉजिक को हमेशा के लिए डेडलॉक होने से रोकता है. |
| एलोकेशन ऑर्डर | सबसे पहले, सबसे ज़्यादा भरे हुए (करीब-करीब पूरे भरे हुए) पेज या स्लैब से मेमोरी असाइन करें. | यह ऐक्टिव ऑब्जेक्ट को एक साथ पैक करके, रेज़िडेंट मेमोरी (आरएसएस) को कम करता है. |
| स्पैन साइज़िंग | साइज़ क्लास को 16 केबी के मल्टीपल के साथ अलाइन करें और बड़े साइज़ के स्लैब से बचें. | इससे टेल-पेज फ़्रैगमेंटेशन की समस्या खत्म होती है और मेमोरी स्लैक कम होता है. |
| बफ़र कैश मेमोरी | बड़े बफ़र को कैश मेमोरी में सेव करते समय, madvise(MADV_DONTNEED) को तुरंत कॉल करें. |
यह सुविधा, इस्तेमाल न होने वाली रैम को खाली करती है, ताकि वर्चुअल रैम को तेज़ी से फिर से इस्तेमाल किया जा सके. |
| स्वैप / ZRAM | मेमोरी को ऐलोकेशन के बजाय free() पर ज़ीरो आउट करें. |
ZRAM कंप्रेसन रेशियो को बेहतर बनाता है, ताकि पिन किए गए पेजों के लिए कम मेमोरी खर्च हो. |
देखें कि एसडीके, 16 केबी वाले पेज साइज़ के साथ काम करते हैं या नहीं
कई एसडीके, 16 केबी वाले पेज साइज़ के साथ काम करते हैं. खास तौर पर, तब जब उन्हें खुद बनाया गया हो या हाल ही में पहले से बने एसडीके इस्तेमाल किए गए हों. हालांकि, एसडीके के कुछ प्रीबिल्ट या वर्शन, 16 केबी के साथ काम नहीं करते. इसलिए, आपको एसडीके बनाने वाली हर कंपनी की वेबसाइट पर जाकर देखना चाहिए कि 16 केबी के साथ कौनसा वर्शन इस्तेमाल करना चाहिए.
अपने ऐप्लिकेशन को उन डिवाइसों पर टेस्ट करें जो 16 केबी वाले पेज साइज़ पर काम करते हों
अपने ऐप्लिकेशन को 16 केबी वाले डिवाइसों के साथ काम करने लायक बनाने के बाद, आपको उसे 16 केबी वाले एनवायरमेंट में टेस्ट करना होगा. इससे आपको यह पता चलेगा कि आपके ऐप्लिकेशन इस्तेमाल करने के अनुभव में कोई रिग्रेशन आया है या नहीं. ऐसा करने के लिए, इन चरणों का अनुसरण करें:
Android 15 SDK या इसके बाद का वर्शन सेट अप करें.
इनमें से कोई एक टेस्टिंग एनवायरमेंट सेट अप करें:
- 16 केबी वाले पेज साइज़ और Android 15 की सिस्टम इमेज के साथ, Android Emulator को सेट अप करना
- ARM64 पर 16 केबी वाले पेज साइज़ के साथ Cuttlefish का इस्तेमाल करना
- x86-64 पर 16 केबी वाले पेज साइज़ के साथ Cuttlefish को सिम्युलेट करना
- डेवलपर के लिए सेटिंग और टूल का इस्तेमाल करके, किसी डिवाइस पर 16 केबी मोड चालू करना
- Samsung Remote Test Lab का इस्तेमाल करके, 16 केबी वाले पेज साइज़ के साथ काम करने वाले डिवाइसों पर ऐप्लिकेशन की जांच करना
टेस्ट डिवाइस को चालू करें. इसके बाद, यह पुष्टि करने के लिए कि वह 16 केबी वाले पेज साइज़ का इस्तेमाल कर रहा है, यह कमांड चलाएं:
adb shell getconf PAGE_SIZEकमांड से
16384वैल्यू मिलनी चाहिए.यह पुष्टि करने के लिए कि आपका ऐप्लिकेशन 16 केबी के पेज साइज़ के साथ काम करता है, यह
zipalignकमांड चलाएं. यहां APK_NAME आपके ऐप्लिकेशन की APK फ़ाइल का नाम है:zipalign -c -P 16 -v 4 APK_NAME.apkअपने ऐप्लिकेशन की अच्छी तरह से जांच करें. खास तौर पर, उन हिस्सों पर ध्यान दें जिन पर खास पेज के साइज़ का रेफ़रंस देने वाले कोड इंस्टेंस बदलने का असर पड़ सकता है.
16 केबी पेज साइज़ वाली सिस्टम इमेज के साथ Android Emulator सेट अप करना
Android Emulator का इस्तेमाल करके 16 केबी वाला एनवायरमेंट सेट अप करने के लिए, यह तरीका अपनाएं:
- Android Studio में, Tools > SDK Manager पर क्लिक करें.
SDK Platforms टैब में, Show Package Details को चुनें. इसके बाद, Android VanillaIceCream या इसके बाद के वर्शन वाले सेक्शन को बड़ा करें. फिर, आपको जो वर्चुअल डिवाइस बनाने हैं उनके हिसाब से, एम्युलेटर सिस्टम की इनमें से एक या दोनों इमेज चुनें:
- Google APIs Experimental 16 KB Page Size ARM 64 v8a System Image
- Google APIs Experimental 16 KB Page Size Intel x86_64 Atom System Image
चुनी गई सिस्टम इमेज डाउनलोड करने के लिए, Apply > OK पर क्लिक करें.
Android 15 के लिए वर्चुअल डिवाइस सेट अप करने के लिए, यह तरीका अपनाएं. इसके बाद, सिस्टम इमेज चुनने के लिए कहा जाने पर, डाउनलोड की गई 16 केबी वाली सिस्टम इमेज चुनें. अगर यह अपने-आप नहीं दिखता है, तो अन्य इमेज टैब में जाकर, 16 केबी वाली सिस्टम इमेज को ढूंढा जा सकता है.
एम्युलेटर लॉन्च करना
Android Emulator और वर्चुअल डिवाइसों को सेट अप करने के बाद, टारगेट डिवाइस मेन्यू या कमांड लाइन से एम्युलेटर को लॉन्च करें.
डेवलपर के लिए सेटिंग और टूल का इस्तेमाल करके, किसी डिवाइस पर 16 केबी मोड चालू करना
डिवाइस को 16 केबी मोड में बूट करने के लिए, डेवलपर विकल्प में जाकर 16 केबी पेज साइज़ के साथ बूट करें को टॉगल करें.
Android 15 के QPR वर्शन में, डेवलपर विकल्प का इस्तेमाल किया जा सकता है. यह विकल्प, कुछ डिवाइसों पर उपलब्ध होता है. इससे डिवाइस को 16 केबी मोड में बूट किया जा सकता है और डिवाइस पर टेस्टिंग की जा सकती है. डेवलपर के लिए सेटिंग और टूल का इस्तेमाल करने से पहले, सेटिंग > सिस्टम > सॉफ़्टवेयर अपडेट पर जाएं और उपलब्ध अपडेट लागू करें.
यह डेवलपर विकल्प, इन डिवाइसों पर उपलब्ध है:
Pixel 8 और 8 Pro (Android 15 QPR1 या उसके बाद के वर्शन के साथ)
Pixel 8a (Android 15 QPR1 या इसके बाद के वर्शन के साथ)
Pixel 9, 9 Pro, और 9 Pro XL (Android 15 QPR2 या इसके बाद के वर्शन के साथ)
Pixel 9a (Android 16 या इसके बाद के वर्शन के साथ)
16 केबी बैककंपैट मोड
पेज साइज़ कंपैटबिलिटी मोड में चेतावनी
16 केबी बैककंपैट का विकल्प तब उपलब्ध होता है, जब कोई डिवाइस 16 केबी कर्नेल के साथ चल रहा हो. पैकेज मैनेजर, किसी ऐप्लिकेशन को 16 केबी वाले बैकवर्ड कंपैटबिलिटी मोड में तब चलाता है, जब ये शर्तें पूरी होती हैं:
- अगर ऐप्लिकेशन में 4 केबी के लोड सेगमेंट अलाइनमेंट वाली ELF फ़ाइलें (
.soएक्सटेंशन वाली) हैं. - अगर ज़िप किए गए APK में, कंप्रेस नहीं की गई ऐसी ELF फ़ाइलें हैं जो 4 केबी के हिसाब से ZIP अलाइन की गई हैं.
अगर पैकेज मैनेजर ने किसी ऐप्लिकेशन के लिए 16 केबी का बैककंपैट मोड चालू किया है, तो ऐप्लिकेशन को पहली बार लॉन्च करने पर एक चेतावनी दिखती है. इसमें बताया जाता है कि ऐप्लिकेशन, 16 केबी के बैककंपैट मोड में चल रहा है.
16 केबी वाले बैकवर्ड कंपैटबिलिटी मोड की मदद से, कुछ ऐप्लिकेशन काम कर सकते हैं. हालांकि, ऐप्लिकेशन को ज़्यादा भरोसेमंद और स्टेबल बनाने के लिए, उन्हें 16 केबी वाले पेज साइज़ के साथ अलाइन किया जाना चाहिए.
ऐप्लिकेशन की जानकारी वाले पेज पर, बेहतर सेटिंग में जाकर, ऐप्लिकेशन को पेज साइज़ कंपैटबिलिटी मोड में चलाएं सेटिंग को टॉगल करें. इससे किसी ऐप्लिकेशन के लिए, 16 केबी वाले बैककंपैट मोड को चालू या बंद किया जा सकता है. यह सेटिंग सिर्फ़ तब दिखती है, जब डिवाइस 16 केबी वाले पेज साइज़ के साथ काम करता हो.
पेज साइज़ कंपैटबिलिटी मोड की सेटिंग
डिवाइस पर मौजूद हर ऐप्लिकेशन के लिए, 16 केबी वाले पेज साइज़ के साथ काम करने की सुविधा को ज़बरदस्ती चालू करने के लिए:
adb shell setprop bionic.linker.16kb.app_compat.enabled true
adb shell setprop pm.16kb.app_compat.disabled false
डिवाइस पर मौजूद हर ऐप्लिकेशन के लिए, 16 केबी वाले पेज साइज़ के साथ काम करने की सुविधा को ज़बरदस्ती बंद करने के लिए:
adb shell setprop bionic.linker.16kb.app_compat.enabled false
adb shell setprop pm.16kb.app_compat.disabled true
Android 17 में, हर ऐप्लिकेशन के लिए 16 केबी के साथ काम करने की सुविधा को ज़बरदस्ती बंद किया जा सकता है. साथ ही, काम न करने वाली किसी भी बाइनरी को तुरंत बंद किया जा सकता है:
adb shell setprop bionic.linker.16kb.app_compat.enabled fatal
adb shell setprop pm.16kb.app_compat.disabled true
किसी ऐप्लिकेशन के AndroidManifest.xml में, बैकवर्ड कंपैटिबिलिटी मोड को चालू या बंद करने के लिए, android:pageSizeCompat प्रॉपर्टी को 'चालू है' या 'बंद है' पर सेट करें. इस प्रॉपर्टी को सेट करने पर, ऐप्लिकेशन लॉन्च होने के बाद बैककंपैट मोड की चेतावनियां नहीं दिखाएगा.