Dimensioni pagina di 16 KB

Le dimensioni della pagina sono la granularità con cui un sistema operativo gestisce la memoria. La maggior parte delle CPU attuali supporta una dimensione di pagina di 4 KB, pertanto il sistema operativo Android e le app sono stati storicamente creati e ottimizzati per essere eseguiti con una dimensione di pagina di 4 KB. Le CPU ARM supportano le dimensioni delle pagine più grandi da 16 KB e, a partire da Android 15, AOSP supporta anche la creazione di Android con una dimensione delle pagine di 16 KB. Questa opzione utilizza memoria aggiuntiva, ma migliora le prestazioni del sistema. A partire da Android 15, questa opzione non è attivata per impostazione predefinita, ma è disponibile come modalità sviluppatore o opzione sviluppatore per OEM e sviluppatori di app per prepararsi al passaggio alla modalità a 16 kB in futuro.

Android 15 e versioni successive supportano la creazione di Android con un allineamento ELF di 16 KB, che funziona con kernel da 4 KB e 16 KB a partire da android14-6.1. Se utilizzata con un kernel da 16 KB, questa configurazione utilizza memoria aggiuntiva, ma migliora le prestazioni del sistema.

Imposta Android su 16 kB

Le pagine da 16 KB sono supportate solo sulle destinazioni arm64 con kernel da 16 KB. Tuttavia, esiste anche un'opzione per simulare lo spazio utente di 16 KB su x86_64 per Cuttlefish.

Spazio del kernel

Per le destinazioni arm64, se utilizzi Kleaf per creare il kernel, --page_size=16k crea il kernel in modalità a 16 KB. Se utilizzi direttamente la configurazione del kernel Linux, puoi selezionare pagine da 16 KB impostando CONFIG_ARM64_16K_PAGES anziché CONFIG_ARM64_4K_PAGES.

Spazio utente

Per attivare il supporto delle dimensioni delle pagine di 16 kB nello spazio utente Android, imposta le seguenti opzioni di build sul tuo prodotto:

  • PRODUCT_NO_BIONIC_PAGE_SIZE_MACRO := true rimuove la definizione PAGE_SIZE e fa in modo che i componenti determinino le dimensioni della pagina in fase di runtime.
  • PRODUCT_MAX_PAGE_SIZE_SUPPORTED := 16384 che garantisce che i file ELF della piattaforma siano creati con un allineamento di 16 KB. Queste dimensioni maggiori del necessario sono per la compatibilità futura. Con l'allineamento ELF a 16 KB, il kernel può supportare dimensioni delle pagine di 4 KB/16 KB.

Verifica i flag di compilazione

Dopo aver selezionato la destinazione lunch, verifica che i flag di build siano configurati correttamente nell'ambiente:

$ source build/envsetup.sh
$ lunch target

$ get_build_var TARGET_MAX_PAGE_SIZE_SUPPORTED
16384
$ get_build_var TARGET_NO_BIONIC_PAGE_SIZE_MACRO
true

Se i due comandi precedenti restituiscono rispettivamente 16384 e true, i flag di build sono configurati correttamente per funzionare con un kernel di 16 KB. Tuttavia, anche se una build viene superata, potrebbero comunque verificarsi problemi di runtime a causa di differenze in un ambiente di 16 KB.

Programmazione del sistema con dimensioni pagina di 16 kB

La stragrande maggioranza del codice su qualsiasi dispositivo Android non gestisce direttamente le dimensioni della pagina. Tuttavia, per il codice che gestisce le pagine, il comportamento di allocazione della memoria del kernel cambia ed è necessario tenerlo presente per scrivere codice non solo compatibile, ma anche con prestazioni massime e utilizzo minimo delle risorse.

Se chiami mmap su una regione di 1 KB, 2 KB o fino a 4 KB su un sistema a 4 KB, il sistema riserva 4 KB per implementare questa operazione. In altre parole, quando richiede memoria al kernel, quest'ultimo deve sempre arrotondare la memoria richiesta alla dimensione di pagina più vicina. Ad esempio, se allochi una regione di 5 KB su una regione di 4 KB, il kernel alloca 8 KB.

In un kernel da 16 KB, queste "code" aggiuntive delle pagine sono più grandi. Ad esempio, tutte queste allocazioni, da 1 KB a 5 KB, allocano 16 KB se utilizzate con un kernel da 16 KB. Se richiedi 17 KB, vengono allocati 32 KB.

Ad esempio, su un sistema da 4 KB, è possibile allocare due regioni anonime di lettura/scrittura da 4 KB. Tuttavia, su un kernel a 16 KB, ciò comporterebbe l'allocazione di due pagine o 32 KB. Su un kernel da 16 KB, se possibile, queste regioni possono essere combinate in una singola pagina di lettura o scrittura, in modo che vengano utilizzati solo 16 KB, sprecando 8 KB rispetto al caso del kernel da 4 KB. Per ridurre ulteriormente l'utilizzo della memoria, è possibile combinare più pagine. Infatti, in un sistema da 16 KB ottimizzato al massimo, le pagine da 16 KB richiedono meno memoria rispetto ai sistemi da 4 KB perché la tabella delle pagine è un quarto delle dimensioni per la stessa memoria.

Ogni volta che utilizzi mmap, assicurati di arrotondare la dimensione che stai richiedendo al valore più vicino della dimensione della pagina. In questo modo, l'intera quantità di memoria allocata dal kernel è direttamente visibile allo spazio utente nei valori di runtime, anziché essere richiesta implicitamente e accessibile implicitamente o accidentalmente.

Crea librerie condivise con allineamento ELF a 16 KB

Per creare librerie condivise che fanno parte del progetto Android, le impostazioni precedenti in Attiva dimensioni pagina di 16 kB sono sufficienti:

  • PRODUCT_NO_BIONIC_PAGE_SIZE_MACRO := true
  • PRODUCT_MAX_PAGE_SIZE_SUPPORTED := 16384

Per creare librerie condivise che non fanno parte di un progetto Android, devi passare questo flag del linker:

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

Verifica i file binari e i prebuild per l'allineamento ELF a 16 kB

Il modo migliore per verificare l'allineamento e il comportamento di runtime è testare ed eseguire un kernel compilato da 16 KB. Tuttavia, per rilevare alcuni problemi in anticipo:

  • A partire da Android 16, puoi impostare PRODUCT_CHECK_PREBUILT_MAX_PAGE_SIZE := true al momento della compilazione. Utilizza ignore_max_page_size: true in Android.bp e LOCAL_IGNORE_MAX_PAGE_SIZE := true in Android.mk per ignorarli temporaneamente. Queste impostazioni verificano tutti i prebuilt e ti consentono di rilevare quando uno viene aggiornato ma non è allineato a 16 KB.

  • Puoi eseguire atest elf_alignment_test, che verifica l'allineamento dei file ELF sul dispositivo sui dispositivi lanciati con Android 15 e versioni successive.