Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Se usó la API de Cloud Translation para traducir esta página.

Usa la optimización guiada por perfil

El sistema de compilación de Android para Android 13 y versiones anteriores admite el uso del mecanismo guiado por perfil de Clang Optimización (PGO) en módulos nativos de Android que tengan compilación blueprint las reglas de firewall. En esta página, se describe la PGO de Clang, cómo generar y actualizar continuamente los perfiles usados para la PGO y cómo integrarla con el sistema de compilación (con caso de uso).

Nota: En este documento, se describe el uso de la PGO en la plataforma de Android. Para aprender a usar PGO desde una aplicación para Android, visita esta página.

Información acerca de la PGO de Clang

Clang puede realizar optimizaciones guiadas por perfil mediante dos tipos de perfiles:

Los perfiles basados en instrumentación se generan a partir de un un programa de segmentación instrumentada. Estos perfiles son detallados e imponen un alto la sobrecarga del entorno de ejecución.
Por lo general, los perfiles basados en muestreo los producen para tomar muestras de contadores de hardware. Imponen una sobrecarga baja del entorno de ejecución y se pueden sin ninguna instrumentación ni modificación en el objeto binario. Ellas son menos detallados que los perfiles basados en instrumentación.

Todos los perfiles deben generarse a partir de una carga de trabajo representativa que el comportamiento típico de la app. Si bien Clang admite Basadas en AST (-fprofile-instr-generate) y basadas en IR de LLVM (-fprofile-generate), Android solo admite LLVM basado en IR para PGO basada en instrumentación.

Las siguientes marcas son necesarias para compilar la colección de perfiles:

-fprofile-generate para la instrumentación basada en IR. Con este el backend usa un enfoque de árbol de intervalo mínimo ponderado reducir la cantidad de puntos de instrumentación y optimizar su ubicación para bordes de poco peso (usa también esta opción para el paso de vinculación). El Clang el controlador pasa automáticamente el entorno de ejecución de la generación de perfiles (libclang_rt.profile-arch-android.a) al vinculador. Esta biblioteca contiene rutinas para escribir los perfiles en el disco después del programa. salir.
-gline-tables-only para la recopilación de perfiles basados en muestras para generar información de depuración mínima.

Se puede usar un perfil para PGO con -fprofile-use=pathname o -fprofile-sample-use=pathname para los sistemas basados en instrumentación y los perfiles basados en muestras, respectivamente.

Nota: A medida que se realizan cambios en el código, si Clang no puede por más tiempo los datos de perfil, genera un Advertencia -Wprofile-instr-out-of-date.

Cómo usar la PGO

El uso de la PGO implica los siguientes pasos:

Compila la biblioteca o el ejecutable con instrumentación pasando -fprofile-generate al compilador y al vinculador.
Recopila perfiles ejecutando una carga de trabajo representativa en el binario instrumentado.
Procesa posteriormente los perfiles con la utilidad llvm-profdata Para obtener más información, consulta Cómo manejar LLVM archivos de perfil).
Usa los perfiles para aplicar la PGO pasando -fprofile-use=<>.profdata al compilador y vinculador.

Para la PGO en Android, los perfiles deben recopilarse sin conexión y registrarse junto con el código para garantizar compilaciones reproducibles. Los perfiles se pueden usar como el código evoluciona, pero debe regenerarse de manera periódica (o cuando Clang advierte que los perfiles están inactivos).

Recopila perfiles

Clang puede usar perfiles recopilados mediante la ejecución de comparativas con un compilación instrumentada de la biblioteca o muestreando contadores de hardware cuando se ejecuta una comparativa. Por el momento, Android no admite el uso de modelos colección de perfiles, por lo que debes recopilar los perfiles con una clave compilación:

Identifica una comparativa y el conjunto de bibliotecas que se ejercitan en conjunto con esa comparativa.
Agrega propiedades pgo a las comparativas y a las bibliotecas (más detalles a continuación).
Produce una compilación de Android con una copia instrumentada de estas bibliotecas. usando:
```
make ANDROID_PGO_INSTRUMENT=benchmark
```

benchmark es un marcador de posición que identifica el colección de bibliotecas que se instrumentaron durante la compilación. El representante real de entrada (y posiblemente otro ejecutable que se vincule con una biblioteca que comparativas) no son específicas de la PGO y están fuera del alcance de este .

Escribe en la memoria flash o sincroniza la compilación instrumentada en un dispositivo.
Ejecuta las comparativas para recopilar perfiles.
Usa la herramienta llvm-profdata (que se explica a continuación) para realizar las siguientes acciones: procesar posteriormente los perfiles y prepararlos para registrarlos en la fuente. de imágenes.

Usa perfiles durante la compilación

Revisa los perfiles en toolchain/pgo-profiles en un dispositivo Android de imágenes. El nombre debe coincidir con lo que se especifica en la Subpropiedad profile_file de la propiedad pgo para la biblioteca. El sistema de compilación pasa automáticamente el archivo de perfil a Clang al crear la biblioteca. El ANDROID_PGO_DISABLE_PROFILE_USE variable de entorno se puede establecer en true para inhabilitar temporalmente la PGO y medir su beneficio de rendimiento

Para especificar directorios de perfil específicos de productos adicionales, agrégalos a la variable Make de PGO_ADDITIONAL_PROFILE_DIRECTORIES en un BoardConfig.mk Si se especifican rutas adicionales, los perfiles en estas rutas de acceso anulan las de toolchain/pgo-profiles.

Cuando se genera una imagen de versión con el destino dist, haz lo siguiente: make, el sistema de compilación escribe los nombres de los archivos de perfil faltantes. a $DIST_DIR/pgo_profile_file_missing.txt. Puedes comprobar esto para ver los archivos de perfil que se soltaron accidentalmente (lo cual, inhabilita la PGO).

Habilita la PGO en archivos Android.bp

Si deseas habilitar la PGO en archivos Android.bp para módulos nativos, simplemente haz lo siguiente: especifica la propiedad pgo. Esta propiedad tiene lo siguiente: subpropiedades:

Propiedad	Descripción
`instrumentation`	Se establece en `true` para la PGO con instrumentación. La configuración predeterminada es `false`
`sampling`	Configúralo en `true` para la PGO con el muestreo. La configuración predeterminada es `false`
`benchmarks`	Lista de cadenas. Este módulo está diseñado para la generación de perfiles de la lista se especifica en la compilación `ANDROID_PGO_INSTRUMENT` de 12 a 1 con la nueva opción de compresión.
`profile_file`	Archivo de perfil (relativo a `toolchain/pgo-profile`) que se usará con la PGO. La compilación advierte que este archivo no existe; para ello, agrega lo siguiente: archivo a `$DIST_DIR/pgo_profile_file_missing.txt` a menos que la propiedad `enable_profile_use` se establezca en `false` O La variable de compilación `ANDROID_PGO_NO_PROFILE_USE` se estableció en `true`
`enable_profile_use`	Se establece en `false` si no se deben usar perfiles durante compilar. Se puede usar durante el arranque para habilitar la recopilación de perfiles o para inhabilitar temporalmente la PGO El valor predeterminado es `true`.
`cflags`	Lista de marcas adicionales para usar durante una compilación instrumentada.

Ejemplo de un módulo con PGO:

cc_library {
    name: "libexample",
    srcs: [
        "src1.cpp",
        "src2.cpp",
    ],
    static: [
        "libstatic1",
        "libstatic2",
    ],
    shared: [
        "libshared1",
    ]
    pgo: {
        instrumentation: true,
        benchmarks: [
            "benchmark1",
            "benchmark2",
        ],
        profile_file: "example.profdata",
    }
}

Si las comparativas benchmark1 y benchmark2 comportamiento representativo de ejercicio para las bibliotecas libstatic1 libstatic2 o libshared1, el pgo de estas bibliotecas también pueden incluir comparativas. El El módulo defaults de Android.bp puede incluir un La especificación pgo para un conjunto de bibliotecas que evita que se repita el las mismas reglas de compilación para varios módulos.

Para seleccionar diferentes archivos de perfil o inhabilitar de manera selectiva la PGO para una de Terraform, especifica el profile_file enable_profile_use y cflags propiedades por arquitectura. Ejemplo (con el objetivo de arquitectura en negrita):

cc_library {
    name: "libexample",
    srcs: [
          "src1.cpp",
          "src2.cpp",
    ],
    static: [
          "libstatic1",
          "libstatic2",
    ],
    shared: [
          "libshared1",
    ],
    pgo: {
         instrumentation: true,
         benchmarks: [
              "benchmark1",
              "benchmark2",
         ],
    }

    target: {
         android_arm: {
              pgo: {
                   profile_file: "example_arm.profdata",
              }
         },
         android_arm64: {
              pgo: {
                   profile_file: "example_arm64.profdata",
              }
         }
    }
}

Para resolver referencias a la biblioteca de entorno de ejecución de generación de perfiles durante generación de perfiles basada en instrumentación, pasa la marca de compilación -fprofile-generate al vinculador Bibliotecas estáticas instrumentadas con PGO, todas las bibliotecas compartidas y cualquier objeto binario que depende directamente del también debe estar instrumentada para la PGO. Sin embargo, estas imágenes los ejecutables o las bibliotecas no necesitan usar perfiles PGO, y sus La propiedad enable_profile_use se puede establecer como false. Fuera de esta restricción, puedes aplicar la PGO a cualquier biblioteca estática, una biblioteca o un ejecutable.

Cómo controlar archivos de perfil de LLVM

La ejecución de una biblioteca instrumentada o ejecutable genera un archivo de perfil. llamado default_unique_id_0.profraw en /data/local/tmp (donde unique_id es un valor de un hash numérico único de esta biblioteca). Si este archivo ya existe, el entorno de ejecución de la generación de perfiles combina el perfil nuevo con el anterior mientras se escribe los perfiles. Ten en cuenta que la app no puede acceder a /data/local/tmp desarrolladores; deberían usar en algún lugar como /storage/emulated/0/Android/data/packagename/files en su lugar. Para cambiar la ubicación del archivo de perfil, configura LLVM_PROFILE_FILE variable de entorno en el entorno de ejecución.

El llvm-profdata se usa para convertir el archivo .profraw (y, posiblemente, combinar varios archivos .profraw) en una .profdata archivo:

  llvm-profdata merge -output=profile.profdata <.profraw and/or .profdata files>

profile.profdata se puede registrar en la fuente. para usarlo durante la compilación.

Si se cargan varios objetos binarios o bibliotecas instrumentados durante una comparativa cada biblioteca genera un archivo .profraw separado con un bloque o un ID único. Por lo general, todos estos archivos pueden combinarse en un solo .profdata y se usa para la compilación de la PGO. En los casos en que una biblioteca otra comparativa, esa biblioteca se debe optimizar con perfiles de ambas comparativas. En este caso, show la opción de llvm-profdata es útil:

  llvm-profdata merge -output=default_unique_id.profdata default_unique_id_0.profraw
llvm-profdata show -all-functions default_unique_id.profdata

Para asignar elementos unique_id a bibliotecas individuales, busca El resultado de show para cada unique_id de un nombre de función que es exclusiva de la biblioteca.

Caso de éxito: PGO para ART

En el caso de éxito, se presenta ART como ejemplo con el que se pueden identificar. Sin embargo, no una descripción precisa del conjunto real de bibliotecas perfiladas para ART o sus interdependencias.

El compilador anticipado dex2oat en ART depende de lo siguiente: libart-compiler.so, que a su vez depende de libart.so El tiempo de ejecución de ART se implementa principalmente en libart.so Se mostrarán las comparativas para el compilador y el tiempo de ejecución diferentes:

Benchmark	Bibliotecas perfiladas
`dex2oat`	`dex2oat` (ejecutable), `libart-compiler.so`, `libart.so`
`art_runtime`	`libart.so`

Agrega la siguiente propiedad pgo a dex2oat: libart-compiler.so:

    pgo: {
        instrumentation: true,
        benchmarks: ["dex2oat",],
        profile_file: "dex2oat.profdata",
    }

Agrega la siguiente propiedad pgo a libart.so:

    pgo: {
        instrumentation: true,
        benchmarks: ["art_runtime", "dex2oat",],
        profile_file: "libart.profdata",
    }

Crear compilaciones instrumentadas para dex2oat y Comparativas de art_runtime según:

    make ANDROID_PGO_INSTRUMENT=dex2oat
    make ANDROID_PGO_INSTRUMENT=art_runtime

De manera alternativa, crea una única compilación instrumentada con todas las bibliotecas instrumentado con:

    make ANDROID_PGO_INSTRUMENT=dex2oat,art_runtime
    (or)
    make ANDROID_PGO_INSTRUMENT=ALL

El segundo comando compila todos los módulos habilitados para PGO para la generación de perfiles.

Ejecuta las comparativas que ejecutan dex2oat y art_runtime para obtener:
- Tres archivos .profraw de dex2oat (dex2oat_exe.profdata, dex2oat_libart-compiler.profdata y dexeoat_libart.profdata), identificados con el método se describe en Cómo administrar perfiles de LLVM archivos.
- Un solo art_runtime_libart.profdata.

Genera un archivo profdata común para el archivo ejecutable dex2oat y libart-compiler.so usando:

llvm-profdata merge -output=dex2oat.profdata \
    dex2oat_exe.profdata dex2oat_libart-compiler.profdata

Combina los perfiles para obtener el perfil de libart.so de las dos comparativas:
```
llvm-profdata merge -output=libart.profdata \
    dex2oat_libart.profdata art_runtime_libart.profdata
```
Es posible que los recuentos sin procesar de libart.so de los dos perfiles sean los siguientes: dispares porque las comparativas difieren en la cantidad de casos de prueba y durante el cual se ejecutaron. En este caso, puedes usar una combinación ponderada:
```
llvm-profdata merge -output=libart.profdata \
    -weighted-input=2,dex2oat_libart.profdata \
    -weighted-input=1,art_runtime_libart.profdata
```
El comando anterior asigna el doble de peso al perfil desde dex2oat El peso real se debe determinar en función del dominio. conocimiento o experimentación.
Revisa los archivos de perfil dex2oat.profdata y libart.profdata en toolchain/pgo-profiles para usar durante la compilación.