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.

Usar ftrace

ftrace es una herramienta de depuración para comprender lo que sucede dentro del Kernel de Linux En las siguientes secciones, se detalla la funcionalidad básica de ftrace, ftrace con atrace (que captura eventos del kernel) y ftrace dinámico.

Para obtener detalles sobre la funcionalidad avanzada de ftrace que no está disponible en Systrace, consulta la documentación de ftrace en <kernel tree>/Documentation/trace/ftrace.txt

Cómo capturar eventos del kernel con atrace

atrace (frameworks/native/cmds/atrace) usa ftrace para capturar eventos de kernel. A su vez, systrace.py (o run_systrace.py en versiones posteriores de Catapult) usa adb. para ejecutar atrace en el dispositivo. atrace hace lo siguiente:

Configura una propiedad para configurar el seguimiento en modo de usuario. (debug.atrace.tags.enableflags).
Habilita la funcionalidad de ftrace deseada escribiendo en el nombre de ftrace sysfs. Sin embargo, como ftrace admite más funciones, puedes establecer algunos nodos sysfs, luego, usa atrace.

A excepción del seguimiento durante el inicio, usa atrace para establecer la al valor adecuado. La propiedad es una máscara de bits y no hay manera de determinar los valores correctos, no solo mediante el encabezado adecuado (que podría cambiar entre las versiones de Android).

Habilitar eventos de ftrace

Los nodos ftrace sysfs están en /sys/kernel/tracing y realizan seguimiento los eventos se dividen en categorías en /sys/kernel/tracing/events.

Para habilitar eventos por categoría, usa lo siguiente:

echo 1 > /sys/kernel/tracing/events/irq/enable

Para habilitar eventos por evento, usa lo siguiente:

echo 1 > /sys/kernel/tracing/events/sched/sched_wakeup/enable

Si se han habilitado eventos adicionales escribiendo en nodos sysfs, estos no puede restablecerse con atrace. Un patrón común para la introducción de dispositivos Qualcomm es habilitar kgsl (GPU) y mdss (canalización de muestra) puntos de seguimiento y, luego, usa atrace o Systrace:

adb shell "echo 1 > /sys/kernel/tracing/events/mdss/enable"
adb shell "echo 1 > /sys/kernel/tracing/events/kgsl/enable"
./systrace.py sched freq idle am wm gfx view binder_driver irq workq ss sync -t 10 -b 96000 -o full_trace.html

También puedes usar ftrace sin atrace o systrace, que es útil cuando quieres seguimientos solo de kernel (o si te tomaste el tiempo para escribir la propiedad de seguimiento de modo de usuario manualmente). Para ejecutar solo ftrace, haz lo siguiente:

Configura el tamaño del búfer en un valor lo suficientemente grande para el seguimiento:
```
echo 96000 > /sys/kernel/tracing/buffer_size_kb
```

Habilita el seguimiento:

echo 1 > /sys/kernel/tracing/tracing_on

Ejecuta la prueba y, luego, inhabilita el seguimiento:
```
echo 0 > /sys/kernel/tracing/tracing_on
```

Vuelca el registro:

cat /sys/kernel/tracing/trace > /data/local/tmp/trace_output

trace_output proporciona el registro en forma de texto. Para visualizarlos usando Con la catapulta, toma el Catapult desde GitHub y ejecuta trace2html:

catapult/tracing/bin/trace2html ~/path/to/trace_file

De forma predeterminada, esto escribe trace_file.html en la misma .

Correlaciona eventos

A menudo, resulta útil observar la visualización de Catapult y la función ftrace registrar simultáneamente; por ejemplo, algunos eventos ftrace (especialmente específicos del proveedor uno) no se visualizan con Catapult. Sin embargo, las marcas de tiempo de Catapult en relación con el primer evento del seguimiento o con una marca de tiempo específica atrace se vuelcan, mientras que las marcas de tiempo de ftrace sin procesar se basan en un fuente de reloj absoluta en el kernel de Linux.

Para encontrar un evento ftrace determinado a partir de un evento Catapult:

Abre el registro ftrace sin procesar. Los seguimientos en versiones recientes de Systrace son se comprime de forma predeterminada:
- Si capturaste tu Systrace con --no-compress, este se encuentra en el archivo html en la sección que comienza con COMENZAR TRACE.
- De lo contrario, ejecuta html2trace desde Catapult árbol (tracing/bin/html2trace) para descomprimir el seguimiento.
Busca la marca de tiempo relativa en la visualización de Catapult.
Busca una línea al comienzo del seguimiento que contenga tracing_mark_sync Debería ser similar a lo siguiente:
```
<5134>-5134  (-----) [003] ...1    68.104349: tracing_mark_write: trace_event_clock_sync: parent_ts=68.104286
```
Si esta línea no existe (o si usaste ftrace sin atrace), entonces los tiempos serán relativos al primer evento en el registro de ftrace.
1. Agrega la marca de tiempo relativa (en milisegundos) al valor en parent_ts (en segundos).
2. Busca la nueva marca de tiempo.

Estos pasos deberían posicionarte en el evento (o, al menos, muy cerca de él).

Cómo usar ftrace dinámico

Cuando Systrace y ftrace estándar no son suficientes, hay un último recurso disponible: dynamic ftrace. El ftrace dinámico incluye la reescritura código del kernel después del inicio y, como resultado, no está disponible en la producción kernels por motivos de seguridad. Sin embargo, cada error de rendimiento difícil en Entre 2015 y 2016, se usó ftrace dinámico. Es especialmente potente para depurar suspensiones sin interrupciones porque puedes obtener un seguimiento de pila en el kernel cada vez que presionas la función que activa la suspensión sin interrupciones. También puedes depurar secciones con interrupciones y interrupciones inhabilitadas, serán muy útiles para demostrar problemas.

Para activar ftrace dinámico, edita la defconfig de tu kernel:

Quita CONFIG_STRICT_MEMORY_RWX (si está presente). Si tienes la versión 3.18 o más nueva y arm64, no está allí.
Agrega lo siguiente: CONFIG_DYNAMIC_FTRACE=y, CONFIG_FUNCTION_TRACER=y, CONFIG_IRQSOFF_TRACER=y, CONFIG_FUNCTION_PROFILER=y y CONFIG_PREEMPT_TRACER=y
Vuelve a compilar e inicia el kernel nuevo.
Ejecuta el siguiente comando para buscar rastreadores disponibles:
```
cat /sys/kernel/tracing/available_tracers
```
Confirma que el comando muestre function, irqsoff. preemptoff y preemptirqsoff.

Ejecuta el siguiente comando para asegurarte de que ftrace dinámico funcione:

cat /sys/kernel/tracing/available_filter_functions | grep <a function you care about>

Luego de completar estos pasos, tendrás ftrace dinámico, el generador de perfiles de funciones, el generador de perfiles irqsoff y el generador de perfiles de interrupción disponible. Nosotros sólidamente recomienda que leas la documentación de ftrace sobre estos temas antes de ya que son potentes pero complejas. irqsoff y preventoff son principalmente útiles para confirmar que los conductores pueden estar dejando interrupciones o interrupciones se desactivó demasiado tiempo.

El generador de perfiles de funciones es la mejor opción para los problemas de rendimiento y, a menudo, que se usa para averiguar dónde se llama a una función.

Mostrar problema: foto HDR + visor giratorio

En este problema, se usa un Pixel XL para tomar una foto con HDR+ y, luego, rotar el visor causaba bloqueos cada vez. Usamos el generador de perfiles de funciones para depurar el problema en menos de una hora. Para seguir con el ejemplo, descargar el archivo ZIP de los seguimientos (que también incluye otros seguimientos a los que se hace referencia en esta sección), descomprime el archivo y abre la trace_30898724.html en el navegador.

El seguimiento muestra varios subprocesos bloqueados en el proceso cameraserver suspensión sin interrupciones en ion_client_destroy. Es un pero debería llamarse con muy poca frecuencia, ya que los clientes ion que abarcan muchas asignaciones. Al principio, la culpa era del código Hexágono en Halide, una de las culpables, creó un cliente nuevo para cada de iones de iones y destruyó al cliente cuando se liberó la asignación, lo que era demasiado caro). Migración a un solo cliente de iones para todos los componentes de Hexagon de datos mejoraron la situación, pero no se solucionó el bloqueo.

En este punto, necesitamos saber quién llama a ion_client_destroy, por lo que es momento de usar el generador de perfiles de funciones:

Como el compilador a veces cambia el nombre de las funciones, confirma ion_client_destroy se encuentra usando lo siguiente:
```
cat /sys/kernel/tracing/available_filter_functions | grep ion_client_destroy
```
Después de confirmar que esté allí, utilízalo como el filtro ftrace:
```
echo ion_client_destroy > /sys/kernel/tracing/set_ftrace_filter
```

Activa el generador de perfiles de funciones:

echo function > /sys/kernel/tracing/current_tracer

Activa los seguimientos de pila cada vez que se llame a una función de filtro:
```
echo func_stack_trace > /sys/kernel/tracing/trace_options
```

Aumenta el tamaño del búfer:

echo 64000 > /sys/kernel/tracing/buffer_size_kb

Activa el registro:
```
echo 1 > /sys/kernel/tracing/trace_on
```

Ejecuta la prueba y obtén el registro:

cat /sys/kernel/tracing/trace > /data/local/tmp/trace

Visualiza el seguimiento para ver montones de seguimientos de pila:

    cameraserver-643   [003] ...1    94.192991: ion_client_destroy <-ion_release
    cameraserver-643   [003] ...1    94.192997: <stack trace>
 => ftrace_ops_no_ops
 => ftrace_graph_call
 => ion_client_destroy
 => ion_release
 => __fput
 => ____fput
 => task_work_run
 => do_notify_resume
 => work_pending

Según la inspección del controlador de iones, podemos ver que ion_client_destroy está recibiendo spam debido a que una función del espacio del usuario se cierra un fd a /dev/ion, no un controlador de kernel aleatorio. Si buscas en la Base de código de Android para \"/dev/ion\", encontramos varios controladores de proveedores haciendo lo mismo que el controlador Hexagon, y la apertura/cierre /dev/ion (crear y destruir un nuevo cliente de iones) cada vez que necesitas una nueva asignación de iones. Cambiarlos a uso en un único cliente de ion durante la vida útil del proceso corrigió el error.

Si los datos del generador de perfiles de funciones no son lo suficientemente específicos, puedes combinarlos ftracepoints con el generador de perfiles de funciones. los eventos de ftrace pueden habilitarse como de costumbre y se intercalarán con tu registro. Esto es muy útil si hay un sueño largo y ocasional en un período específico función que quieres depurar: establece el filtro ftrace en la función que desees habilitar puntos de seguimiento, hacer un seguimiento. Puedes analizar el seguimiento resultante con trace2html, encuentra el evento que deseas y, luego, obtén seguimientos de pila cercanos en el seguimiento sin procesar.

Cómo usar la estadística de bloqueo

A veces, ftrace no es suficiente y debes depurar lo que parece contención de bloqueo de kernel. Hay una opción más de kernel que vale la pena probar: CONFIG_LOCK_STAT Este es un último recurso, ya que es muy difícil de poner en funcionamiento en dispositivos Android, ya que aumenta el tamaño más allá de lo que pueden manejar la mayoría de los dispositivos.

Sin embargo, Lockstat usa el modelo de bloqueando la infraestructura, que es útil para muchas otras apps. Todos Cuando trabajas con la carga del dispositivo, deberías encontrar la manera de hacer que esa opción funcione. en todos los dispositivos, ya que habrá algún momento en que pienses "Si tan solo pudiera activar LOCK_STAT, podría confirmar o refutar esto como el problema en cinco minutos en lugar de cinco días".

Mostrar problema: Se detiene en SCHED_FIFO cuando los núcleos en la carga máxima con valores que no son SCHED_FIFO.

En este problema, el subproceso SCHED_FIFO se detuvo cuando todos los núcleos alcanzaron el máximo. se cargan con subprocesos que no son de SCHED_FIFO. Había rastros que mostraban un bloqueo significativo la contención en una fd en aplicaciones de RV, pero no pudimos identificar con facilidad la fd en uso. Para seguir con el ejemplo, descarga el archivo ZIP archivo de seguimientos (que también incluye otros seguimientos a los que se hace referencia en esta descomprime el archivo y abre el archivo trace_30905547.html en el navegador.

Nuestra hipótesis fue que ftrace en sí era la fuente de la contención de bloqueo, cuando de prioridad baja empezaría a escribir en el canal de ftrace y, luego, obtendría antes de poder liberar la cerradura. Esta es la peor situación que se vio exacerbada por una mezcla de subprocesos de prioridad muy baja que escriben el marcador de ftrace junto con algunos subprocesos de mayor prioridad que giran en las CPU para simular un dispositivo completamente cargado.

Como no pudimos usar ftrace para depurar, LOCK_STAT funciona. y, luego, desactivaste todos los demás registros de la app. Los resultados mostraron el candado la contención era en realidad de ftrace porque ninguna de ellas apareció en el seguimiento de bloqueo cuando no se estaba ejecutando ftrace.

Si puedes iniciar un kernel con la opción de configuración, el seguimiento de bloqueo es similar a ftrace:

Habilita el seguimiento:
```
echo 1 > /proc/sys/kernel/lock_stat
```
Ejecuta la prueba.
Inhabilita el seguimiento:
```
echo 0 > /proc/sys/kernel/lock_stat
```

Vuelca el registro:

cat /proc/lock_stat > /data/local/tmp/lock_stat

Para obtener ayuda en la interpretación del resultado resultante, consulta la documentación de Lockstat en <kernel>/Documentation/locking/lockstat.txt.

Usar puntos de seguimiento del proveedor

Usa puntos de seguimiento ascendentes primero, aunque a veces deberás usar puntos de seguimiento del proveedor:

  { "gfx",        "Graphics",         ATRACE_TAG_GRAPHICS, {
        { OPT,      "events/mdss/enable" },
        { OPT,      "events/sde/enable" },
        { OPT,      "events/mali_systrace/enable" },
    } },

El servicio de HAL puede extender los puntos de seguimiento, lo que te permite agregar un seguimiento específico del dispositivo. puntos/categorías. Los puntos de seguimiento están integrados en perfetto, atrace/systrace y en el sistema integrado en el dispositivo app de seguimiento de conversiones.

Las APIs para implementar puntos de seguimiento o categorías son las siguientes:

listCategories() genera (vec<TracingCategory>>).
enableCategories(vec<string> categories) genera (Estado de estado);
inhabilitarAllCategories() genera (estado de estado);

Para obtener más información, consulta la definición y la implementación predeterminada de HAL en AOSP: