La résolution des LMK dans votre jeu Unity est un processus systématique :
Obtenir un instantané de mémoire
Utilisez le Profileur Unity pour obtenir un instantané de la mémoire gérée par Unity. La figure 2 montre les couches de gestion de la mémoire utilisées par Unity pour gérer la mémoire dans votre jeu.
Mémoire gérée
La gestion de la mémoire d'Unity implémente une couche de mémoire contrôlée qui utilise un tas géré et un récupérateur de mémoire pour allouer et attribuer automatiquement de la mémoire. Le système de mémoire gérée est un environnement de script C# basé sur Mono ou IL2CPP. L'avantage du système de mémoire gérée est qu'il utilise un récupérateur de mémoire pour libérer automatiquement les allocations de mémoire.
Mémoire non gérée C#
La couche de mémoire C# non gérée permet d'accéder à la couche de mémoire native, ce qui permet de contrôler précisément les allocations de mémoire lors de l'utilisation du code C#. Cette couche de gestion de la mémoire est accessible via l'espace de noms Unity.Collections et par des fonctions telles que UnsafeUtility.Malloc et UnsafeUtility.Free.
Mémoire native
Le cœur C/C++ interne d'Unity utilise un système de mémoire natif pour gérer les scènes, les éléments, les API graphiques, les pilotes, les sous-systèmes et les tampons de plug-in. Bien que l'accès direct soit limité, vous pouvez manipuler les données en toute sécurité avec l'API C# d'Unity et bénéficier d'un code natif efficace. La mémoire native nécessite rarement une interaction directe, mais vous pouvez surveiller son impact sur les performances à l'aide du Profileur et ajuster les paramètres pour optimiser les performances.
La mémoire n'est pas partagée entre C# et le code natif, comme illustré dans la figure 3. Les données requises par C# sont allouées dans l'espace mémoire géré chaque fois que cela est nécessaire.
Pour que le code du jeu géré (C#) accède aux données de mémoire natives du moteur, par exemple, un appel à GameObject.transform effectue un appel natif pour accéder aux données de mémoire dans la zone native, puis renvoie les valeurs à C# à l'aide de Bindings. Les liaisons garantissent des conventions d'appel appropriées pour chaque plate-forme et gèrent le marshaling automatique des types gérés dans leurs équivalents natifs.
Cela ne se produit que la première fois, car le shell géré permettant d'accéder à la propriété transform est conservé dans le code natif. La mise en cache de la propriété de transformation peut réduire le nombre d'appels entre le code géré et le code natif, mais l'utilité de la mise en cache dépend de la fréquence d'utilisation de la propriété. Notez également qu'Unity ne copie pas de parties de la mémoire native dans la mémoire gérée lorsque vous accédez à ces API.
Pour en savoir plus, consultez Memory in Unity introduction (Introduction à la mémoire dans Unity).
De plus, il est essentiel d'établir un budget mémoire pour que votre jeu fonctionne correctement. L'implémentation d'un système d'analyse ou de reporting de la consommation de mémoire permet de s'assurer que chaque nouvelle version ne dépasse pas le budget mémoire. L'intégration de tests en mode Lecture à votre intégration continue (CI) pour vérifier la consommation de mémoire dans des zones spécifiques du jeu est une autre stratégie pour obtenir de meilleures informations.
Gérer les éléments
Il s'agit de la partie la plus importante et la plus exploitable de la consommation de mémoire. Profilez le plus tôt possible.
L'utilisation de la mémoire dans les jeux Android peut varier considérablement en fonction du type de jeu, du nombre et des types d'assets, ainsi que des stratégies d'optimisation de la mémoire. Toutefois, les textures, les maillages, les fichiers audio, les nuanceurs, les animations et les scripts sont généralement les principaux facteurs d'utilisation de la mémoire.
Détecter les assets en double
La première étape consiste à détecter les éléments mal configurés et les éléments en double à l'aide du profileur de mémoire, d'un outil de rapport de compilation ou de Project Auditor.
Textures
Analysez la compatibilité de votre jeu avec les appareils et choisissez le format de texture approprié. Vous pouvez diviser les bundles de textures pour les appareils haut de gamme et bas de gamme à l'aide de Play Asset Delivery, d'Addressable ou d'un processus plus manuel avec un AssetBundle.
Suivez les recommandations les plus connues disponibles dans Optimize Your Mobile Game Performance (Optimiser les performances de votre jeu mobile) et dans le post de discussion Optimising Unity Texture Import Settings (Optimiser les paramètres d'importation de textures Unity). Essayez ensuite les solutions suivantes :
Compressez les textures avec les formats ASTC pour réduire l'espace mémoire utilisé et testez un taux de bloc plus élevé, par exemple 8x8.
Si vous devez utiliser ETC2, regroupez vos textures dans Atlas. Placer plusieurs textures dans une seule texture garantit sa puissance de deux (POT), peut réduire les appels de dessin et accélérer l'affichage.
Optimisez le format et la taille de la texture RenderTarget. Évitez les textures en haute résolution inutilement. L'utilisation de textures plus petites sur les appareils mobiles permet d'économiser de la mémoire.
Utilisez la combinaison de canaux de texture pour économiser de la mémoire de texture.
Maillages et modèles
Commencez par vérifier les paramètres fondamentaux (page 27), puis vérifiez les paramètres d'importation de maillage suivants :
- Fusionnez les maillages redondants et plus petits.
- Réduisez le nombre de sommets pour les objets des scènes (par exemple, les objets statiques ou distants).
- Générez des groupes de niveaux de détail (LOD) pour les éléments à géométrie élevée.
Matériaux et nuanceurs
- Supprimez les variantes de nuanceur inutilisées de manière programmatique pendant le processus de compilation.
- Regroupez les variantes de nuanceurs fréquemment utilisées dans des nuanceurs Uber pour éviter la duplication des nuanceurs.
- Activez le chargement dynamique des nuanceurs pour résoudre le problème d'espace mémoire important utilisé par les nuanceurs préchargés dans la VRAM/RAM. Toutefois, faites attention si la compilation du nuanceur entraîne des saccades.
- Utilisez le chargement dynamique des nuanceurs pour empêcher le chargement de toutes les variantes. Pour en savoir plus, consultez l'article de blog Improvements to shader build times and memory usage (Améliorations des temps de compilation et de l'utilisation de la mémoire des nuanceurs).
- Utilisez correctement l'instanciation de matériaux en exploitant
MaterialPropertyBlocks.
Audio
Commencez par vérifier les paramètres fondamentaux (page 41), puis vérifiez les paramètres d'importation de maillage suivants :
- Supprimez les références
AudioClipinutilisées ou redondantes lorsque vous utilisez des moteurs audio tiers tels que FMOD ou Wwise. - Précharger les données audio. Désactivez le préchargement pour les clips qui ne sont pas immédiatement requis lors de l'exécution ou du démarrage de la scène. Cela permet de réduire la surcharge de mémoire lors de l'initialisation de la scène.
Animations
- Ajustez les paramètres de compression d'animation d'Unity pour réduire le nombre d'images clés et éliminer les données redondantes.
- Réduction des images clés : supprime automatiquement les images clés inutiles.
- Compression des quaternions : compresse les données de rotation pour réduire l'utilisation de la mémoire.
Vous pouvez ajuster les paramètres de compression dans les paramètres d'importation d'animation sous l'onglet Rig ou Animation.
Réutilisez les clips d'animation au lieu de les dupliquer pour différents objets.
Utilisez des contrôleurs de remplacement d'animateur pour réutiliser un contrôleur d'animateur et remplacer des clips spécifiques pour différents personnages.
Intégrez les animations basées sur la physique : si vos animations sont basées sur la physique ou procédurales, intégrez-les dans des clips d'animation pour éviter les calculs d'exécution.
Optimisez le squelette : utilisez moins d'os dans votre squelette pour réduire la complexité et la consommation de mémoire.
- Évitez d'utiliser trop d'os pour les objets petits ou statiques.
- Si certains os ne sont pas animés ou nécessaires, supprimez-les du squelette.
Réduisez la durée du clip d'animation.
- Découpez les clips d'animation pour n'inclure que les images nécessaires. Évitez de stocker des animations inutilisées ou excessivement longues.
- Utilisez des animations en boucle au lieu de créer de longs clips pour les mouvements répétés.
Assurez-vous qu'un seul composant d'animation est associé ou activé. Par exemple, désactivez ou supprimez les composants Ancienne animation si vous utilisez Animator.
Évitez d'utiliser l'Animator si ce n'est pas nécessaire. Pour les effets visuels de base, utilisez des bibliothèques d'interpolation ou implémentez l'effet visuel dans un script. Le système d'animation peut consommer beaucoup de ressources, en particulier sur les appareils mobiles bas de gamme.
Utilisez le système de tâches pour les animations lorsque vous gérez un grand nombre d'animations, car ce système a été entièrement repensé pour être plus efficace en termes de mémoire.
Scènes
Lorsque de nouvelles scènes sont chargées, elles importent des éléments en tant que dépendances. Toutefois, sans une gestion appropriée du cycle de vie des éléments, ces dépendances ne sont pas surveillées par les compteurs de référence. Par conséquent, les éléments peuvent rester en mémoire même après le déchargement des scènes inutilisées, ce qui entraîne une fragmentation de la mémoire.
- Utilisez le pooling d'objets d'Unity pour réutiliser les instances GameObject pour les éléments de gameplay récurrents, car le pooling d'objets utilise une pile pour contenir une collection d'instances d'objets à réutiliser et n'est pas thread-safe. La réduction de
Instantiateet deDestroyaméliore à la fois les performances du processeur et la stabilité de la mémoire. - Déchargement des éléments :
- Déchargez les éléments de manière stratégique pendant les moments moins critiques, comme les écrans de démarrage ou de chargement.
- L'utilisation fréquente de
Resources.UnloadUnusedAssetsentraîne des pics de traitement du processeur en raison d'opérations de surveillance des dépendances internes volumineuses. - Recherchez les pics d'utilisation du processeur dans le repère de profil GC.MarkDependencies.
Supprimez ou réduisez sa fréquence d'exécution, et déchargez manuellement des ressources spécifiques à l'aide de Resources.UnloadAsset au lieu de vous fier à la méthode globale
Resources.UnloadUnusedAssets().
- Restructurez les scènes plutôt que d'utiliser constamment Resources.UnloadUnusedAssets.
- L'appel de
Resources.UnloadUnusedAssets()pourAddressablespeut décharger involontairement des bundles chargés dynamiquement. Gérez soigneusement le cycle de vie des éléments chargés de manière dynamique.
Autres
Fragmentation causée par les transitions de scène : lorsque la méthode
Resources.UnloadUnusedAssets()est appelée, Unity effectue les opérations suivantes :- Libère de la mémoire pour les éléments qui ne sont plus utilisés
- Exécute une opération de type récupérateur de mémoire pour vérifier si le tas d'objets gérés et natifs contient des éléments inutilisés et les décharge.
- Nettoie la mémoire de texture, de maillage et d'asset, à condition qu'aucune référence active n'existe.
AssetBundleouAddressable: il est complexe d'apporter des modifications dans ce domaine, et cela nécessite un effort collectif de la part de l'équipe pour mettre en œuvre les stratégies. Toutefois, une fois ces stratégies maîtrisées, elles améliorent considérablement l'utilisation de la mémoire, réduisent la taille de téléchargement et diminuent les coûts liés au cloud. Pour en savoir plus sur la gestion des assets dans Unity, consultezAddressables.Dépendances partagées centralisées : regroupez systématiquement les dépendances partagées, telles que les nuanceurs, les textures et les polices, dans des bundles ou des groupes
Addressabledédiés. Cela réduit la duplication et garantit que les éléments inutiles sont déchargés efficacement.Utilisez
Addressablespour le suivi des dépendances. Les Addressables simplifient le chargement et le déchargement, et peuvent décharger automatiquement les dépendances qui ne sont plus référencées. La transition versAddressablespour la gestion du contenu et la résolution des dépendances peut être une solution viable, selon le cas spécifique du jeu. Analysez les chaînes de dépendances à l'aide de l'outil d'analyse pour identifier les doublons ou les dépendances inutiles. Vous pouvez également consulter les outils de données Unity si vous utilisez des AssetBundles.TypeTrees: si les fichiersAddressablesetAssetBundlesde votre jeu sont créés et déployés à l'aide de la même version d'Unity que le lecteur et ne nécessitent pas de rétrocompatibilité avec d'autres builds du lecteur, envisagez de désactiver l'écriture deTypeTree, ce qui devrait réduire la taille du bundle et l'espace mémoire utilisé par les objets de fichier sérialisés. Modifiez le processus de compilation dans le paramètre ContentBuildFlags du package Addressables local sur DisableWriteTypeTree.
Écrire du code compatible avec le récupérateur de mémoire
Unity utilise la récupération de mémoire pour gérer la mémoire en identifiant et en libérant automatiquement la mémoire inutilisée. Bien que le GC soit essentiel, il peut entraîner des problèmes de performances (par exemple, des pics de fréquence d'images) s'il n'est pas géré correctement, car ce processus peut interrompre momentanément le jeu, ce qui entraîne des problèmes de performances et une expérience utilisateur non optimale.
Consultez le manuel Unity pour découvrir des techniques utiles permettant de réduire la fréquence des allocations de segments de mémoire gérés, ainsi que la page 271 du document UnityPerformanceTuningBible pour obtenir des exemples.
Réduisez les allocations du récupérateur de mémoire :
- Évitez LINQ, les lambdas et les fermetures, qui allouent de la mémoire de tas.
- Utilisez
StringBuilderpour les chaînes modifiables au lieu de la concaténation de chaînes. - Réutilisez les collections en appelant
COLLECTIONS.Clear()plutôt qu'en les réinstanciant.
Pour en savoir plus, consultez l'e-book Ultimate Guide to Profiling Unity games (Guide de profilage des jeux Unity).
Gérez les mises à jour du canevas de l'interface utilisateur :
- Modifications dynamiques des éléments d'interface utilisateur : lorsque des éléments d'interface utilisateur tels que les propriétés Text, Image ou
RectTransformsont mis à jour (par exemple, modification du contenu textuel, redimensionnement des éléments ou animation des positions), le moteur peut allouer de la mémoire pour les objets temporaires. - Allocations de chaînes : les éléments d'interface utilisateur tels que Text nécessitent souvent des mises à jour de chaînes, car les chaînes sont immuables dans la plupart des langages de programmation.
- Canevas sale : lorsqu'un élément d'un canevas change (par exemple, redimensionnement, activation et désactivation d'éléments, ou modification des propriétés de mise en page), l'intégralité du canevas ou une partie de celui-ci peut être marquée comme sale et être recréée. Cela peut déclencher la création de structures de données temporaires (par exemple, des données de maillage, des tampons de sommets ou des calculs de mise en page), ce qui augmente la génération de déchets.
- Mises à jour complexes ou fréquentes : si le canevas comporte un grand nombre d'éléments ou est mis à jour fréquemment (par exemple, à chaque frame), ces recompilations peuvent entraîner une saturation importante de la mémoire.
- Modifications dynamiques des éléments d'interface utilisateur : lorsque des éléments d'interface utilisateur tels que les propriétés Text, Image ou
Activez le GC incrémentiel pour réduire les pics de collecte importants en répartissant les nettoyages d'allocation sur plusieurs frames. Profilez pour vérifier si cette option améliore les performances et l'espace mémoire utilisé de votre jeu.
Si votre jeu nécessite une approche contrôlée, définissez le mode de récupération de mémoire sur manuel. Ensuite, lors d'un changement de niveau ou à un autre moment sans gameplay actif, appelez le garbage collection.
Appelez des appels de récupération de mémoire manuels GC.Collect() pour les transitions d'état du jeu (par exemple, le changement de niveau).
Optimisez les tableaux en commençant par les pratiques de base du code et, si nécessaire, en utilisant des tableaux natifs ou d'autres conteneurs natifs pour les tableaux volumineux.
Surveillez les objets gérés à l'aide d'outils tels que le profileur de mémoire Unity pour suivre les références d'objets non gérés qui persistent après la destruction.
Utilisez un repère de profileur pour envoyer des données à l'outil de reporting des performances pour une approche automatisée.
Éviter les fuites de mémoire et la fragmentation
Fuites de mémoire
Dans le code C#, lorsqu'une référence à un objet Unity existe après la destruction de l'objet, l'objet wrapper géré, appelé shell géré, reste en mémoire. La mémoire native associée à la référence est libérée lorsque la scène est déchargée ou lorsque le GameObject auquel la mémoire est associée, ou l'un de ses objets parents, est détruit via la méthode Destroy(). Toutefois, si d'autres références à la scène ou au GameObject n'ont pas été effacées, la mémoire gérée peut persister en tant qu'objet shell ayant fuité. Pour en savoir plus sur les objets Managed Shell, consultez le manuel Managed Shell Objects.
De plus, les fuites de mémoire peuvent être causées par des abonnements à des événements, des lambdas et des fermetures, des concaténations de chaînes et une mauvaise gestion des objets mis en pool :
- Pour commencer, consultez Rechercher les fuites de mémoire afin de comparer correctement les instantanés de mémoire Unity.
- Recherchez les abonnements aux événements et les fuites de mémoire. Si des objets s'abonnent à des événements (par exemple, par le biais de délégués ou de UnityEvents), mais ne se désabonnent pas correctement avant d'être détruits, le gestionnaire ou l'éditeur d'événements peut conserver des références à ces objets. Cela empêche la récupération de mémoire de ces objets, ce qui entraîne des fuites de mémoire.
- Surveillez les événements de classe globaux ou singleton qui ne sont pas désenregistrés lors de la destruction d'un objet. Par exemple, désabonnez ou dissociez les délégués dans les destructeurs d'objets.
- Assurez-vous que la destruction des objets mis en pool annule complètement les références aux composants de maillage de texte, aux textures et aux GameObjects parents.
- N'oubliez pas que lorsque vous comparez des instantanés du profileur de mémoire Unity et que vous observez une différence de consommation de mémoire sans raison claire, cette différence peut être due au pilote graphique ou au système d'exploitation lui-même.
Fractionnement de la mémoire
La fragmentation de la mémoire se produit lorsque de nombreuses petites allocations sont libérées dans un ordre aléatoire. Les allocations de segments de mémoire sont effectuées de manière séquentielle, ce qui signifie que de nouveaux fragments de mémoire sont créés lorsque le fragment précédent manque d'espace. Par conséquent, les nouveaux objets ne remplissent pas les zones vides des anciens fragments, ce qui entraîne une fragmentation. De plus, des allocations temporaires volumineuses peuvent entraîner une fragmentation permanente pendant la durée d'une session de jeu.
Ce problème est particulièrement problématique lorsque des allocations volumineuses de courte durée sont effectuées à proximité d'allocations de longue durée.
Regroupez les allocations en fonction de leur durée de vie. Idéalement, les allocations de longue durée doivent être effectuées ensemble, au début du cycle de vie de l'application.
Observateurs et gestionnaires d'événements
- En plus du problème mentionné dans la section Fuites de mémoire, les fuites de mémoire peuvent contribuer à la fragmentation au fil du temps en laissant de la mémoire inutilisée allouée à des objets qui ne sont plus utilisés.
- Assurez-vous que la destruction des objets mis en pool annule complètement les références aux composants de maillage de texte, aux textures et au
GameObjectsparent. - Les gestionnaires d'événements créent et stockent souvent des listes ou des dictionnaires pour gérer les abonnements aux événements. Si ces éléments augmentent et diminuent de manière dynamique pendant l'exécution, ils peuvent contribuer à la fragmentation de la mémoire en raison d'allocations et de désallocations fréquentes.
Code
- Les coroutines allouent parfois de la mémoire, ce qui peut être évité en mettant en cache l'instruction return de l'IEnumerator au lieu d'en déclarer une nouvelle à chaque fois.
- Surveillez en permanence les états du cycle de vie des objets mis en pool pour éviter de conserver des références fantômes
UnityEngine.Object.
Éléments
- Utilisez des systèmes de remplacement dynamiques pour les expériences de jeu basées sur du texte afin d'éviter de précharger toutes les polices pour les cas multilingues.
- Organisez les éléments (par exemple, les textures et les particules) par type et par cycle de vie attendu.
- Condensez les éléments avec des attributs de cycle de vie inactifs, tels que les images d'interface utilisateur redondantes et les maillages statiques.
Allocations basées sur la durée de vie
- Allouez les éléments de longue durée au début du cycle de vie de l'application pour garantir des allocations compactes.
- Utilisez des NativeCollections ou des allocateurs personnalisés pour les structures de données temporaires ou gourmandes en mémoire (par exemple, les clusters physiques).
Action de mémoire liée au code et aux exécutables
L'exécutable et les plug-ins du jeu ont également un impact sur l'utilisation de la mémoire.
Métadonnées IL2CPP
IL2CPP génère des métadonnées pour chaque type (par exemple, les classes, les génériques et les délégués) au moment de la compilation, qui sont ensuite utilisées au moment de l'exécution pour la réflexion, la vérification du type et d'autres opérations spécifiques à l'exécution. Ces métadonnées sont stockées en mémoire et peuvent contribuer de manière significative à l'espace mémoire total utilisé par l'application. Le cache de métadonnées d'IL2CPP contribue de manière significative aux temps d'initialisation et de chargement. De plus, IL2CPP ne déduplique pas certains éléments de métadonnées (par exemple, les types génériques ou les informations sérialisées), ce qui peut entraîner une utilisation excessive de la mémoire. Ce problème est exacerbé par l'utilisation de types répétitifs ou redondants dans le projet.
Vous pouvez réduire les métadonnées IL2CPP de différentes manières :
- Évitez d'utiliser des API de réflexion, car elles peuvent contribuer de manière significative aux allocations de métadonnées IL2CPP.
- Désactiver les packages intégrés
- Implémentation du partage générique complet d'Unity 2022, qui devrait aider à réduire la surcharge causée par les génériques. Toutefois, pour réduire encore davantage les allocations, réduisez l'utilisation des génériques.
Suppression de code
En plus de réduire la taille de la compilation, la suppression de code réduit également l'utilisation de la mémoire. Lors de la compilation avec le backend de script IL2CPP, la suppression du bytecode géré (activée par défaut) supprime le code inutilisé des assemblages gérés. Le processus consiste à définir des assemblys racine, puis à utiliser l'analyse de code statique pour déterminer quel autre code géré ces assemblys racine utilisent. Tout code inaccessible est supprimé. Pour en savoir plus sur la suppression de code géré, consultez l'article de blog Tales from the optimization trenches: Better managed code stripping with Unity 2020 LTS (en anglais) et la documentation sur la suppression de code géré.
Allocateurs natifs
Testez les allocateurs de mémoire natifs pour affiner les allocateurs de mémoire. Si le jeu manque de mémoire, utilisez des blocs de mémoire plus petits, même si cela implique des allocateurs plus lents. Pour en savoir plus, consultez l'exemple d'allocateur de segments de mémoire dynamique.
Gérer les plug-ins et SDK natifs
Recherchez le plug-in problématique : supprimez chaque plug-in et comparez les instantanés de mémoire du jeu. Cela implique de désactiver de nombreuses fonctionnalités de code avec Scripting Define Symbols et de refactoriser des classes fortement couplées avec des interfaces. Consultez Améliorez votre code avec des modèles de programmation de jeux pour faciliter le processus de désactivation des dépendances externes sans rendre votre jeu injouable.
Contactez l'auteur du plug-in ou du SDK. La plupart des plug-ins ne sont pas Open Source.
Reproduisez l'utilisation de la mémoire du plug-in : vous pouvez écrire un petit plug-in (utilisez ce plug-in Unity comme référence) qui effectue des allocations de mémoire. Inspectez les instantanés de mémoire à l'aide d'Android Studio (car Unity ne suit pas ces allocations) ou appelez la classe
MemoryInfoet la méthodeRuntime.totalMemory()dans le même projet.
Un plug-in Unity alloue de la mémoire Java et native. Voici comment procéder :
Java
byte[] largeObject = new byte[1024 * 1024 * megaBytes];
list.add(largeObject);
Natif
char* buffer = new char[megabytes * 1024 * 1024];
// Random data to fill the buffer
for (int i = 1; i < megabytes * 1024 * 1024; ++i) {
buffer[i] = 'A' + (i % 26); // Fill with letters A-Z
}