Testes de desempenho em apps Flutter

O framework Flutter faz um bom trabalho em ser rápido por padrão, mas isso significa que você não precisa pensar em desempenho de forma alguma? Não.

O framework do Flutter faz um bom trabalho em ser rápido por padrão, mas isso significa que você não precisa pensar em performance de jeito nenhum? Não. É totalmente possível escrever apps Flutter lentos. Por outro lado, também é possível tirar o máximo do framework e fazer seus apps não apenas rápidos, mas também eficientes, consumindo menos tempo de CPU e bateria.

Isso é o que queremos: um resultado estatisticamente significativo comparando duas versões do seu app em alguma métrica relevante. Continue lendo para aprender como conseguir isso.
Isso é o que queremos: um resultado estatisticamente significativo comparando duas versões do seu app em alguma métrica relevante. Continue lendo para aprender como conseguir isso.

Existem algumas diretrizes gerais para otimização de performance no Flutter:

  • Mire o menor número possível de widgets ao atualizar o estado.

  • Atualize o estado somente quando realmente precisar.

  • Mantenha tarefas computacionalmente intensivas fora dos seus métodos build e — idealmente — fora do isolate principal.

A dura verdade é que, para muitas perguntas sobre otimização de performance, a resposta é “depende”. Esta otimização específica para este widget específico vale o esforço e o custo de manutenção? Esta abordagem específica em esta situação específica faz sentido?

As únicas respostas úteis para essas perguntas vêm de testes e medição. Quantifique que impacto cada escolha tem sobre a performance e decida com base nesses dados.

A boa notícia é que o Flutter oferece ótimas ferramentas de profiling de performance, como o Dart DevTools (atualmente em versão de prévia), que inclui o Flutter Inspector, ou você pode usar o Flutter Inspector diretamente do Android Studio (com o plugin Flutter instalado). Você tem o Flutter Driver para exercitar seu app e o modo profile para salvar informações de performance.

A má notícia é que os smartphones modernos são — bem — inteligentes.

O problema dos governadores

A quantificação da performance de apps Flutter fica particularmente difícil por causa dos governadores do iOS e do Android. Esses daemons de nível de sistema ajustam a velocidade das unidades de CPU e GPU de acordo com a carga. Isso é, claro, majoritariamente bom, porque garante desempenho fluido consumindo o mínimo possível de bateria.

A desvantagem é que você pode tornar seu app significativamente mais rápido fazendo-o trabalhar mais.

Abaixo, você pode ver como adicionar um loop com instruções print sem sentido a um app fez o governador passar para uma marcha mais alta, tornando o app muito mais rápido e sua performance mais previsível.

O problema dos governadores: por padrão, é que você não pode confiar nos seus números. Neste boxplot, temos execuções individuais no eixo x (rotuladas pelo horário exato em que começaram), e tempos de build no eixo y. Como você pode ver, quando introduzimos algumas instruções print completamente desnecessárias, os tempos de build caem, e não sobem.
O problema dos governadores: por padrão, é que você não pode confiar nos seus números. Neste boxplot, temos execuções individuais no eixo x (rotuladas pelo horário exato em que começaram), e tempos de build no eixo y. Como você pode ver, quando introduzimos algumas instruções print completamente desnecessárias, os tempos de build caem, e não sobem.

Neste experimento, código pior resultou em tempos de build mais rápidos (acima), tempos de rasterização mais rápidos e maior taxa de frames. Quando código objetivamente pior produz métricas de performance melhores, você não pode depender dessas métricas como guia.

Este é apenas um exemplo de como o benchmarking de performance de apps mobile pode ser pouco intuitivo e difícil.

Abaixo, compartilho algumas dicas que reuni enquanto trabalhava no app do Google I/O do Flutter, o Developer Quest.

Conselhos básicos

  • Não meça performance no modo DEBUG. Meça performance apenas no modo profile.

  • Meça em um dispositivo real, não no iOS Simulator ou no Android Emulator. Os emuladores de software são ótimos para desenvolvimento, mas têm características de performance muito diferentes das do dispositivo real. O Flutter não permite executar no modo profile em um dispositivo simulado, porque isso não faz sentido. Os dados que você coleta assim não se aplicam à performance no mundo real.

  • Idealmente, use exatamente o mesmo dispositivo físico. Torne-o seu dispositivo dedicado de testes de performance e nunca o use para mais nada.

  • Aprenda as ferramentas de profiling de performance do Flutter.

Governadores de CPU/GPU

Como discutido acima, sistemas operacionais modernos mudam a frequência de cada CPU e GPU disponível de acordo com a carga e algumas outras heurísticas. (Por exemplo, tocar na tela normalmente coloca um celular Android em uma marcha muito mais alta.)

No Android, você pode desligar esses governadores. Chamamos esse processo de “scale locking”.

  • Crie um script que faça scale-lock do seu dispositivo de testes de performance. Você pode usar a receita do Skia como inspiração. Você também pode consultar a API de CPU do Unix.

  • Você provavelmente quer algo menos genérico e mais leve, a menos que esteja executando uma operação grande de benchmarking como o Skia. Dê uma olhada no script de shell do Developer Quest para algumas referências. Por exemplo, o trecho a seguir define uma CPU para o governador userspace (o único governador que não muda as frequências da CPU por conta própria).

bash
#!/usr/bin/env bash

GOV="userspace"
echo "Setting CPU governor to: ${GOV}"
adb shell "echo ${GOV} > /sys/devices/system/cpu/cpu${CPU_NO}/cpufreq/scaling_governor"
ACTUAL_GOV=`adb shell "cat /sys/devices/system/cpu/cpu${CPU_NO}/cpufreq/scaling_governor"`
echo "- result: ${ACTUAL_GOV}"
  • Seu objetivo aqui não é simular a performance do mundo real (nenhum usuário trava a escala do próprio dispositivo), mas obter métricas de performance comparáveis entre execuções.

  • No fim das contas, você precisa experimentar e adaptar o script de shell ao dispositivo que vai usar. Dá trabalho, mas, enquanto você não fizer isso, seus dados de performance vão mentir para você.

Uma versão inicial do Developer Quest sendo exercitada pelo Flutter Driver na minha mesa.
Uma versão inicial do Developer Quest sendo exercitada pelo Flutter Driver na minha mesa.

Flutter Driver

O Flutter Driver permite exercitar seu app automaticamente. Leia a seção Profiling de performance do flutter.dev para uma receita concreta de como usá-lo ao fazer profiling do seu app.

  • Não exercite seu app manualmente ao testar performance. Use sempre o Flutter Driver para garantir que você está comparando coisas equivalentes.

  • Escreva o código do seu Flutter Driver para que ele exercite exatamente o que você quer medir. Se você busca a performance geral do app, tente percorrer todas as partes do app e fazer o que um usuário faria.

  • Se o seu app tiver um elemento de acaso (Random, eventos de rede etc.), simule esses elementos. Os percursos devem ser o mais parecidos possível entre si.

  • Se quiser, adicione eventos personalizados da timeline usando os métodos startSync() e finishSync() do Timeline. Isso é útil, por exemplo, quando você se interessa pela performance de uma função específica. Coloque startSync() no início dela e finishSync() no fim.

  • Salve tanto o resumo (writeSummaryToFile) quanto, mais importante, a timeline bruta (writeTimelineToFile).

  • Para cada versão do seu app, execute-o muitas vezes. Para o Developer Quest, convergi para 100 execuções. (Quando você mede coisas mais ruidosas, como o percentil 99, pode precisar de muito mais execuções.) Para sistemas baseados em POSIX, basta rodar algo como o seguinte: for i in {1..100}; do flutter drive --target=test_driver/perf.dart --profile; done.

Usando a ferramenta de timeline do Chrome para inspecionar a saída de profile do Flutter.
Usando a ferramenta de timeline do Chrome para inspecionar a saída de profile do Flutter.

Cronograma

A timeline é a saída bruta da sua execução de profile. O Flutter despeja essa informação em um arquivo JSON que pode ser carregado no chrome://tracing.

  • Aprenda a abrir a timeline completa na timeline de tracing do Chrome. Basta abrir chrome://tracing no navegador Chrome, clicar em “Load” e selecionar o arquivo JSON. Você pode ler mais em este tutorial curto. (Também existe a ferramenta de timeline do Flutter, em prévia técnica. Eu não a usei porque o projeto Developer Quest começou antes de a ferramenta de timeline do Flutter estar pronta.)

  • Use as teclas WSAD para se mover pela timeline em chrome://tracing, e 1234 para trocar os modos de operação.

  • Ao configurar seus testes de performance pela primeira vez, considere executar o Flutter Driver com o systrace completo do Android. Isso dá mais visibilidade sobre o que realmente acontece no dispositivo, incluindo informações de escalonamento da CPU. Não meça seu app com o systrace totalmente ativado, porém, pois isso deixa tudo mais lento e menos previsível.

  • Como executar o systrace completo do Android com o Flutter Driver? Primeiro, inicie o systrace do Android com /path/to/your/android/sdk/platform-tools/systrace/systrace.py --atrace-categories=gfx,input,view,webview,wm,am,sm,audio,video,camera,hal,app,res,dalvik,rs,bionic,power,pm,ss,database,network,adb,pdx,sched,irq,freq,idle,disk,load,workq,memreclaim,regulators,binder_driver,binder_lock. Depois, inicie o app com flutter run test_driver/perf.dart --profile --trace-systrace. Por fim, inicie o Flutter Driver com flutter drive --driver=test_driver/perf_test.dart --use-existing-app=http://127.0.0.1:NNNNN/ (onde NNNNN é a porta que flutter run acima informa).

Métricas

É melhor olhar para o máximo de métricas possível, mas descobri que algumas são mais úteis do que outras.

  • Tempos de build e tempos de rasterização (as métricas que TimelineSummary fornece por padrão) só são úteis para testes de performance bem restritos que não incluem muito além da construção de UI.

  • Não use TimelineSummary.frameCount como forma de calcular frames por segundo (FPS). A ferramenta de profiling do Flutter não fornece informação real de taxa de frames. TimelineSummary fornece o método countFrames(), mas ele só conta o número de builds de frame concluídos. Um app bem otimizado que limita reconstruções desnecessárias terá menos frames por segundo do que um app não otimizado que reconstrói com frequência.

  • Pessoalmente, obtenho os dados mais úteis medindo o tempo total de CPU gasto executando código Dart. Isso conta o código executado tanto nos seus métodos build quanto fora deles. Supondo que você execute seus testes de profile em um dispositivo com escala travada, o tempo total de CPU é uma boa aproximação de quanto mais ou menos bateria seu app vai consumir.

  • A maneira mais fácil de descobrir o tempo total de CPU gasto executando código Dart é medir a extensão dos eventos MessageLoop:FlushTasks na timeline. Para o Developer Quest, escrevi uma ferramenta em Dart para extrair esses dados.

  • Para detectar jank (ou seja, frames pulados), observe os extremos. Por exemplo, para o caso específico do Developer Quest e o dispositivo que temos para testes, foi útil olhar para os tempos de build no percentil 95. (Os tempos de build no percentil 90 ficaram parecidos demais mesmo ao comparar códigos com níveis de eficiência muito diferentes, e os números do percentil 99 tendem a ser ruidosos. Sua experiência pode variar.)

  • Como mencionado acima, execute cada versão do seu app várias vezes (talvez 100). Depois use dados de média ou de percentis com margens de erro. Melhor ainda, use boxplots.

Resultados

Depois que isso estiver configurado, você poderá comparar commits e experimentos com confiança. Abaixo, você pode ver a resposta a um dilema comum: “essa otimização vale a sobrecarga de manutenção?”

Acho que, neste caso específico, a resposta é sim. Com apenas algumas linhas a mais de código, cada percurso automatizado do nosso app consome, em média, 12% menos tempo de CPU.

Mas — e essa é a mensagem principal deste artigo — as medições de outra otimização podem mostrar algo muito diferente. É tentador, mas errado, tentar extrapolar uma medição de performance de forma ampla demais.

Em outras palavras: “depende”. E devemos abraçar essa frase.

Mais do Flutter