Te recomendamos que automatices la generación de reglas de perfil con la biblioteca de Jetpack Macrobenchmark para reducir el esfuerzo manual y aumentar la escalabilidad general. Sin embargo, es posible crear y medir de forma manual las reglas de perfil en tu app.
Cómo definir manualmente reglas de perfil
Puedes definir manualmente reglas de perfil en una app o un módulo de biblioteca. Para ello, crea un archivo llamado baseline-prof.txt
ubicado en el directorio src/main
. Esta es la misma carpeta que contiene el archivo AndroidManifest.xml
.
El archivo especifica una regla por línea. Cada regla representa un patrón para buscar coincidencias de métodos o clases en la app o biblioteca que se debe optimizar.
La sintaxis de estas reglas es un superconjunto del formato de perfil de ART legible por humanos (HRF) cuando se usa adb shell profman --dump-classes-and-methods
. La sintaxis es similar a la sintaxis para descriptores y firmas, pero permite usar comodines para simplificar el proceso de escritura de reglas.
En los siguientes ejemplos, se muestran algunas reglas del Perfil de Baseline que se incluyen en la biblioteca de Jetpack Compose:
HSPLandroidx/compose/runtime/ComposerImpl;->updateValue(Ljava/lang/Object;)V
HSPLandroidx/compose/runtime/ComposerImpl;->updatedNodeCount(I)I
HLandroidx/compose/runtime/ComposerImpl;->validateNodeExpected()V
PLandroidx/compose/runtime/CompositionImpl;->applyChanges()V
HLandroidx/compose/runtime/ComposerKt;->findLocation(Ljava/util/List;I)I
Landroidx/compose/runtime/ComposerImpl;
Puedes intentar modificar las reglas de perfil en este ejemplo de Compiler Explorer proyecto. Ten en cuenta que solo el Explorador de compiladores admite el formato de perfil de ART legible por humanos (HRF), por lo que no se deben usar comodines no es compatible.
Sintaxis de reglas
Estas reglas adoptan una de dos formas para referirse a métodos o clases.
[FLAGS][CLASS_DESCRIPTOR]->[METHOD_SIGNATURE]
Una regla de clase usa el siguiente patrón:
[CLASS_DESCRIPTOR]
Consulta la siguiente tabla para obtener una descripción detallada:
Sintaxis | Descripción |
---|---|
FLAGS |
Representa uno o más de los caracteres H , S y P para indicar si este método debe marcarse como Hot , Startup o Post Startup en relación con el tipo de inicio. Un método con la marca H indica que es un método "caliente", lo que significa que se lo llama muchas veces durante la vida útil de la app. Un método con la marca S indica que es un método al que se llama durante el inicio. Un método con la marca P indica que es un método al que se llama después del inicio. Una clase presente en este archivo indica que se usa durante el inicio y debe asignarse previamente en el montón para evitar el costo de cargarla. El compilador de ART utiliza varias estrategias de optimización, como la compilación AOT de estos métodos y la optimización de diseños en el archivo AOT generado. |
CLASS_DESCRIPTOR |
Es el descriptor de la clase del método al que se hace referencia. Por ejemplo, androidx.compose.runtime.SlotTable tiene un descriptor de Landroidx/compose/runtime/SlotTable; . L está precedido por el formato ejecutable Dalvik (DEX). |
METHOD_SIGNATURE |
Firma del método, incluidos el nombre, los tipos de parámetros y los tipos de datos que se devuelven del método. Por ejemplo:// LayoutNode.kt fun isPlaced():Boolean { // ... } en LayoutNode tiene la firma isPlaced()Z . |
Estos patrones pueden tener comodines para tener una sola regla que abarque varios métodos o clases. Si deseas obtener asistencia guiada cuando escribas con la sintaxis de reglas en Android Studio, consulta el complemento de Perfiles de Baseline para Android.
Un ejemplo de una regla de comodín podría verse de la siguiente manera:
HSPLandroidx/compose/ui/layout/**->**(**)**
Tipos admitidos en reglas de Perfil de Baseline
Las reglas del Perfil de Baseline admiten los siguientes tipos. Si deseas obtener información detallada sobre estos tipos, consulta el formato ejecutable Dalvik (DEX).
Carácter | Tipo | Descripción |
---|---|---|
B |
byte | Byte firmado |
C |
char | Punto de código de caracteres Unicode codificado en UTF-16 |
D |
double | Valor de punto flotante de doble precisión |
F |
float | Valor de punto flotante de precisión simple |
I |
int | Entero |
J |
long | Entero largo |
S |
short | Entero corto firmado |
V |
void | Nulo |
Z |
boolean | Verdadero o falso |
L (nombre de clase) |
reference | Una instancia de un nombre de clase |
Además, las bibliotecas pueden definir reglas que se empaquetan en artefactos de AAR. Cuando compilas un APK para incluir estos artefactos, las reglas se combinan (de manera similar a como se realiza la combinación de manifiestos) y se compilan en un perfil de ART binario compacto que es específico del APK.
ART aprovecha este perfil cuando se usa el APK en los dispositivos para compilar a través de AOT un subconjunto específico de la aplicación al momento de la instalación en Android 9 (nivel de API 28) o Android 7 (nivel de API 24) cuando se usa ProfileInstaller
.
Cómo recopilar perfiles de Baseline de forma manual
Puedes generar un Perfil de Baseline de forma manual sin configurar la biblioteca de Macrobenchmark ni crear automatizaciones de la IU de tus recorridos críticos del usuario. Si bien recomendamos el uso de macrocomparativas, es posible que no siempre sea posible. Por ejemplo, si usas un sistema de compilación que no es de Gradle, no puedes usar el complemento de Gradle para perfiles de Baseline. En esos casos, puedes recopilar de forma manual las reglas del Perfil de Baseline. Esto es mucho más fácil si usas un dispositivo o emulador con el nivel de API 34 o superior. Si bien es posible con niveles de API inferiores, se requiere acceso raíz y debes usar un emulador que ejecute una imagen del AOSP. Puedes recopilar reglas directamente si haces lo siguiente:
- Instala una versión de actualización de tu app en un dispositivo de prueba. El tipo de compilación de la app debe estar optimizado para R8 y no debe ser depurable para lograr un perfil preciso.
- Asegúrate de que los perfiles no estén ya compilados.
Nivel de API 34 y niveles superiores
adb shell cmd package compile -f -m verify $PACKAGE_NAME adb shell pm art clear-app-profiles $PACKAGE_NAME
Nivel de API 33 y niveles inferiores
adb root adb shell cmd package compile --reset $PACKAGE_NAME
Si tu APK tiene una dependencia en la biblioteca de Profile Installer de Jetpack, esta biblioteca inicia un perfil en el primer inicio del APK. Esto puede interferir en el proceso de generación de perfiles, por lo que debes inhabilitarlo con el siguiente comando:
adb shell am broadcast -a androidx.profileinstaller.action.SKIP_FILE $PACKAGE_NAME/androidx.profileinstaller.ProfileInstallReceiver
- Ejecuta la app y navega de forma manual por los recorridos críticos del usuario para los que quieres recopilar un perfil.
- Indica a ART que vuelque los perfiles. Si tu APK tiene una dependencia en la biblioteca de Profile Installer de Jetpack, úsala para volcar los perfiles:
adb shell am broadcast -a androidx.profileinstaller.action.SAVE_FILE $PACKAGE_NAME/androidx.profileinstaller.ProfileInstallReceiver adb shell am force-stop $PACKAGE_NAME
Si no usas Profile Installer, vuelca los perfiles manualmente en una emulador con el siguiente comando:adb root adb shell killall -s SIGUSR1 $PACKAGE_NAME adb shell am force-stop $PACKAGE_NAME
- Espera al menos cinco segundos para permitir que se complete la generación de perfiles.
- Convierte en texto los perfiles binarios que se generan:
Nivel de API 34 y niveles superiores
adb shell pm dump-profiles --dump-classes-and-methods $PACKAGE_NAME
Nivel de API 33 y niveles inferiores
Determina si se creó un perfil de referencia o un perfil actual. Un perfil de referencia se encuentra en la siguiente ubicación:
/data/misc/profiles/ref/$$PACKAGE_NAME/primary.prof
Un perfil actual se encuentra en la siguiente ubicación:
/data/misc/profiles/cur/0/$PACKAGE_NAME/primary.prof
Determina la ubicación del APK:
adb root adb shell pm path $PACKAGE_NAME
Realiza la conversión:
adb root adb shell profman --dump-classes-and-methods --profile-file=$PROFILE_PATH --apk=$APK_PATH > /data/misc/profman/$PACKAGE_NAME-primary.prof.txt
- Usa
adb
para recuperar el perfil volcado del dispositivo:adb pull /data/misc/profman/$PACKAGE_NAME-primary.prof.txt PATH_TO_APP_MODULE/src/main/
Esto extrae las reglas de perfil generadas y las instala en el módulo de tu app. La próxima vez que compiles la app, se incluirá el Perfil de Baseline. Para verificar esto, sigue los pasos que se indican en Problemas de instalación.
Cómo medir manualmente las mejoras de la app
Te recomendamos que uses comparativas para medir las mejoras de la app. Sin embargo, si deseas medir las mejoras de forma manual, puedes comenzar por medir el inicio de la app no optimizado como referencia.
PACKAGE_NAME=com.example.app
# Force Stop App adb shell am force-stop $PACKAGE_NAME # Reset compiled state adb shell cmd package compile --reset $PACKAGE_NAME
# Measure App startup # This corresponds to `Time to initial display` metric. adb shell am start-activity -W -n $PACKAGE_NAME/.ExampleActivity \ | grep "TotalTime"
A continuación, transfiere el Perfil de Baseline.
# Unzip the Release APK first. unzip release.apk
# Create a ZIP archive. # The name should match the name of the APK. # Copy `baseline.prof{m}` and rename it `primary.prof{m}`. cp assets/dexopt/baseline.prof primary.prof cp assets/dexopt/baseline.profm primary.profm
# Create an archive. zip -r release.dm primary.prof primary.profm
# Confirm that release.dm only contains the two profile files: unzip -l release.dm # Archive: release.dm # Length Date Time Name # --------- ---------- ----- ---- # 3885 1980-12-31 17:01 primary.prof # 1024 1980-12-31 17:01 primary.profm # --------- ------- # 2 files
# Install APK + Profile together. adb install-multiple release.apk release.dm
Para verificar si el paquete se optimizó durante la instalación, ejecuta el siguiente comando:
# Check dexopt state.
adb shell dumpsys package dexopt | grep -A 1 $PACKAGE_NAME
El resultado debe indicar que el paquete está compilado:
[com.example.app]
path: /data/app/~~YvNxUxuP2e5xA6EGtM5i9A==/com.example.app-zQ0tkJN8tDrEZXTlrDUSBg==/base.apk
arm64: [status=speed-profile] [reason=install-dm]
Ahora, puedes medir el rendimiento del inicio de la app como antes, pero sin restablecer el estado compilado. Asegúrate de no restablecer el estado compilado del paquete.
# Force stop app adb shell am force-stop $PACKAGE_NAME
# Measure app startup adb shell am start-activity -W -n $PACKAGE_NAME/.ExampleActivity \ | grep "TotalTime"
Perfiles de Baseline y profgen
En esta sección, se describe lo que hace la herramienta profgen cuando se compila una versión binaria compacta de un perfil de Baseline.
Profgen-cli ayuda con la compilación de perfiles, la introspección y la transpilación de perfiles de ART, por lo que se pueden instalar en dispositivos con Android, independientemente de la versión del SDK de destino.
Profgen-cli es una CLI que compila el HRF de un Perfil de Baseline a su formato compilado. La CLI también se envía al repositorio cmdline-tools
como parte del SDK de Android.
Estas funciones están disponibles en la rama studio-main
:
➜ ../cmdline-tools/latest/bin
apkanalyzer
avdmanager
lint
profgen
retrace
screenshot2
sdkmanager
Cómo crear perfiles binarios compactos con Profgen-cli
Los comandos disponibles con Profgen-cli son bin
, validate
y dumpProfile
. Para ver los comandos disponibles, usa profgen --help
:
➜ profgen --help
Usage: profgen options_list
Subcommands:
bin - Generate Binary Profile
validate - Validate Profile
dumpProfile - Dump a binary profile to a HRF
Options:
--help, -h -> Usage info
Usa el comando bin
para generar el perfil binario compacto. A continuación, se muestra un ejemplo de invocación:
profgen bin ./baseline-prof.txt \
--apk ./release.apk \
--map ./obfuscation-map.txt \
--profile-format v0_1_0_p \
--output ./baseline.prof \
Para ver las opciones disponibles, usa profgen bin options_list
:
Usage: profgen bin options_list
Arguments:
profile -> File path to Human Readable profile { String }
Options:
--apk, -a -> File path to apk (always required) { String }
--output, -o -> File path to generated binary profile (always required)
--map, -m -> File path to name obfuscation map { String }
--output-meta, -om -> File path to generated metadata output { String }
--profile-format, -pf [V0_1_0_P] -> The ART profile format version
{ Value should be one of [
v0_1_5_s, v0_1_0_p, v0_0_9_omr1, v0_0_5_o, v0_0_1_n
]
}
--help, -h -> Usage info
El primer argumento representa la ruta de acceso al HRF baseline-prof.txt
.
Profgen-cli también necesita la ruta de acceso a la compilación de lanzamiento del APK y un mapa de ofuscación que se usa para ofuscar el APK cuando se usa R8 o ProGuard. De esta manera, profgen
puede traducir símbolos de origen en el HRF a sus nombres ofuscados correspondientes cuando se compila el perfil compilado.
Debido a que los formatos de perfiles de ART no son compatibles con versiones anteriores ni posteriores, proporciona un formato de perfil para que profgen
empaquete los metadatos del perfil (profm
) que puedes usar para transcodificar un formato de perfil de ART a otro cuando se requiera.
Formatos de perfil y versiones de plataforma
Las siguientes opciones están disponibles cuando eliges un formato de perfil:
Formato del perfil | Versión de plataforma | Nivel de API |
---|---|---|
v0_1_5_s | Android S+ | 31+ |
v0_1_0_p | Android P, Q y R | 28-30 |
v0_0_9_omr1 | Android O MR1 | 27 |
v0_0_5_o | Android O | 26 |
v0_0_1_n | Android N | 24-25 |
Copia los archivos de salida baseline.prof
y baseline.profm
en la carpeta assets
o dexopt
en el APK.
Mapas de ofuscación
Solo debes proporcionar el mapa de ofuscación si el HRF utiliza símbolos de origen. Si el HRF se genera a partir de una compilación de lanzamiento ya ofuscada y no se requiere asignación, puedes ignorar esa opción y copiar los resultados en la carpeta assets
o dexopt
.
Instalación tradicional de perfiles de Baseline
Tradicionalmente, los perfiles de Baseline se entregan a un dispositivo de una de dos maneras.
Usa install-multiple
con DexMetadata
En los dispositivos que ejecutan la API 28 y versiones posteriores, el cliente de Play descarga el APK y la carga útil de DexMetadata (DM) para la instalación de una versión de APK. El DM contiene la información de perfil que se pasa al Administrador de paquetes del dispositivo.
El APK y el DM se instalan como parte de una sola sesión de instalación usando algo como lo siguiente:
adb install-multiple base.apk base.dm
Jetpack ProfileInstaller
En los dispositivos que ejecutan el nivel de API 29 y versiones posteriores, la biblioteca de Jetpack ProfileInstaller proporciona un mecanismo alternativo para instalar un perfil empaquetado en assets
o dexopt
después de instalar el APK en el dispositivo. ProfileInstallReceiver
o la app invocan directamente a ProfileInstaller
.
La biblioteca de ProfileInstaller transcodifica el perfil según la versión del SDK del dispositivo de destino y lo copia en el directorio cur
del dispositivo (un directorio de etapa de pruebas específico del paquete para los perfiles de ART en el dispositivo).
Una vez que el dispositivo está inactivo, se recoge el perfil a través de un proceso llamado bg-dexopt
en el dispositivo.
Transferencia de un perfil de Baseline
En esta sección, se describe cómo instalar un perfil de Baseline dado un APK.
Transmite con androidx.profileinstaller
En dispositivos que ejecutan el nivel de API 24 y versiones posteriores, puedes transmitir un comando para instalar el perfil:
# Broadcast the install profile command - moves binary profile from assets
# to a location where ART uses it for the next compile.
# When successful, the following command prints "1":
adb shell am broadcast \
-a androidx.profileinstaller.action.INSTALL_PROFILE \
<pkg>/androidx.profileinstaller.ProfileInstallReceiver
# Kill the process
am force-stop <pkg>
# Compile the package based on profile
adb shell cmd package compile -f -m speed-profile <pkg>
ProfileInstaller no está presente en la mayoría de los APKs con perfiles de Baseline, lo que se cumple en alrededor de 77,000 de 450,000 apps en Play, aunque está presente de forma efectiva en todos los APKs que usan Compose. Esto se debe a que las bibliotecas pueden proporcionar perfiles sin declarar una dependencia en ProfileInstaller. Agregar una dependencia en cada biblioteca con un perfil se aplica a partir de Jetpack.
Usa install-multiple
con profgen o DexMetaData
En dispositivos que ejecutan la API 28 y versiones posteriores, puedes transferir un perfil de Baseline sin tener que tener la biblioteca de ProfileInstaller en la app.
Para hacerlo, usa Profgen-cli:
profgen extractProfile \
--apk app-release.apk \
--output-dex-metadata app-release.dm \
--profile-format V0_1_5_S # Select based on device and the preceding table.
# Install APK and the profile together
adb install-multiple appname-release.apk appname-release.dm
Para admitir las divisiones de APK, ejecuta los pasos de extracción de perfiles anteriores una vez por APK. En el momento de la instalación, pasa cada APK y el archivo .dm
asociado para asegurarte de que coincidan el APK y los nombres .dm
:
adb install-multiple appname-base.apk appname-base.dm \
appname-split1.apk appname-split1.dm
Verificación
Para verificar que el perfil esté instalado correctamente, puedes usar los pasos que se indican en Cómo medir de forma manual las mejoras de la app.
Cómo volcar el contenido de un perfil binario
Para examinar el contenido de una versión binaria compacta de un perfil de Baseline, usa la opción dumpProfile
de Profgen-cli:
Usage: profgen dumpProfile options_list
Options:
--profile, -p -> File path to the binary profile (always required)
--apk, -a -> File path to apk (always required) { String }
--map, -m -> File path to name obfuscation map { String }
--strict, -s [true] -> Strict mode
--output, -o -> File path for the HRF (always required) { String }
--help, -h -> Usage info
dumpProfile
necesita el APK, ya que la representación binaria compacta solo almacena desplazamientos DEX y, por lo tanto, los necesita para reconstruir nombres de clases y métodos.
El modo estricto está habilitado de forma predeterminada, lo que realiza una verificación de compatibilidad del perfil de los archivos DEX en el APK. Si intentas depurar perfiles que generó otra herramienta, es posible que obtengas fallas de compatibilidad que te impidan volcar para la investigación. En esos casos, puedes inhabilitar el modo estricto con --strict false
. Sin embargo, en la mayoría de los casos, mantén habilitado el modo estricto.
El mapa de ofuscación es opcional. Cuando se proporciona, ayuda a reasignar los símbolos ofuscados a sus versiones legibles por humanos para facilitar su uso.
Recomendaciones para ti
- Nota: El texto del vínculo se muestra cuando JavaScript está desactivado
- Prácticas recomendadas para el rendimiento de SQLite
- Perfiles de Baseline {:#baseline-profiles}
- Bloqueos de activación sostenidos parciales