Profilage GPU mobile (compteurs matériels Mali et Adreno)

Compétence de codage. Lit ce que le GPU du téléphone fait réellement à partir de ses compteurs matériels, afin que les correctifs ciblent la vraie limite. Support Arm Mali via Arm Performance Studio (capture Streamline sans tête, Performance Advisor, Mali Offline Compiler, Frame Advisor, RenderDoc pour Arm) et Qualcomm Adreno via Snapdragon Profiler / Android GPU Inspector. Fournit des scripts qui capturent les compteurs Mali via adb et les transforment en verdicts (limit fragment vs géométrie vs CPU, fragments par pixel, shader ALU par pixel, compression de texture).

Qu'est-ce que Profilage GPU mobile (compteurs matériels Mali et Adreno) ?

Cette compétence plonge dans les compteurs matériels du GPU mobile pour déterminer avec précision ce qui limite les performances : pixels (fragments), sommets (géométrie), textures, bande passante ou calculs de shaders. Elle est conçue comme un outil de diagnostic avancé, à utiliser lorsque la sonde externe `mobile-3d-rendering` montre un FPS bas malgré des budgets de dessins raisonnables, ou que la chaleur est suspecte sans cause évidente. La compétence supporte les GPU Arm Mali (via Arm Performance Studio : capture Streamline, analyseur Performance Advisor, compilateur offline MaliOC) et Qualcomm Adreno (via Snapdragon Profiler ou Android GPU Inspector). Elle automatisé la détection du GPU, la capture des compteurs via adb, et l'analyse avec un script unique `gpu_profile.py`. Le résultat est un rapport clair (`report.md`) et un fichier de métriques (`metrics.json`) listant des indicateurs comme `gpu_util`, `fragment_queue_util`, `fragments_per_screen_pixel`, `alu_instr_per_fragment`, `bandwidth_mb_per_frame`, etc. Pour les shaders coûteux, la compétence propose `malioc_batch.py` qui évalue le coût en cycles par pixel/sommet, et un script pour extraire les shaders Godot via Mesa. Enfin, elle insiste sur la vérification par une re-mesure avec `device_probe.py` pour confirmer que le correctif n'engendre pas de fuite thermique ou mémoire.

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

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Profilage GPU mobile (compteurs matériels Mali et Adreno) ?

mobile-3d-rendering mesure de l'extérieur : fps, mémoire, température et compteurs moteur. Cette compétence ouvre le GPU et lit ses compteurs matériels. Elle répond à la question : le GPU est-il vraiment le goulot d'étranglement, et si oui, est-ce les pixels, sommets, textures, bande passante ou les calculs de shaders ? Chacun nécessite un correctif différent, donc deviner fait perdre des jours.

Quand l'utiliser (escalade, pas la première étape) :

  • le triage de mobile-3d-rendering montre un fps en dessous de la cible avec un budget de dessins respecté, ou le fps ne bouge pas quand on réduit les dessins et les triangles ;
  • décider si un effet haut de gamme (normal maps, MSAA 4x, bloom halo, plus de lumières) tient dans le budget sur le téléphone de référence ;
  • identifier quel shader ou matériau est coûteux ;
  • chaleur sans cause évidente (la bande passante apparaît ici) ;
  • anomalies côté GPU chez un seul constructeur.

Terminez toujours par une re-mesure avec mobile-3d-rendering/scripts/device_probe.py sur l'appareil (fps, p95, pente mémoire, thermiques). Les compteurs expliquent ; la sonde confirme.

0. Détecter le GPU et choisir la voie

S=~/.claude/skills/mobile-gpu-profiling/scripts
python3 $S/gpu_profile.py detect          # constructeur, GPU, pilote, version Android, taille écran
GPUCapture de compteursCoût du shaderCapture d'image
Arm Mali / Immortalisgpu_profile.py mali-capture (Streamline, sans tête)malioc_batch.py (Mali Offline Compiler)Frame Advisor, RenderDoc pour GPU Arm
Qualcomm AdrenoSnapdragon Profiler Realtime/Trace (GUI), ou AGI sur les appareils Android 11+ supportésCompilateur offline Adreno (si disponible) ou statistiques shader SDPSnapdragon Profiler Snapshot, profileur d'images AGI
autre (PowerVR, Xclipse)outil constructeur / AGI ; gpu_profile.py gpu-busy—RenderDoc / AGI

Notes d'installation pour chaque outil : references/arm-performance-studio.md, references/adreno.md. L'application doit être une version debuggable (Godot : export debug ; Unity : Development Build ; android:debuggable="true").

1. Mali : capturer et lire les compteurs

python3 $S/gpu_profile.py mali-capture -p <package> -s 30 -o gpu-profile-<nom>
#   le premier exécution construit une configuration de compteurs à partir du modèle Arm pour ce GPU (mis en cache dans ~/.cache/mobile-gpu-profiling)
#   le script lance l'application ; jouez la scène que vous voulez mesurer (le pire cas : foules, combat, nuit)
python3 $S/gpu_profile.py mali-analyze gpu-profile-<nom>/capture.apc --fps 60   # relire plus tard

Il écrit report.md + metrics.json. Lisez le verdict en haut, puis les nombres :

MétriqueSain sur un téléphone moyenSinon
gpu_util< 75–80% au fps cible (marge thermique)> 85% : limité GPU, lisez les lignes suivantes. < 60% avec fps bas : limité CPU, profilez donc le CPU
fragment_queue_util vs non_fragment_queue_util / tiler_util—celui proche de 100% est la limite : fragment = coût par pixel ; non-fragment/tiler = sommets, triangles, projecteurs d'ombre
fragments_per_screen_pixel< 2.0 (toutes passes)surdessin, cartes d'ombre, passes de rendu supplémentaires (voir render_passes_per_frame)
alu_instr_per_fragment< 20–30 sur Bifrostshaders fragment lourds → §2
tex_compressed_share / tex_mipmapped_shareélevé pour les textures de scènetextures non compressées/sans mipmap gaspillent la bande passante et le cache (les cartes d'ombre et rendu targets ne sont jamais compressés, vérifiez donc quelles textures dominent)
late_zs_test_share< 10%discard/test alpha, ou écritures de profondeur dans le shader, désactivent le early-Z
early_zs_kill_rate, fpk_occluding_shareélevé est bontrier opaque de devant à derrière ; éviter discard sur les grandes surfaces
bandwidth_mb_per_frame< ~30–40 Mo à 60 fps sur les téléphones 2018–2020rendu targets, textures non compressées, résolutions MSAA → chaleur
facing_culled_share~40–50% pour les maillages fermésmatériaux double-face doublant le travail de sommets
fp16_varying_shareélevéles varyings mediump réduisent de moitié le coût d'interpolation

La référence complète des compteurs aux correctifs, avec formules, est dans references/mali-counters.md.

Marqueurs d'image : Le rapport HTML par image de Performance Advisor a besoin des limites d'image de la couche Arm. Arm supporte Android 11+. Sur Android 10 (testé sur un Galaxy Note 9) les compteurs fonctionnent mais les images de la couche n'ont jamais atteint gatord, donc le script retombe sur les compteurs par seconde × le fps qu'il mesure depuis SurfaceFlinger pendant la capture.

2. Trouver le shader coûteux (tout moteur, modèle de coût Mali)

# Godot (Compatibility/GLES3) : vider le GLSL ES que le jeu compile vraiment, via Mesa sur le bureau
HEADLESS=1 $S/godot_dump_shaders.sh <projet_godot> dump/ 20 [res://test_scene.tscn]
python3 $S/malioc_batch.py --core Mali-G72 dump/ --label-src <projet_godot>/shaders --top 15
  • Le classement liste les cycles par pixel (ou par sommet) et quel pipeline les limite (A arithmétique, LS chargement/sauvegarde, V varying, T texture). Les étiquettes nomment votre fichier shader ; "engine" signifie un matériau intégré.
  • Drapeaux : occ50 signifie plus de 32 registres de travail, donc la moitié des threads sont en vol (latence cachée moins bien) ; SPILL signifie débordement de pile ; lateZS signifie discard ; fp16:0% signifie pas de calcul 16 bits.
  • Coût d'un shader ≈ cycles × pixels qu'il couvre. Un shader de 38 cycles sur le sol et les bâtiments est plus important qu'un shader de 60 cycles sur un petit panneau.
  • Extraction de shaders Unity, three.js et Bevy : references/shader-cost.md.

Le script de vidage exécute le jeu contre une copie jetable de ses données utilisateur, donc les sauvegardes et paramètres ne sont pas touchés et le cache de shaders de Godot ne cache pas les compilations. Visitez les zones qui vous intéressent pendant l'exécution (ou passez une scène de test). Godot compile les variantes paresseusement.

3. Adreno (Qualcomm)

Utilisez Snapdragon Profiler : Realtime pour les métriques en direct, Trace pour une chronologie, Snapshot pour une image avec des statistiques par dessin. Lisez les mêmes questions dans ses métriques : % Shaders Busy, % Time Shading Fragments vs Vertices, Avg Bytes / Fragment, % Texture Fetch Stall, % Texture L1 Miss, ALU / Fragment, % Prims Trivially Rejected, Read/Write Total. La table métrique-à-correctif est dans references/adreno.md.

Sur les appareils Android 11+ qu'AGI supporte, Android GPU Inspector fournit des compteurs neutres vis-à-vis du constructeur plus un profileur d'images. Pour une lecture rapide de l'utilisation sans outils, gpu_profile.py gpu-busy -s 30 lit le nœud busy du noyau là où la version le permet.

4. Des compteurs aux modifications (puis vérifier)

  1. Corrigez le plus grand facteur limitant nommé par le rapport. Faites un changement à la fois.

  2. Correspondances typiques :

    LimiteCorrectifs
    limité fragmentcartes d'ombre moins nombreuses/plus petites et distance d'ombre plus courte, moins de surdessin transparent, shaders moins chers sur les grandes surfaces (déplacer les calculs vers le vertex shader, supprimer le bruit/brouillard/speculaire par pixel sur Bas/Moyen, mediump), textures compressées+mipmappées, résolution interne plus basse uniquement là où c'est prouvé sûr (Mali-G72 fuitait la mémoire avec le redimensionnement de rendu)
    limité géométrie/tilerLOD et distances de visibilité, moins de projecteurs d'ombre, back-face culling activé, skinning plus simple sur les foules
    bande passante/chaleurtextures compressées, moins de rendu targets/passes, MSAA au lieu de post-AA, pas de post-traitement plein écran
    limité CPU (GPU < 60% occupé)appels de dessin, scripts, animation, physique (performance-optimization)
  3. Re-capturez la même scène et comparez metrics.json avant/après (ms GPU par image, la part du facteur limitant).

  4. Confirmez sur l'appareil avec device_probe.py pendant au moins 60 s (fps, p95, pente mémoire, thermiques). Un gain de compteurs qui chauffe le téléphone ou fuit n'est pas un gain.

  5. Enregistrez la découverte dans les notes du projet (ce qui était limitant, ce qui l'a corrigé, nombres avant/après).

Règles durement acquises (de vraies captures)

  • Générez la configuration de compteurs à partir du modèle du GPU, et gardez uniquement les compteurs GPU par défaut. Les compteurs PMU CPU faisaient que la capture enfant se terminait au démarrage sur un noyau Samsung Android 10.
  • Le adb Wi-Fi fonctionne, mais l'identifiant de l'appareil est ip:port. Passez-le partout (les scripts le font).
  • Une capture qui a planté peut laisser des agents gatord vivants dans le bac à sable de l'application. Ils bloquent les sockets de la capture suivante ("Address already in use") et l'écourtent. Le script les tue par PID (run-as <pkg> pkill n'a pas fonctionné).
  • Forcer l'arrêt de l'application juste avant une capture peut la terminer après une seconde. Le script attend que les choses se stabilisent.
  • Streamline-cli -generate-config nécessite -template <nom> avant la cible, malgré son texte d'-help.
  • Godot conserve un cache de shaders GLES dans user://shader_cache, donc une deuxième exécution sur le bureau ne compile rien. Utilisez un XDG_DATA_HOME frais (le script de vidage le fait).
  • Exécuter le vrai jeu sur le bureau pour des audits écrit sa sauvegarde automatique. Isolez le répertoire de données utilisateur.

Références

FichierLire quand
references/arm-performance-studio.mdinstaller/utiliser Streamline, Performance Advisor, Frame Advisor, RenderDoc pour Arm, malioc ; détails du pipeline sans tête
references/mali-counters.mdce que chaque métrique Mali signifie, formules, seuils, Bifrost vs Valhall vs 5e génération
references/adreno.mdconfiguration Snapdragon Profiler / AGI et table métrique-à-correctif pour Adreno
references/shader-cost.mdobtenir les shaders compilés de Godot/Unity/three.js/Bevy et lire la sortie de malioc

Skills associés