Obsługa rozmiaru stron 16 KB

W przeszłości Android obsługiwał jedynie strony o rozmiarze 4 KB, które obsługują zoptymalizowana wydajność pamięci systemowej dla średniej ilości pamięci Urządzenia z Androidem zwykle mają Począwszy od Androida 15, AOSP obsługuje urządzenia skonfigurowane pod kątem używania strony o rozmiarze 16 KB (16 KB). urządzenia). Jeśli aplikacja korzysta z jakichkolwiek bibliotek NDK, bezpośrednio lub pośrednio za pomocą pakietu SDK, musisz ponownie skompilować aplikację, na urządzeniach o rozmiarze 16 KB.

W miarę jak producenci tworzą urządzenia, na których jest coraz więcej pamięci fizycznej (RAM) wiele z tych urządzeń będzie miało rozmiar 16 KB, w celu optymalizacji wydajności urządzenia. Dodaję obsługa urządzeń o rozmiarze strony 16 KB umożliwia urządzeń i pomaga aplikacji czerpać korzyści z powiązanej wydajności wiele ulepszeń. Bez ponownej kompilacji aplikacje mogą nie działać na urządzeniach o rozmiarze 16 KB podczas produkcji w kolejnych wersjach Androida.

Aby pomóc Ci w obsłudze aplikacji, przygotowaliśmy wskazówki, jak sprawdzić, jeśli ma to wpływ na Twoją aplikację, jak stworzyć aplikację ponownie (w stosownych przypadkach) i jak przetestować ją środowisko o wielkości 16 KB z emulatorami (w tym Android 15). obrazów systemu dla emulatora Androida).

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 Twoja aplikacja korzysta z systemu Android NDK, aplikacja użyje kodu natywnego.
• Aplikacja łączy się z zewnętrznymi bibliotekami natywnymi lub zależnościami, które korzystanie z nich.
• Twoja aplikacja została utworzona w kreatorze aplikacji innej firmy, który korzysta z bibliotek natywnych urządzenia.

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

Analizator plików APK to narzędzie, które umożliwia ocenę różnych aspektów kompilacji plik APK. Aby określić, czy aplikacja korzysta z kodu natywnego czy bibliotek, postępuj zgodnie z tymi wskazówkami kroki:

1. Otwórz Android Studio, po czym kliknij Plik > Otwórz i wybierz dowolny projekt.

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

   

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

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

   

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

Aby zapewnić obsługę urządzeń o rozmiarze 16 KB, aplikacje korzystające z kodu natywnego powinny wykonać czynności opisane w kolejnych sekcjach.

Zaktualizuj pakiet bibliotek udostępnionych

Zalecamy uaktualnienie go do wersji AGP 8.3 lub nowszej i korzystanie z biblioteki udostępnione.

AGP w wersji 8.3 lub nowszej

Urządzenia o rozmiarze 16 KB wymagają aplikacji dostarczonych z nieskompresowanymi bibliotekami udostępnionymi wyrównaj je na granicy 16 KB wyrównanej do pliku ZIP. Aby to zrobić, musisz przejść na wyższą wersję do wtyczki Androida do obsługi Gradle (AGP) w wersji 8.3 lub nowszej. Patrz: Android sekcji Asystent uaktualniania wtyczki Gradle, w której znajdziesz szczegółowe informacje o procesie uaktualniania.

AGP w wersji 8.2 lub starszej

Jeśli nie możesz uaktualnić AGP do wersji 8.3 lub nowszej, na używanie skompresowanych bibliotek udostępnionych. Zaktualizuj konfigurację Gradle do pozwól Gradle skompresować biblioteki udostępnione podczas pakowania aplikacji, aby uniknąć jej Problemy z instalacją z niedopasowanymi bibliotekami udostępnionymi.

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ą bibliotek udostępnionych Segmenty ELF do wyrównania używając dopasowania 16 KB do pliku ELF, aby aplikacja działała.

Uwaga: jeśli aplikacja nie wyodrębnia bibliotek natywnych do systemu plików (extractNativeLibs ustawiony na false), prawdopodobnie zauważysz niewielkie zwiększenie rozmiaru pliku binarnego aplikacji po skompilowaniu za pomocą pliku ELF o wielkości 16 KB. wyrównanie. Optymalizacje menedżera pakietów w Androidzie 15 ignorują środowisko wykonawcze. kosztów wynikających z tego wzrostu.

Aby skompilować aplikację przy użyciu dopasowania 16 KB ELF, wykonaj czynności opisane w jednym z tych sekcji w zależności od używanej wersji Androida NDK .

Ważne: jeśli aplikacja używa gotowych bibliotek udostępnionych, musisz też skompilować je ponownie w ten sam sposób i ponownie zaimportować biblioteki o rozmiarze 16 KB. do aplikacji.

Android NDK r26 i starsze

Do kompilowania bibliotek udostępnionych dopasowanych do 16 KB za pomocą Androida NDK wersji r26 lub starszej, musisz zaktualizować ndk-build lub cmake konfigurację w następujący 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")

Ważne: nawet jeśli aplikacja dynamicznie łączy się ze standardową biblioteką w C++ (libc++_shared.so) z NDK od r26 i starszych, z których niektóre nie mają 16 KB wyrównanie, nadal musisz zaktualizować wyrównanie wszystkich innych bibliotek zaktualizuj kod, aby unikać z powodu zależności od PAGE_SIZE. Aby przetestować na tych starszych wersjach NDK na urządzeniach o rozmiarze 16 KB, wersje do wczesnych testów LTS Wersje NDK r21 (dla tylko Windows i Linux), r23 i R25 jest dostępne w Androidzie CI z bibliotekami libc++_shared.so dostosowanymi do 16 KB. Niezależnie od tego zalecamy przejście na Androida NDK r27 lub nowszego, aby zaktualizować go na wersji standardowej biblioteki C++ w wersji ELF z plikiem 16 KB. W przeciwnym razie aplikacji nie uda się dziś zainstalować na urządzeniach o rozmiarze 16 KB.

Jeśli nie możesz tego zrobić przejdź na nowszą wersję Androida NDK, możliwe, że uda Ci się zaktualizować aplikację statycznie skompiluj standardową bibliotekę C++ w swoje zasoby wspólne. Więcej informacji: sekcji Obsługa biblioteki C++, aby uzyskać szczegółowe informacje na temat statycznego łączenia w bibliotece C++. Przeczytaj ważne informacje.

Android NDK r27 lub nowszy

Do kompilowania bibliotek udostępnionych dopasowanych do 16 KB za pomocą Androida NDK w wersji r27 lub nowszej, musisz zaktualizować urządzenia ndk-build, build.gradle, build.gradle.kts lub flagi 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 zakładamy, ż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 PAGE_SIZE. stałe lub wystąpienia w kodzie, które zakładają, że strona urządzenia rozmiar to 4 KB (4096).

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

2. Poszukaj zastosowań mmap() i innych interfejsów API, które wymagają dopasowania do strony i w razie potrzeby zastąpić je innymi.

W niektórych przypadkach, jeśli aplikacja używa wartości PAGE_SIZE jako wygodnej wartości, która nie jest powiązane z rozmiarem strony, nie spowoduje to jej awarii; przy użyciu w trybie 16 KB. Jeśli jednak ta wartość zostanie przekazana do jądra systemu jeśli używasz zmiennej mmap bez MAP_FIXED, jądro nadal używa całej strony, marnuje trochę pamięci. Z tego powodu wartość w polu PAGE_SIZE jest nieokreślona, gdy plik ma 16 KB tryb jest włączony w NDK r27 i nowszych wersjach.

Jeśli Twoja aplikacja używa w ten sposób wartości PAGE_SIZE i nigdy nie przekazuje bezpośrednio tej wartości do ją jądra. Zamiast używać parametru PAGE_SIZE, utwórz nową zmienną aby wskazać, że są one używane do innych celów i nie odzwierciedlają strony pamięci.

Testowanie aplikacji w środowisku o rozmiarze 16 KB

Po utworzeniu aplikacji z obsługą urządzeń o rozmiarze 16 KB warto skonfigurować przetestuj aplikację w środowisku o wielkości 16 KB, aby sprawdzić, czy działa dochodzi do regresji. W tym celu należy wykonać następujące czynności:

1. Skonfiguruj pakiet SDK do Androida 15.

2. Skonfiguruj jedno z tych środowisk testowych:

   • Konfigurowanie emulatora Androida na Androidzie 15 i o rozmiarze 16 KB obraz
   • Użyj mątwy o rozmiarze strony 16 KB na ARM64
   • Symuluj mątwę o rozmiarze strony 16 KB na urządzeniach x86–64

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

   adb shell getconf PAGE_SIZE
   

   Polecenie powinno zwrócić wartość 16384.

4. W przypadku bibliotek udostępnionych sprawdź, czy biblioteki udostępnione Segmenty ELF są wyrównanie przy użyciu wyrównania 16 KB ELF. Możesz użyć tego skryptu, aby pomoc w tym procesie:

   #!/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 narzędziu /tmp/my_apk_out katalogu:

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

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

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

5. Uruchom to polecenie zipalign, aby sprawdzić, czy aplikacja 16 KB, gdzie APK_NAME to nazwa plik APK aplikacji:

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

6. Dokładnie przetestuj aplikację, skupiając się na obszarach, na które mogą mieć wpływ zmieniając instancje kodu, które odwołują się do określonych rozmiarów stron.

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

Ważne: występuje znany problem, który uniemożliwia debugowanie za pomocą LLDB Obrazy systemu emulatora o rozmiarze 16 KB. Rozwiązanie tego problemu jest zawarte w NDK r27 Pakiet nowych funkcji RC 1 i Android Studio Koala | 2024.1.2 Canary 5

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

1. Obrazy systemu emulatora Androida 15 i o rozmiarze 16 KB są zgodne z Android Studio – meduza | Wersja 2023.3.1 lub nowsza. Aby jednak zapewnić współpracy z Androidem 15 w wersji beta, pobierz najnowszą wersję wersję testową Android Studio.

   Pamiętaj, że możesz zachować istniejącą wersję Android Studio Zainstalowane są te wersje, bo możesz zainstalować wiele wersji obok siebie.

2. W Android Studio kliknij Narzędzia > Menedżer pakietów SDK.

3. Na karcie Platformy SDK zaznacz Pokaż szczegóły pakietu, a następnie rozwiń sekcję Android VanillaIceCream Preview i wybierz co najmniej jedną z tych z poniższych obrazów systemu emulatora zależnie 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
   Uwaga: jeśli planujesz emulować obsługiwane urządzenie Google Pixel, potrzebujesz tylko obrazu systemu ARM 64 v8a.

   

4. Kliknij Zastosuj > OK, aby pobrać wybrane obrazy systemu.

5. Postępuj zgodnie z instrukcjami, aby skonfigurować urządzenie wirtualne na Androidzie 15, i kiedy jako obraz systemu, wybierz obraz systemu o rozmiarze 16 KB, pobranego pliku. Jeśli nie jest ona zalecana automatycznie, w sekcji 16 KB na karcie Inne obrazy.