Seitengrößen von 16 KB werden unterstützt

Bisher wurden in Android nur Seitengrößen von 4 KB unterstützt, eine optimierte Systemspeicherleistung für die durchschnittliche In der Regel gab es Android-Geräte. Ab Android 15 unterstützt AOSP Geräte, die für die Verwendung einer Seitengröße von 16 KB (16 KB) konfiguriert sind Geräte). Wenn Ihre App NDK-Bibliotheken verwendet, können Sie entweder direkt oder indirekt über ein SDK, müssen Sie Ihre App die auf diesen 16-KB-Geräten funktionieren.

Da Gerätehersteller immer mehr Geräte entwickeln, physischen Arbeitsspeicher (RAM), verwenden viele dieser Geräte 16 KB (und größer werden), um die Leistung des Geräts zu optimieren. Wird hinzugefügt wird die Unterstützung für Geräte mit einer Seitengröße von 16 KB ermöglicht, Geräte und unterstützt Ihre App dabei, von der damit verbundenen Leistung Verbesserungen. Ohne Neukompilierung funktionieren Apps auf Geräten mit 16 KB möglicherweise nicht wenn sie in zukünftigen Android-Versionen produktionsreif sind.

Damit Sie Unterstützung für Ihre App hinzufügen können, haben wir eine Anleitung zur Überprüfung der falls Ihre App betroffen ist, Ihre App neu zu erstellen (falls zutreffend) und wie Sie Ihre App eine 16 KB-Umgebung mit Emulatoren (einschließlich Android 15) System-Images für den Android-Emulator).

Vorteile und Leistungssteigerungen

Geräte, die mit einer Seitengröße von 16 KB konfiguriert sind, benötigen im Durchschnitt etwas mehr Arbeitsspeicher, erzielen aber auch verschiedene Leistungsverbesserungen für das System und die Apps:

• Kürzere App-Startzeiten, während das System unter Speicherauslastung steht: im Durchschnitt 3,16 % niedriger, mit deutlicheren Verbesserungen (bis zu 30%) bei einigen von uns getesteten Apps
• Verringerter Stromverbrauch beim Starten der App: durchschnittlich 4,56% weniger
• Schnellerer Kamerastart: 4,48% schnellere Heißstarts und 6,60% schnellere Kaltstarts im Durchschnitt
• Verbesserte Systemstartzeit: durchschnittlich um 8% (ca. 950 Millisekunden)

Diese Verbesserungen basieren auf unseren ersten Tests. Die Ergebnisse auf tatsächlichen Geräten werden sich wahrscheinlich unterscheiden. Im Rahmen unserer Tests werden wir zusätzliche Analysen zu den potenziellen Vorteilen für Apps durchführen.

Prüfen, ob Ihre App betroffen ist

Wenn Ihre App nativen Code verwendet, sollten Sie Ihre App mit Unterstützung für 16 KB-Geräte neu erstellen. Wenn du nicht sicher bist, ob deine App nativen Code verwendet, kannst du mit dem APK Analyzer herausfinden, ob nativer Code vorhanden ist. Anschließend kannst du die Ausrichtung der ELF-Segmente für alle gefundenen gemeinsam genutzten Bibliotheken prüfen.

Wenn in Ihrer App nur Code verwendet wird, der in der Programmiersprache Java oder Kotlin geschrieben ist, einschließlich aller Bibliotheken oder SDKs, unterstützt Ihre App bereits Geräte mit 16 KB. Trotzdem empfehlen wir, die Anwendung in einer 16-KB-Umgebung zu testen, um zu prüfen, ob es zu unerwarteten Regressionen im Anwendungsverhalten kommt.

Verwendet Ihre App nativen Code?

Ihre App verwendet nativen Code, wenn eine der folgenden Bedingungen zutrifft:

• Ihre App verwendet C/C++-Code (nativer Code). Wenn Ihre App das Android-NDK verwendet, verwendet sie nativen Code.
• Ihre App ist mit nativen Bibliotheken oder Abhängigkeiten von Drittanbietern (z. B. SDKs) verknüpft, die diese verwenden.
• Ihre App wurde von einem Drittanbieter-App-Builder erstellt, der native Bibliotheken auf dem Gerät verwendet.

Native Bibliotheken mit APK Analyzer ermitteln

Mit dem APK Analyzer können Sie verschiedene Aspekte eines erstellten APKs bewerten. So finden Sie heraus, ob Ihre App nativen Code oder Bibliotheken verwendet:

1. Öffnen Sie Android Studio, klicken Sie auf File > Open (Datei > Öffnen) und wählen Sie ein beliebiges Projekt aus.

2. Klicken Sie in der Menüleiste auf Build > APK analysieren….

   

3. Wählen Sie das APK aus, das Sie analysieren möchten.

4. Suchen Sie im Ordner lib nach Dateien für freigegebene Objekte (.so), falls vorhanden. Wenn Shared Object-Dateien vorhanden sind, verwendet Ihre App nativen Code. Wenn keine Shared Object-Dateien vorhanden sind oder kein lib-Ordner vorhanden ist, verwendet Ihre App keinen nativen Code.

   

Ausrichtung von ELF-Segmenten für freigegebene Bibliotheken prüfen

Prüfen Sie bei allen freigegebenen Bibliotheken, ob die ELF-Segmente der freigegebenen Bibliotheken mit einer ELF-Ausrichtung von 16 KB richtig ausgerichtet sind. Wenn Sie unter Linux oder macOS entwickeln, können Sie das check_elf_alignment.sh-Script wie im folgenden Abschnitt beschrieben verwenden. Sie können auch die Befehlszeilentools direkt verwenden.

Skript „check_elf_alignment.sh“ verwenden (Linux oder macOS)

So prüfen Sie die Ausrichtung von ELF-Segmenten mit dem check_elf_alignment.sh-Script:

1. Speichern Sie das check_elf_alignment.sh-Script in einer Datei.

2. Führen Sie das Script auf der APK-Datei Ihrer App aus:

   check_elf_alignment.sh APK_NAME.apk
   

   Das Script gibt für alle arm64-v8a freigegebenen Bibliotheken entweder ALIGNED oder UNALIGNED aus.

3. Wenn eine arm64-v8a- oder x86_64-Bibliothek UNALIGNED ist, müssen Sie die Verpackung für diese Bibliotheken aktualisieren, dann Ihre App neu kompilieren und die Schritte in diesem Abschnitt ausführen, um sie noch einmal zu testen.

Befehlszeilentools direkt verwenden

So prüfen Sie die Ausrichtung von ELF-Segmenten direkt mit Befehlszeilentools:

1. Achten Sie darauf, dass sowohl die Android SDK Build Tools Version 35.0.0 oder höher als auch das Android NDK über den SDK-Manager in Android Studio oder das Befehlszeilentool sdkmanager installiert sind.

2. Extrahieren Sie die APK-Datei Ihrer App:

   Linux oder macOS

   unzip APK_NAME.apk -d /tmp/my_apk_out
   

   Windows (PowerShell)

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

3. Prüfen Sie im temporären Verzeichnis, in das Sie Ihre APK-Datei extrahiert haben, den Inhalt des Verzeichnisses lib auf Dateien des Typs „Shared Object“ (.so). Dies sind dieselben gemeinsam genutzten Objektdateien, die Sie beim Identifizieren nativer Bibliotheken mit dem APK-Analyzer gesehen haben. Führen Sie den folgenden Befehl für jede Shared Object-Datei aus:

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

   Dabei ist SDK_ROOT_LOCATION der Pfad zum Verzeichnis, in dem Sie das Android SDK installiert haben, SHARED_OBJECT_FILE der Name der zu prüfenden Shared Object-Datei und NDK_VERSION die Version des installierten Android NDK (z. B. 28.0.12433566). Die Ausgabe sieht für jede geprüfte Datei in etwa so aus:

   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. Prüfen Sie die Ausgabezeilen, um sicherzustellen, dass die Werte der Lastsegmente nicht unter 2**14 liegen. Wenn für Ladesegmente 2**13, 2**12 oder niedrigere Werte angegeben sind, müssen Sie die Verpackung für diese Bibliotheken aktualisieren, dann Ihre App neu kompilieren und die Schritte in diesem Abschnitt ausführen, um sie noch einmal zu testen.

5. Führen Sie als Nächstes das zipalign-Befehlszeilentool auf der APK-Datei Ihrer App aus:

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

   Dabei ist SDK_ROOT_LOCATION der Pfad zum Verzeichnis, in dem Sie das Android SDK installiert haben, und APK_NAME der Name der APK-Datei Ihrer App. In der letzten Zeile der Ausgabe wird „Verifizierung erfolgreich“ angezeigt, wenn alle freigegebenen Bibliotheken richtig ausgerichtet sind.

   Wenn die Überprüfung fehlgeschlagen ist, müssen einige freigegebene Bibliotheken neu ausgerichtet werden. Aktualisieren Sie dazu die Verpackung für diese Bibliotheken, kompilieren Sie Ihre App neu und wiederholen Sie die Schritte in diesem Abschnitt.

App mit Unterstützung für 16-KB-Geräte erstellen

Wenn Sie Apps mit nativem Code für Geräte mit 16 KB unterstützen möchten, müssen Sie die in den folgenden Abschnitten beschriebenen Schritte ausführen. Wenn Sie auf die AGP-Version 8.5.1 oder höher und die NDK-Version r28 oder höher aktualisieren und vorgefertigte Abhängigkeiten verwenden, die mit 16 KB kompatibel sind, sind Apps standardmäßig mit 16 KB kompatibel.

Verpackung Ihrer freigegebenen Bibliotheken aktualisieren

Wir empfehlen ein Upgrade auf AGP-Version 8.5.1 oder höher und die Verwendung nicht komprimierter freier Bibliotheken.

AGP-Version 8.5.1 oder höher

Für Geräte mit 16 KB müssen Apps, die mit nicht komprimierten freigegebenen Bibliotheken ausgeliefert werden, an einer 16 KB großen ZIP-ausgerichteten Grenze ausgerichtet werden. Dazu müssen Sie auf das Android Gradle Plugin (AGP) Version 8.5.1 oder höher aktualisieren. Weitere Informationen zum Upgrade finden Sie im Abschnitt Android Gradle Plugin Upgrade Assistant.

AGP-Version 8.5 oder niedriger

Wenn Sie AGP nicht auf Version 8.5.1 oder höher aktualisieren können, können Sie stattdessen komprimierte freigegebene Bibliotheken verwenden. Aktualisieren Sie Ihre Gradle-Konfiguration, damit Gradle Ihre freigegebenen Bibliotheken beim Verpacken Ihrer App komprimiert, um Probleme bei der App-Installation mit nicht ausgerichteten freigegebenen Bibliotheken zu vermeiden.

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

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

App mit 16 KB ELF-Ausrichtung kompilieren

Bei Geräten mit 16 KB müssen die ELF-Segmente der freigegebenen Bibliotheken richtig mit einer ELF-Ausrichtung von 16 KB ausgerichtet sein, damit Ihre App ausgeführt werden kann.

Führen Sie je nach verwendeter Version des Android NDK die Schritte in einem der folgenden Abschnitte aus, um Ihre App mit einer ELF-Ausrichtung von 16 KB zu kompilieren.

Android NDK r28 und höher

Ab der NDK-Version r28 werden standardmäßig 16 KB-ausgerichtete Module kompiliert.

Android NDK r27

Wenn Sie freigegebene Bibliotheken mit einer Ausrichtung von 16 KB mit der Android NDK-Version r27 und höher kompilieren möchten, müssen Sie die ndk-build-, build.gradle-, build.gradle.kts- oder Linker-Flags so aktualisieren:

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 und niedriger

Wenn Sie freigegebene Bibliotheken mit einer Ausrichtung von 16 KB mit der Android NDK-Version r26 oder niedriger kompilieren möchten, müssen Sie Ihre ndk-build- oder cmake-Konfiguration so aktualisieren:

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

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

Nach Codeinstanzen suchen, die auf bestimmte Seitengrößen verweisen

Auch wenn Ihre App auf 16 KB ausgerichtet ist, kann es zu Fehlern kommen, wenn an Stellen in Ihrem Code davon ausgegangen wird, dass ein Gerät eine bestimmte Seitengröße verwendet. Führen Sie dazu die folgenden Schritte aus:

1. Entfernen Sie alle hartcodierten Abhängigkeiten, die auf die Konstante PAGE_SIZE oder Instanzen in Ihrer Codelogik verweisen, die davon ausgehen, dass die Seitengröße eines Geräts 4 KB (4096) beträgt.

   Verwenden Sie stattdessen getpagesize() oder sysconf(_SC_PAGESIZE).

2. Suchen Sie nach Verwendungen von mmap() und anderen APIs, die seitenausgerichtete Argumente erfordern, und ersetzen Sie sie bei Bedarf durch Alternativen.

Wenn Ihre App PAGE_SIZE als praktischen Wert verwendet, der nicht an die zugrunde liegende Seitengröße gebunden ist, funktioniert sie in einigen Fällen auch im 16-KB-Modus. Wenn dieser Wert jedoch mit mmap ohne MAP_FIXED an den Kernel übergeben wird, verwendet der Kernel weiterhin eine ganze Seite, was etwas Speicher verschwendet. Aus diesen Gründen ist PAGE_SIZE nicht definiert, wenn der 16-KB-Modus in NDK r27 und höher aktiviert ist.

Wenn Ihre App PAGE_SIZE auf diese Weise verwendet und diesen Wert nie direkt an den Kernel weitergibt, erstellen Sie anstelle von PAGE_SIZE eine neue Variable mit einem neuen Namen, um anzuzeigen, dass sie für andere Zwecke verwendet wird und keine echte Speicherseite darstellt.

SDKs auf Unterstützung von 16 KB prüfen

Viele SDKs sind mit Seitengrößen von 16 KB kompatibel, insbesondere wenn Sie sie selbst erstellen oder aktuelle vorkonfigurierte SDKs verwenden. Da einige vorkonfigurierte SDKs oder SDK-Versionen jedoch nicht mit 16 KB kompatibel sind, sollten Sie auf der Website des jeweiligen SDK-Anbieters nachsehen, welche Version mit 16 KB verwendet werden kann.

App in einer 16 KB großen Umgebung testen

Nachdem Sie Ihre App mit Unterstützung für 16 KB-Geräte erstellt haben, sollten Sie sie in einer 16 KB-Umgebung testen, um festzustellen, ob es zu Rückschritten gekommen ist. Gehen Sie hierzu folgendermaßen vor:

1. Android 15 SDK einrichten

2. Richten Sie eine der folgenden Testumgebungen ein:

   • Android-Emulator mit einem 16-KB-basierten Android 15-System-Image einrichten
   • 16-KB-Modus auf einem Gerät mithilfe der Entwickleroptionen aktivieren
   • Cuttlefish mit 16 KB Seitengröße auf ARM64 verwenden
   • Cuttlefish mit einer Seitengröße von 16 KB auf x86-64 simulieren

3. Starten Sie Ihr Testgerät und führen Sie den folgenden Befehl aus, um zu prüfen, ob eine 16-KB-Umgebung verwendet wird:

   adb shell getconf PAGE_SIZE
   

   Der Befehl sollte den Wert 16384 zurückgeben.

4. Führen Sie den folgenden Befehl zipalign aus, um zu prüfen, ob Ihre App auf 16 KB ausgerichtet ist. Dabei ist APK_NAME der Name der APK-Datei Ihrer App:

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

5. Testen Sie Ihre App gründlich und konzentrieren Sie sich dabei auf Bereiche, die sich durch Änderungen an Codeinstanzen, die auf bestimmte Seitengrößen verweisen, auswirken könnten.

Android-Emulator mit einem 16-KB-basierten Android 15-System-Image einrichten

So richten Sie eine 16 KB-Umgebung mit dem Android-Emulator ein:

1. 16 KB große Android 15-Emulator-Systembilder sind mit Android Studio Jellyfish | 2023.3.1 oder höher kompatibel. Für die beste Leistung bei der Arbeit mit der Android 15-Betaversion sollten Sie jedoch die aktuelle Vorschauversion von Android Studio herunterladen.

   Sie können die vorhandene Version von Android Studio installiert lassen, da Sie mehrere Versionen parallel installieren können.

2. Klicken Sie in Android Studio auf Tools > SDK-Manager.

3. Klicken Sie auf dem Tab SDK-Plattformen auf Paketdetails anzeigen, maximieren Sie den Bereich Android VanillaIceCream Preview und wählen Sie je nach den virtuellen Geräten, die Sie erstellen möchten, eines oder beide der folgenden Emulator-Systemimages aus:

   • Google APIs Experimental 16k Page Size ARM 64 v8a System Image
   • Google APIs – experimentelles System-Image mit 16 KiB Seitengröße für Intel x86_64 Atom

   

4. Klicken Sie auf Übernehmen > OK, um die ausgewählten Systembilder herunterzuladen.

5. Folgen Sie der Anleitung zum Einrichten eines virtuellen Geräts für Android 15. Wenn Sie aufgefordert werden, ein System-Image auszuwählen, wählen Sie das heruntergeladene 16-KB-System-Image aus. Wenn es nicht automatisch empfohlen wird, finden Sie das 16 KB große System-Image auf dem Tab Weitere Bilder.

   

1. Klicken Sie im Gerätemanager auf das Dreipunkt-Menü neben dem 16-KB-Image und dann auf Auf dem Laufwerk anzeigen.
2. Suchen Sie in diesem Ordner nach der Datei config.ini.

3. Fügen Sie der Datei config.ini die folgende Zeile hinzu und speichern Sie die Änderungen:

   kernel.parameters = androidboot.page_shift=14
   

4. Führen Sie den folgenden Befehl aus, um Ihre Änderungen zu überprüfen. Er sollte 16384 zurückgeben:

   adb shell getconf PAGE_SIZE
   

16-KB-Modus auf einem Gerät mithilfe von Entwickleroptionen aktivieren

Entwickler zur Option Mit einer Seitengröße von 16 KB starten umschalten Option zum Starten eines Geräts im 16-KB-Modus.

Ab Android 15 QPR1 können Sie verwenden Sie die Entwickleroption, die auf bestimmten Geräte, um das Gerät im 16-KB-Modus zu starten und Tests auf dem Gerät durchzuführen.

Diese Entwickleroption ist auf den folgenden Geräten verfügbar:

• Google Pixel 8 und Google Pixel 8 Pro (mit Android 15 QPR1 Beta 1 oder höher)