Suporte a tamanhos de página de 16 KB

Android 过去仅支持 4 KB 内存页面大小， 优化了系统内存性能，以针对 Android 设备通常具备的功能。从 Android 15 开始，AOSP 支持 配置为使用 16 KB (16 KB) 页面大小的设备 设备）。如果您的应用使用任何 NDK 库，请直接使用 或者通过 SDK 间接创建，那么，您需要重新构建自己的应用 支持这些 16KB 设备。

随着设备制造商不断打造出 物理内存 (RAM)，许多此类设备都会采用 16KB（以及 页面大小以优化设备的性能。正在添加 支持 16 KB 页面大小的设备，可使您的应用在这些设备上运行 并有助于您的应用从相关的广告效果中获益 改进。如果不重新编译，应用可能无法在 16KB 设备上运行 在未来的 Android 版本中正式推出。

为帮助您为应用添加支持，我们提供了有关如何检查 如果您的应用受到影响 重新构建您的应用（如果适用），以及如何在 Google Play 中 使用模拟器（包括 Android 15）的 16 KB 环境 系统映像）。

Benefícios e ganhos de desempenho

Dispositivos configurados com tamanhos de página de 16 KB usam um pouco mais de memória em média, mas também recebem várias melhorias de desempenho para o sistema e os apps:

• Menor tempo de inicialização do app enquanto o sistema está sob pressão de memória: 3,16% menor, em média, com melhorias mais significativas (até 30%) para alguns apps testados.
• Consumo de energia reduzido durante a inicialização do app: em média, 4,56% de redução
• Lançamento mais rápido da câmera: inicializações a quente 4,48% mais rápidas, em média, e inicializações a frio 6,60% mais rápidas, em média.
• Melhoria no tempo de inicialização do sistema: melhoria de 1,5% (aproximadamente 0,8 segundo) em média.

Essas melhorias são baseadas em nossos testes iniciais, e os resultados em dispositivos reais provavelmente serão diferentes. Forneceremos análises adicionais de ganhos potenciais para apps à medida que continuarmos nossos testes.

Verificar se o app vai ser afetado

Se o app usar código nativo, recrie-o com suporte a dispositivos de 16 KB. Se você não tem certeza se o app usa código nativo, use o APK Analyzer para identificar se há algum código nativo.

Se o app usa apenas código escrito na linguagem de programação Java ou Kotlin, incluindo bibliotecas ou SDKs, ele já oferece suporte a dispositivos de 16 KB. No entanto, recomendamos que você teste seu app em um ambiente de 16 KB para verificar se não há regressões inesperadas no comportamento dele.

O app usa código nativo?

O app usa código nativo se alguma das seguintes condições se aplicar:

• O app usa qualquer código C/C++ (nativo). Caso seu app use a plataforma NDK, o app usará código nativo.
• O app é vinculado a quaisquer bibliotecas ou dependências nativas de terceiros que usá-los.
• Seu app foi feito por um criador de apps de terceiros que usa bibliotecas nativas em dispositivo.

Identificar bibliotecas nativas usando o APK Analyzer

O APK Analyzer é uma ferramenta que permite avaliar vários aspectos de um aplicativo APK. Para identificar se o app usa bibliotecas ou código nativo, siga estas etapas:

1. Abra o Android Studio e clique em File > Abra e escolha um projeto.

2. Na barra de menus, clique em Build > Analisar APK...

   

3. Escolha o APK que você quer analisar.

4. Procure na pasta lib, que hospeda arquivos de objetos compartilhados (.so), se houver estão presentes. Se houver arquivos de objeto compartilhado, o app vai usar arquivos o código-fonte é alterado. Se nenhum arquivo de objeto compartilhado estiver presente ou não houver uma pasta lib: o app não vai usar código nativo.

   

Criar o app com suporte a dispositivos de 16 KB

Para oferecer suporte a dispositivos de 16 KB, os apps que usam código nativo precisam concluir a etapas descritas nas seções a seguir.

Atualizar o empacotamento das suas bibliotecas compartilhadas

Recomendamos que você faça upgrade para a versão 8.3 ou mais recente do AGP e use o comando bibliotecas compartilhadas.

AGP versão 8.3 ou mais recente.

Em dispositivos de 16 KB, os apps vêm com bibliotecas compartilhadas não compactadas. alinhe-as em um limite alinhado em zip de 16 KB. Para isso, você precisa fazer upgrade ao Plug-in do Android para Gradle (AGP, na sigla em inglês) versão 8.3 ou mais recente. Consulte a documentação Seção "Assistente de upgrade do plug-in do Gradle" para mais detalhes sobre o processo de upgrade.

AGP versão 8.2 ou anterior.

Se não for possível fazer upgrade do AGP para a versão 8.3 ou mais recente, a alternativa é mudar para bibliotecas compartilhadas compactadas. Atualizar a configuração do Gradle para faça com que o Gradle compacte as bibliotecas compartilhadas ao empacotar seu aplicativo para evitar que ele problemas de instalação com bibliotecas compartilhadas desalinhadas.

Groovy

No seu arquivo build.gradle, adicione esta opção:

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

Kotlin

No seu arquivo build.gradle.kts, adicione esta opção:

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

Compile seu app usando o alinhamento de ELF de 16 KB.

Os dispositivos de 16 KB exigem a versão da biblioteca compartilhada Segmentos do ELF a serem alinhados corretamente usando o alinhamento ELF de 16 KB para que seu app seja executado.

Observação: se o app não extrair bibliotecas nativas para o sistema de arquivos (extractNativeLibs definido como false), você provavelmente vai notar um pequeno de aumento no tamanho do binário do app após a compilação com um ELF de 16 KB alinhamento dos dados. As otimizações no gerenciador de pacotes do Android 15 negam o tempo de execução custos com esse aumento.

Para compilar seu app usando o alinhamento de ELF de 16 KB, conclua as etapas de uma das as seções a seguir, dependendo da versão do Android NDK que você usando.

Importante: caso seu app use bibliotecas compartilhadas pré-criadas, você também vai precisar recompile-os da mesma maneira e importe novamente as bibliotecas alinhadas de 16 KB no seu app.

Android NDK r26 e versões anteriores

Para oferecer compatibilidade com a compilação de bibliotecas compartilhadas alinhadas de 16 KB com o Android NDK versão r26 ou anterior, é necessário atualizar seu ndk-build ou cmake da seguinte maneira:

ndk-build

Atualize o Android.mk para ativar o alinhamento do ELF de 16 KB:

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

CMake

Atualize o CMakeLists.txt para ativar o alinhamento do ELF de 16 KB:

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

Importante: mesmo que o app seja vinculado dinamicamente à biblioteca C++ padrão, (libc++_shared.so) do NDKs r26 e versões anteriores, alguns deles com menos de 16 KB alinhado, você ainda deve atualizar o alinhamento de todas as outras bibliotecas aqui, e atualize o código para evitar depender de PAGE_SIZE. Para testar nessas versões anteriores do NDK em dispositivos de 16 KB, versões canário do LTS Versões do NDK r21 (para somente Windows e Linux), r23 e r25 são disponível no Android CI com bibliotecas libc++_shared.so alinhadas a 16 KB. Independentemente disso, é recomendável mudar para o Android NDK r27 ou uma versão mais recente para atualizar para o a versão de 16 KB alinhada ao ELF da biblioteca C++ padrão. Caso contrário, seus não será possível instalar o app em dispositivos de 16 KB hoje.

Se isso não for possível, mudar para o Android NDK mais recente, atualize o app para Compile estaticamente a biblioteca C++ padrão na sua biblioteca compartilhada. Consulte a seção Suporte à biblioteca C++ para ver detalhes sobre a vinculação estática à biblioteca C++ padrão e leia as Considerações importantes nesta seção.

Android NDK r27 e versões mais recentes

Para oferecer compatibilidade com a compilação de bibliotecas compartilhadas alinhadas de 16 KB com o Android NDK versão r27 e superior, é necessário atualizar o ndk-build, build.gradle, build.gradle.kts ou sinalizações do vinculador da seguinte maneira:

ndk-build

No seu Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Groovy

No arquivo build.gradle, defina o argumento -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

No arquivo build.gradle.kts, defina o argumento -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")
      }
    }
  }
}

Outros sistemas de build

Especifique as seguintes sinalizações do vinculador:

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

Verificar se há instâncias de código que fazem referência a tamanhos de página específicos

Mesmo que seu aplicativo esteja alinhado a 16 KB, ele pode encontrar erros se os lugares no seu código presumem que um dispositivo está usando um tamanho de página específico. Para evitar isso, siga estas etapas:

1. Remova todas as dependências codificadas que fazem referência ao PAGE_SIZE. ou instâncias na lógica do código que pressupõem que a página de um dispositivo é 4 KB (4096).

   Use getpagesize() ou sysconf(_SC_PAGESIZE).

2. Procure usos de mmap() e outras APIs que exigem alinhamento à página e substitua por alternativas quando necessário.

Em alguns casos, se o app usa PAGE_SIZE como um valor conveniente que não é vinculado ao tamanho da página subjacente, isso não causará falhas no aplicativo quando usada no modo de 16 KB. No entanto, se esse valor for passado para o kernel, com mmap sem MAP_FIXED, o kernel ainda usa uma página inteira, que desperdiça um pouco de memória. Por esses motivos, PAGE_SIZE é indefinido quando 16 KB está ativado no NDK r27 e versões mais recentes.

Se o app usar PAGE_SIZE dessa maneira e nunca transmitir esse valor diretamente para o kernel e, em vez de usar PAGE_SIZE, crie uma nova variável com um novo para indicar que ele é usado para outros fins e não reflete uma identidade real na página "Memória".

Testar o app em um ambiente de 16 KB

Depois de criar seu app com suporte a dispositivos de 16 KB, você vai querer testar o app em um ambiente de 16 KB para saber se ele é compatível regressões. Para isso, siga estas etapas:

1. Configurar o SDK do Android 15.

2. Configure um dos seguintes ambientes de teste:

   • Configurar o Android Emulator com um sistema Android 15 de 16 KB imagem
   • Usar o Cuttlefish com tamanho de página de 16 KB no ARM64
   • Simule o Cuttlefish com tamanho de página de 16 KB em uma arquitetura x86-64.

3. Inicie o dispositivo de teste e execute o seguinte comando para verificar se ele usa um ambiente de 16 KB:

   adb shell getconf PAGE_SIZE
   

   O comando precisa retornar um valor 16384.

4. Para as bibliotecas compartilhadas, verifique se o arquivo Os segmentos de ELF são corretamente alinhados com o alinhamento ELF de 16 KB. É possível usar esse script para ajudar com esse processo:

   #!/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. Salve o script em um arquivo, como alignment.sh.

   2. Extraia o arquivo APK do seu app:

      unzip APK_NAME.apk -d /tmp/my_apk_out
      

   3. Execute o script nos arquivos extraídos no /tmp/my_apk_out diretório:

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

      O script gera ALIGNED ou UNALIGNED para todos os arm64-v8a bibliotecas compartilhadas.

   4. Se alguma biblioteca compartilhada arm64-v8a for UNALIGNED, você precisará atualize o empacotamento dessas bibliotecas e recompile seu e teste novamente seguindo as etapas desta seção.

5. Execute o comando zipalign a seguir para verificar se o app está 16 KB alinhado, em que APK_NAME é o nome do arquivo APK do seu app:

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

6. Testar minuciosamente seu app, concentrando-se em todas as áreas que podem ser afetadas alterar instâncias de código que fazem referência a tamanhos de página específicos.

Configurar o Android Emulator com uma imagem do sistema Android 15 baseada em 16 KB

Importante: há um problema conhecido que impede a depuração com o LLDB com Imagens do sistema do emulador de 16 KB. Uma correção para esse problema está incluída no NDK r27 RC 1 e Android Studio Koala Feature Drop | 2024.1.2 Canary 5.

Para configurar um ambiente de 16 KB usando o Android Emulator, siga estas etapas: etapas:

1. Imagens do sistema do emulador do Android 15 de 16 KB são compatíveis com Android Studio Jellyfish | 2023.3.1 ou mais recente. No entanto, para que as melhores ao trabalhar com o Android 15 Beta, baixe a versão mais recente versão de pré-lançamento do Android Studio.

   Vale lembrar que você pode manter a versão atual do Android Studio instalada, já que é possível instalar diversas versões lado a lado.

2. No Android Studio, clique em Tools > SDK Manager.

3. Na guia SDK Platforms, marque Show Package Details e expanda na seção Android VanillaIceCream Preview e selecione uma as seguintes imagens do sistema do emulador, dependendo dos dispositivos virtuais que você que queremos criar:

   • Imagem do sistema experimental de 16 mil das APIs do Google ARM 64 v8a
   • Imagem do sistema Atom experimental 16k das APIs do Google
   .
   Observação: se você está planejando emular um dispositivo Google Pixel compatível, você só vai precisar da imagem do sistema ARM 64 v8a.

   

4. Clique em Aplicar > OK para fazer o download das imagens do sistema selecionadas.

5. Siga as etapas para configurar um dispositivo virtual para o Android 15 e quando for solicitado que você escolha uma imagem do sistema, escolha a imagem de 16 KB que você fez o download. Se ele não for recomendado automaticamente, Imagem do sistema de 16 KB na guia Outras imagens.

   

.

Aviso: para simular um ambiente de 16 KB em sistemas x86_64, também é necessário para concluir as etapas a seguir. Estas etapas são temporárias e serão removidas no futuro.

1. No Gerenciador de dispositivos, clique nos três pontos ao lado da imagem de 16 KB e clique em Mostrar no disco.
2. Nela, localize o arquivo config.ini.

3. Adicione a linha abaixo ao arquivo config.ini e salve as mudanças:

   kernel.parameters = androidboot.page_shift=14
   

4. Para verificar as alterações, execute o comando a seguir, que deve retornar 16384:

   adb shell getconf PAGE_SIZE