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.
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.
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).
#!/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ê.
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()efinishSync()do Timeline. Isso é útil, por exemplo, quando você se interessa pela performance de uma função específica. ColoquestartSync()no início dela efinishSync()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.
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://tracingno 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 comflutter run test_driver/perf.dart --profile --trace-systrace. Por fim, inicie o Flutter Driver comflutter drive --driver=test_driver/perf_test.dart --use-existing-app=http://127.0.0.1:NNNNN/(onde NNNNN é a porta queflutter runacima 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
TimelineSummaryfornece 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.frameCountcomo forma de calcular frames por segundo (FPS). A ferramenta de profiling do Flutter não fornece informação real de taxa de frames.TimelineSummaryfornece o métodocountFrames(), 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:FlushTasksna 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.