Testes de performance na web
Execute testes de performance para apps web Flutter no Chrome
Este artigo foi atualizado em 25 de novembro de 2020 para usar o web_benchmarks pacote.
Visão geral
Durante o desenvolvimento, muitas vezes queremos testar a performance de um app no navegador. Testes de performance são úteis, pois revelam possíveis bugs que deixam o app mais lento.
Este artigo descreve uma forma de testar a performance de um app no Chrome. Esse método é semelhante a como testamos a performance da nova Flutter Gallery.
App de exemplo
Usamos um app simples que contém uma appbar, um floating action button e uma lista infinita de itens. A lista também mostra quantas vezes o botão foi pressionado.

O app tem uma segunda página com algumas informações.

Você pode clonar o app aqui:
O que testar?
Queremos testar a performance do app no Chrome nos seguintes cenários de uso:
O usuário rola pela lista infinita.
O usuário alterna entre as duas páginas.
O usuário toca no floating action button.
Configurando o framework
Adicione o seguinte a pubspec.yaml:
dependencies:
flutter:
sdk: flutter
web_benchmarks: ^0.0.2
Essa dependência traz web_benchmarks, um pacote mínimo que implementa testes de performance no Chrome.
Esse pacote é adaptado de macrobenchmarks
e devicelab, dois pacotes usados pelo Flutter para testes de performance web na Flutter Gallery. Atualmente, esses dois pacotes são especializados em testes de performance web dentro de flutter/flutter, então é mais fácil importar o pacote mais geral, web_benchmarks.
Execute flutter pub get para baixar este pacote.
Escrevendo o primeiro teste
Adicione um diretório benchmarks em lib e um novo arquivo dart chamado
runner.dart:

O conteúdo do arquivo é o seguinte:
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:web_benchmarks/client.dart';
import 'package:web_benchmarks_example/main.dart';
import 'package:web_benchmarks_example/homepage.dart' show textKey;
/// A recorder that measures frame building durations.
abstract class AppRecorder extends WidgetRecorder {
AppRecorder({@required this.benchmarkName}) : super(name: benchmarkName);
final String benchmarkName;
Future<void> automate();
@override
Widget createWidget() {
Future.delayed(Duration(milliseconds: 400), automate);
return MyApp();
}
Future<void> animationStops() async {
while (WidgetsBinding.instance.hasScheduledFrame) {
await Future<void>.delayed(Duration(milliseconds: 200));
}
}
}
class ScrollRecorder extends AppRecorder {
ScrollRecorder() : super(benchmarkName: 'scroll');
Future<void> automate() async {
final scrollable = Scrollable.of(find.byKey(textKey).evaluate().single);
await scrollable.position.animateTo(
30000,
curve: Curves.linear,
duration: Duration(seconds: 20),
);
}
}
Future<void> main() async {
await runBenchmarks(
{
'scroll': () => ScrollRecorder(),
},
);
}
O que esse teste faz?
-
Quando este app roda, um objeto
ScrollRecorderé criado, que conduz o app fazendo gestos automaticamente. Nesse caso, logo após o app iniciar, ele começa a rolar a lista infinita para baixo. -
A classe
ScrollRecorderestende a classeAppRecorder, que estende a classeWidgetRecorder, que também registra dados de performance enquanto conduz o app. -
runBenchmarksé uma função definida empackage:web_benchmarks/client.dart, que permite ao usuário selecionar qual benchmark executar e exibe os resultados no navegador. -
O método
automateusa o pacoteflutter_test, que oferece métodos para fazer gestos ou encontrar determinados widgets em um app.
Executando o primeiro teste
No diretório raiz do projeto, execute flutter run -d chrome -t lib/benchmarks/runner.dart. Isso diz ao Flutter para usar runner.dart como ponto de entrada, em vez de main.dart.

Temos apenas um benchmark até agora, então clique em “scroll” para iniciá-lo.

O teste começa e a lista rola automaticamente para baixo.
O teste termina em alguns segundos, mostrando a seguinte tela:

Este gráfico mostra o tempo que o app levou para desenhar cada quadro (gravado). O eixo horizontal representa o fluxo do tempo; o eixo vertical, a duração que cada quadro levou.
Os primeiros 2/3 do gráfico têm fundo cinza; esses quadros são considerados “quadros de aquecimento” (warm-up) e são omitidos das estatísticas. Os quadros de aquecimento normalmente dão ao compilador JIT tempo para compilar o código e preencher vários caches, para que os quadros medidos reflitam o desempenho “final” do app, e não os primeiros segundos dele. A fase de aquecimento não deve ser sempre ignorada: ela pode trazer informações valiosas sobre o desempenho do seu app nos primeiros segundos, que ainda podem influenciar a percepção da qualidade do app.
Os quadros vermelhos são “outliers”: quadros que levam significativamente mais tempo para desenhar do que os outros. Alguns outliers podem ser quase imperceptíveis. Por exemplo, um jank no início ou no fim de uma animação, até certo ponto, não será visível. Porém, um quadro com jank no meio de uma animação será muito perceptível.
Os outliers são um bom indicador do jank do app. Ao melhorar seu app, você pode reduzir os valores dos outliers ou diminuir a quantidade de outliers, o que mostra que seu app ficou mais fluido.
Coletando dados do DevTools do Chrome
Este benchmark é executado inteiramente dentro do Chrome. Adicione o seguinte arquivo como test/run_benchmarks.dart:
import 'dart:convert' show JsonEncoder;
import 'dart:io';
import 'package:web_benchmarks/server.dart';
Future<void> main () async {
final taskResult = await serveWebBenchmark(
benchmarkAppDirectory: Directory('.'),
entryPoint: 'lib/benchmarks/runner.dart',
useCanvasKit: false,
);
print (JsonEncoder.withIndent(' ').convert(taskResult.toJson()));
}
Depois, execute dart test/run_benchmarks.dart.
Após cerca de um minuto, você deverá ver os seguintes resultados:
Received profile data
{
"scroll": [
{
"metric": "preroll_frame.average",
"value": 122.22105263157894
},
{
"metric": "preroll_frame.outlierAverage",
"value": 767.4
},
{
"metric": "preroll_frame.outlierRatio",
"value": 6.278787356816812
},
{
"metric": "preroll_frame.noise",
"value": 0.35245125929858917
},
{
"metric": "apply_frame.average",
"value": 529.8888888888889
},
{
"metric": "apply_frame.outlierAverage",
"value": 2696.5
},
{
"metric": "apply_frame.outlierRatio",
"value": 5.0888026840008385
},
{
"metric": "apply_frame.noise",
"value": 0.4154574507186871
},
{
"metric": "drawFrameDuration.average",
"value": 2562.0243902439024
},
{
"metric": "drawFrameDuration.outlierAverage",
"value": 6828.888888888889
},
{
"metric": "drawFrameDuration.outlierRatio",
"value": 2.66542696271474
},
{
"metric": "drawFrameDuration.noise",
"value": 0.4512335390240227
},
{
"metric": "totalUiFrame.average",
"value": 4971
}
]
}
Os valores exatos do benchmark podem variar dependendo da máquina.
O que esse teste faz?
-
Executar
test/run_benchmarks.dartcompila o app para a web. Em seguida, ele inicia uma instância do Chrome e executa o app nela. -
test/run_benchmarks.dartse conecta à porta do DevTools do Chrome, e escuta e coleta os dados de desempenho relevantes dela.
O que os resultados significam?
-
Ao renderizar um quadro, a árvore de camadas (layer tree) é percorrida duas vezes.
-
“Preroll” é o primeiro percurso. Ele não renderiza nada, mas calcula valores que são usados depois na renderização. Exemplos incluem: matrizes de transformação, a inversa de transformações e clips.
“Apply frame” é o segundo percurso, em que a UI é de fato renderizada.
-
“Draw frame” é o tempo total que o framework leva para renderizar um quadro. Ele inclui “Preroll” e “Apply frame”, mas também inclui o tempo gasto na construção e no layout dos widgets.
-
“Total UI frame” inclui tudo em “Draw frame”, mas também inclui um trabalho oculto que o navegador executa, como atualizações da layer tree, recálculos de estilo e layout feito pelo navegador (que não deve ser confundido com o layout próprio do Flutter).
Quando um dataset (uma lista de durações) é coletado, o algoritmo remove os outliers.
-
Primeiro, são calculadas a média e o desvio padrão dos dados, e qualquer ponto de dados maior que (média + 1 desvio padrão) é considerado um outlier.
-
A média e o desvio padrão dos não outliers (dados limpos) são usados para calcular a média e o ruído do dataset, que são então reportados.
-
A média de todos os outliers, assim como a razão entre a “média dos outliers” e a “média dos não outliers”, também são reportadas.
-
Para cada dataset, “outlierRatio” e “noise” são bons indicadores de quanto ruído há no desempenho do app. Se os resultados estiverem muito ruidosos, isso pode indicar inconsistências de desempenho (como quadros com jank causados por pausas do GC). Ao buscar reduzir o ruído, você pode fazer seu app ter um desempenho mais fluido.
Adicione mais testes
Edite lib/benchmarks/runner.dart para adicionar mais dois testes.
Primeiro, modifique a função main:
Future<void> main() async {
await runBenchmarks(
{
'scroll': () => ScrollRecorder(),
'page': () => PageRecorder(),
'tap': () => TapRecorder(),
},
);
}
Por fim, adicione mais duas classes que estendem AppRecorder:
class PageRecorder extends AppRecorder {
PageRecorder() : super(benchmarkName: 'page');
bool _completed = false;
@override
bool shouldContinue() => profile.shouldContinue() || !_completed;
Future<void> automate() async {
final controller = LiveWidgetController(WidgetsBinding.instance);
for (int i = 0; i < 10; ++i) {
print('Testing round $i...');
await controller.tap(find.byKey(aboutPageKey));
await animationStops();
await controller.tap(find.byKey(backKey));
await animationStops();
}
_completed = true;
}
}
class TapRecorder extends AppRecorder {
TapRecorder() : super(benchmarkName: 'tap');
bool _completed = false;
@override
bool shouldContinue() => profile.shouldContinue() || !_completed;
Future<void> automate() async {
final controller = LiveWidgetController(WidgetsBinding.instance);
for (int i = 0; i < 10; ++i) {
print('Testing round $i...');
await controller.tap(find.byIcon(Icons.add));
await animationStops();
}
_completed = true;
}
}
O que esses testes fazem?
-
Adicionamos os dois benchmarks restantes: um para trocar de página e outro para tocar no floating action button.
-
animationStopsverifica repetidamente se uma animação está acontecendo e para quando todas as animações pararam. Isso garante, por exemplo, uma transição bem-sucedida para a página “about”. -
Nos benchmarks “page” e “tap”, o booleano
_completedacompanha se os gestos automatizados terminaram. -
Nos benchmarks “page” e “tap”, sobrescrever o método
shouldContinuefaz com que oAppRecorderpare de gravar quadros depois que todos os gestos terminarem.
Como executar estes testes?
Para executar esses testes (e ver as animações) no Chrome, execute:
flutter run -d chrome -t lib/benchmarks/runner.dart --profile
Para executar esses testes e coletar os dados do DevTools, execute:
dart test/run_benchmarks.dart
E agora?
Quando você tiver uma forma de coletar dados de desempenho, pode usá-los como quiser:
-
Você pode configurar um job no CI que execute esses testes de benchmark sempre que alguém enviar um PR, para evitar a introdução de mudanças pesadas em desempenho.
-
Você também pode configurar um dashboard que acompanha a tendência dos benchmarks de desempenho. É o que fazemos para a Flutter Gallery (veja o Flutter Dashboard).