Como depurar ocorrências em cache remoto para execução remota

Reportar um problema Ver a fonte Nightly · 8.4 · 8.3 · 8.2 · 8.1 · 8.0 · 7.6

Nesta página, descrevemos como verificar a taxa de acertos de cache e investigar falhas de cache no contexto da execução remota.

Esta página pressupõe que você tenha uma build e/ou um teste que use a execução remota com sucesso e queira garantir o uso eficaz do cache remoto.

Verificar sua taxa de ocorrência em cache

Na saída padrão da execução do Bazel, observe a linha INFO que lista os processos, que correspondem aproximadamente às ações do Bazel. Essa linha detalha onde a ação foi executada. Procure o rótulo remote, que indica uma ação executada remotamente, linux-sandbox para ações executadas em uma sandbox local e outros valores para outras estratégias de execução. Uma ação cujo resultado veio de um cache remoto é mostrada como remote cache hit.

Exemplo:

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

Neste exemplo, houve seis acertos de cache remoto, e duas ações não tiveram acertos de cache e foram executadas remotamente. A parte interna 3 pode ser ignorada. Normalmente, são pequenas ações internas, como a criação de links simbólicos. Ocorrências em cache local não estão incluídas neste resumo. Se você estiver recebendo 0 processos (ou um número menor do que o esperado), execute bazel clean seguido pelo comando de build/teste.

Como solucionar problemas de ocorrências em cache

Se você não estiver recebendo a taxa de acerto de cache esperada, faça o seguinte:

Verifique se a nova execução do mesmo comando de build/teste produz acertos de cache.

Execute as compilações e/ou os testes que você espera preencher o cache. Na primeira vez que uma nova versão é executada em uma determinada pilha, não há hits de cache remoto. Como parte da execução remota, os resultados da ação são armazenados no cache, e uma execução subsequente deve buscá-los.
Execute bazel clean. Esse comando limpa o cache local, o que permite investigar ocorrências de cache remoto sem que os resultados sejam mascarados por ocorrências de cache local.
Execute as compilações e os testes que você está investigando novamente (na mesma máquina).
Verifique a linha INFO para a taxa de ocorrência em cache. Se você não vir nenhum processo, exceto remote cache hit e internal, o cache está sendo preenchido e acessado corretamente. Nesse caso, avance para a próxima seção.
Uma possível fonte de discrepância é algo não hermético no build, fazendo com que as ações recebam chaves de ação diferentes nas duas execuções. Para encontrar essas ações, faça o seguinte:

a. Execute novamente as compilações ou os testes em questão para receber os registros de execução:
```
  bazel clean
  bazel --optional-flags build //your:target --execution_log_compact_file=/tmp/exec1.log
```
b. Compare os registros de execução entre as duas execuções. Verifique se as ações são idênticas nos dois arquivos de registro. As discrepâncias fornecem uma pista sobre as mudanças que ocorreram entre as execuções. Atualize seu build para eliminar essas discrepâncias.

Se você conseguir resolver os problemas de armazenamento em cache e agora a execução repetida produzir todos os acertos de cache, pule para a próxima seção.

Se os IDs de ação forem idênticos, mas não houver acertos de cache, algo na sua configuração está impedindo o armazenamento em cache. Continue com esta seção para verificar problemas comuns.
Verifique se todas as ações no registro de execução têm cacheable definido como "true". Se cacheable não aparecer no registro de execução de uma determinada ação, isso significa que a regra correspondente pode ter uma tag no-cache na definição dela no arquivo BUILD. Analise os campos mnemonic e target_label no registro de execução para determinar de onde a ação está vindo.
Se as ações forem idênticas e cacheable, mas não houver acertos de cache, é possível que a linha de comando inclua --noremote_accept_cached, o que desativaria as pesquisas de cache para um build.

Se for difícil descobrir a linha de comando real, use a linha de comando canônica do Build Event Protocol da seguinte maneira:

a. Adicione --build_event_text_file=/tmp/bep.txt ao seu comando Bazel para receber a versão em texto do registro.

b. Abra a versão em texto do registro e procure a mensagem structured_command_line com command_line_label: "canonical". Ele vai listar todas as opções após a expansão.

c. Pesquise remote_accept_cached e verifique se ele está definido como false.

d. Se remote_accept_cached for false, determine onde ele está sendo definido como false: na linha de comando ou em um arquivo bazelrc.

Garantir o armazenamento em cache em todas as máquinas

Depois que os acertos de cache estiverem ocorrendo conforme o esperado na mesma máquina, execute os mesmos builds/testes em uma máquina diferente. Se você suspeitar que o armazenamento em cache não está ocorrendo em todas as máquinas, faça o seguinte:

Faça uma pequena modificação no build para evitar o uso de caches atuais.

Execute o build na primeira máquina:

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

Execute o build na segunda máquina, garantindo que a modificação da etapa 1 esteja incluída:
```
 bazel clean
 bazel ... build ... --execution_log_compact_file=/tmp/exec2.log
```
Compare os registros de execução das duas execuções. Se os registros não forem idênticos, investigue as configurações de build para encontrar discrepâncias e propriedades do ambiente host que vazam para um dos builds.

Comparar os registros de execução

O registro de execução contém registros de ações executadas durante o build. Cada registro descreve as entradas (não apenas arquivos, mas também argumentos de linha de comando, variáveis de ambiente etc.) e as saídas da ação. Assim, o exame do registro pode revelar por que uma ação foi executada novamente.

O registro de execução pode ser produzido em um dos três formatos: compacto (--execution_log_compact_file), binário (--execution_log_binary_file) ou JSON (--execution_log_json_file). O formato compacto é recomendado porque produz arquivos muito menores com pouquíssimo overhead de tempo de execução. As instruções a seguir funcionam para qualquer formato. Também é possível converter entre eles usando a ferramenta //src/tools/execlog:converter.

Para comparar registros de duas versões que não estão compartilhando acertos de cache como esperado, faça o seguinte:

Receba os registros de execução de cada build e armazene-os como /tmp/exec1.log e /tmp/exec2.log.
Faça o download do código-fonte do Bazel e crie a ferramenta //src/tools/execlog:parser:

git clone https://github.com/bazelbuild/bazel.git cd bazel bazel build //src/tools/execlog:parser
Use a ferramenta //src/tools/execlog:parser para converter os registros em um formato de texto legível para humanos. Nesse formato, as ações no segundo registro são classificadas para corresponder à ordem no primeiro, facilitando a comparação.
```
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
```
Use seu comparador de texto favorito para comparar /tmp/exec1.log.txt e /tmp/exec2.log.txt.

Como depurar ocorrências em cache remoto para execução remota Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.