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-renderingmontre 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
| GPU | Capture de compteurs | Coût du shader | Capture d'image |
|---|---|---|---|
| Arm Mali / Immortalis | gpu_profile.py mali-capture (Streamline, sans tête) | malioc_batch.py (Mali Offline Compiler) | Frame Advisor, RenderDoc pour GPU Arm |
| Qualcomm Adreno | Snapdragon Profiler Realtime/Trace (GUI), ou AGI sur les appareils Android 11+ supportés | Compilateur offline Adreno (si disponible) ou statistiques shader SDP | Snapdragon 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étrique | Sain sur un téléphone moyen | Sinon |
|---|---|---|
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 Bifrost | shaders fragment lourds → §2 |
tex_compressed_share / tex_mipmapped_share | élevé pour les textures de scène | textures 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 bon | trier 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–2020 | rendu targets, textures non compressées, résolutions MSAA → chaleur |
facing_culled_share | ~40–50% pour les maillages fermés | maté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 :
occ50signifie plus de 32 registres de travail, donc la moitié des threads sont en vol (latence cachée moins bien) ;SPILLsignifie débordement de pile ;lateZSsignifie 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)
-
Corrigez le plus grand facteur limitant nommé par le rapport. Faites un changement à la fois.
-
Correspondances typiques :
Limite Correctifs limité fragment cartes 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/tiler LOD et distances de visibilité, moins de projecteurs d'ombre, back-face culling activé, skinning plus simple sur les foules bande passante/chaleur textures 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) -
Re-capturez la même scène et comparez
metrics.jsonavant/après (ms GPU par image, la part du facteur limitant). -
Confirmez sur l'appareil avec
device_probe.pypendant 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. -
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
gatordvivants 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> pkilln'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-configné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 unXDG_DATA_HOMEfrais (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
| Fichier | Lire quand |
|---|---|
references/arm-performance-studio.md | installer/utiliser Streamline, Performance Advisor, Frame Advisor, RenderDoc pour Arm, malioc ; détails du pipeline sans tête |
references/mali-counters.md | ce que chaque métrique Mali signifie, formules, seuils, Bifrost vs Valhall vs 5e génération |
references/adreno.md | configuration Snapdragon Profiler / AGI et table métrique-à-correctif pour Adreno |
references/shader-cost.md | obtenir les shaders compilés de Godot/Unity/three.js/Bevy et lire la sortie de malioc |