Sessions lentes (jeux uniquement)

Les sessions lentes sont une nouvelle métrique Android Vitals dans la Google Play Console. Une session lente est une session dans laquelle plus de 25% des images s'affichent lentement. Un frame est lent s'il n'est pas présenté moins de 50 ms après le frame précédent (équivalent à 20 FPS). Android Vitals signale également une deuxième métrique "Sessions lentes" avec une cible de 34 ms (équivalent à 30 FPS). Les sessions lentes vous permettent de comprendre les performances de votre jeu liées à la fréquence d'images, qui ont un impact sur sa fluidité.

À terme, Play évitera de proposer aux utilisateurs des jeux qui ne peuvent pas atteindre 20 FPS sur leur téléphone. Notez qu'Android Vitals ne surveille la fréquence d'images que si votre jeu s'exécute plus d'une minute.

Pour en savoir plus sur cette métrique, consultez notre Centre d'aide.

Figure 1. Session lente dans Android Vitals.

Remarque :La métrique "Sessions lentes" est calculée à partir des données collectées depuis SurfaceFlinger. Plus concrètement, la fréquence d'images d'une session est estimée en fonction du temps entre les images dessinées sur les surfaces appartenant à l'application. Elle inclut les images affichées par OpenGL, Vulkan et le kit UI Android. Cette métrique n'est disponible que pour les jeux. Si vos applications utilisent le kit d'interface utilisateur basé sur View, dans lequel la partie de l'application visible par l'utilisateur provient de Canvas ou de la hiérarchie View, consultez Rendu lent

.

Mesurer les FPS et détecter les images lentes

La commande dumpsys surfaceflinger timestats Android fournit un histogramme de fréquence d'images moyenne et de présentation à présentation pour toutes les couches en cours d'affichage. Le temps présent à présent d'un frame correspond à l'intervalle entre le frame actuel et le frame précédent en cours de dessin. Voici les étapes à suivre pour utiliser la commande afin de collecter les FPS de votre jeu:

1. Exécutez la commande avec les options enable et clear pour commencer à capturer des informations:

   adb shell dumpsys SurfaceFlinger --timestats -clear -enable
   

2. Lorsque le jeu a été joué suffisamment longtemps, exécutez à nouveau la commande avec l'indicateur dump pour vider les informations:

   adb shell dumpsys SurfaceFlinger --timestats -dump
   

   Les informations extraites fournissent le nombre total de frames et l'histogramme presentToPresent pour toutes les couches affichées par SurfaceFlinger. Vous devez trouver la section de votre jeu en filtrant en fonction de layerName:

   layerName = SurfaceView[com.google.test/com.devrel.MainActivity]@0(BLAST)#132833
   

   La fréquence d'images lente de la session peut être calculée en fonction des informations de chaque couche.

   Par exemple, le pourcentage de frames lents à 20 FPS = (somme des valeurs de 54 ms à 1 000 ms) / totalFrames x 100

   totalFrames = 274
   ...
   presentToPresent histogram is as below:
   0ms=0 1ms=0 2ms=0 3ms=0 4ms=0 5ms=0 6ms=0 7ms=0 8ms=0 9ms=0 10ms=0 11ms=0 12ms=0
   13ms=0 14ms=0 15ms=0 16ms=1 17ms=0 18ms=0 19ms=0 20ms=0 21ms=0 22ms=0 23ms=0
   24ms=0 25ms=0 26ms=0 27ms=0 28ms=0 29ms=0 30ms=0 31ms=0 32ms=0 33ms=269 34ms=0
   36ms=0 38ms=0 40ms=0 42ms=0 44ms=0 46ms=0 48ms=0 50ms=1 54ms=0 58ms=0 62ms=0
   66ms=0 70ms=1 74ms=0 78ms=0 82ms=0 86ms=0 90ms=0 94ms=0 98ms=0 102ms=0 106ms=0
   110ms=0 114ms=0 118ms=0 122ms=0 126ms=0 130ms=0 134ms=0 138ms=0 142ms=0 146ms=0
   150ms=0 200ms=0 250ms=0 300ms=0 350ms=0 400ms=0 450ms=0 500ms=0 550ms=0 600ms=0
   650ms=0 700ms=0 750ms=0 800ms=0 850ms=0 900ms=0 950ms=0 1000ms=0
   

   Le nombre moyen d'images par seconde de chaque calque est également affiché dans le dump:

   ...
   averageFPS = 30.179
   ...
   

3. Une fois toutes les informations collectées, vous devez désactiver les statistiques temporelles à l'aide de l'indicateur disable:

   adb shell dumpsys SurfaceFlinger --timestats -disable
   

Causes et solutions des images lentes

Un cadre peut s'afficher ou s'afficher plus longtemps à l'écran que la cible du développeur pour de nombreuses raisons. Le jeu peut être lié au processeur/GPU. Ou l'appareil surchauffe et active un état thermique limité. Ou il existe un incompatibilité entre la fréquence d'images du jeu et la fréquence d'actualisation de l'écran de l'appareil.

Utilisez Android Frame Pacing (Swappy), Vulkan et ADPF pour résoudre ces problèmes et améliorer les performances de votre jeu.

Qu'est-ce que Swappy ?

La bibliothèque Android Frame Pacing, également appelée Swappy, fait partie des bibliothèques AGDK. Swappy permet aux jeux OpenGL et Vulkan d'obtenir un rendu fluide et un frame pacing correct sur Android.

Le frame pacing désigne la synchronisation de la logique et de la boucle de rendu d'un jeu avec le sous-système d'affichage d'un système d'exploitation et le matériel utilisé pour l'affichage. Le sous-système d'affichage Android a été conçu pour éviter les artefacts visuels (appelés "tearing") qui peuvent se produire lorsque le matériel d'affichage passe à une nouvelle image avant d'avoir terminé l'affichage de la précédente. Pour éviter ces artefacts, le sous-système d'affichage effectue les opérations suivantes:

• Met en mémoire tampon les images précédentes
• Détecte les envois d'images tardifs
• Réaffiche des images passées en cas d'images tardives détectées

Découvrez comment Mir 2 a utilisé Swappy pour réduire son taux de sessions lentes de 40% à 10%.

Utiliser Swappy dans des projets natifs

Consultez les guides suivants pour intégrer la bibliothèque Android Frame Pacing à votre jeu:

• Intégrer le frame pacing Android dans votre moteur de rendu OpenGL
• Intégrer Android Frame Pacing dans votre moteur de rendu Vulkan

Utiliser Swappy dans le moteur de jeu Unity

Unity a intégré Android Frame Pacing dans son moteur. Pour activer cette fonctionnalité dans Unity 2019.2 ou version ultérieure, cochez la case Optimized Frame Pacing (Frame pacing optimisé) sous Project Settings > Player > Settings (Paramètres du projet > Lecteur > Paramètres) pour Android > Resolution and Presentation (Android > Résolution et présentation) :

Figure 2. Activez le Frame Pacing dans Unity Engine.

Vous pouvez également activer de manière programmatique l'option Optimized Frame Pacing (Rythme de frames optimisé) dans votre code logique pour permettre à Unity de distribuer uniformément les frames afin de réduire la variance de la fréquence d'images, ce qui améliore le gameplay.

Utiliser Swappy dans le moteur de jeu Unreal

Unreal 4.25 et versions ultérieures intègrent la bibliothèque Android Frame Pacing, qui fait partie de l'Android Game Development Kit. L'article Frame Pacing mobile explique comment activer la bibliothèque Frame Pacing d'Android et comment contrôler le rythme d'affichage des frames depuis du code C++.

Qu'est-ce que Vulkan ?

Vulkan est une API multiplate-forme moderne pour les graphismes 3D conçue pour minimiser l'abstraction entre le matériel graphique de l'appareil et votre jeu. Vulkan est la principale API graphique de bas niveau sur Android. Elle remplace OpenGL ES. OpenGL ES est toujours compatible avec Android, mais ses fonctionnalités ne sont plus en cours de développement.

Vulkan offre les avantages suivants par rapport à OpenGL ES :

• Architecture plus efficace avec une surcharge du processeur réduite dans le pilote graphique
• Nouvelles stratégies d'optimisation pour améliorer les performances du processeur
• Nouvelles fonctionnalités graphiques non disponibles dans OpenGL ES, telles que les API sans liaison et le ray tracing

Utiliser Vulkan dans des projets Android natifs

L'atelier de programmation Premiers pas avec Vulkan sur Android vous explique comment configurer votre pipeline de rendu Vulkan, puis afficher un triangle texturé et rotatif à l'écran. Utilisez l'atelier de programmation pour apprendre à afficher les graphismes de votre jeu.

Utiliser Vulkan dans le moteur de jeu Unity

Pour activer la sélection automatique de l'appareil sur Unity, suivez la procédure de configuration de l'API Auto Graphics.

Figure 3. Activez l'API Auto Graphics d'Unity.

Vous pouvez également activer Vulkan manuellement en désactivant l'API Auto Graphics et en attribuant à Vulkan la priorité la plus élevée dans la liste des API graphiques. Si vous utilisez Unity 2021.1 ou une version antérieure, il s'agit de la seule méthode pour utiliser Vulkan.

Figure 4. Choisissez manuellement Vulkan comme API graphique principale dans Unity.

Utilisez le plug-in du moteur Unity VkQuality pour fournir des recommandations au moment du lancement de l'API graphique à utiliser par votre jeu sur des appareils spécifiques.

Utiliser Vulkan dans le moteur de jeu Unreal

Pour activer l'API graphique Vulkan, accédez à Project Settings > Platforms > Android > Build (Paramètres de projet > Plates-formes > Android > Compilation) et sélectionnez Support Vulkan (Prendre en charge Vulkan). Lorsque vous sélectionnez à la fois Prendre en charge Vulkan et Prendre en charge OpenGL ES 3.2, Unreal utilise Vulkan par défaut. Si l'appareil n'est pas compatible avec Vulkan, Unreal bascule sur OpenGL ES 3.2.

Figure 5 : Activez Vulkan dans Unreal Engine.

Si vous utilisez des fonctionnalités Vulkan spécifiques qui sont connues pour se comporter mal sur certains appareils, vous pouvez personnaliser votre fichier BaseDeviceProfile.ini pour exclure ces appareils. Consultez Personnaliser les profils d'appareil et la scalabilité pour Android pour découvrir comment personnaliser BaseDeviceProfile.ini. Comme de nouveaux pilotes d'appareils peuvent corriger des appareils défectueux précédemment identifiés, mettez à jour votre fichier BaseDeviceProfile.ini pour bénéficier de toutes les optimisations.

Qu'est-ce que l'ADPF ?

Android Dynamic Performance Framework (ADPF) optimise les jeux en fonction des fonctionnalités dynamiques de gestion thermique, de processeur et de GPU sur Android. Bien que nous mettions ici l'accent sur les jeux, ces fonctionnalités peuvent également s'appliquer à d'autres applications haute performance.

ADPF est un ensemble d'API permettant aux jeux et aux applications haute performance d'interagir plus directement avec les systèmes d'alimentation et thermiques des appareils Android. Ces API vous offrent la possibilité de surveiller le comportement dynamique des appareils Android et d'optimiser les performances de jeu à un niveau durable sans provoquer de surchauffe des appareils.

Voici les principales fonctionnalités d'ADPF :

• API Thermal: surveillez l'état thermique d'un appareil afin que l'application puisse ajuster de manière proactive la charge de travail avant qu'elle ne devienne insoutenable.
• API CPU Performance Hint: fournit des indices de performances permettant à Android de choisir les paramètres de performances appropriés (par exemple, le point de fonctionnement ou le cœur du processeur) pour la charge de travail.
• API Game Mode et API Game State: permet d'optimiser le jeu en donnant la priorité aux performances ou à l'autonomie de la batterie, en fonction des paramètres de l'utilisateur et des configurations spécifiques à chaque jeu.
• Mode performances fixes: activez le mode performances fixes sur un appareil lors de l'analyse comparative afin d'obtenir des mesures qui ne sont pas modifiées par les horloges de processeur dynamiques.
• Mode d'efficacité énergétique: indique à la session que les threads de la session d'indice de performances peuvent être planifiés en toute sécurité pour privilégier l'efficacité énergétique aux performances. Disponible dans Android 15 (niveau d'API 35).

Utiliser ADPF dans des projets Android natifs

L'atelier de programmation Intégrer des fonctionnalités d'adaptabilité dans votre jeu natif vous aide à intégrer les fonctionnalités d'adaptabilité dans votre jeu en suivant les étapes à votre rythme. À la fin de l'atelier de programmation, vous aurez intégré les fonctionnalités suivantes:

• API Thermal: écoutez l'état thermique de l'appareil et réagissez avant qu'il ne passe en mode de limitation thermique.
• API Game Mode: identifiez les préférences d'optimisation des joueurs (maximiser les performances ou préserver la batterie) et ajustez-les en conséquence.
• API Game State: indiquez au système l'état de votre jeu (chargement, lecture, UI, etc.). Le système peut alors ajuster les ressources en conséquence (booster les E/S, ou le processeur, le GPU, etc.).
• API Performance Hint: indiquez au système votre modèle de thread et votre charge de travail afin qu'il puisse allouer les ressources en conséquence.

Utiliser ADPF dans le moteur de jeu Unity

Les performances adaptatives d'Unity sont un outil destiné aux développeurs de jeux qui souhaitent optimiser leurs jeux sur les appareils mobiles, en particulier pour le vaste écosystème Android. Les performances adaptatives permettent à votre jeu de s'adapter aux performances et aux caractéristiques thermiques de l'appareil en temps réel, ce qui garantit une expérience de jeu fluide et efficace.

Le fournisseur Android Adaptive Performance vous guide tout au long de la procédure d'implémentation d'ADPF dans Unity.

Figure 6 : Intégrez ADPF dans Unity Engine.

Utiliser ADPF dans le moteur de jeu Unreal

Figure 7 : Intégrez ADPF dans Unreal Engine.

1. Télécharger le plug-in
2. Copier le plug-in dans le dossier des plug-ins du projet
3. Activer le plug-in Unreal Engine ADPF dans l'éditeur Unreal
4. Redémarrer l'éditeur Unreal
5. Créer et compiler le jeu

Le plug-in Android Dynamic Performance Framework(ADPF) pour Unreal Engine offre des performances stables et empêche le throttling thermique. Téléchargez le plug-in sur GitHub. Ce plug-in modifie les fonctionnalités en définissant des valeurs de console irréelles.