Dicas de otimização de performance da raster thread

Recentemente, sentei para ajustar a performance do FlutterFolio, um app criado como vitrine de design para o Flutter Engage

Recentemente, sentei para ajustar o desempenho do FlutterFolio, um app criado como vitrine de design para o Flutter Engage. Com uma única mudança, deixei o FlutterFolio significativamente mais rápido.

Mas, antes, eu precisava descobrir o que mudar. Este artigo trata dessa busca.

O FlutterFolio é um app totalmente funcional criado em 6 semanas (!), do design à implementação, para mobile, desktop e web. A equipe de desenvolvimento claramente precisou cortar alguns cantos — sem julgamentos. O escopo do projeto e o prazo muito curto os obrigaram a isso.

Watch on YouTube in a new tab: "Flutter Folio Trailer"

Na verdade, isso representa uma ótima oportunidade, porque o app é mais “da vida real” do que todos os apps de exemplo que consigo pensar.

E a otimização de desempenho é mais bem explicada em apps da vida real do que em problemas sintéticos.

Passo 1: Profiling de desempenho

Qual é o primeiro passo de qualquer otimização? Medir. Saber que um app parece lento não basta. Você precisa ser um pouco mais preciso. Dois motivos:

  1. A medição pode apontar a direção dos maiores vilões. Toda parte de todo app pode ser mais rápida e eficiente. Mas é preciso começar por algum lugar. O profiling de desempenho nos permite ver quais partes estão indo bem e quais estão indo mal. Podemos então focar nas partes que vão mal e avançar mais com nosso tempo limitado.

  2. Podemos comparar o antes e o depois. Às vezes, uma mudança de código parece uma boa ideia, mas na prática não faz uma diferença significativa. Ter uma linha de base (o antes) significa que podemos quantificar o efeito das nossas mudanças. Podemos comparar o antes com o depois.

Fazer profiling de desempenho de apps é difícil. Escrevi um artigo longo sobre isso em 2019. Então, vamos começar de forma simples. Executamos o app no modo profile, ativamos o overlay de desempenho e usamos o app, observando o gráfico do overlay de desempenho.

Imediatamente, vemos que a thread raster está com dificuldade.

Isso acontece especialmente ao rolar a página inicial do app. Você deve sempre priorizar as partes do app onde o usuário passa a maior parte do tempo ou onde problemas de desempenho são especialmente perceptíveis para ele. Em outras palavras, se você tem dois problemas de desempenho, e um deles acontece na tela inicial e o outro está escondido na página de configurações, corrija primeiro a tela inicial.

Vamos ver o que a thread raster está fazendo.

Aparte: thread da UI versus thread raster

Antes, vamos esclarecer o que a thread raster faz.

Todos os apps Flutter rodam em pelo menos duas threads paralelas: a thread da UI e a thread raster. A thread da UI é onde você constrói os widgets e onde roda a lógica do app. (Você pode criar isolates, o que significa que pode executar sua lógica em outras threads, mas, por simplicidade, vamos ignorar isso.) A thread raster é o que o Flutter usa para rasterizar seu app. Ela recebe instruções da thread da UI e as traduz em algo que pode ser enviado para a placa de vídeo.

Para ser mais concreto, vamos dar uma olhada em uma função build:

dart
Widget build(BuildContext context) {
  return Image.asset('dash.png');
}

O código acima roda na thread da UI. O framework do Flutter descobre onde posicionar o widget, que tamanho dar a ele, e assim por diante — ainda na thread da UI.

Depois, quando o Flutter sabe tudo sobre o frame, a tarefa passa para a thread raster. A thread raster pega os bytes em dash.png, redimensiona a imagem (se necessário) e então aplica opacidade, modos de mesclagem, blur e assim por diante, até obter os pixels finais. A thread raster então envia a informação resultante para a placa de vídeo e, portanto, para a tela.

Passo 2: Analisando a timeline

Ok, voltando ao FlutterFolio. Abrir o Flutter DevTools nos permite olhar a timeline com mais detalhes.

Na aba Performance, você pode ver que a thread da UI (as barras azul-claro) está indo bem, enquanto a thread raster (as barras azul-escuro e vermelhas) leva um tempo surpreendente em cada frame, especialmente ao rolar a página inicial. Portanto, o problema não são métodos build ineficientes nem a lógica de negócio. O problema é pedir que a thread raster faça trabalho demais.

O fato de que todo frame passa muito tempo na thread raster nos diz algo. Isso significa que estamos pedindo à thread raster que faça algum trabalho repetidamente — não é algo feito de vez em quando.

Vamos escolher um frame e olhar o painel Timeline Events..

A parte superior da timeline, com o fundo cinza-claro, é a thread da UI. Mais uma vez, você pode ver que a thread da UI não é o problema.

Abaixo da thread da UI, você vê os eventos na thread raster, começando com GPURasterizer:Draw. Infelizmente, aqui as coisas ficam um pouco nebulosas. Há muitas chamadas a métodos de nomes exóticos, como TransformLayer::Preroll, OpacityLayer::Preroll, PhysicalShapeLayer::Paint e assim por diante. Não há detalhes sobre o que está acontecendo nesses métodos, e esses não são nomes que a maioria dos desenvolvedores Flutter reconhece.

Eles são métodos C++ da engine do Flutter. Se quiser, você pode pesquisar esses nomes de métodos, ler o código e os comentários para entender o que está acontecendo por baixo dos panos. Às vezes, isso pode dar um pouco mais de intuição sobre o que a thread raster está fazendo. Mas esse tipo de pesquisa não é estritamente necessário para encontrar problemas de desempenho. (Eu só fiz isso relativamente recentemente e, ainda assim, consegui otimizar o desempenho de bastante apps.)

Depois, há o evento longo rotulado SkCanvas::Flush. Ele leva 18 milissegundos, o que está muito acima do razoável. Infelizmente, esse evento também não tem nenhuma informação detalhada, então vamos ter que investigar um pouco.

O Sk em SkCanvas significa Skia, o mecanismo gráfico que o Flutter usa para renderização na base de sua pilha. SkCanvas é uma classe C++ de baixo nível, semelhante ao Canvas do Flutter (que você pode conhecer se trabalha com CustomPaint). Todos os pixels, linhas e gradientes do seu app — toda a UI — passam pelo SkCanvas. E SkCanvas::Flush é onde essa classe faz a maior parte do trabalho depois de reunir todas as informações de que precisa. A documentação diz que o método Flush “resolve todas as operações pendentes de GPU.”

Vamos revisar o que aprendemos com a timeline de desempenho:

  • A thread raster é o grande problema. A thread da UI está indo razoavelmente bem.

  • Ao rolar, a thread raster leva muito tempo em cada frame. Algum trabalho caro de rasterização está sendo feito o tempo todo.

  • SkCanvas::Flush leva muito tempo, o que significa que o Skia está dando duro.

Nós não sabemos que trabalho é esse. Vamos revisar o código.

Passo 3: Leia o código

Munidos desse conhecimento, vamos olhar o código-fonte. Se o código for desconhecido (como foi para mim no caso do FlutterFolio), vale a pena trocar do modo profile para o modo debug e usar o Flutter Inspector para ir direto ao código-fonte dos widgets relevantes.

A página inicial do FlutterFolio, pelo menos em dispositivos móveis, parece basicamente ser um PageView vertical preenchido com BookCoverWidgets. Olhando para BookCoverWidget, você pode ver que é essencialmente um Stack de vários widgets, começando com uma imagem grande na parte de baixo, continuando com algumas sobreposições animadas, o conteúdo de texto principal, e terminando com uma sobreposição de hover (passar o mouse) no topo.

dart
child: Stack(fit: StackFit.expand, children: [
  /// /////////////////////////////
  /// Background Image
  // Animated scale for when we mouse-over
  AnimatedScale(
    duration: Times.slow,
    begin: 1,
    end: isClickable ? 1.1 : 1,
    child: BookCoverImage(widget.data),
  ),
​
  /// Black overlay, fades out on mouseOver
  AnimatedContainer(duration: Times.slow,
     color: Colors.black.withOpacity(overlayOpacity)),
​
  /// When in large mode, show some gradients,
  /// should sit under the Text elements
  if (widget.largeMode) ...[
    FadeInLeft(
      duration: Times.slower,
      child: _SideGradient(Colors.black),
    ),
    FadeInUp(child: _BottomGradientLg(Colors.black))
  ] else ...[
    FadeInUp(child: _BottomGradientSm(Colors.black)),
  ],
​
  /// Sit under the text content, and unfocus when tapped.
  GestureDetector(behavior: HitTestBehavior.translucent,
      onTap: InputUtils.unFocus),
​
  /// BookContent, shows either the Large cover or Small
  Align(
    alignment: widget.topTitle ? Alignment.topLeft : Alignment.bottomLeft,
    // Tween the padding depending on which mode we're in
    child: AnimatedContainer(
      duration: Times.slow,
      padding: EdgeInsets.all(widget.largeMode ? Insets.offset : Insets.sm),
      child: (widget.largeMode)
          ? LargeBookCover(widget.data)
          : SmallBookCover(widget.data, topTitle: widget.topTitle),
    ),
  ),
​
/// Mouse-over effect
  if (isClickable) ...[
    Positioned.fill(child: FadeIn(child: RoundedBorder(color: theme.accent1, ignorePointer: false))),
  ],
]),

Agora, lembre-se: você está procurando algo que acontece em todo frame (ou seja, está sempre presente) e que pode ser caro para o renderizador Skia desenhar (imagens, blurs, mesclagens e assim por diante).

Passo 4: Aprofunde-se

Agora, você precisa se aprofundar para encontrar widgets que possam ser problemáticos. Uma forma de fazer isso é remover temporariamente vários widgets do app e ver que efeito isso tem no desempenho.

Lembre-se: o primeiro filho de Stack é o fundo, e cada filho subsequente é uma camada sobre os widgets anteriores. Então, o primeiro filho é a imagem de fundo, representada por BookCoverImage. Você poderia removê-la, mas a página inicial ficaria assim:

Isso desfaz o propósito da página inteira. Olhando mais de perto BookCoverImage, você vê que ele é apenas um wrapper simples em torno de Image. Com uma exceção notável (mencionada mais adiante neste artigo), não há muito que possa ser melhorado aqui.

Passando adiante, há este código:

dart
/// Black overlay, fades out on mouseOver
AnimatedContainer(duration: Times.slow,
  color: Colors.black.withOpacity(overlayOpacity)),

Este é um widget que cobre toda a imagem com uma camada de preto transparente. overlayOpacity é 0 por padrão (e na maioria das vezes), então essa camada fica totalmente transparente. Hmm. Vamos removê-la e rodar o app no modo profile de novo.

Interessante! A thread Raster ainda consome bastante carga, mas há uma melhora de performance considerável.

Decidi implementar uma ferramenta de profiling de performance mais robusta para o FlutterFolio, para que eu possa provar que a melhoria é real e não apenas um acaso. Essa mudança me deu uma redução impressionante de 20% no tempo de CPU gasto com rasterização no geral e 50% menos jank potencial.

No fim das contas, é uma mudança enorme para remover um único widget que não faz nada na maior parte do tempo.

A correção é simples:

dart
/// Black overlay, fades out on mouseOver
if (overlayOpacity > 0)
  AnimatedContainer(duration: Times.slow,
      color: Colors.black.withOpacity(overlayOpacity)),

Agora, você só adiciona a camada transparente quando ela tem opacidade diferente de zero (ou seja, está pelo menos parcialmente visível). Assim você evita o cenário (muito comum!) em que uma camada completamente transparente é criada e rasterizada, mas não tem efeito nenhum.

E, assim de cara, o app fica mais fluido e mais eficiente em bateria.

Nota: Por que você precisa fazer isso? O Flutter não deveria ser inteligente o suficiente para fazer essa otimização por nós? Leia a issue aqui para entender por que ele não consegue. E por que a opacidade transparente é lenta para começar? Isso está fora do escopo deste artigo, mas tem a ver com o widget BackdropFilter mais acima na Stack, que interage com todos os widgets abaixo dele.

O ponto principal deste artigo não é ensinar sobre essa armadilha de performance específica. Você talvez nunca mais a encontre. Meu objetivo é ensinar como otimizar a performance da thread Raster em geral.

Passo 5: Generalizar

Antes de passar para um problema completamente diferente, geralmente vale a pena procurar problemas parecidos em outras partes do projeto. Há outros lugares no app com overlays de grande área? Você consegue evitá-los?

Neste caso, as próximas linhas criam gradientes grandes que surgem gradualmente conforme você rola a tela:

dart
/// When in large mode, show some gradients,
/// should sit under the Text elements
if (widget.largeMode) ...[
  FadeInLeft(
    duration: Times.slower,
    child: _SideGradient(Colors.black),
  ),
  FadeInUp(child: _BottomGradientLg(Colors.black))
] else ...[
  FadeInUp(child: _BottomGradientSm(Colors.black)),
],

E, como esperado, remover esses gradientes animados, quase em tela cheia, melhora significativamente a performance da rolagem. Infelizmente, neste caso, a solução não é tão simples quanto no exemplo anterior. Esses gradientes não são invisíveis. Eles começam a aparecer assim que o usuário chega àquela capa. Removê-los faz diferença visual.

Uma ideia é atrasar um pouco o fade in, para que a animação só comece quando o usuário chegar em uma tela específica (BookCover). Assim, você pode aliviar a carga da thread Raster enquanto o usuário rola a tela e, com sorte, evitar parte do jank potencial.

Mas isso é uma mudança no design de movimento do app e, por isso, precisa ser discutida com a equipe maior. Muitas otimizações de performance caem nessa categoria. Otimizar performance costuma ser um exercício de compromissos.

Repita os passos 2 a 5 até ficar satisfeito

Até agora, olhamos para apenas um tipo de problema. Sempre há mais.

Aqui vai uma ideia do que fazer em seguida: as imagens do app são grandes demais? Lembre-se: a thread Raster é responsável por pegar os bytes das imagens, decodificá-los, redimensioná-los, aplicar filtros e assim por diante. Se ela estiver carregando e redimensionando uma imagem de alta definição de 20 MB para um avatar minúsculo na tela, você está desperdiçando recursos.

Quando seu app estiver rodando no modo debug, você pode usar o Flutter Inspector para inverter imagens superdimensionadas.

Isso inverte as cores e espelha todas as imagens do app que são grandes demais para o uso real. Depois, você pode navegar pelo app e observar mudanças estranhas.

O modo debug também reporta um erro sempre que encontra uma imagem assim, por exemplo:

[ERROR] A imagem assets/images/empty-background.png tem um tamanho de exibição de 411×706, mas um tamanho de decodificação de 2560×1600, o que usa 19818KB adicionais.

Aqui a solução não é direta, porém. Em mobile, você não precisa de uma imagem de 2560×1600, mas no desktop, pode precisar. E, lembre-se, o FlutterFolio é um app que roda em todos os targets do Flutter, incluindo desktop. Na dúvida, leia a documentação da API.

Conclusão

Como você pode ver, otimizar performance é uma arte e uma ciência. Benchmarks robustos ajudam, assim como um entendimento profundo do framework e dos seus widgets nativos.

No fim das contas, a prática leva à perfeição. Otimize apps o suficiente e você vai ficando cada vez melhor.

Boa caçada!

Atualização de 2025: Estou escrevendo um livro sobre performance em Flutter. Você pode ler meus rascunhos aqui e pode se inscrever para ser avisado quando o livro for publicado aqui.

Mais do Flutter