Depuración de hits de caché remota para ejecución remota

Nightly · 9.0 · 8.6 · 8.5 · 8.4 · 8.3 · 8.2 · 7.7

En esta página, se describe cómo verificar tu tasa de aciertos de caché y cómo investigar los errores de caché en el contexto de la ejecución remota.

En esta página, se supone que tienes una compilación o prueba que utiliza correctamente la ejecución remota y que deseas asegurarte de usar la caché remota de manera eficaz.

Cómo verificar tu tasa de aciertos de caché

En el resultado estándar de tu ejecución de Bazel, observa la línea INFO que muestra procesos, que corresponden aproximadamente a las acciones de Bazel. Esa línea detalla dónde se ejecutó la acción. Busca la etiqueta remote, que indica una acción ejecutada de forma remota, linux-sandbox para las acciones ejecutadas en un sandbox local, y otros valores para otras estrategias de ejecución. Una acción cuyo resultado provino de una caché remota se muestra como remote cache hit.

Por ejemplo:

INFO: 11 processes: 6 remote cache hit, 3 internal, 2 remote.

En este ejemplo, hubo 6 aciertos de caché remota, y 2 acciones no tuvieron aciertos de caché y se ejecutaron de forma remota. Se puede ignorar la parte interna 3. Por lo general, son acciones internas pequeñas, como la creación de vínculos simbólicos. Los aciertos de caché local no se incluyen en este resumen. Si obtienes 0 procesos (o un número inferior al esperado), ejecuta bazel clean seguido de tu comando de compilación o prueba.

Solución de problemas de aciertos de caché

Si no obtienes la tasa de aciertos de caché que esperas, haz lo siguiente:

Asegúrate de que volver a ejecutar el mismo comando de compilación o prueba produzca aciertos de caché

Ejecuta las compilaciones o pruebas que esperas que propaguen la caché. La primera vez que se ejecuta una compilación nueva en una pila en particular, no puedes esperar aciertos de caché remota. Como parte de la ejecución remota, los resultados de las acciones se almacenan en la caché y una ejecución posterior debería recuperarlos.
Ejecuta bazel clean. Este comando limpia tu caché local, lo que te permite investigar los aciertos de caché remota sin que los resultados se enmascaren con los aciertos de caché local.
Vuelve a ejecutar las compilaciones y las pruebas que estés investigando (en la misma máquina).
Verifica la línea INFO para obtener la tasa de aciertos de caché. Si no ves ningún proceso, excepto remote cache hit y internal, significa que tu caché se propaga y se accede correctamente. En ese caso, ve a la siguiente sección.
Una fuente probable de discrepancia es algo no hermético en la compilación que hace que las acciones reciban diferentes claves de acción en las dos ejecuciones. Para encontrar esas acciones, haz lo siguiente:

a. Vuelve a ejecutar las compilaciones o pruebas en cuestión para obtener registros de ejecución:
```
  bazel clean
  bazel --optional-flags build //your:target --execution_log_binary_file=/tmp/exec1.log
```
b. Compara los registros de ejecución entre las dos ejecuciones. Asegúrate de que las acciones sean idénticas en los dos archivos de registro. Las discrepancias proporcionan una pista sobre los cambios que se produjeron entre las ejecuciones. Actualiza tu compilación para eliminar esas discrepancias.

Si puedes resolver los problemas de almacenamiento en caché y ahora la ejecución repetida produce todos los aciertos de caché, ve a la siguiente sección.

Si tus IDs de acción son idénticos, pero no hay aciertos de caché, significa que algo en tu configuración impide el almacenamiento en caché. Continúa con esta sección para verificar si hay problemas comunes.

Si no necesitas diferenciar los registros de ejecución, puedes usar la marca --execution_log_json_file legible por humanos. No se puede usar para la diferenciación estable, ya que contiene el tiempo de ejecución y no garantiza el orden.
Verifica que todas las acciones en el registro de ejecución tengan cacheable configurado como verdadero. Si cacheable no aparece en el registro de ejecución para una acción determinada, eso significa que la regla correspondiente puede tener una etiqueta no-cache en su definición en el archivo BUILD. Observa el campo progress_message legible por humanos en el registro de ejecución para determinar de dónde proviene la acción.
Si las acciones son idénticas y cacheable pero no hay aciertos de caché, es posible que tu línea de comandos incluya --noremote_accept_cached lo que inhabilitaría las búsquedas de caché para una compilación.

Si es difícil determinar la línea de comandos real, usa la línea de comandos canónica del Protocolo de eventos de compilación de la siguiente manera:

a. Agrega --build_event_text_file=/tmp/bep.txt a tu comando de Bazel para obtener la versión de texto del registro.

b. Abre la versión de texto del registro y busca el structured_command_line mensaje con command_line_label: "canonical". Se mostrarán todas las opciones después de la expansión.

c. Busca remote_accept_cached y verifica si está configurado como false.

d. Si remote_accept_cached es false, determina dónde se configura como false: en la línea de comandos o en un bazelrc archivo.

Asegúrate de que el almacenamiento en caché funcione en todas las máquinas

Después de que los aciertos de caché se produzcan como se espera en la misma máquina, ejecuta las mismas compilaciones o pruebas en una máquina diferente. Si sospechas que el almacenamiento en caché no se produce en todas las máquinas, haz lo siguiente:

Realiza una pequeña modificación en tu compilación para evitar alcanzar las cachés existentes.

Ejecuta la compilación en la primera máquina:

 bazel clean
 bazel ... build ... --execution_log_binary_file=/tmp/exec1.log

Ejecuta la compilación en la segunda máquina y asegúrate de que se incluya la modificación del paso 1:
```
 bazel clean
 bazel ... build ... --execution_log_binary_file=/tmp/exec2.log
```
Compara los registros de ejecución de las dos ejecuciones. Si los registros no son idénticos, investiga las configuraciones de compilación para detectar discrepancias, así como las propiedades del entorno host que se filtran en cualquiera de las compilaciones.

Cómo comparar los registros de ejecución

Los registros de ejecución contienen registros de todas las acciones ejecutadas durante la compilación. Para cada acción, hay un SpawnExec elemento que contiene toda la información de la clave de acción. Por lo tanto, si los registros son idénticos, también lo son las claves de caché de acción.

Para comparar los registros de dos compilaciones que no comparten aciertos de caché como se espera, haz lo siguiente:

Obtén los registros de ejecución de cada compilación y almacénalos como /tmp/exec1.log y /tmp/exec2.log.
Descarga el código fuente de Bazel y navega a la carpeta de Bazel con el siguiente comando. Necesitas el código fuente para analizar los registros de ejecución con el analizador execlog.
```
git clone https://github.com/bazelbuild/bazel.git
cd bazel
```
Usa el analizador de registros de ejecución para convertir los registros en texto. La siguiente invocación también ordena las acciones en el segundo registro para que coincidan con el orden de las acciones en el primer registro para facilitar la comparación.
```
bazel build src/tools/execlog:parser
bazel-bin/src/tools/execlog/parser \
  --log_path=/tmp/exec1.log \
  --log_path=/tmp/exec2.log \
  --output_path=/tmp/exec1.log.txt \
  --output_path=/tmp/exec2.log.txt
```
Usa tu diferenciador de texto favorito para diferenciar /tmp/exec1.log.txt y /tmp/exec2.log.txt.

Depuración de hits de caché remota para ejecución remota Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.