Perfilhamento de GPU Móvel (Contadores de Hardware Mali e Adren…

Habilidade de codificação. Lê o que a GPU do telefone realmente está fazendo a partir de seus contadores de hardware, para que as correções atinjam o limite real. Suporta Arm Mali via Arm Performance Studio (captura headless Streamline, Performance Advisor, Mali Offline Compiler, Frame Advisor, RenderDoc para Arm) e Qualcomm Adreno via Snapdragon Profiler / Android GPU Inspector. Inclui scripts que capturam contadores Mali via adb e os transformam em vereditos (limitado por fragmento vs. geometria vs. CPU, fragmentos por pixel, ALU de shader por pixel, compressão de textura).

O que é Perfilhamento de GPU Móvel (Contadores de Hardware Mali e Adren…?

Esta habilidade especializada permite que desenvolvedores e engenheiros de software realizem uma análise aprofundada do desempenho da GPU móvel, indo além de métricas superficiais como FPS e temperatura. Ela se concentra na leitura direta dos contadores de hardware da GPU para identificar gargalos precisos — se o limitador são pixels, vértices, texturas, largura de banda ou matemática de shader — permitindo correções direcionadas que economizam dias de suposições. A habilidade suporta as duas principais arquiteturas de GPU móvel: Arm Mali (via Arm Performance Studio, incluindo ferramentas como Streamline, Performance Advisor e Mali Offline Compiler) e Qualcomm Adreno (via Snapdragon Profiler ou Android GPU Inspector). Ela fornece scripts automatizados para captura de contadores via adb, análise de relatórios e identificação de shaders caros. Estes scripts geram relatórios em markdown com métricas como utilização da GPU, fragmentos por pixel, instruções ALU por fragmento e largura de banda por quadro, juntamente com um veredito claro sobre qual subsistema da GPU está saturado. O fluxo de trabalho orienta o usuário desde a detecção da GPU, passando pela captura de contadores, análise de custo de shaders (com suporte a Godot, Unity, three.js e Bevy) até a aplicação de correções e verificação com ferramentas de sonda de dispositivo. A habilidade também documenta regras práticas aprendidas com capturas reais em dispositivos Android, como lidar com falhas de captura, problemas de conexão e particularidades de ferramentas. É uma ferramenta de escalada para quando a triagem inicial de renderização 3D móvel indica problemas de GPU, mas não consegue identificar a causa raiz exata.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/P0r0ro/mobile-gpu-profiling-skill/tree/HEAD/mobile-gpu-profiling

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Perfilhamento de GPU Móvel (Contadores de Hardware Mali e Adreno)

mobile-3d-rendering mede de fora: fps, memória, temperatura e contadores do mecanismo. Esta habilidade abre a GPU e lê seus contadores de hardware. Ela responde: a GPU é realmente o limite, e, se for, é pixels, vértices, texturas, largura de banda ou matemática de shader? Cada um precisa de uma correção diferente, então adivinhar desperdiça dias.

Quando trazê-la à tona (escalada, não o primeiro passo):

  • A triagem mobile-3d-rendering mostra fps abaixo da meta com contagens de draw dentro do orçamento, ou o fps não se move quando draws e triângulos são cortados;
  • decidir se um efeito de alto nível (mapas normais, MSAA 4x, halo bloom, mais luzes) cabe no orçamento no telefone de referência;
  • encontrar qual shader ou material é caro;
  • calor sem causa óbvia (largura de banda aparece aqui);
  • peculiaridades do lado da GPU em um único fornecedor.

Sempre termine medindo novamente com mobile-3d-rendering/scripts/device_probe.py no dispositivo (fps, p95, inclinação de memória, térmicas). Contadores explicam; a sonda confirma.

0. Detecte a GPU e escolha o caminho

S=~/.claude/skills/mobile-gpu-profiling/scripts
python3 $S/gpu_profile.py detect          # fornecedor, GPU, driver, versão do Android, tamanho da tela
GPUCaptura de contadoresCusto do shaderCaptura de quadro
Arm Mali / Immortalisgpu_profile.py mali-capture (Streamline, headless)malioc_batch.py (Mali Offline Compiler)Frame Advisor, RenderDoc para GPUs Arm
Qualcomm AdrenoSnapdragon Profiler Realtime/Trace (GUI), ou AGI em dispositivos Android 11+ suportadosCompilador offline Adreno (se disponível) ou estatísticas de shader SDPSnapdragon Profiler Snapshot, perfilador de quadro AGI
outro (PowerVR, Xclipse)ferramenta do fornecedor / AGI; gpu_profile.py gpu-busy—RenderDoc / AGI

Notas de instalação para cada ferramenta: references/arm-performance-studio.md, references/adreno.md. O aplicativo deve ser uma compilação depurável (Godot: exportação de depuração; Unity: Development Build; android:debuggable="true").

1. Mali: capture e leia os contadores

python3 $S/gpu_profile.py mali-capture -p <pacote> -s 30 -o gpu-profile-<nome>
#   a primeira execução constrói uma configuração de contador a partir do modelo da Arm para aquela GPU (armazenado em cache em ~/.cache/mobile-gpu-profiling)
#   o script inicia o aplicativo; jogue a cena que você deseja medir (pior caso: multidões, combate, noite)
python3 $S/gpu_profile.py mali-analyze gpu-profile-<nome>/capture.apc --fps 60   # releia depois

Ele escreve report.md + metrics.json. Leia o veredito no topo, depois os números:

MétricaSaudável em um telefone médioSe não for
gpu_util< 75–80% no fps alvo (margem térmica)> 85%: limitado pela GPU, leia as próximas linhas. < 60% com fps baixo: limitado pela CPU, então perfile a CPU
fragment_queue_util vs non_fragment_queue_util / tiler_util—o que estiver perto de 100% é o limite: fragmento = custo por pixel; não-fragmento/tiler = vértices, triângulos, emissores de sombra
fragments_per_screen_pixel< 2.0 (todas as passagens)overdraw, mapas de sombra, passagens de renderização extras (veja render_passes_per_frame)
alu_instr_per_fragment< 20–30 no Bifrostshaders de fragmento pesados → §2
tex_compressed_share / tex_mipmapped_sharealto para texturas de cenatexturas não compactadas/sem mipmap desperdiçam largura de banda e cache (mapas de sombra e render targets nunca são compactados, então verifique quais texturas dominam)
late_zs_test_share< 10%descarte/teste alfa, ou gravações de profundidade do shader, desabilitam early-Z
early_zs_kill_rate, fpk_occluding_sharealto é bomclassifique opacos de frente para trás; evite descarte em grandes superfícies
bandwidth_mb_per_frame< ~30–40 MB a 60 fps em telefones 2018–2020render targets, texturas não compactadas, resoluções MSAA → calor
facing_culled_share~40–50% para malhas fechadasmateriais de dois lados dobrando o trabalho de vértice
fp16_varying_sharealtovaryings mediump reduzem pela metade o custo de interpolação

A referência completa de contador-para-correção, com fórmulas, está em references/mali-counters.md.

Marcadores de quadro: O relatório HTML por quadro do Performance Advisor precisa de limites de quadro da camada da Arm. A Arm suporta Android 11+. No Android 10 (testado em um Galaxy Note 9) os contadores funcionam, mas os quadros da camada nunca alcançaram gatord, então o script volta para contadores por segundo × o fps que ele mede do SurfaceFlinger durante a captura.

2. Encontre o shader caro (qualquer mecanismo, modelo de custo Mali)

# Godot (Compatibility/GLES3): despeje o GLSL ES que o jogo realmente compila, via Mesa no desktop
HEADLESS=1 $S/godot_dump_shaders.sh <projeto_godot> dump/ 20 [res://test_scene.tscn]
python3 $S/malioc_batch.py --core Mali-G72 dump/ --label-src <projeto_godot>/shaders --top 15
  • A classificação lista ciclos por pixel (ou por vértice) e qual pipeline o limita (A aritmética, LS load/store, V varying, T textura). Rótulos nomeiam o seu arquivo de shader; "engine" significa um material embutido.
  • Flags: occ50 significa mais de 32 registradores de trabalho, então metade dos threads estão em voo (latência escondida pior); SPILL significa derramamento de pilha; lateZS significa descarte; fp16:0% significa nenhuma matemática de 16 bits.
  • Custo de um shader ≈ ciclos × pixels que ele cobre. Um shader de 38 ciclos no chão e edifícios importa mais do que um de 60 ciclos em uma placa pequena.
  • Extração de shader Unity, three.js e Bevy: references/shader-cost.md.

O script de despejo executa o jogo contra uma cópia descartável de seus dados de usuário, para que saves e configurações não sejam tocados e o cache de shader do Godot não esconda compilações. Visite as áreas que lhe interessam durante a execução (ou passe uma cena de teste). O Godot compila variantes preguiçosamente.

3. Adreno (Qualcomm)

Use o Snapdragon Profiler: Realtime para métricas ao vivo, Trace para uma linha do tempo, Snapshot para um quadro com estatísticas por draw. Leia as mesmas perguntas de suas métricas: % Shaders Busy, % Time Shading Fragments vs Vertices, Avg Bytes / Fragment, % Texture Fetch Stall, % Texture L1 Miss, ALU / Fragment, % Prims Trivially Rejected, Read/Write Total. A tabela de métrica-para-correção está em references/adreno.md.

Em dispositivos Android 11+ suportados pelo AGI, o Android GPU Inspector fornece contadores neutros de fornecedor mais um perfilador de quadro. Para uma leitura rápida de utilização sem ferramentas, gpu_profile.py gpu-busy -s 30 lê o nó de ocupado do kernel onde a compilação permite.

4. Dos contadores para as mudanças (depois verifique)

  1. Corrija o maior limitador que o relatório nomeia. Faça uma mudança de cada vez.

  2. Mapeamentos típicos:

    LimiteCorreções
    limitado por fragmentomapas de sombra menores/mais curtos e distância de sombra mais curta, menos overdraw transparente, shaders mais baratos em grandes superfícies (mova matemática para o shader de vértice, remova ruído/neblina/especular por pixel em Baixo/Médio, mediump), texturas compactadas+com mipmap, resolução interna mais baixa apenas onde é comprovadamente segura (Mali-G72 vazou memória com escala de renderização)
    limitado por geometria/tilerLOD e faixas de visibilidade, menos emissores de sombra, culling de face traseira ativado, skinning mais simples em multidões
    largura de banda/calortexturas compactadas, menos render targets/passagens, MSAA em vez de AA de pós-processamento, sem pós-processamento em tela cheia
    limitado por CPU (GPU < 60% ocupada)chamadas de draw, scripts, animação, física (performance-optimization)
  3. Recapture a mesma cena e compare metrics.json antes/depois (ms da GPU por quadro, a participação do limitador).

  4. Confirme no dispositivo com device_probe.py por pelo menos 60 s (fps, p95, inclinação de memória, térmicas). Uma vitória de contador que aquece o telefone ou vaza não é uma vitória.

  5. Registre a descoberta nas notas do projeto (o que estava limitando, o que corrigiu, números antes/depois).

Regras duramente conquistadas (de capturas reais)

  • Gere a configuração do contador a partir do modelo da GPU e mantenha apenas contadores de GPU por padrão. Contadores PMU da CPU fizeram a captura filha sair no início em um kernel Samsung Android 10.
  • adb via Wi-Fi funciona, mas o id do dispositivo é ip:porta. Passe-o em todos os lugares (os scripts fazem).
  • Uma captura travada pode deixar agentes gatord vivos dentro da sandbox do aplicativo. Eles bloqueiam os sockets da próxima captura ("Address already in use") e a interrompem precocemente. O script os mata por PID (run-as <pkg> pkill não funcionou).
  • Forçar a parada do aplicativo logo antes de uma captura pode encerrá-la após um segundo. O script espera as coisas se estabilizarem.
  • Streamline-cli -generate-config precisa de -template <nome> antes do alvo, apesar do seu texto de -help.
  • O Godot mantém um cache de shader GLES em user://shader_cache, então uma segunda execução no desktop não compila nada. Use um XDG_DATA_HOME novo (o script de despejo faz).
  • Executar o jogo real no desktop para auditorias escreve seu autosave. Isole o diretório de dados do usuário.

Referências

ArquivoLeia quando
references/arm-performance-studio.mdinstalando/usando Streamline, Performance Advisor, Frame Advisor, RenderDoc para Arm, malioc; detalhes do pipeline headless
references/mali-counters.mdo que cada métrica Mali significa, fórmulas, limiares, Bifrost vs Valhall vs 5ª geração
references/adreno.mdconfiguração do Snapdragon Profiler / AGI e tabela de métrica-para-correção para Adreno
references/shader-cost.mdobtendo shaders compilados do Godot/Unity/three.js/Bevy e lendo a saída do malioc

Habilidades Relacionadas