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:

  1. O usuário rola pela lista infinita.

  2. O usuário alterna entre as duas páginas.

  3. O usuário toca no floating action button.

Configurando o framework

Adicione o seguinte a pubspec.yaml:

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:

dart
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 ScrollRecorder estende a classe AppRecorder, que estende a classe WidgetRecorder , que também registra dados de performance enquanto conduz o app.

  • runBenchmarks é uma função definida em package:web_benchmarks/client.dart, que permite ao usuário selecionar qual benchmark executar e exibe os resultados no navegador.

  • O método automate usa o pacote flutter_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:

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.dart compila o app para a web. Em seguida, ele inicia uma instância do Chrome e executa o app nela.

  • test/run_benchmarks.dart se 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:

dart
Future<void> main() async {
  await runBenchmarks(
    {
      'scroll': () => ScrollRecorder(),
      'page': () => PageRecorder(),
      'tap': () => TapRecorder(),
    },
  );
}

Por fim, adicione mais duas classes que estendem AppRecorder:

dart
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.

  • animationStops verifica 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 _completed acompanha se os gestos automatizados terminaram.

  • Nos benchmarks “page” e “tap”, sobrescrever o método shouldContinue faz com que o AppRecorder pare 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).

Mais do Flutter