Criando perfis de apps Flutter usando a Timeline
Usar a Timeline permite encontrar e resolver problemas específicos de desempenho nos seus apps Flutter
Usar a Timeline permite encontrar e resolver problemas específicos de performance na sua aplicação. Ela também é uma ótima ferramenta para identificar o custo relativo de performance de todos os recursos fornecidos pelo Flutter, e permite tomar decisões mais informadas sobre onde você pode evitar certos recursos ou identificar folga para usar efeitos que podem fazer sua aplicação se destacar.
Uma das ferramentas de profiling mais úteis que o Flutter oferece por padrão é a capacidade de gravar traces na Timeline do Dart. A timeline permite fazer e responder perguntas específicas sobre por que a sua aplicação pode estar com jank. Como alguém que frequentemente é designado para analisar problemas de performance em bases de código desconhecidas, fazer profiling usando a timeline exige o mínimo de conhecimento da base de código da aplicação. Por isso, a timeline costuma ser a primeira e mais útil ferramenta que eu uso pessoalmente para diagnosticar e corrigir problemas de performance. Para gargalos de performance no próprio Flutter, abrir uma issue que inclua casos de teste reduzidos e um trace da Timeline facilita identificar, cruzar referências e priorizar tarefas específicas que melhoram a performance da engine e do framework do Flutter. Devo admitir que, entre issues com prioridade semelhante, eu escolho primeiro a que tem um trace da timeline anexado.
O que é a Timeline
A Timeline é um ring buffer de eventos registrados pelo código da aplicação conforme ela executa suas operações. O tipo de evento a ser registrado e a frequência de registro são determinados pelos autores do subsistema que emitiu o evento, que avaliaram o que pode ser relevante para a performance.
Para trabalhar com a Timeline, você precisa do seguinte:
Uma forma de iniciar e parar a gravação de eventos da timeline.
Uma forma de exportar os eventos da timeline em um formato portátil e visualizá-los offline.
Código que emite eventos da Timeline.
Formato Trace Event da Timeline
Os eventos registrados no ring buffer são extremamente leves. Para visualizar esses eventos de forma diagnosticável, você precisa exportá-los para um formato portátil adequado. O Trace Event Format é usado pelo Flutter para exportar esses eventos da timeline para visualização em um visualizador de trace dedicado. Este é o mesmo formato e visualizador desenvolvidos na família de ferramentas de coleta, exibição e análise de performance Catapult.
O Trace Event Format e o visualizador são usados por vários outros projetos. Entre eles estão o Chromium e o Android (via systrace). Na verdade, ele é tão útil que o Chromium tem um embutido. Experimente acessar chrome://tracing em um navegador baseado em Chromium.
Os traces que você compartilha com outros desenvolvedores são arquivos JSON ou seus tarballs. Uma dica útil que eu não conhecia até recentemente é que o visualizador de trace consegue descompactar o tarball do arquivo JSON automaticamente.
Alguns conceitos sobre como o Flutter renderiza frames
Antes de tentar identificar possíveis problemas de performance, precisamos entender como uma aplicação Flutter saudável se comporta. Esta seção é um curso rápido sobre como o Flutter renderiza seus frames.
As threads
Quando uma aplicação Flutter é iniciada, ela inicia (ou pega de um pool) mais três threads. Essas threads às vezes têm responsabilidades sobrepostas, mas, de forma geral, são chamadas de thread de UI, thread de GPU e thread de IO. É importante notar que a thread de UI não é a mesma que a thread principal da plataforma. Algumas plataformas também chamam suas threads principais de thread de UI. A thread de UI usada pelo Flutter é diferente dessa thread. Descritivamente, o Flutter chama a thread principal da plataforma de “Platform thread”.
A thread de UI é a thread na qual todo o código Dart executado em nome do framework e da sua aplicação roda. A menos que sua aplicação ou o framework (via métodos como foundation::compute) inicie seus próprios isolates (via métodos como Isolate.spawn), o código Dart nunca será executado em nenhuma outra thread. Mesmo nos casos de inicialização de isolates secundários, o código Dart nunca roda nas threads de GPU ou de IO.
A Platform thread é onde roda todo o código que depende de plugins. Essa thread também é onde os frameworks nativos da plataforma podem executar suas tarefas. Aplicações Flutter interagem com seus plugins de forma assíncrona, e os plugins não devem conseguir bloquear nenhuma das threads gerenciadas pelo Flutter.
Além das quatro threads descritas, a Dart VM também gerencia um pool de threads. Esse pool é usado para atender a várias funções, como aguardar um socket para dart:io, garbage collection e geração de código JIT (somente no modo debug, já que o Flutter usa AOT no modo release).
O pipeline de frames
Para gerar um único frame, a engine do Flutter primeiro arma o vsync latch. Um evento vsync é um sinal para a engine do Flutter começar a trabalhar, o que eventualmente renderiza um novo frame na tela. O evento vsync gerado pela plataforma leva em conta a taxa de atualização do display (entre outros fatores).
O evento vsync acorda a thread de UI. É aqui que roda o código Dart da aplicação Flutter e do framework. O resultado de todas as operações na thread de UI é uma descrição da cena a ser renderizada na tela, independente do backend de renderização (OpenGL, Vulkan ou Software). Essa descrição é chamada de layer tree.
Assim que a layer tree é criada, a thread de GPU é acordada. Essa thread começa a transformação da layer tree em um command buffer da GPU. Esse command buffer é então enviado para a GPU, na mesma thread.
Em cenas suficientemente complexas, a thread de UI pode gerar o próximo frame ao mesmo tempo em que a thread de GPU consome a layer tree do frame anterior. A engine chama o trabalho feito nas threads de UI e de GPU de item do pipeline. A profundidade do pipeline é o número de cargas de frame nas quais a engine está trabalhando em um dado momento. A profundidade do pipeline pode variar.
O que causa jank
Dado esse modo de operação, o jank pode ser percebido em uma aplicação Flutter se uma das seguintes condições for atendida:
-
A parte da thread de UI ou da thread de GPU de um item do pipeline excede o orçamento do frame (tipicamente 16,67 ms para uma taxa de atualização de display de 60Hz).
A engine altera a profundidade do pipeline.
Os eventos vsync da plataforma são emitidos ou capturados em uma taxa inconsistente.
Uma exceção notável a essa lista é o cenário em que a engine ignora seletivamente eventos vsync em uma taxa constante. Por exemplo, em um display de 60Hz, se a engine só começar a trabalhar em um item do pipeline a cada pulso vsync alternado, a aplicação Flutter renderizará a uma taxa constante de 30Hz.
Como coletar e ler traces da Timeline
Armados com esse conhecimento de como a engine do Flutter funciona, bem como com uma compreensão básica das condições que causam jank, estamos prontos para coletar traces por conta própria.
O custo de coleta de traces é relativamente baixo, mas definitivamente não é zero. Por isso, a engine do Flutter coleta traces somente nos modos debug ou profile. O modo profile é o mais parecido com a performance que seus usuários podem esperar ao rodar sua aplicação. Esse modo compila seu código Dart com AOT e, fora isso, se comporta exatamente como o modo release. No entanto, ele também habilita a timeline, bem como outras ferramentas de tracing disponíveis pelo Observatory do Dart.
O tempo para criar um build em modo profile também é praticamente o mesmo do modo release. Mas não deixe isso te desencorajar a usar o modo profile. Eu costumo adicionar traces à Timeline no modo debug (com todos os benefícios que o hot reload traz). Depois, quando tenho razoável certeza de que meus traces vão coletar as informações de que preciso, faço um build em modo profile para coletar informações de tempo válidas.
Para coletar traces, você precisa abrir o Dart Observatory da sua aplicação Flutter. O Observatory é uma aplicação web servida por todas as aplicações Flutter rodando no dispositivo, nos modos debug ou profile. A aplicação web é iniciada no dispositivo e disponibilizada em uma porta aleatória livre. As ferramentas do Flutter fazem o trabalho de encaminhar essa porta para o seu host.
Nota: o Observatory está sendo substituído pelo Dart DevTools. Essa ferramenta baseada em navegador ainda está em desenvolvimento, mas já está disponível para prévia. Para instruções de instalação e primeiros passos, veja a documentação do DevTools e, em particular, como usar a visualização de timeline.
Observatory pela linha de comando
-
Inicie a aplicação usando flutter run — profile (ou debug se você estiver prototipando seus traces)
-
As ferramentas devem encaminhar a porta do Observatory para o seu host e exibir uma linha como esta: An Observatory debugger and profiler on iPhone X is available at: http://127.0.0.1:60551/
Abra essa URL no seu navegador
Observatory pela IDE
Inicie a aplicação Flutter usando o botão Play ou o atalho.
-
No painel Run, clique no ícone de cronômetro para abrir o Observatory dessa aplicação no seu navegador.
Navegue até a Timeline no Observatory
Clique no link da timeline na página principal do Observatory ou acesse a timeline diretamente abrindo http://127.0.0.1:61102/#/timeline (substitua o # pelo número real da porta).
Se você sempre quiser encaminhar o Observatory para a mesma porta do host, especifique a --observatory-port=<port>
opção de linha de comando. Assim, basta recarregar seu navegador depois de reiniciar a aplicação no dispositivo. Eu faço isso para evitar procurar a nova porta do Observatory. Digite
flutter help run na linha de comando para mais detalhes.
Agora você verá uma timeline vazia. Os traces são atribuídos a categorias e, por padrão, nenhuma categoria está habilitada.
Coletando um trace
Habilite o tracing em todas as categorias de trace clicando em All e depois no botão clear para iniciar o tracing no dispositivo. Observe que os “Recorded Streams” estão todos habilitados. A timeline ainda está vazia, mas o dispositivo já começou a coletar traces. Certifique-se de interagir com a aplicação de forma a adicionar traces à Timeline. Geralmente, renderizar alguns frames já basta.
Quando terminar o tracing e quiser ver o trace, clique no botão Refresh para que o Observatory puxe o buffer de trace atual do dispositivo.
Você pode navegar rapidamente pelo trace usando o mouse e as teclas W, A, S, D. Também é uma boa ideia habilitar as opções Flow events e Highlight VSync no menu View Options. Isso permite visualizar os traces no contexto dos frames conforme eles são renderizados na tela.
Navegar pelo trace com o mouse depende do modo de navegação selecionado. Eu costumo deixar a ferramenta de ‘seleção’ habilitada no painel. Uso essa ferramenta para selecionar elementos específicos do trace enquanto uso as teclas do teclado para mover a visualização. No entanto, você pode alternar entre os modos do mouse clicando no item correspondente do painel ou pressionando uma das teclas 1 para seleção, 2 para pan, 3 para zoom ou 4 para timing.
Também é uma boa ideia pressionar ? no teclado. Isso abre uma caixa de ajuda com os atalhos suportados.
Salvando e compartilhando traces
Clicar no botão save faz o navegador baixar um arquivo JSON com o trace. Você pode compartilhar esse trace em relatórios de bug ou por e-mail. Para visualizar um trace compartilhado, acesse about://tracing no Chrome e carregue o arquivo de trace salvo.
O visualizador de trace no Chrome em about://tracing também funciona com arquivos JSON compactados. Eu acho esses mais fáceis de compartilhar e de trabalhar.
Elementos de um trace
Eventos de duração
De longe, o tipo mais comum de evento de trace usado na engine são os eventos de duração. Esses eventos permitem anotar um bloco de código no seu trace. Eles são extremamente simples de adicionar, pois não exigem identificadores. Em Dart, você pode usar a classe Timeline do pacote dart:developer para adicionar traces por conta própria. O próprio framework e a engine do Flutter já adicionam eventos de duração às cargas de trabalho que consideram importantes, e você deve se sentir à vontade para fazer o mesmo. Clicar em uma duração específica mostra um resumo do tempo gasto nesse evento.
Procure eventos de duração nas threads de UI ou de GPU que sejam partes significativas do intervalo do frame. Os intervalos de frame podem ser destacados habilitando o botão Highlight Vsync descrito anteriormente ou simplesmente pressionando a tecla v.
Se você vir um evento de duração particularmente grande, o próximo passo é destacar qual parte do código está contribuindo para que esse trecho seja tão grande. Identificar esses trechos é bem mais fácil usando o profiler de amostragem descrito abaixo. Mas, se você tiver alguma compreensão da base de código em questão, também pode adicionar traces ao seu código por especulação. Embora números de instrumentação definitivos só devam ser coletados no modo profile, eu gosto de trabalhar no modo debug com hot reload para adicionar traces de forma especulativa e ver se estou chegando mais perto de isolar o gargalo.
O resumo do evento
Clicar em um evento exibe o resumo do evento em um painel na parte inferior. A seção Events do resumo é especialmente útil porque tenta conectar todos os eventos de duração logicamente relacionados. Essas relações são inferidas usando eventos de flow, descritos abaixo. O framework e a engine do Flutter já adicionam eventos de flow para todas as cargas de trabalho relacionadas a frames. Dessa forma, fica mais fácil isolar todo o trabalho (em várias threads) relacionado a um frame específico. Quando você clica no link do flow relacionado, o visualizador de trace seleciona e destaca todos os flows conectados.
No exemplo abaixo, ao selecionar todos os traces relacionados e ordenar a lista por Self Time fica evidente que o trace PhysicalShapeLayer::Paint é o trace dominante. Você pode perceber que esse trace está na thread de GPU porque, ao passar o mouse sobre ele no resumo, o mesmo trace fica destacado.
Quando esses traces dominantes são identificados, geralmente sei em quais partes do código devo me aprofundar. O resumo também é útil porque múltiplas ocorrências de pequenos eventos com durações extremamente curtas são fáceis de passar despercebidas visualmente no trace. Mas esses traces são destacados imediatamente no resumo.
Eventos repetidos
Às vezes, em vez de um único evento, você quer caracterizar o desempenho de eventos repetidos que geram traces de duração. Isso pode ser feito selecionando, arrastando o mouse, uma seção da timeline que contenha esses eventos.
O visualizador de trace se chama Catapult e podem existir versões diferentes do Catapult embutidas no Chrome em about://tracing e no Observatory. Estou usando a versão mais recente do Chrome para isso, pois ela tem recursos de visualização de trace mais atualizados. Você também pode usar o Catapult diretamente na versão HEAD no GitHub. Se quiser visualizar um trace coletado no Observatory em uma versão mais nova do Catapult, salve o trace como JSON e carregue-o em outra versão do Catapult. O formato JSON é estável.
Depois de selecionar um grupo de traces, você deve ver um resumo de todos os traces que se repetem dentro dessa seleção. Ao selecionar um trace (estou usando a versão mais recente do visualizador Catapult no exemplo a seguir), devem aparecer informações úteis, como o tempo médio por slice, o desvio padrão, a contagem de repetições etc..
Isso deve dar uma ideia melhor sobre as melhorias que você faz na base de código refletidas em eventos de duração menores dentro de eventos repetidos (como frames). Além disso, depois de identificar outliers, fica mais fácil selecioná-los e analisar os traces ao redor para explicar o desvio.
Eventos de flow
Eventos de flow são usados para conectar logicamente eventos de duração (possivelmente em várias threads). No visualizador de trace, eles aparecem como setas. Por padrão, os eventos de flow tendem a deixar a visualização do trace bastante bagunçada, por isso ficam desabilitados. Para habilitá-los, marque a caixa “Flow events” em “View Options”. Eventos de flow precisam se originar dentro de um evento de duração. Usar a classe Flow do pacote dart:developer faz isso automaticamente para você. A engine do Flutter também adiciona um flow implícito chamado “PipelineItem” a todas as cargas de trabalho relacionadas a frames. Todos os eventos de duração conectados por um flow contam como “relacionados” no resumo de eventos descrito acima. Os descendentes dos eventos conectados também são contados.
No exemplo a seguir, a engine do Flutter está produzindo o próximo frame na thread de UI antes que o frame anterior tenha sido renderizado pela thread de GPU. Sem os flows, teria sido muito difícil correlacionar eventos de duração com cargas de trabalho de frames específicas.
O profiler de amostragem
Muitas vezes, pode ser difícil descobrir por onde começar a adicionar traces. Sempre que a engine acorda uma thread para fazer algum trabalho, ela adiciona um trace de duração implícito chamado MessageLoop::RunExpiredTasks. No entanto, pode não haver mais traces aninhados dentro dele. Nesse caso, o profiler de amostragem é extremamente útil. A Dart VM coleta o backtrace do código em execução em uma frequência específica. Essas amostras aparecem como eventos instantâneos na thread de UI sempre que algum código Dart está sendo executado.
As amostras são fáceis de passar despercebidas, mas são extremamente úteis. Ao selecionar uma amostra, é exibido um backtrace da pilha Dart e nativa naquele momento. Se você estiver perdido e não souber por onde começar a adicionar traces, basta continuar selecionando amostras até identificar um código que pareça familiar.
Essa foi uma breve visão geral de algumas das formas como você pode usar a timeline de forma eficaz para instrumentar sua aplicação. Bom tracing!