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

Historically, Android has only supported 4 KB memory page sizes, which has optimized system memory performance for the average amount of total memory that Android devices have typically had. Beginning with Android 15, AOSP supports devices that are configured to use a page size of 16 KB (16 KB devices). If your app uses any NDK libraries, either directly or indirectly through an SDK, then you will need to rebuild your app for it to work on these 16 KB devices.

As device manufacturers continue to build devices with larger amounts of physical memory (RAM), many of these devices will adopt 16 KB (and eventually greater) page sizes to optimize the device's performance. Adding support for 16 KB page size devices enables your app to run on these devices and helps your app benefit from the associated performance improvements. Without recompiling, apps might not work on 16 KB devices when they are productionized in future Android releases.

To help you add support for your app, we've provided guidance on how to check if your app is impacted, how to rebuild your app (if applicable), and how to test your app in a 16 KB environment using emulators (including Android 15 system images for the 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 8% (approximately 950 milliseconds) 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 and then check the alignment of ELF segments for any shared libraries that you find.

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 का इस्तेमाल करता है, तो इसका मतलब है कि आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है.
• आपका ऐप्लिकेशन, तीसरे पक्ष की उन नेटिव लाइब्रेरी या डिपेंडेंसी (जैसे, SDK टूल) से लिंक होता है जो उनका इस्तेमाल करती हैं.
• आपका ऐप्लिकेशन, तीसरे पक्ष के किसी ऐप्लिकेशन बिल्डर ने बनाया है. यह ऐप्लिकेशन, डिवाइस पर मौजूद नेटिव लाइब्रेरी का इस्तेमाल करता है.

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

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

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

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

   

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

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

   

शेयर की गई लाइब्रेरी के लिए ELF सेगमेंट के अलाइनमेंट की जांच करना

किसी भी शेयर की गई लाइब्रेरी के लिए, पुष्टि करें कि शेयर की गई लाइब्रेरी के ELF सेगमेंट, 16 KB ELF अलाइनमेंट का इस्तेमाल करके सही तरीके से अलाइन किए गए हैं. अगर Linux या macOS पर डेवलप किया जा रहा है, तो नीचे दिए गए सेक्शन में बताए गए तरीके से check_elf_alignment.sh स्क्रिप्ट का इस्तेमाल किया जा सकता है. कमांड-लाइन टूल का सीधे इस्तेमाल भी किया जा सकता है.

check_elf_alignment.sh स्क्रिप्ट (Linux या macOS) का इस्तेमाल करना

check_elf_alignment.sh स्क्रिप्ट का इस्तेमाल करके, ELF सेगमेंट के अलाइनमेंट की जांच करने के लिए, यह तरीका अपनाएं:

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

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

   check_elf_alignment.sh APK_NAME.apk
   

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

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

कमांड-लाइन टूल का सीधे तौर पर इस्तेमाल करना

सीधे कमांड-लाइन टूल का इस्तेमाल करके, ELF सेगमेंट के अलाइनमेंट की जांच करने के लिए, यह तरीका अपनाएं:

1. पक्का करें कि Android Studio में SDK मैनेजर या sdkmanager कमांड-लाइन टूल का इस्तेमाल करके, Android SDK Build-Tools का 35.0.0 या उसके बाद का वर्शन और Android NDK, दोनों इंस्टॉल किए गए हों.

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

   Linux या macOS

   unzip APK_NAME.apk -d /tmp/my_apk_out
   

   Windows (PowerShell)

   Expand-Archive -Path .\APK_NAME.apk -DestinationPath ~\tmp\my_apk_out
   

3. 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 LOAD
   

   Windows (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
   

4. आउटपुट लाइन की जांच करके पक्का करें कि लोड सेगमेंट की वैल्यू, 2**14 से कम न हों. अगर किसी लोड सेगमेंट की वैल्यू 2**13, 2**12 या इससे कम है, तो आपको उन लाइब्रेरी के लिए पैकेजिंग अपडेट करनी होगी. इसके बाद, अपने ऐप्लिकेशन को फिर से कंपाइल करें और इस सेक्शन में दिए गए निर्देशों का पालन करके फिर से जांच करें.

5. इसके बाद, अपने ऐप्लिकेशन की APK फ़ाइल पर zipalign कमांड-लाइन टूल चलाएं:

   Linux या macOS

   SDK_ROOT_LOCATION/Android/sdk/build-tools/35.0.0/zipalign -v -c -P 16 4 APK_NAME.apk
   

   Windows (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 फ़ाइल का नाम है. अगर सभी शेयर की गई लाइब्रेरी सही तरीके से अलाइन की गई हैं, तो आउटपुट की आखिरी लाइन में "पुष्टि हो गई" दिखेगा.

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

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

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

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

हमारा सुझाव है कि आप AGP के 8.5.1 या उसके बाद के वर्शन पर अपग्रेड करें और बिना कंप्रेस की गई शेयर की गई लाइब्रेरी का इस्तेमाल करें.

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

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

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

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

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

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

16 केबी ELF अलाइनमेंट का इस्तेमाल करके, अपने ऐप्लिकेशन को कंपाइल करना

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

16 KB ELF अलाइनमेंट का इस्तेमाल करके अपने ऐप्लिकेशन को कंपाइल करने के लिए, यहां दिए गए किसी एक सेक्शन में दिया गया तरीका अपनाएं. यह तरीका, इस्तेमाल किए जा रहे Android NDK के वर्शन के हिसाब से अलग-अलग हो सकता है.

Android NDK r28 और उसके बाद के वर्शन

NDK का r28 और उसके बाद के वर्शन, डिफ़ॉल्ट रूप से 16 केबी अलाइनमेंट के साथ कॉम्पाइल करते हैं.

Android NDK r27

Android NDK के वर्शन r27 और उसके बाद के वर्शन के साथ, 16 केबी के अलाइन किए गए शेयर की गई लाइब्रेरी को कंपाइल करने के लिए, आपको अपने 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

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

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

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

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

ऐसे कोड इंस्टेंस देखें जो खास पेज साइज़ का रेफ़रंस देते हैं

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

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

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

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

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

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

देखें कि एसडीके टूल 16 केबी के साथ काम करते हैं या नहीं

कई SDK टूल, 16 केबी के पेज साइज़ के साथ काम करते हैं. खास तौर पर, अगर आपने उन्हें खुद बनाया है या हाल ही में बनाए गए टूल इस्तेमाल किए हैं. हालांकि, कुछ SDK टूल के पहले से बने वर्शन या SDK टूल के कुछ वर्शन, 16 केबी के साथ काम नहीं करते. इसलिए, आपको SDK टूल की सेवा देने वाली हर कंपनी की वेबसाइट पर जाकर यह पता करना चाहिए कि 16 केबी के साथ किस वर्शन का इस्तेमाल किया जा सकता है.

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

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

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

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

   • 16 केबी वाले Android 15 सिस्टम इमेज के साथ Android एमुलेटर सेट अप करना
   • डेवलपर के लिए सेटिंग और टूल का इस्तेमाल करके, किसी डिवाइस पर 16 केबी मोड चालू करना
   • ARM64 पर 16 केबी पेज साइज़ के साथ Cuttlefish का इस्तेमाल करना
   • x86-64 पर 16 केबी पेज साइज़ के साथ Cuttlefish को सिम्युलेट करना

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

   adb shell getconf PAGE_SIZE
   

   इस कमांड से 16384 वैल्यू मिलनी चाहिए.

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

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

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

Android 15 की 16 केबी वाली सिस्टम इमेज की मदद से, Android एमुलेटर सेट अप करना

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

1. 16 केबी वाली, Android 15 एमुलेटर सिस्टम इमेज, Android Studio Jellyfish | 2023.3.1 या इसके बाद के वर्शन के साथ काम करती हैं. हालांकि, Android 15 बीटा वर्शन का इस्तेमाल करते समय बेहतर अनुभव पाने के लिए, Android Studio का नया प्री-रिलीज़ वर्शन डाउनलोड करें.

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

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

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

   • Google API एक्सपेरिमेंटल 16k पेज साइज़ ARM 64 v8a सिस्टम इमेज
   • Google API के लिए एक्सपेरिमेंटल 16k पेज साइज़ वाली Intel x86_64 Atom सिस्टम इमेज

   

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

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

   

1. डिवाइस मैनेजर में, 16 केबी की इमेज के बगल में मौजूद तीन बिंदुओं पर क्लिक करें. इसके बाद, डिस्क पर दिखाएं पर क्लिक करें.
2. इस फ़ोल्डर में, config.ini फ़ाइल ढूंढें.

3. config.ini फ़ाइल में यह लाइन जोड़ें और बदलाव सेव करें:

   kernel.parameters = androidboot.page_shift=14
   

4. अपने बदलावों की पुष्टि करने के लिए, यह कमांड चलाएं. इससे आपको 16384 दिखेगा:

   adb shell getconf PAGE_SIZE
   

डेवलपर विकल्पों का इस्तेमाल करके डिवाइस पर 16 केबी मोड चालू करें

16 केबी के पेज साइज़ वाला बूट डेवलपर टॉगल करें डिवाइस को 16 केबी मोड में बूट करने का विकल्प होता है.

Android 15 QPR1 की शुरुआत में, ये काम किए जा सकते हैं डेवलपर के लिए सेटिंग और टूल की उस सुविधा का इस्तेमाल करें जो आपके ब्राउज़र पर उपलब्ध है डिवाइस को 16 केबी मोड में बूट करने और डिवाइस पर टेस्ट करने के लिए.

डेवलपर के लिए बना यह विकल्प, इन डिवाइसों पर उपलब्ध है:

• Pixel 8 और 8 Pro (Android 15 QPR1 Beta 1 या इसके बाद के वर्शन के साथ)