La resolución de LMK en tu juego de Unity es un proceso sistemático:

Obtén una instantánea de memoria
Usa el Generador de perfiles de Unity para obtener una instantánea de memoria administrada por Unity. En la Figura 2, se muestran las capas de administración de la memoria que Unity usa para administrar la memoria en tu juego.
Memoria administrada
La administración de la memoria de Unity implementa una capa de memoria controlada que usa un montón administrado y un recolector de elementos no utilizados para asignar memoria automáticamente. El sistema de memoria administrada es un entorno de secuencias de comandos de C# basado en Mono o IL2CPP. El beneficio del sistema de memoria administrada es que utiliza un recolector de elementos no utilizados para liberar automáticamente las asignaciones de memoria.
Memoria no administrada de C#
La capa de memoria de C# no administrada proporciona acceso a la capa de memoria nativa, lo que permite un control preciso de las asignaciones de memoria mientras se usa el código de C#. Se puede acceder a esta capa de administración de la memoria a través del espacio de nombres Unity.Collections y mediante funciones como UnsafeUtility.Malloc y UnsafeUtility.Free.
Memoria nativa
El núcleo interno de C/C++ de Unity usa un sistema de memoria nativo para administrar escenas, recursos, APIs de gráficos, controladores, subsistemas y búferes de complementos. Si bien el acceso directo está restringido, puedes manipular los datos de forma segura con la API de C# de Unity y beneficiarte del código nativo eficiente. La memoria nativa rara vez requiere interacción directa, pero puedes supervisar su impacto en el rendimiento con el Generador de perfiles y ajustar la configuración para optimizar el rendimiento.
La memoria no se comparte entre C# y el código nativo, como se muestra en la figura 3. Los datos que requiere C# se asignan en el espacio de memoria administrado cada vez que se necesitan.
Para que el código del juego administrado (C#) acceda a los datos de la memoria nativa del motor, por ejemplo, una llamada a GameObject.transform realiza una llamada nativa para acceder a los datos de la memoria en el área nativa y, luego, devuelve valores a C# con Bindings. Las vinculaciones garantizan las convenciones de llamada adecuadas para cada plataforma y controlan la serialización automática de los tipos administrados en sus equivalentes nativos.
Esto solo sucede la primera vez, ya que la shell administrada para acceder a la propiedad transform se conserva en el código nativo. Almacenar en caché la propiedad transform puede reducir la cantidad de llamadas de ida y vuelta entre el código administrado y el nativo, pero la utilidad del almacenamiento en caché depende de la frecuencia con la que se use la propiedad. Además, ten en cuenta que Unity no copia partes de la memoria nativa en la memoria administrada cuando accedes a estas APIs.
Para obtener más información, consulta Introducción a la memoria en Unity.
Además, es fundamental establecer un presupuesto de memoria para que el juego se ejecute sin problemas, y la implementación de un sistema de análisis o informes de consumo de memoria garantiza que cada versión nueva no supere el presupuesto de memoria. Otra estrategia para obtener más información es integrar las pruebas de Play Mode con tu integración continua (CI) para verificar el consumo de memoria en áreas específicas del juego.
Administrar activos
Esta es la parte más impactante y práctica del consumo de memoria. Genera perfiles lo antes posible.
El uso de memoria en los juegos para Android puede variar de forma significativa según el tipo de juego, la cantidad y los tipos de recursos, y las estrategias de optimización de memoria. Sin embargo, los factores comunes que contribuyen al uso de memoria suelen incluir texturas, mallas, archivos de audio, sombreadores, animaciones y secuencias de comandos.
Detecta recursos duplicados
El primer paso es detectar los recursos mal configurados y los recursos duplicados con el Generador de perfiles de memoria, una herramienta de informes de compilación o el Project Auditor.
Texturas
Analiza la compatibilidad de dispositivos de tu juego y decide el formato de textura correcto. Puedes dividir los paquetes de texturas para dispositivos de alta y baja gama con Play Asset Delivery, Addressable o un proceso más manual con un AssetBundle.
Sigue las recomendaciones más conocidas disponibles en Optimize Your Mobile Game Performance y en la publicación Optimising Unity Texture Import Settings. Luego, prueba estas soluciones:
Comprime las texturas con formatos ASTC para reducir el espacio en memoria y experimenta con una tasa de bloques más alta, como 8 x 8.
Si es necesario usar ETC2, empaqueta tus texturas en Atlas. Colocar varias texturas en una sola garantiza su potencia de dos (POT), puede reducir las llamadas de dibujo y acelerar el renderizado.
Optimiza el formato y el tamaño de la textura de RenderTarget. Evita las texturas de alta resolución innecesarias. El uso de texturas más pequeñas en dispositivos móviles ahorra memoria.
Usa el empaquetado de canales de texturas para ahorrar memoria de texturas.
Mallas y modelos
Comienza por verificar la configuración fundamental (página 27) y, luego, verifica estos parámetros de configuración de importación de mallas:
- Combina mallas redundantes y más pequeñas.
- Reduce el recuento de vértices de los objetos de las escenas (por ejemplo, objetos estáticos o distantes).
- Genera grupos de nivel de detalle (LOD) para los recursos con geometría alta.
Materiales y sombreadores
- Quita las variantes de sombreadores que no se usen de manera programática durante el proceso de compilación.
- Consolida las variantes de sombreadores que se usan con frecuencia en sombreadores uber para evitar la duplicación de sombreadores.
- Habilita la carga dinámica de sombreadores para abordar el gran espacio en memoria de los sombreadores precargados en la VRAM o RAM. Sin embargo, presta atención si la compilación de sombreadores provoca interrupciones en los fotogramas.
- Usa la carga dinámica de sombreadores para evitar que se carguen todas las variantes. Para obtener más información, consulta la entrada de blog Mejoras en los tiempos de compilación de sombreadores y el uso de memoria.
- Usa la instanciación de materiales de forma adecuada con
MaterialPropertyBlocks.
Audio
Comienza por verificar la configuración fundamental (página 41) y, luego, comprueba estos parámetros de configuración de importación de mallas:
- Quita las referencias de
AudioClipredundantes o sin usar cuando emplees motores de audio de terceros, como FMOD o Wwise. - Precarga datos de audio. Inhabilita la carga previa de los clips que no se necesitan de inmediato durante el tiempo de ejecución o el inicio de la escena. Esto ayuda a reducir la sobrecarga de memoria durante la inicialización de la escena.
Animaciones
- Ajusta la configuración de compresión de animación de Unity para minimizar la cantidad de fotogramas clave y eliminar los datos redundantes.
- Reducción de fotogramas clave: Quita automáticamente los fotogramas clave innecesarios.
- Compresión de cuaterniones: Comprime los datos de rotación para reducir el uso de memoria.
Puedes ajustar la configuración de compresión en Animation Import Settings, en la pestaña Rig o Animation.
Reutiliza los clips de animación en lugar de duplicarlos para diferentes objetos.
Usa Animator Override Controllers para reutilizar un Animator Controller y reemplazar clips específicos para diferentes personajes.
Prepara animaciones basadas en la física: Si tus animaciones se basan en la física o son de procedimiento, prepáralas en clips de animación para evitar cálculos de tiempo de ejecución.
Optimiza el esqueleto: Usa menos huesos en el esqueleto para reducir la complejidad y el consumo de memoria.
- Evita usar demasiados huesos para objetos pequeños o estáticos.
- Si ciertos huesos no están animados o no son necesarios, quítalos del esqueleto.
Reduce la duración del clip de animación.
- Recorta los clips de animación para incluir solo los fotogramas necesarios. Evita almacenar animaciones que no se usen o que sean demasiado largas.
- Usa animaciones en bucle en lugar de crear clips largos para movimientos repetidos.
Asegúrate de que solo se adjunte o active un componente de animación. Por ejemplo, inhabilita o quita los componentes de Legacy animation si usas Animator.
Evita usar el Animator si no es necesario. Para los VFX básicos, usa bibliotecas de interpolación o implementa el efecto visual en una secuencia de comandos. El sistema de animadores puede consumir muchos recursos, en especial en dispositivos móviles de gama baja.
Usa el sistema de trabajos para las animaciones cuando manejes una gran cantidad de ellas, ya que ese sistema se rediseñó por completo para que sea más eficiente en cuanto a la memoria.
Escenas
Cuando se cargan escenas nuevas, estas incorporan recursos como dependencias. Sin embargo, sin una administración adecuada del ciclo de vida de los recursos, los contadores de referencias no supervisan estas dependencias. Como resultado, los recursos pueden permanecer en la memoria incluso después de que se hayan descargado las escenas no utilizadas, lo que provoca la fragmentación de la memoria.
- Usa la agrupación de objetos de Unity para reutilizar instancias de GameObject en elementos de juego recurrentes, ya que la agrupación de objetos usa una pila para contener una colección de instancias de objetos para su reutilización y no tiene seguridad de subprocesos. Minimizar
InstantiateyDestroymejora el rendimiento de la CPU y la estabilidad de la memoria. - Descarga de recursos:
- Descarga recursos de forma estratégica durante momentos menos críticos, como las pantallas de presentación o de carga.
- El uso frecuente de
Resources.UnloadUnusedAssetsprovoca picos en el procesamiento de la CPU debido a las grandes operaciones de supervisión de dependencias internas. - Verifica si hay picos de CPU grandes en el marcador de perfil GC.MarkDependencies.
Quita o reduce su frecuencia de ejecución y, en su lugar, descarga manualmente recursos específicos con Resources.UnloadAsset en lugar de depender de la función integral
Resources.UnloadUnusedAssets().
- Reestructura las escenas en lugar de usar Resources.UnloadUnusedAssets de forma constante.
- Llamar a
Resources.UnloadUnusedAssets()paraAddressablespuede descargar de forma involuntaria paquetes cargados de forma dinámica. Administra con cuidado el ciclo de vida de los recursos cargados de forma dinámica.
Varios
Fragmentación causada por transiciones de escenas: Cuando se llama al método
Resources.UnloadUnusedAssets(), Unity hace lo siguiente:- Libera memoria para los recursos que ya no se usan.
- Ejecuta una operación similar a la de un recolector de elementos no utilizados para verificar el montón de objetos administrados y nativos en busca de recursos sin usar y descargarlos.
- Limpia la memoria de texturas, mallas y recursos, siempre que no exista una referencia activa.
AssetBundleoAddressable: Realizar cambios en esta área es complejo y exige un esfuerzo colectivo del equipo para implementar las estrategias. Sin embargo, una vez que se dominan estas estrategias, mejoran significativamente el uso de memoria, reducen el tamaño de descarga y disminuyen los costos de la nube. Para obtener más información sobre la administración de recursos en Unity, consultaAddressables.Dependencias compartidas centralizadas: Agrupa las dependencias compartidas, como los sombreadores, las texturas y las fuentes, de forma sistemática en paquetes dedicados o grupos de
Addressable. Esto reduce la duplicación y garantiza que los recursos innecesarios se descarguen de manera eficiente.Usa
Addressablespara el seguimiento de dependencias: Los Addressables simplifican la carga y descarga, y pueden descargar automáticamente las dependencias que ya no se referencian. La transición aAddressablespara la administración de contenido y la resolución de dependencias puede ser una solución viable, según el caso específico del juego. Analiza las cadenas de dependencias con la herramienta Analyze para identificar duplicados o dependencias innecesarios. Como alternativa, consulta las herramientas de datos de Unity si usas AssetBundles.TypeTrees: Si losAddressablesyAssetBundlesde tu juego se compilan y se implementan con la misma versión de Unity que el reproductor y no requieren retrocompatibilidad con otras compilaciones del reproductor, considera inhabilitar la escritura deTypeTree, lo que debería reducir el tamaño del paquete y el espacio en memoria de los objetos de archivo serializados. Modifica el proceso de compilación en el parámetro de configuración ContentBuildFlags del paquete local Addressables a DisableWriteTypeTree.
Escribe código compatible con el recolector de elementos no utilizados
Unity utiliza la recolección de elementos no utilizados (GC) para administrar la memoria, ya que identifica y libera automáticamente la memoria que no se usa. Si bien la GC es esencial, puede causar problemas de rendimiento (por ejemplo, picos en la velocidad de fotogramas) si no se maneja de forma correcta, ya que este proceso puede pausar el juego de forma momentánea, lo que genera problemas de rendimiento y una experiencia del usuario deficiente.
Consulta el manual de Unity para conocer técnicas útiles que te permitan reducir la frecuencia de las asignaciones de montón administradas y la UnityPerformanceTuningBible, página 271, para ver ejemplos.
Reduce las asignaciones del recolector de elementos no utilizados:
- Evita LINQ, lambdas y cierres, que asignan memoria del montón.
- Usa
StringBuilderpara cadenas mutables en lugar de la concatenación de cadenas. - Reutiliza las colecciones llamando a
COLLECTIONS.Clear()en lugar de volver a crear instancias de ellas.
Puedes encontrar más información en el libro electrónico Ultimate Guide to Profiling Unity games.
Administra las actualizaciones del lienzo de la IU:
- Cambios dinámicos en los elementos de la IU: Cuando se actualizan las propiedades de los elementos de la IU, como Text, Image o
RectTransform(por ejemplo, cuando se cambia el contenido de texto, se cambia el tamaño de los elementos o se animan las posiciones), el motor puede asignar memoria para los objetos temporales. - Asignaciones de cadenas: Los elementos de la IU, como Text, suelen requerir actualizaciones de cadenas, ya que estas son inmutables en la mayoría de los lenguajes de programación.
- Lienzo sucio: Cuando cambia algo en un lienzo (por ejemplo, cuando se cambia el tamaño, se habilitan o inhabilitan elementos, o se modifican las propiedades de diseño), todo el lienzo o una parte de él se puede marcar como sucio y se vuelve a compilar. Esto puede activar la creación de estructuras de datos temporales (por ejemplo, datos de malla, búferes de vértices o cálculos de diseño), lo que aumenta la generación de elementos no utilizados.
- Actualizaciones complejas o frecuentes: Si el lienzo tiene una gran cantidad de elementos o se actualiza con frecuencia (por ejemplo, cada fotograma), estas reconstrucciones pueden generar una saturación de la memoria significativa.
- Cambios dinámicos en los elementos de la IU: Cuando se actualizan las propiedades de los elementos de la IU, como Text, Image o
Habilita la GC incremental para reducir los picos de recolección grandes distribuyendo las limpiezas de asignación en varios fotogramas. Genera un perfil para verificar si esta opción mejora el rendimiento y el espacio en memoria de tu juego.
Si tu juego requiere un enfoque controlado, configura el modo de recolección de elementos no utilizados como manual. Luego, en un cambio de nivel o en otro momento sin juego activo, llama a la recolección de elementos no utilizados.
Invoca llamadas manuales de recolección de elementos no utilizados GC.Collect() para las transiciones de estado del juego (por ejemplo, cambio de nivel).
Optimiza los arrays a partir de prácticas de código básicas y, si es necesario, usa arrays nativos o contenedores nativos para arrays grandes.
Supervisa los objetos administrados con herramientas como el Generador de perfiles de memoria de Unity para hacer un seguimiento de las referencias de objetos no administrados que persisten después de la destrucción.
Usa un marcador de generador de perfiles para enviarlo a la herramienta de informes de rendimiento y obtener un enfoque automatizado.
Evita las fugas de memoria y la fragmentación
Fugas de memoria
En el código de C#, cuando existe una referencia a un objeto de Unity después de que se destruye el objeto, el objeto de wrapper administrado, conocido como shell administrado, permanece en la memoria. La memoria nativa asociada con la referencia se libera cuando se descarga la escena o cuando se destruye el GameObject al que está conectada la memoria, o cualquiera de sus objetos superiores, a través del método Destroy(). Sin embargo, si no se borraron otras referencias a la escena o al GameObject, la memoria administrada puede persistir como un objeto de shell con fugas. Para obtener más detalles sobre los objetos de shell administrados, consulta
el manual de objetos de shell administrados.
Además, las fugas de memoria pueden deberse a suscripciones a eventos, lambdas y cierres, concatenaciones de cadenas y administración inadecuada de objetos agrupados:
- Para comenzar, consulta Cómo encontrar fugas de memoria para comparar correctamente las instantáneas de memoria de Unity.
- Verifica si hay suscripciones a eventos y fugas de memoria. Si los objetos se suscriben a eventos (por ejemplo, mediante delegados o UnityEvents), pero no cancelan la suscripción correctamente antes de destruirse, es posible que el administrador o publicador de eventos retenga referencias a esos objetos. Esto evita que se recolecten esos objetos, lo que genera fugas de memoria.
- Supervisa los eventos de clase global o singleton que no se cancelan cuando se destruye el objeto. Por ejemplo, anula la suscripción o desvincula los delegados en los destructores de objetos.
- Asegúrate de que la destrucción de los objetos agrupados anule por completo las referencias a los componentes de malla de texto, las texturas y los GameObjects superiores.
- Ten en cuenta que, cuando compares instantáneas del Generador de perfiles de memoria de Unity y observes una diferencia en el consumo de memoria sin un motivo claro, es posible que la diferencia se deba al controlador de gráficos o al sistema operativo.
Fragmentación de memoria
La fragmentación de memoria se produce cuando se liberan muchas asignaciones pequeñas en un orden aleatorio. Las asignaciones de montón se realizan de forma secuencial, lo que significa que se crean nuevos fragmentos de memoria cuando el fragmento anterior se queda sin espacio. Por lo tanto, los objetos nuevos no llenan las áreas vacías de los fragmentos antiguos, lo que genera fragmentación. Además, las asignaciones temporales grandes pueden causar una fragmentación permanente durante la sesión de un juego.
Este problema es particularmente problemático cuando se realizan asignaciones grandes de corta duración cerca de las de larga duración.
Agrupa las asignaciones según su vida útil. Lo ideal es que las asignaciones de larga duración se realicen juntas, al principio del ciclo de vida de la aplicación.
Observadores y administradores de eventos
- Además del problema mencionado en la sección Fugas de memoria, con el tiempo, las fugas de memoria pueden contribuir a la fragmentación, ya que dejan memoria sin usar asignada a objetos que ya no se utilizan.
- Asegúrate de que la destrucción de los objetos agrupados anule por completo las referencias a los componentes de malla de texto, las texturas y el
GameObjectssuperior. - Los administradores de eventos suelen crear y almacenar listas o diccionarios para administrar las suscripciones a eventos. Si estos aumentan y disminuyen de forma dinámica durante el tiempo de ejecución, pueden contribuir a la fragmentación de la memoria debido a las asignaciones y desasignaciones frecuentes.
Código
- A veces, las corrutinas asignan memoria, lo que se puede evitar almacenando en caché la sentencia return de IEnumerator en lugar de declarar una nueva cada vez.
- Supervisa de forma continua los estados del ciclo de vida de los objetos agrupados para evitar mantener
referencias fantasma de
UnityEngine.Object.
Recursos
- Usa sistemas de resguardo dinámicos para las experiencias de juego basadas en texto para evitar la carga previa de todas las fuentes en los casos de varios idiomas.
- Organiza los recursos (por ejemplo, texturas y partículas) por tipo y ciclo de vida esperado.
- Condensa los recursos con atributos de ciclo de vida inactivos, como imágenes de IU redundantes y mallas estáticas.
Asignaciones basadas en el ciclo de vida
- Asigna recursos de larga duración al comienzo del ciclo de vida de la aplicación para garantizar asignaciones compactas.
- Usa NativeCollections o asignadores personalizados para estructuras de datos transitorias o que consumen mucha memoria (por ejemplo, clústeres de física).
Acción de memoria relacionada con el código y los ejecutables
El ejecutable y los complementos del juego también afectan el uso de memoria.
Metadatos de IL2CPP
IL2CPP genera metadatos para cada tipo (por ejemplo, clases, genéricos y delegados) en el momento de la compilación, que luego se usan en el entorno de ejecución para la reflexión, la verificación de tipos y otras operaciones específicas del entorno de ejecución. Estos metadatos se almacenan en la memoria y pueden contribuir de forma significativa al espacio en memoria total de la aplicación. La caché de metadatos de IL2CPP contribuye de forma significativa a los tiempos de inicialización y carga. Además, IL2CPP no anula duplicado ciertos elementos de metadatos (por ejemplo, tipos genéricos o información serializada), lo que puede generar un uso de memoria excesivo. Esto se agrava por el uso de tipos repetitivos o redundantes en el proyecto.
Los metadatos de IL2CPP se pueden reducir de las siguientes maneras:
- Evitar el uso de APIs de reflexión, ya que pueden contribuir de forma significativa a las asignaciones de metadatos de IL2CPP
- Inhabilita los paquetes integrados
- Implementar el uso compartido genérico completo de Unity 2022, que debería ayudar a reducir la sobrecarga que causan los genéricos Sin embargo, para ayudar a reducir aún más las asignaciones, disminuye el uso de genéricos.
Eliminación de código
Además de reducir el tamaño de la compilación, la eliminación de código también disminuye el uso de memoria. Cuando se compila con el backend de secuencias de comandos de IL2CPP, la eliminación de código de bytes administrado (que se activa de forma predeterminada) quita el código no utilizado de los ensamblados administrados. El proceso funciona definiendo ensamblados raíz y, luego, usando el análisis de código estático para determinar qué otro código administrado usan esos ensamblados raíz. Se quita cualquier código al que no se pueda acceder. Para obtener más información sobre la eliminación de código administrado, consulta la entrada de blog Tales from the optimization trenches: Better managed code stripping with Unity 2020 LTS y la documentación de eliminación de código administrado.
Asignadores nativos
Experimenta con asignadores de memoria nativos para ajustar los asignadores de memoria. Si el juego tiene poca memoria, usa bloques de memoria más pequeños, incluso si esto implica asignadores más lentos. Consulta el ejemplo de asignación de montón dinámico para obtener más información.
Administra complementos y SDKs nativos
Encuentra el complemento problemático: Quita cada complemento y compara las instantáneas de memoria del juego. Esto implica inhabilitar muchas funciones de código con Scripting Define Symbols y refactorizar clases muy acopladas con interfaces. Consulta LEVEL UP your code with game programming patterns para facilitar el proceso de inhabilitación de dependencias externas sin que tu juego deje de ser jugable.
Comunícate con el autor del complemento o del SDK: La mayoría de los complementos no son de código abierto.
Reproduce el uso de memoria del complemento: Puedes escribir un complemento pequeño (usa este complemento de Unity como referencia) que realice asignaciones de memoria. Inspecciona las instantáneas de memoria con Android Studio (ya que Unity no hace un seguimiento de estas asignaciones) o llama a la clase
MemoryInfoy al métodoRuntime.totalMemory()en el mismo proyecto.
Un complemento de Unity asigna memoria nativa y de Java. A continuación, se muestra cómo hacerlo:
Java
byte[] largeObject = new byte[1024 * 1024 * megaBytes];
list.add(largeObject);
Nativa
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
}