Mendukung ukuran halaman 16 KB

Sebelumnya, Android hanya mendukung ukuran halaman memori 4 KB, yang memiliki performa memori sistem yang optimal untuk jumlah rata-rata total memori yang perangkat Android. Mulai Android 15, AOSP mendukung perangkat yang dikonfigurasi untuk menggunakan ukuran halaman 16 KB (16 KB perangkat). Jika aplikasi Anda menggunakan library NDK, baik secara langsung atau secara tidak langsung melalui SDK, Anda harus membangun ulang aplikasi agar berfungsi di perangkat 16 KB ini.

Karena produsen perangkat terus membuat perangkat dengan jumlah memori fisik (RAM), banyak perangkat ini akan menggunakan 16 KB (dan akhirnya lebih besar) ukuran halaman untuk mengoptimalkan performa perangkat. Menambahkan dukungan untuk perangkat ukuran halaman 16 KB memungkinkan aplikasi Anda berjalan di perangkat lain dan membantu aplikasi Anda mendapatkan manfaat dari performa terkait peningkatan performa. Tanpa kompilasi ulang, aplikasi mungkin tidak berfungsi di perangkat 16 KB saat diproduksi dalam rilis Android mendatang.

Untuk membantu menambahkan dukungan bagi aplikasi Anda, kami telah memberikan panduan tentang cara memeriksa jika aplikasi Anda terdampak, berikut cara membuat ulang aplikasi (jika ada), dan cara menguji aplikasi Anda di lingkungan berukuran 16 KB menggunakan emulator (termasuk Android 15 image sistem untuk Android Emulator).

Manfaat dan peningkatan performa

Perangkat yang dikonfigurasi dengan ukuran halaman 16 KB menggunakan memori yang sedikit lebih banyak secara rata-rata, tetapi juga mendapatkan berbagai peningkatan performa untuk sistem dan aplikasi:

• Waktu peluncuran aplikasi lebih rendah saat sistem berada dalam tekanan memori: rata-rata 3,16% lebih rendah, dengan peningkatan yang lebih signifikan (hingga 30%) untuk beberapa aplikasi yang kami uji
• Mengurangi penggunaan daya selama peluncuran aplikasi: Pengurangan rata-rata 4,56%
• Peluncuran kamera lebih cepat: rata-rata hot start 4,48% lebih cepat dan cold start 6,60% lebih cepat
• Waktu booting sistem yang lebih baik: rata-rata meningkat sebesar 8% (sekitar 950 milidetik)

Peningkatan ini didasarkan pada pengujian awal kami, dan hasil pada perangkat aktual kemungkinan akan berbeda. Kami akan memberikan analisis tambahan tentang potensi keuntungan untuk aplikasi saat kami melanjutkan pengujian.

Periksa apakah aplikasi Anda terpengaruh

Jika aplikasi Anda menggunakan kode native, Anda harus mem-build ulang aplikasi dengan dukungan untuk perangkat 16 KB. Jika tidak yakin apakah aplikasi Anda menggunakan kode native, Anda dapat menggunakan APK Analyzer untuk mengidentifikasi apakah ada kode native, lalu periksa penyelarasan segmen ELF untuk library bersama yang Anda temukan.

Jika aplikasi Anda hanya menggunakan kode yang ditulis dalam bahasa pemrograman Java atau di Kotlin, termasuk semua library atau SDK, berarti aplikasi tersebut sudah mendukung perangkat 16 KB. Namun, sebaiknya Anda menguji aplikasi di lingkungan 16 KB untuk memverifikasi bahwa tidak ada regresi yang tidak terduga dalam perilaku aplikasi.

Apakah aplikasi Anda menggunakan kode native?

Aplikasi Anda menggunakan kode native jika salah satu hal berikut berlaku:

• Aplikasi Anda menggunakan kode C/C++ (native). Jika aplikasi Anda menggunakan Android NDK, aplikasi Anda menggunakan kode native.
• Aplikasi Anda ditautkan dengan library native atau dependensi pihak ketiga (seperti SDK) yang menggunakannya.
• Aplikasi Anda dibuat oleh pembuat aplikasi pihak ketiga yang menggunakan library native di perangkat.

Mengidentifikasi library native menggunakan APK Analyzer

APK Analyzer adalah alat yang memungkinkan Anda mengevaluasi berbagai aspek APK yang telah dibuat. Untuk mengidentifikasi apakah aplikasi Anda menggunakan kode atau library native, ikuti langkah-langkah berikut:

1. Buka Android Studio, lalu klik File > Open dan pilih project apa pun.

2. Dari panel menu, klik Build > Analyze APK...

   

3. Pilih APK yang ingin Anda analisis.

4. Lihat di dalam folder lib, yang menghosting file objek bersama (.so) jika ada. Jika ada file objek bersama, aplikasi Anda akan menggunakan kode native. Jika tidak ada file objek bersama atau tidak ada folder lib, aplikasi Anda tidak menggunakan kode native.

   

Memeriksa perataan segmen ELF untuk library bersama

Untuk library bersama apa pun, pastikan segmen ELF library bersama disejajarkan dengan benar menggunakan perataan ELF 16 KB. Jika Anda mengembangkan di Linux atau macOS, Anda dapat menggunakan skrip check_elf_alignment.sh seperti yang dijelaskan di bagian berikut. Anda juga dapat menggunakan alat command line secara langsung.

Menggunakan skrip check_elf_alignment.sh (Linux atau macOS)

Ikuti langkah-langkah berikut untuk memeriksa perataan segmen ELF menggunakan skrip check_elf_alignment.sh:

1. Simpan skrip check_elf_alignment.sh ke file.

2. Jalankan skrip pada file APK aplikasi Anda:

   check_elf_alignment.sh APK_NAME.apk
   

   Skrip menghasilkan ALIGNED atau UNALIGNED untuk semua library bersama arm64-v8a.

3. Jika library bersama arm64-v8a atau x86_64 adalah UNALIGNED, Anda harus mengupdate paket untuk library tersebut, lalu mengompilasi ulang aplikasi dan menguji ulang dengan mengikuti langkah-langkah di bagian ini.

Menggunakan alat command line secara langsung

Ikuti langkah-langkah berikut untuk memeriksa perataan segmen ELF menggunakan alat command line secara langsung:

1. Pastikan Android SDK Build-Tools versi 35.0.0 atau yang lebih tinggi dan Android NDK diinstal menggunakan SDK Manager di Android Studio atau alat command line sdkmanager.

2. Ekstrak file APK aplikasi:

   Linux atau macOS

   unzip APK_NAME.apk -d /tmp/my_apk_out
   

   Windows (PowerShell)

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

3. Di direktori sementara tempat Anda mengekstrak file APK, periksa konten direktori lib untuk file objek bersama (.so). File ini adalah file objek bersama yang sama dengan yang Anda lihat saat mengidentifikasi library native menggunakan APK Analyzer. Jalankan perintah berikut di setiap file objek bersama:

   Linux atau 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"
   

   Dengan SDK_ROOT_LOCATION adalah jalur ke direktori tempat Anda menginstal Android SDK, SHARED_OBJECT_FILE adalah nama file objek bersama yang Anda periksa, dan NDK_VERSION adalah versi Android NDK yang telah Anda instal (misalnya, 28.0.12433566). Output akan terlihat seperti berikut untuk setiap file yang Anda periksa:

   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. Periksa baris output untuk memastikan segmen muatan tidak memiliki nilai yang kurang dari 2**14. Jika segmen pemuatan memiliki nilai 2**13, 2**12, atau yang lebih rendah, Anda harus memperbarui paket untuk library tersebut, lalu mengompilasi ulang aplikasi dan menguji ulang dengan mengikuti langkah-langkah di bagian ini.

5. Selanjutnya, jalankan alat command line zipalign pada file APK aplikasi Anda:

   Linux atau 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
   

   Dengan SDK_ROOT_LOCATION adalah jalur ke direktori tempat Anda menginstal Android SDK, dan APK_NAME adalah nama file APK aplikasi Anda. Baris terakhir output akan menampilkan "Verifikasi berhasil" jika semua library bersama disejajarkan dengan benar.

   Jika verifikasi gagal, beberapa library bersama perlu disesuaikan kembali, sehingga Anda harus memperbarui paket untuk library tersebut, lalu mengompilasi ulang aplikasi dan menguji ulang dengan mengikuti langkah-langkah di bagian ini.

Mem-build aplikasi dengan dukungan untuk perangkat 16 KB

Untuk mendukung perangkat 16 KB, aplikasi yang menggunakan kode native harus menyelesaikan langkah-langkah yang diuraikan di bagian berikut. Jika Anda mengupdate ke AGP versi 8.5.1 atau yang lebih tinggi dan NDK versi r28 atau yang lebih tinggi, dan menggunakan dependensi bawaan yang kompatibel dengan 16 KB, aplikasi akan kompatibel dengan 16 KB secara default.

Memperbarui paket library bersama

Sebaiknya upgrade ke AGP versi 8.5.1 atau yang lebih tinggi dan gunakan library bersama yang tidak dikompresi.

AGP versi 8.5.1 atau yang lebih tinggi

Perangkat 16 KB memerlukan aplikasi yang dikirimkan dengan library bersama yang tidak dikompresi untuk menyejajarkannya pada batas yang diselaraskan zip 16 KB. Untuk melakukannya, Anda harus mengupgrade ke Plugin Android Gradle (AGP) versi 8.5.1 atau yang lebih tinggi. Lihat bagian Upgrade Assistant plugin Android Gradle untuk mengetahui detail tentang proses upgrade.

AGP versi 8.5 atau yang lebih rendah

Catatan: Di AGP versi 8.3 hingga 8.5, aplikasi di-align 16 KB secara default. Namun, bundletool tidak melakukan zipalign APK secara default. Jadi, aplikasi mungkin tampak berfungsi, tetapi saat di-build dari app bundle di Play, aplikasi tidak akan diinstal.

Jika Anda tidak dapat mengupgrade AGP ke versi 8.5.1 atau yang lebih tinggi, alternatifnya adalah beralih untuk menggunakan library bersama yang dikompresi. Update konfigurasi Gradle agar Gradle mengompresi library bersama saat memaketkan aplikasi untuk menghindari masalah penginstalan aplikasi dengan library bersama yang tidak diselaraskan.

Groovy

Di file build.gradle, tambahkan opsi berikut:

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

Kotlin

Di file build.gradle.kts, tambahkan opsi berikut:

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

Mengompilasi aplikasi menggunakan perataan ELF 16 KB

Perangkat 16 KB memerlukan segmen ELF library bersama untuk disejajarkan dengan benar menggunakan perataan ELF 16 KB agar aplikasi Anda dapat berjalan.

Catatan: Jika aplikasi Anda tidak mengekstrak library native ke sistem file (extractNativeLibs ditetapkan ke false), Anda mungkin akan melihat sedikit peningkatan ukuran biner aplikasi setelah mengompilasi menggunakan perataan ELF 16 KB. Pengoptimalan pada pengelola paket di Android 15 akan meniadakan biaya runtime dari peningkatan ini.

Untuk mengompilasi aplikasi menggunakan perataan ELF 16 KB, selesaikan langkah-langkah di salah satu bagian berikut, bergantung pada versi Android NDK yang Anda gunakan.

Penting: Jika aplikasi Anda menggunakan library bersama bawaan, Anda juga harus mengompilasi ulang dengan cara yang sama dan mengimpor ulang library yang di-align 16 KB ke aplikasi Anda.

Android NDK r28 dan yang lebih tinggi

NDK versi r28 dan yang lebih tinggi mengompilasi 16 KB yang diselaraskan secara default.

Android NDK r27

Untuk mendukung kompilasi library bersama yang diselaraskan 16 KB dengan Android NDK versi r27 dan yang lebih tinggi, Anda perlu mengupdate tanda ndk-build, build.gradle, build.gradle.kts, atau penaut sebagai berikut:

ndk-build

Di Application.mk Anda:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Groovy

Dalam file build.gradle, tetapkan argumen -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 "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }
}

Kotlin

Dalam file build.gradle.kts, tetapkan argumen -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")
      }
    }
  }
}

Sistem build lainnya

Tentukan flag penaut berikut:

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

Android NDK r26 dan yang lebih lama

Untuk mendukung kompilasi library bersama yang diselaraskan 16 KB dengan Android NDK versi r26 atau yang lebih rendah, Anda perlu mengupdate konfigurasi ndk-build atau cmake sebagai berikut:

ndk-build

Perbarui Android.mk untuk mengaktifkan perataan ELF 16 KB:

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

CMake

Perbarui CMakeLists.txt untuk mengaktifkan perataan ELF 16 KB:

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

Penting: Meskipun aplikasi Anda ditautkan secara dinamis ke library standar C++ (libc++_shared.so) dari NDK r26 dan yang lebih rendah, beberapa di antaranya tidak sejajar dengan 16 KB, Anda tetap harus memperbarui perataan semua library lainnya di sini, dan Anda harus memperbarui kode untuk menghindari dependensi pada PAGE_SIZE. Untuk menguji versi NDK yang lebih rendah tersebut di perangkat 16 KB, rilis canary LTS NDK versi r23 dan r25 tersedia di Android CI dengan library libc++_shared.so yang diselaraskan 16 KB. Terlepas dari itu, sebaiknya beralih ke Android NDK r27 atau yang lebih tinggi untuk mengupdate ke library standar C++ versi ELF yang sejajar 16 KB. Jika tidak, aplikasi Anda akan gagal diinstal di perangkat 16 KB saat ini.

Jika tidak dapat beralih ke Android NDK yang lebih baru, Anda mungkin dapat mengupdate aplikasi untuk mengompilasi library standar C++ secara statis ke dalam library bersama. Lihat bagian Dukungan Library C++ untuk mengetahui detail tentang penautan statis ke library standar C++ dan pastikan untuk membaca bagian Pertimbangan Penting.

Memeriksa instance kode yang mereferensikan ukuran halaman tertentu

Meskipun aplikasi Anda sejajar dengan 16 KB, aplikasi Anda dapat mengalami error jika tempat dalam kode Anda mengasumsikan bahwa perangkat menggunakan ukuran halaman tertentu. Untuk menghindari hal ini, selesaikan langkah-langkah berikut:

1. Hapus dependensi hard code yang mereferensikan konstanta atau instance PAGE_SIZE dalam logika kode Anda yang mengasumsikan bahwa ukuran halaman perangkat adalah 4 KB (4096).

   Sebagai gantinya, gunakan getpagesize() atau sysconf(_SC_PAGESIZE).

2. Cari penggunaan mmap() dan API lain yang memerlukan argumen yang sejajar dengan halaman dan ganti dengan alternatif jika diperlukan.

Dalam beberapa kasus, jika aplikasi Anda menggunakan PAGE_SIZE sebagai nilai praktis yang tidak terikat dengan ukuran halaman yang mendasarinya, hal ini tidak akan menyebabkan aplikasi Anda rusak saat digunakan dalam mode 16 KB. Namun, jika nilai ini diteruskan ke kernel dengan mmap tanpa MAP_FIXED, kernel masih menggunakan seluruh halaman, yang membuang beberapa memori. Karena alasan ini, PAGE_SIZE tidak ditentukan saat mode 16 KB diaktifkan di NDK r27 dan yang lebih tinggi.

Jika aplikasi Anda menggunakan PAGE_SIZE dengan cara ini dan tidak pernah meneruskan nilai ini secara langsung ke kernel, maka buat variabel baru dengan nama baru, bukan menggunakan PAGE_SIZE, untuk menunjukkan bahwa variabel tersebut digunakan untuk tujuan lain dan tidak mencerminkan halaman memori yang sebenarnya.

Memeriksa SDK untuk dukungan 16 KB

Banyak SDK yang kompatibel dengan ukuran halaman 16 KB, terutama jika Anda mem-buildnya sendiri atau mendapatkan build bawaan terbaru. Namun, karena beberapa SDK bawaan atau versi SDK tidak kompatibel dengan 16 KB, Anda harus memeriksa situs untuk setiap penyedia SDK guna menentukan versi mana yang akan digunakan dengan 16 KB.

Menguji aplikasi di lingkungan 16 KB

Setelah mem-build aplikasi dengan dukungan untuk perangkat 16 KB, Anda sebaiknya menguji aplikasi di lingkungan 16 KB untuk melihat apakah aplikasi mengalami regresi. Untuk melakukannya, ikuti langkah berikut:

1. Menyiapkan Android 15 SDK.

2. Siapkan salah satu lingkungan pengujian berikut:

   • Menyiapkan Android Emulator dengan image sistem Android 15 berbasis 16 KB
   • Mengaktifkan mode 16 KB di perangkat menggunakan opsi developer
   • Menggunakan Cuttlefish dengan ukuran halaman 16 KB di ARM64
   • Mensimulasikan Cuttlefish dengan ukuran halaman 16 KB di x86-64

3. Mulai perangkat pengujian, lalu jalankan perintah berikut untuk memverifikasi bahwa perangkat menggunakan lingkungan 16 KB:

   adb shell getconf PAGE_SIZE
   

   Perintah akan menampilkan nilai 16384.

4. Jalankan perintah zipalign berikut untuk memverifikasi bahwa aplikasi Anda diselaraskan dengan 16 KB, dengan APK_NAME adalah nama file APK aplikasi Anda:

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

5. Uji aplikasi Anda secara menyeluruh, dengan berfokus pada area yang mungkin terpengaruh oleh perubahan instance kode yang mereferensikan ukuran halaman tertentu.

Menyiapkan Android Emulator dengan image sistem Android 15 berbasis 16 KB

Penting: Ada masalah umum yang mencegah proses debug dengan LLDB dengan image sistem emulator 16 KB. Perbaikan untuk masalah ini disertakan dalam NDK r27 RC 1 dan Update Fitur Baru Android Studio Koala | 2024.1.2 Canary 5.

Untuk menyiapkan lingkungan 16 KB menggunakan Android Emulator, ikuti langkah-langkah berikut:

1. Image sistem emulator Android 15 berbasis 16 KB kompatibel dengan Android Studio Jellyfish | 2023.3.1 atau yang lebih tinggi. Namun, untuk pengalaman terbaik saat menggunakan Android 15 Beta, download versi pratinjau terbaru Android Studio.

   Perlu diingat bahwa Anda tidak perlu meng-uninstal versi Android Studio yang ada karena Anda dapat menginstal beberapa versi secara berdampingan.

2. Di Android Studio, klik Tools > SDK Manager.

3. Di tab SDK Platforms, centang Show Package Details, lalu luaskan bagian Android VanillaIceCream Preview dan pilih salah satu atau kedua image sistem emulator berikut, bergantung pada perangkat virtual yang ingin Anda buat:

   • Image Sistem ARM 64 v8a Ukuran Halaman 16k Eksperimental Google API
   • Image Sistem Atom Intel x86_64 Ukuran Halaman 16k Eksperimental Google API
   Catatan: Jika berencana untuk mengemulasi perangkat Google Pixel yang didukung, Anda hanya memerlukan Image Sistem ARM 64 v8a.

   

4. Klik Apply > OK untuk mendownload image sistem yang Anda pilih.

5. Ikuti langkah-langkah untuk menyiapkan perangkat virtual untuk Android 15, dan saat diminta untuk memilih image sistem, pilih image sistem 16 KB yang Anda download. Jika tidak direkomendasikan secara otomatis, Anda dapat menemukan image sistem 16 KB di tab Image Lainnya.

   

Peringatan: Untuk menyimulasikan lingkungan 16 KB di sistem x86_64, Anda juga harus menyelesaikan langkah-langkah berikut. Langkah-langkah ini bersifat sementara dan akan dihapus di masa mendatang.

1. Di Pengelola perangkat, klik 3 titik di samping image 16 KB, lalu klik Tampilkan di Disk.
2. Di folder ini, temukan file config.ini.

3. Tambahkan baris berikut ke file config.ini dan simpan perubahan Anda:

   kernel.parameters = androidboot.page_shift=14
   

4. Untuk memverifikasi perubahan Anda, jalankan perintah berikut, yang akan menampilkan 16384:

   adb shell getconf PAGE_SIZE
   

Mengaktifkan mode 16 KB di perangkat menggunakan opsi developer

Aktifkan/nonaktifkan developer Boot with 16 KB page size untuk mem-booting perangkat ke mode 16 KB.

Mulai Android 15 QPR1, Anda dapat menggunakan opsi developer yang tersedia di beberapa agar perangkat dapat melakukan booting dalam mode 16 KB dan melakukan pengujian di perangkat.

Opsi developer ini tersedia di perangkat berikut:

• Pixel 8 dan 8 Pro (dengan Android 15 QPR1 Beta 1 atau yang lebih baru)

Catatan: Android 15 QPR1 masih dalam versi beta. Untuk informasi selengkapnya tentang cara mendapatkan QPR1 di perangkat yang memenuhi syarat, lihat Mendapatkan build Android 15 QPR Beta .