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.
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:
-
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.
-
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:
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::Flushleva 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.
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:
/// 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:
/// 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:
/// 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.