Obsługa rozmiaru stron 16 KB

Do tej pory Android obsługiwał tylko strony o rozmiarze 4 KB, co zapewniało optymalną wydajność pamięci systemowej pod kątem średniej ilości pamięci dostępnej zwykle na urządzeniach z Androidem. Począwszy od Androida 15, Android obsługuje urządzenia, na których rozmiar strony wynosi 16 KB (16 KB).

Producenci wciąż tworzą urządzenia z większą ilością pamięci RAM, dlatego wiele z nich zostanie prawdopodobnie skonfigurowanych tak, aby rozmiar strony wynosił 16 KB (i w miarę potrzeby można zwiększyć ich wydajność). Dodanie obsługi urządzeń 16 KB umożliwia działanie aplikacji na tych urządzeniach i ułatwia jej poprawę wydajności. Aby Ci w tym pomóc, przygotowaliśmy wskazówki dotyczące sprawdzania, czy dotyczy to Twojej aplikacji, odtwarzania aplikacji (w stosownych przypadkach) oraz przetestowania aplikacji w środowisku o rozmiarze 16 KB przy użyciu emulatorów i urządzeń fizycznych.

Korzyści i wzrost skuteczności

Urządzenia o rozmiarze stron o rozmiarze 16 KB zużywają średnio trochę więcej pamięci, ale poprawiają też wydajność zarówno systemu, jak i aplikacji:

  • Krótszy czas uruchamiania aplikacji, gdy system wykorzystuje pamięć: średnio o 3,16% krótszy niż w przypadku niektórych testowanych aplikacji
  • Mniejsze wykorzystanie energii podczas uruchamiania aplikacji: średnio o 4,56%
  • Szybsze uruchamianie kamery: średnio o 4,48% szybsze uruchomienia z pamięci i o 6,60% szybsze uruchomienia „na zimno”
  • Skrócony czas uruchamiania systemu: średnio o 1,5% (około 0,8 sekundy).

Te ulepszenia są oparte na naszych wstępnych testach, więc wyniki na rzeczywistych urządzeniach będą się prawdopodobnie różnić. W trakcie testów będziemy przeprowadzać dodatkową analizę potencjalnych korzyści związanych z aplikacjami.

Sprawdź, czy ta zmiana wpłynie na Twoją aplikację

Jeśli Twoja aplikacja korzysta z kodu natywnego, musisz odbudować ją na urządzeniach z obsługą 16 KB. Jeśli nie masz pewności, czy Twoja aplikacja używa kodu natywnego, możesz skorzystać z Analizatora plików APK, by sprawdzić, czy w aplikacji znajduje się kod natywny.

Jeśli Twoja aplikacja używa tylko kodu napisanego w języku Java lub w Kotlin, w tym wszystkich bibliotek i pakietów SDK, obsługuje już urządzenia z 16 KB. Zalecamy jednak przetestowanie aplikacji w środowisku 16 KB, aby sprawdzić, czy w jej działaniu nie występują nieoczekiwane regresje.

Czy Twoja aplikacja używa kodu natywnego?

Aplikacja używa kodu natywnego, jeśli ma miejsce jedna z tych sytuacji:

  • Aplikacja używa dowolnego kodu natywnego w C/C++. Jeśli aplikacja używa Androida NDK, używa kodu natywnego.
  • Aplikacja łączy się z zewnętrznymi bibliotekami natywnymi lub zależnościami, które z nich korzystają.
  • Twoja aplikacja została utworzona w kreatorze aplikacji innej firmy, który korzysta z bibliotek natywnych na urządzeniu.

Zidentyfikuj biblioteki natywne przy użyciu Analizatora plików APK

Analizator plików APK to narzędzie umożliwiające ocenę różnych aspektów utworzonego pliku APK. Aby określić, czy aplikacja korzysta z kodu natywnego czy bibliotek, wykonaj te czynności:

  1. Otwórz Android Studio, a potem kliknij Plik > Otwórz i wybierz dowolny projekt.

  2. Na pasku menu kliknij Kompilacja > Analizuj plik APK...

    Opcja tworzenia pakietów APK w menu Studio do uruchamiania Analizatora plików APK

  3. Wybierz plik APK, który chcesz przeanalizować.

  4. Sprawdź, czy w folderze lib znajdują się pliki z udostępnionymi obiektami (.so), jeśli takie istnieją. Jeśli są dostępne udostępnione pliki obiektów, aplikacja używa kodu natywnego. Jeśli nie ma udostępnionych plików obiektów lub nie ma folderu lib, aplikacja nie używa kodu natywnego.

    Widok Analizatora plików APK pokazujący, że są dostępne udostępnione pliki obiektów

Tworzenie aplikacji z obsługą urządzeń o rozmiarze 16 KB

Aby zapewnić obsługę urządzeń o rozmiarze 16 KB, aplikacje używające kodu natywnego powinny wykonać czynności opisane w sekcjach poniżej.

Zaktualizuj pakiet bibliotek udostępnionych

Zalecamy uaktualnienie pakietu AGP do wersji 8.3 lub nowszej i korzystanie z nieskompresowanych bibliotek udostępnionych.

AGP w wersji 8.3 lub nowszej

Urządzenia o rozmiarze 16 KB wymagają aplikacji, które mają skompresowane biblioteki udostępnione, aby wyrównać je do granicy 16 KB ustalonej na potrzeby pliku ZIP. Aby to zrobić, musisz uaktualnić wtyczkę Androida do obsługi Gradle (AGP) w wersji 8.3 lub nowszej. Szczegółowe informacje o procesie uaktualnienia znajdziesz w sekcji Asystent aktualizacji wtyczki Android Gradle.

AGP w wersji 8.2 lub starszej

Jeśli nie możesz uaktualnić AGP do wersji 8.3 lub nowszej, możesz korzystać z skompresowanych bibliotek udostępnionych. Zaktualizuj konfigurację Gradle, tak aby podczas pakowania aplikacji kompresowała ona biblioteki współdzielone. Pozwoli to uniknąć problemów z instalacją aplikacji w przypadku niedopasowanych bibliotek udostępnionych.

Odlotowe

W pliku build.gradle dodaj tę opcję:

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

Kotlin

W pliku build.gradle.kts dodaj tę opcję:

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

Kompiluj aplikację, dopasowując plik ELF o rozmiarze 16 KB

Urządzenia o rozmiarze 16 KB wymagają prawidłowego wyrównania segmentów ELF bibliotek udostępnionych przy użyciu dopasowania 16 KB, aby aplikacja mogła działać.

Aby skompilować aplikację przy użyciu pliku ELF o rozmiarze 16 KB, wykonaj czynności opisane w jednej z poniższych sekcji w zależności od używanej wersji Androida NDK.

Android NDK r26 i starsze

Aby obsługiwać kompilację bibliotek udostępnionych o rozmiarze 16 KB wyrównanych do 16 KB za pomocą Androida NDK w wersji R26 lub starszej, musisz zaktualizować konfigurację ndk-build lub cmake w ten sposób:

ndk-build

Zaktualizuj Android.mk, aby włączyć wyrównanie ELF o rozmiarze 16 KB:

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

CMake

Zaktualizuj CMakeLists.txt, aby włączyć wyrównanie ELF o rozmiarze 16 KB:

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

Android NDK r27 lub nowszy

Aby obsługiwać kompilację bibliotek udostępnionych o rozmiarze 16 KB wyrównanych do 16 KB za pomocą Androida NDK w wersji R27 lub nowszej, musisz zaktualizować flagi ndk-build, build.gradle, build.gradle.kts i tagu łączącego w ten sposób:

ndk-build

W Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Odlotowe

W pliku build.gradle ustaw argument -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

W pliku build.gradle.kts ustaw argument -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")
      }
    }
  }
}

Inne systemy kompilacji

Określ te flagi tagu łączącego:

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

Szukanie instancji kodu, które odwołują się do konkretnych rozmiarów stron

Nawet jeśli rozmiar aplikacji wynosi 16 KB, może ona zawierać błędy, jeśli miejsca w kodzie będą zakładać, że urządzenie używa strony o określonym rozmiarze. Aby tego uniknąć, wykonaj te czynności:

  1. Usuń wszelkie wpisane na stałe zależności, które odwołują się do stałej PAGE_SIZE, lub instancje w kodzie logicznym, które zakładają, że rozmiar strony na urządzeniu to 4 KB (4096).

    Użyj zamiast niego getpagesize() lub sysconf(_SC_PAGESIZE).

  2. Poszukaj użycia interfejsu mmap() i innych interfejsów API, które wymagają argumentów wyrównanych do strony, i w razie potrzeby zastąp je alternatywnymi.

W niektórych przypadkach, jeśli aplikacja używa parametru PAGE_SIZE jako wygodnej wartości, która nie jest powiązana z rozmiarem strony, nie spowoduje to jej awarii, gdy zostanie użyta w trybie 16 KB. Jeśli jednak ta wartość zostanie przekazana do jądra z użyciem parametru mmap bez użycia MAP_FIXED, jądro nadal będzie używać całej strony, co spowoduje zużycie pamięci. Z tego powodu wartość PAGE_SIZE jest nieokreślona, gdy włączony jest tryb 16 KB w NDK r27 i nowszych.

Jeśli Twoja aplikacja używa w ten sposób klasy PAGE_SIZE i nigdy nie przekazuje bezpośrednio tej wartości do jądra, zamiast używać PAGE_SIZE, utwórz nową zmienną z nową nazwą, która będzie wskazywać, że jest używana do innych celów i nie odzwierciedla rzeczywistej strony pamięci.

Testowanie aplikacji w środowisku o rozmiarze 16 KB

Gdy utworzysz aplikację z obsługą urządzeń o rozmiarze 16 KB, przetestuj ją w środowisku o rozmiarze 16 KB, aby sprawdzić, czy nie występują w niej jakieś regresje. Jak to zrobić:

  1. Skonfiguruj pakiet SDK do Androida 15.

  2. Skonfiguruj jedno z tych środowisk testowych:

  3. Uruchom urządzenie testowe, a następnie uruchom to polecenie, aby sprawdzić, czy korzysta ono ze środowiska o rozmiarze 16 KB:

    adb shell getconf PAGE_SIZE

    Polecenie powinno zwrócić wartość 16384.

  4. W przypadku wszystkich bibliotek udostępnionych sprawdź, czy segmenty ELF w bibliotekach udostępnionych są prawidłowo wyrównane, używając dopasowania 16 KB. Możesz skorzystać z tego skryptu, aby ułatwić sobie ten proces:

    #!/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. Zapisz skrypt w pliku, np. alignment.sh.

    2. Rozpakuj plik APK aplikacji:

      unzip APK_NAME.apk -d /tmp/my_apk_out

    3. Uruchom skrypt na wyodrębnionych plikach w katalogu /tmp/my_apk_out:

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

      Skrypt generuje ALIGNED lub UNALIGNED w przypadku wszystkich bibliotek udostępnionych arm64-v8a.

    4. Jeśli któreś z bibliotek udostępnionych arm64-v8a mają pakiet UNALIGNED, zaktualizuj pakiet tych bibliotek, a następnie ponownie skompiluj aplikację i przetestuj ją ponownie, wykonując czynności opisane w tej sekcji.

  5. Uruchom to polecenie zipalign, by sprawdzić, czy rozmiar aplikacji został wyrównany do 16 KB, gdzie APK_NAME to nazwa pliku APK aplikacji:

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

  6. Dokładnie przetestuj aplikację, skupiając się na obszarach, na które może mieć wpływ zmiana instancji kodu, które odnoszą się do stron o określonych rozmiarach.

Konfigurowanie emulatora Androida z obrazem systemu Android 15 opartym na rozmiarze 16 KB

Aby skonfigurować środowisko o rozmiarze 16 KB za pomocą emulatora Androida, wykonaj te czynności:

  1. Obrazy systemu emulatora Androida 15 o rozmiarze 16 KB są zgodne z Android Studio Jellyfish | 2023.3.1 lub nowszym. Aby jednak zapewnić większy komfort pracy z Androidem 15 w wersji beta, pobierz najnowszą wersję testową Android Studio.

    Pamiętaj, że możesz zachować dotychczasową wersję Android Studio, ponieważ możesz zainstalować wiele wersji obok siebie.

  2. W Android Studio kliknij Narzędzia > SDK Manager.

  3. Na karcie Platformy SDK zaznacz Pokaż szczegóły pakietu, a następnie rozwiń sekcję Android VanillaIceCream Preview i wybierz jeden lub oba z tych obrazów systemu emulatora w zależności od urządzeń wirtualnych, które chcesz utworzyć:

    • Eksperymentalny obraz systemu interfejsów API Google (16 tys. rozmiaru strony ARM 64 v8a)
    • Eksperymentalny obraz systemu Atom API x86_64, rozmiar strony 16 kB

    Pobierz obrazy systemu emulatora o wielkości 16 KB, korzystając z SDK Manager w Android Studio

  4. Aby pobrać wybrane obrazy systemu, kliknij Zastosuj > OK.

  5. Postępuj zgodnie z instrukcjami, aby skonfigurować urządzenie wirtualne na Androidzie 15. Gdy pojawi się prośba o wybranie obrazu systemu, wybierz pobrany obraz systemu o rozmiarze 16 KB. Jeśli nie jest to zalecane automatycznie, 16 KB obrazu systemu znajdziesz na karcie Inne obrazy.

    Znajdź obraz emulatora o wielkości 16 KB na karcie Inne obrazy.

Wstecz
Obsługa wersji 64-bitowej