16 केबी वाले पेज साइज़ का इस्तेमाल करें

अब तक, Android पर सिर्फ़ 4 केबी मेमोरी पेज का साइज़ काम करता था, जिसमें कुल मेमोरी की औसत मात्रा के लिए ऑप्टिमाइज़ की गई सिस्टम मेमोरी परफ़ॉर्मेंस आम तौर पर, Android डिवाइसों पर यह सुविधा ज़्यादा काम करती थी. Android 15 और इसके बाद के वर्शन में, AOSP काम करता है ऐसे डिवाइस जिन्हें 16 केबी (16 केबी) के पेज साइज़ का इस्तेमाल करने के लिए कॉन्फ़िगर किया गया है डिवाइसों के हिसाब से). अगर आपका ऐप्लिकेशन किसी भी NDK लाइब्रेरी का इस्तेमाल करता है, तो सीधे तौर पर है, तो आपको इसके लिए अपना ऐप्लिकेशन फिर से बनाना होगा: काम करता है.

जैसा कि डिवाइस बनाने वाली कंपनियां, बड़ी संख्या में डिवाइसों को बनाना जारी रख रही हैं फ़िज़िकल मेमोरी (रैम) का इस्तेमाल करते हैं, तो इनमें से कई डिवाइस 16 केबी (और पेज का साइज़ तय करना होता है. जोड़ा जा रहा है 16 केबी वाले पेज साइज़ वाले डिवाइसों पर काम करने से, आपका ऐप्लिकेशन इन डिवाइसों पर काम करता है डिवाइस और आपके ऐप्लिकेशन को इनसे जुड़ी परफ़ॉर्मेंस का फ़ायदा मिलता है सुधार किए गए हैं. फिर से कंपाइल किए बिना, हो सकता है कि ऐप्लिकेशन 16 केबी वाले डिवाइसों पर काम न करें करने के लिए डिज़ाइन किया गया है.

आपके ऐप्लिकेशन के लिए सहायता जोड़ने में आपकी मदद करने के लिए, हमने यह देखने का तरीका बताने के लिए दिशा-निर्देश दिए हैं अगर इसका असर आपके ऐप्लिकेशन पर पड़ा है, तो ऐप्लिकेशन को फिर से बनाएं (अगर लागू हो) और अपने ऐप्लिकेशन की जांच करने का तरीका एम्युलेटर का इस्तेमाल करके, 16 केबी एनवायरमेंट (इसमें Android 15 शामिल है) Android Emulator के लिए सिस्टम इमेज).

फ़ायदे और बेहतर परफ़ॉर्मेंस

Devices configured with 16 KB page sizes use slightly more memory on average, but also gain various performance improvements for both the system and apps:

• Lower app launch times while the system is under memory pressure: 3.16% lower on average, with more significant improvements (up to 30%) for some apps that we tested
• Reduced power draw during app launch: 4.56% reduction on average
• Faster camera launch: 4.48% faster hot starts on average, and 6.60% faster cold starts on average
• Improved system boot time: improved by 1.5% (approximately 0.8 seconds) on average

These improvements are based on our initial testing, and results on actual devices will likely differ. We'll provide additional analysis of potential gains for apps as we continue our testing.

देखें कि क्या आपके ऐप्लिकेशन पर असर पड़ा है

If your app uses any native code, then you should rebuild your app with support for 16 KB devices. If you are unsure if your app uses native code, you can use the APK Analyzer to identify whether any native code is present.

If your app only uses code written in the Java programming language or in Kotlin, including all libraries or SDKs, then your app already supports 16 KB devices. Nevertheless, we recommend that you test your app in a 16 KB environment to verify that there are no unexpected regressions in app behavior.

क्या आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है?

अगर इनमें से कोई भी शर्त लागू होती है, तो आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है:

• आपका ऐप्लिकेशन किसी भी C/C++ (नेटिव) कोड का इस्तेमाल करता है. अगर आपका ऐप्लिकेशन Android NDK, तो आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है.
• आपका ऐप्लिकेशन, तीसरे पक्ष की ऐसी किसी भी नेटिव लाइब्रेरी या डिपेंडेंसी से लिंक होता है जो उनका इस्तेमाल कैसे हो सकता है.
• आपके ऐप्लिकेशन को तीसरे पक्ष के ऐसे ऐप्लिकेशन बिल्डर ने बनाया है जो इन डिवाइसों पर नेटिव लाइब्रेरी का इस्तेमाल करता है डिवाइस.

APK ऐनालाइज़र का इस्तेमाल करके नेटिव लाइब्रेरी पहचानें

APK विश्लेषक एक ऐसा टूल है जो आपको APK के साथ दिखेगा. यह पता करने के लिए कि आपका ऐप्लिकेशन स्थानीय कोड का इस्तेमाल करता है या लाइब्रेरी का, इन निर्देशों का पालन करें कदम:

1. Android Studio खोलें. इसके बाद, फ़ाइल > खोलें और कोई भी प्रोजेक्ट चुनें.

2. मेन्यू बार में, बिल्ड > पर क्लिक करें APK का विश्लेषण करें...

   

3. वह APK चुनें जिसका विश्लेषण करना है.

4. lib फ़ोल्डर में देखें. अगर कोई ऐसा फ़ोल्डर है जिसमें शेयर किए गए ऑब्जेक्ट (.so) फ़ाइलें होस्ट की जाती हैं, तो इसे होस्ट करें मौजूद हैं. अगर शेयर किए गए ऑब्जेक्ट वाली कोई फ़ाइल मौजूद है, तो आपका ऐप्लिकेशन नेटिव विज्ञापन का इस्तेमाल करता है कोड. अगर शेयर किए गए ऑब्जेक्ट वाली कोई फ़ाइल मौजूद नहीं है या कोई lib फ़ोल्डर नहीं है, तो आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल नहीं करता.

   

16 केबी वाले डिवाइसों पर चलने वाला अपना ऐप्लिकेशन बनाएं

16 केबी वाले डिवाइस पर काम करने के लिए, खास कोड का इस्तेमाल करने वाले ऐप्लिकेशन को इन सेक्शन में बताया गया है.

शेयर की गई अपनी लाइब्रेरी की पैकेजिंग अपडेट करें

हमारा सुझाव है कि आप AGP के 8.3 या इसके बाद वाले वर्शन पर अपग्रेड करें. साथ ही, बिना कंप्रेस किए इसका इस्तेमाल करें शेयर की गई लाइब्रेरी पर टैप करें.

AGP वर्शन 8.3 या इसके बाद का वर्शन

16 केबी वाले डिवाइसों के लिए, ऐसे ऐप्लिकेशन ज़रूरी होते हैं जो कंप्रेस न की गई शेयर की गई लाइब्रेरी की मदद से शिप किए जा सकें उन्हें 16 केबी की ज़िप-अलाइन सीमा पर अलाइन करें. ऐसा करने के लिए आपको अपग्रेड करना होगा Android Gradle प्लग इन (AGP) के 8.3 या इसके बाद वाले वर्शन का इस्तेमाल करता है. इसके बारे में ज़्यादा जानने के लिए, Android अपग्रेड की प्रोसेस के बारे में जानकारी के लिए, Gradle प्लगिन अपग्रेड असिस्टेंट सेक्शन.

AGP वर्शन 8.2 या इससे पहले का वर्शन

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

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging true
      }
  }
}

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging = true
      }
  }
}

16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके अपने ऐप्लिकेशन को कंपाइल करें

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

16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके अपने ऐप्लिकेशन को कंपाइल करने के लिए, इनमें से किसी एक चरण को पूरा करें जो Android एनडीके (NDK) के वर्शन के हिसाब से तय होते हैं का उपयोग करके.

Android NDK r26 और इससे पहले के वर्शन

इसका मकसद, शेयर की गई ऐसी लाइब्रेरी को Android एनडीके के साथ इकट्ठा करना है जो 16 केबी अलाइन की गई हैं r26 या इससे पहले के वर्शन के लिए, आपको अपने ndk-build या cmake को अपडेट करना होगा कॉन्फ़िगरेशन इस तरह है:

LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"

target_link_options(${CMAKE_PROJECT_NAME} PRIVATE "-Wl,-z,max-page-size=16384")

Android NDK r27 और इसके बाद वाला वर्शन

इससे, शेयर की गई 16 केबी अलाइन की गई लाइब्रेरी को Android एनडीके के साथ कंपाइल करने में मदद मिलती है r27 और इसके बाद के वर्शन के लिए, आपको अपने ndk-build, build.gradle, build.gradle.kts या लिंकर इस तरह फ़्लैग करता है:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }
}

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments += listOf("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON")
      }
    }
  }
}

-Wl,-z,max-page-size=16384

किसी पेज के साइज़ से जुड़े कोड इंस्टेंस की जांच करें

आपका ऐप्लिकेशन 16 केबी-अलाइन किया गया होने पर भी, अगर आपके ऐप्लिकेशन को यह मान लेते हैं कि डिवाइस किसी खास पेज साइज़ का इस्तेमाल कर रहा है. इससे बचने के लिए, इन चरणों को पूरा करें:

1. PAGE_SIZE से जुड़ी हार्ड कोड की गई सभी डिपेंडेंसी हटाएं आपके कोड लॉजिक में लगातार या ऐसे इंस्टेंस जो यह मानते हों कि किसी डिवाइस का पेज साइज़ 4 केबी (4096) है.

   इसके बजाय, getpagesize() या sysconf(_SC_PAGESIZE) का इस्तेमाल करें.

2. mmap() और ऐसे अन्य एपीआई के इस्तेमाल देखें जिनके लिए पेज को अलाइन करना ज़रूरी है तर्क के साथ इस्तेमाल करें और जहां ज़रूरी हो वहां विकल्पों से बदलें.

कुछ मामलों में, अगर आपका ऐप्लिकेशन PAGE_SIZE का इस्तेमाल एक सुविधाजनक वैल्यू के तौर पर करता है, जो पेज साइज़ से जुड़ा होता है, तो इससे आपका ऐप्लिकेशन काम नहीं करेगा जब 16 केबी मोड में इस्तेमाल किया जाता है. हालांकि, अगर यह वैल्यू कर्नेल को पास की जाती है MAP_FIXED के बिना mmap के साथ, कर्नेल अब भी पूरे पेज का इस्तेमाल करता है, जो कुछ मेमोरी बर्बाद हो जाती है. इन वजहों से, 16 केबी होने पर PAGE_SIZE तय नहीं होता है यह मोड, NDK r27 और इसके बाद के वर्शन पर चालू है.

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

अपने ऐप्लिकेशन को 16 केबी वाले एनवायरमेंट में टेस्ट करें

16 केबी वाले डिवाइसों के लिए ऐप्लिकेशन बनाने के बाद, आपको अपने ऐप्लिकेशन को 16 केबी वाले एनवायरमेंट में टेस्ट करके देखें कि आपके ऐप्लिकेशन का अनुभव मिलता है या नहीं किसी भी रिग्रेशन पर. ऐसा करने के लिए, इन चरणों का अनुसरण करें:

1. Android 15 SDK टूल सेट अप करें.

2. इनमें से कोई एक टेस्टिंग एनवायरमेंट सेट अप करें:

   • 16 केबी पर आधारित Android 15 सिस्टम की मदद से Android Emulator सेट अप करना इमेज
   • ARM64 पर 16 केबी पेज साइज़ वाली कटलफ़िश का इस्तेमाल करें
   • x86-64 पर 16 केबी वाले पेज साइज़ वाली कटलफ़िश की नकल करें

3. अपना टेस्ट डिवाइस चालू करें. इसके बाद, यह पुष्टि करने के लिए नीचे दिया गया कमांड चलाएं यह 16 केबी एनवायरमेंट का इस्तेमाल कर रहा है:

   adb shell getconf PAGE_SIZE
   

   निर्देश से 16384 की वैल्यू मिलनी चाहिए.

4. शेयर की गई किसी भी लाइब्रेरी के लिए, पुष्टि करें कि शेयर की गई लाइब्रेरी ईएलएफ़ सेगमेंट 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके सही तरीके से अलाइन किया गया है. इस स्क्रिप्ट का इस्तेमाल इन कामों के लिए किया जा सकता है इस प्रक्रिया में सहायता के लिए:

   #!/bin/bash
   
   # usage: alignment.sh path to search for *.so files
   
   dir="$1"
   
   RED="\e[31m"
   GREEN="\e[32m"
   ENDCOLOR="\e[0m"
   
   matches="$(find $dir -name "*.so" -type f)"
   IFS=$'\n'
   for match in $matches; do
     res="$(objdump -p ${match} | grep LOAD | awk '{ print $NF }' | head -1)"
     if [[ $res =~ "2**14" ]] || [[ $res =~ "2**16" ]]; then
       echo -e "${match}: ${GREEN}ALIGNED${ENDCOLOR} ($res)"
     else
       echo -e "${match}: ${RED}UNALIGNED${ENDCOLOR} ($res)"
     fi
   done
   

   1. स्क्रिप्ट को किसी फ़ाइल में सेव करें, जैसे कि alignment.sh.

   2. अपने ऐप्लिकेशन की APK फ़ाइल एक्सट्रैक्ट करना:

      unzip APK_NAME.apk -d /tmp/my_apk_out
      

   3. /tmp/my_apk_out में निकाली गई फ़ाइलों पर स्क्रिप्ट चलाएं डायरेक्ट्री:

      alignment.sh /tmp/my_apk_out | grep "arm64-v8a"
      

      स्क्रिप्ट सभी के लिए ALIGNED या UNALIGNED आउटपुट देती है शेयर की गई arm64-v8a लाइब्रेरी.

   4. अगर शेयर की गई कोई भी arm64-v8a लाइब्रेरी UNALIGNED है, तो आपको ये काम करने होंगे उन लाइब्रेरी की पैकेजिंग अपडेट करें. इसके बाद, अपने डेटा को कंपाइल करें ऐप्लिकेशन डाउनलोड करें और इस सेक्शन में दिया गया तरीका अपनाकर, फिर से जांच करें.

5. यह पुष्टि करने के लिए कि आपका ऐप्लिकेशनzipalign 16 केबी- अलाइन किया गया है, जहां APK_NAME का नाम है आपके ऐप्लिकेशन की APK फ़ाइल:

   zipalign -c -P 16 -v 4 APK_NAME.apk
   

6. अपने ऐप्लिकेशन की अच्छी तरह से जांच करें. साथ ही, उन चीज़ों पर फ़ोकस करें जिन पर इसका असर पड़ सकता है किसी खास पेज साइज़ का रेफ़रंस देने वाले कोड इंस्टेंस बदलना.

16 केबी-आधारित, Android 15 वाली सिस्टम इमेज के साथ Android Emulator सेट अप करें

Android Emulator का इस्तेमाल करके 16 केबी एनवायरमेंट को सेट अप करने के लिए, इन निर्देशों का पालन करें कदम:

1. 16 केबी पर आधारित, Android 15 के एम्युलेटर सिस्टम की इमेज, इमेज के साथ काम करती हैं Android Studio जेलीफ़िश | 2023.3.1 या इसके बाद. हालांकि, सर्वोत्तम Android 15 के बीटा वर्शन पर काम करने का बेहतरीन अनुभव पाने के लिए, Google Play Store पर मौजूद सबसे नया वर्शन Android Studio के वर्शन की झलक देखें.

   याद रखें कि आपके पास Android Studio के मौजूदा वर्शन का इस्तेमाल जारी रखने का विकल्प है इंस्टॉल है, क्योंकि एक साथ कई वर्शन इंस्टॉल किए जा सकते हैं.

2. Android Studio में, टूल > पर क्लिक करें एसडीके मैनेजर.

3. SDK प्लैटफ़ॉर्म टैब में, पैकेज की जानकारी दिखाएं को चुनें. इसके बाद, सेक्शन को बड़ा करें Android VenillaIceCream Preview सेक्शन पर जाकर, इनमें से किसी एक या दोनों को चुनें आपके वर्चुअल डिवाइस के आधार पर, यहां एम्युलेटर सिस्टम की इमेज दी गई हैं बनाना चाहते हैं:

   • Google API प्रयोगात्मक 16k पेज आकार ARM 64 v8a सिस्टम इमेज
   • Google API एक्सपेरिमेंटल 16k पेज साइज़ Intel x86_64 ऐटम सिस्टम इमेज

   

4. लागू करें > आपने जो भी सिस्टम इमेज चुनी हैं उन्हें डाउनलोड करने के लिए ठीक है.

5. Android 15 के लिए वर्चुअल डिवाइस सेट अप करने के लिए बताया गया तरीका अपनाएं. साथ ही, एक सिस्टम इमेज चुनने के लिए कहा जाए, तो 16 केबी की सिस्टम इमेज चुनें डाउनलोड किया है. अगर इसका सुझाव अपने-आप नहीं दिया जाता, तो अन्य इमेज टैब में, सिस्टम इमेज 16 केबी की होनी चाहिए.