Depurar LMKs

Resolver LMKs no seu jogo do Unity é um processo sistemático:

Figura 1. Etapas para resolver encerramentos por falta de memória (LMKs) em jogos do Unity.

Gerar um snapshot de memória

Use o Unity Profiler para receber um snapshot de memória gerenciado pelo Unity. A Figura 2 mostra as camadas de gerenciamento de memória que o Unity usa para processar a memória no seu jogo.

Figura 2. Visão geral do gerenciamento de memória do Unity.

Memória gerenciada

O gerenciamento de memória do Unity implementa uma camada de memória controlada que usa um heap gerenciado e um coletor de lixo para alocar e atribuir memória automaticamente. O sistema de memória gerenciada é um ambiente de script em C# baseado em Mono ou IL2CPP. O benefício do sistema de memória gerenciada é que ele usa um coletor de lixo para liberar automaticamente as alocações de memória.

Memória não gerenciada em C#

A camada de memória não gerenciada do C# fornece acesso à camada de memória nativa, permitindo um controle preciso sobre as alocações de memória ao usar o código C#. Essa camada de gerenciamento de memória pode ser acessada pelo namespace Unity.Collections e por funções como UnsafeUtility.Malloc e UnsafeUtility.Free.

Memória nativa

O núcleo interno de C/C++ do Unity usa um sistema de memória nativo para gerenciar cenas, recursos, APIs gráficas, drivers, subsistemas e buffers de plug-ins. Embora o acesso direto seja restrito, é possível manipular dados com segurança usando a API C# do Unity e aproveitar o código nativo eficiente. A memória nativa raramente requer interação direta, mas é possível monitorar o impacto dela no desempenho usando o Profiler e ajustar as configurações para otimizar o desempenho.

A memória não é compartilhada entre o C# e o código nativo, como mostrado na figura 3. Os dados exigidos pelo C# são alocados no espaço de memória gerenciado sempre que necessário.

Para que o código do jogo gerenciado (C#) acesse os dados de memória nativa do mecanismo, por exemplo, uma chamada para GameObject.transform faz uma chamada nativa para acessar dados de memória na área nativa e, em seguida, retorna valores para C# usando Bindings. As vinculações garantem as convenções de chamada adequadas para cada plataforma e processam o marshalling automático de tipos gerenciados nos equivalentes nativos.

Isso acontece apenas na primeira vez, já que o shell gerenciado para acessar a propriedade transform é preservado no código nativo. Armazenar em cache a propriedade de transformação pode reduzir o número de chamadas entre o código gerenciado e o nativo, mas a utilidade do armazenamento em cache depende da frequência com que a propriedade é usada. Além disso, o Unity não copia partes da memória nativa para a memória gerenciada quando você acessa essas APIs.

Figura 3. Acessar a memória nativa do código gerenciado em C#.

Para saber mais, consulte Introdução à memória no Unity.

Além disso, estabelecer um orçamento de memória é crucial para manter o jogo funcionando sem problemas, e implementar um sistema de análise ou relatório de consumo de memória garante que cada nova versão não exceda o orçamento de memória. Integrar testes do modo de jogo à integração contínua (CI) para verificar o consumo de memória em áreas específicas do jogo é outra estratégia para ter uma visão melhor.

Gerenciar recursos

Essa é a parte mais impactante e prática do consumo de memória. Crie perfis o mais cedo possível.

O uso da memória em jogos Android pode variar significativamente dependendo do tipo de jogo, do número e dos tipos de recursos e das estratégias de otimização de memória. No entanto, os fatores comuns que contribuem para o uso da memória geralmente incluem texturas, malhas, arquivos de áudio, sombreadores, animações e scripts.

Detectar recursos duplicados

A primeira etapa é detectar recursos mal configurados e recursos duplicados usando o Memory Profiler, uma ferramenta de relatório de build ou o Project Auditor.

Texturas

Analise a compatibilidade do jogo com dispositivos e decida o formato de textura correto. É possível dividir os pacotes de textura para dispositivos sofisticados e de baixa performance usando o Play Asset Delivery, o Addressable ou um processo mais manual com um AssetBundle.

Siga as recomendações mais conhecidas disponíveis em Otimizar o desempenho do seu jogo para dispositivos móveis e na postagem de discussão Otimizar as configurações de importação de textura do Unity. Em seguida, tente estas soluções:

  • Compacte texturas com formatos ASTC para reduzir o consumo de memória e teste uma taxa de blocos mais alta, como 8x8.

    Se for necessário usar o ETC2, empacote as texturas no Atlas. Colocar várias texturas em uma única textura garante a potência de dois (POT, na sigla em inglês), pode reduzir as chamadas de desenho e acelerar a renderização.

  • Otimize o formato e o tamanho da textura de RenderTarget. Evite texturas de alta resolução desnecessárias. O uso de texturas menores em dispositivos móveis economiza memória.

  • Use o agrupamento de canais de textura para economizar memória de textura.

Malhas e modelos

Comece verificando as configurações fundamentais (página 27) e as configurações de importação de malha:

  • Mescle malhas redundantes e menores.
  • Reduza a contagem de vértices para objetos em cenas (por exemplo, objetos estáticos ou distantes).
  • Gerar grupos de nível de detalhe (LOD) para recursos de alta geometria.

Materiais e sombreadores

  • Remova as variantes de sombreador não usadas de forma programática durante o processo de build.
  • Consolide as variantes de sombreador usadas com frequência em uber shaders para evitar a duplicação de sombreadores.
  • Ative o carregamento dinâmico de sombreadores para lidar com o grande consumo de memória de sombreadores pré-carregados na VRAM/RAM. No entanto, preste atenção se a compilação de sombreador está causando problemas de frame.
  • Use o carregamento dinâmico de sombreadores para evitar que todas as variantes sejam carregadas. Para mais informações, consulte a postagem do blog Melhorias nos tempos de build de sombreadores e no uso da memória.
  • Use a instanciação de material corretamente com MaterialPropertyBlocks.

Áudio

Comece verificando as configurações fundamentais (página 41) e as configurações de importação de malha:

  • Remova referências não utilizadas ou redundantes de AudioClip ao usar mecanismos de áudio de terceiros, como FMOD ou Wwise.
  • Pré-carregar dados de áudio. Desative o pré-carregamento de clipes que não são necessários imediatamente durante o ambiente de execução ou a inicialização da cena. Isso ajuda a reduzir a sobrecarga de memória durante a inicialização da cena.

Animações

  • Ajuste as configurações de compactação de animação do Unity para minimizar o número de frames-chave e eliminar dados redundantes.
    • Redução de frames-chave: remove automaticamente os frames-chave desnecessários.
    • Compactação de quatérnios: compacta dados de rotação para reduzir o uso da memória.

É possível ajustar as configurações de compactação em Animation Import Settings na guia Rig ou Animation.

  • Reutilize clipes de animação em vez de duplicá-los para objetos diferentes.

    Use Animator Override Controllers para reutilizar um Animator Controller e substituir clipes específicos para personagens diferentes.

  • Grave animações baseadas em física: se as animações forem baseadas em física ou processuais, grave-as em clipes de animação para evitar cálculos de tempo de execução.

  • Otimize o rig do esqueleto: use menos ossos no rig para reduzir a complexidade e o consumo de memória.

    • Evite usar muitos ossos em objetos pequenos ou estáticos.
    • Se determinados ossos não forem animados ou necessários, remova-os do rig.
  • Reduza a duração do clipe de animação.

    • Corte os clipes de animação para incluir apenas os frames necessários. Evite armazenar animações não utilizadas ou excessivamente longas.
    • Use animações em loop em vez de criar clipes longos para movimentos repetidos.
  • Verifique se apenas um componente de animação está anexado ou ativado. Por exemplo, desative ou remova os componentes de animação legada se estiver usando o Animator.

  • Evite usar o Animator se não for necessário. Para efeitos visuais básicos, use bibliotecas de interpolação ou implemente o efeito visual em um script. O sistema de animação pode consumir muitos recursos, principalmente em dispositivos móveis mais simples.

  • Use o sistema de jobs para animações ao lidar com um grande número de animações, já que esse sistema foi totalmente reformulado para ser mais eficiente em termos de memória.

Cenas

Quando novas cenas são carregadas, elas trazem recursos como dependências. No entanto, sem o gerenciamento adequado do ciclo de vida dos recursos, essas dependências não são monitoradas por contadores de referência. Como resultado, os recursos podem permanecer na memória mesmo depois que as cenas não utilizadas forem descarregadas, causando fragmentação de memória.

  • Use o Object Pooling do Unity para reutilizar instâncias de GameObject em elementos de jogabilidade recorrentes, porque o pool de objetos usa uma pilha para manter uma coleção de instâncias de objeto para reutilização e não é thread-safe. Minimizar Instantiate e Destroy melhora o desempenho da CPU e a estabilidade da memória.
  • Descarregando recursos:
    • Descarregue recursos estrategicamente durante momentos menos críticos, como telas de apresentação ou de carregamento.
    • O uso frequente de Resources.UnloadUnusedAssets causa picos no processamento da CPU devido a grandes operações de monitoramento de dependência interna.
    • Verifique se há grandes picos de CPU no marcador de perfil GC.MarkDependencies. Remova ou reduza a frequência de execução e descarregue manualmente recursos específicos usando Resources.UnloadAsset (link em inglês) em vez de depender do Resources.UnloadUnusedAssets() (link em inglês), que abrange tudo.
  • Reestruture as cenas em vez de usar constantemente Resources.UnloadUnusedAssets.
  • Chamar Resources.UnloadUnusedAssets() para Addressables pode descarregar acidentalmente pacotes carregados dinamicamente. Gerencie com cuidado o ciclo de vida dos recursos carregados dinamicamente.

Diversos

  • Fragmentação causada por transições de cena: quando o método Resources.UnloadUnusedAssets() é chamado, o Unity faz o seguinte:

    • Libera memória para recursos que não estão mais em uso
    • Executa uma operação semelhante a um coletor de lixo para verificar se há recursos não utilizados no heap de objetos gerenciados e nativos e os descarrega.
    • Limpa a memória de textura, malha e recursos, desde que não haja referência ativa
  • AssetBundle ou Addressable: fazer mudanças nessa área é complexo e exige um esforço coletivo da equipe para implementar as estratégias. No entanto, depois que essas estratégias são dominadas, elas melhoram significativamente o uso da memória, reduzem o tamanho do download e diminuem os custos da nuvem. Para mais informações sobre o gerenciamento de recursos no Unity, consulte Addressables.

  • Dependências compartilhadas centralizadas: agrupe dependências compartilhadas, como sombreamentos, texturas e fontes, de forma sistemática em pacotes dedicados ou grupos Addressable. Isso reduz a duplicação e garante que recursos desnecessários sejam descarregados de forma eficiente.

  • Use Addressables para rastrear dependências. Os Addressables simplificam o carregamento e o descarregamento e podem descarregar automaticamente dependências que não são mais referenciadas. A transição para o Addressables para gerenciamento de conteúdo e resolução de dependências pode ser uma solução viável, dependendo do caso específico do jogo. Analise as cadeias de dependência com a ferramenta Analyze para identificar duplicatas ou dependências desnecessárias. Se você estiver usando AssetBundles, consulte as ferramentas de dados do Unity.

  • TypeTrees: se o Addressables e o AssetBundles do jogo forem criados e implantados usando a mesma versão do Unity que o player e não exigirem compatibilidade com versões anteriores de outros builds do player, considere desativar a gravação de TypeTree, o que reduz o tamanho do pacote e o consumo de memória do objeto de arquivo serializado. Modifique o processo de build na configuração ContentBuildFlags do pacote Addressables local para DisableWriteTypeTree.

Escrever código compatível com o coletor de lixo

O Unity usa a coleta de lixo (GC, na sigla em inglês) para gerenciar a memória, identificando e liberando automaticamente a memória não utilizada. Embora a GC seja essencial, ela pode causar problemas de desempenho (por exemplo, picos de frame rate) se não for processada corretamente, já que esse processo pode pausar o jogo momentaneamente, levando a problemas de desempenho e uma experiência do usuário abaixo do ideal.

Consulte o manual do Unity (em inglês) para ver técnicas úteis de redução da frequência de alocações de heap gerenciadas e a UnityPerformanceTuningBible (em inglês), página 271, para ver exemplos.

  • Reduza as alocações do coletor de lixo:

    • Evite LINQ, lambdas e closures, que alocam memória heap.
    • Use StringBuilder para strings mutáveis em vez de concatenação de strings.
    • Reutilize coleções chamando COLLECTIONS.Clear() em vez de reinstanciá-las.

    Mais informações estão disponíveis no e-book Ultimate Guide to Profiling Unity games.

  • Gerenciar atualizações da tela da interface:

    • Mudanças dinâmicas nos elementos da interface: quando elementos da interface, como propriedades de Text, Image ou RectTransform, são atualizados (por exemplo, mudança de conteúdo de texto, redimensionamento de elementos ou animação de posições), o mecanismo pode alocar memória para objetos temporários.
    • Alocações de strings: elementos da interface, como Text, geralmente exigem atualizações de strings, já que elas são imutáveis na maioria das linguagens de programação.
    • Tela suja: quando algo em uma tela muda (por exemplo, redimensionamento, ativação e desativação de elementos ou modificação de propriedades de layout), toda a tela ou parte dela pode ser marcada como suja e ser recriada. Isso pode acionar a criação de estruturas de dados temporárias (por exemplo, dados de malha, buffers de vértices ou cálculos de layout), o que aumenta a geração de lixo.
    • Atualizações complexas ou frequentes: se o canvas tiver um grande número de elementos ou for atualizado com frequência (por exemplo, a cada frame), essas recriações podem levar a uma rotatividade de memória significativa.
  • Ative a GC incremental para reduzir grandes picos de coleta distribuindo as limpezas de alocação em vários frames. Crie um perfil para verificar se essa opção melhora o desempenho e o consumo de memória do jogo.

  • Se o jogo exigir uma abordagem controlada, defina o modo de coleta de lixo como manual. Em seguida, em uma mudança de nível ou em outro momento sem jogabilidade ativa, chame a coleta de lixo.

  • Invoque chamadas manuais de coleta de lixo GC.Collect() para transições de estado do jogo (por exemplo, mudança de nível).

  • Otimize matrizes começando com práticas básicas de código e, se necessário, usando matrizes nativas ou outros contêineres nativos para matrizes grandes.

  • Monitore objetos gerenciados usando ferramentas como o Unity Memory Profiler para rastrear referências de objetos não gerenciados que persistem após a destruição.

    Use um marcador do Profiler para enviar à ferramenta de relatórios de performance para uma abordagem automatizada.

Evitar vazamentos de memória e fragmentação

Vazamentos de memória

No código C#, quando uma referência a um objeto do Unity existe depois que o objeto é destruído, o objeto wrapper gerenciado, conhecido como shell gerenciado, permanece na memória. A memória nativa associada à referência é liberada quando a cena é descarregada ou quando o GameObject ao qual a memória está anexada, ou qualquer um dos objetos pai, é destruído pelo método Destroy(). No entanto, se outras referências à Scene ou ao GameObject não forem limpas, a memória gerenciada pode persistir como um objeto de shell vazado. Para mais detalhes sobre os Managed Shell Objects, consulte o manual Managed Shell Objects.

Além disso, os vazamentos de memória podem ser causados por assinaturas de eventos, lambdas e closures, concatenações de strings e gerenciamento inadequado de objetos em um pool:

  • Para começar, consulte Encontrar vazamentos de memória para comparar snapshots de memória do Unity corretamente.
  • Verifique se há inscrições em eventos e vazamentos de memória. Se os objetos se inscreverem em eventos (por exemplo, por delegados ou UnityEvents), mas não cancelarem a inscrição corretamente antes de serem destruídos, o gerenciador ou editor de eventos poderá reter referências a esses objetos. Isso impede que esses objetos sejam coletados pelo lixo, levando a vazamentos de memória.
  • Monitore eventos de classe global ou singleton que não são cancelados na destruição de objetos. Por exemplo, cancele a inscrição ou desvincule delegados em destruidores de objetos.
  • Garanta que a destruição de objetos em pool anule totalmente as referências a componentes de malha de texto, texturas e GameObjects pai.
  • Ao comparar snapshots do Unity Memory Profiler e observar uma diferença no consumo de memória sem um motivo claro, lembre-se de que a diferença pode ser causada pelo driver gráfico ou pelo próprio sistema operacional.

Fragmentação de memória

A fragmentação de memória ocorre quando muitas alocações pequenas são liberadas em uma ordem aleatória. As alocações de heap são feitas sequencialmente, o que significa que novos blocos de memória são criados quando o bloco anterior fica sem espaço. Consequentemente, novos objetos não preenchem as áreas vazias de blocos antigos, o que leva à fragmentação. Além disso, grandes alocações temporárias podem causar fragmentação permanente durante a sessão de um jogo.

Esse problema é especialmente problemático quando alocações grandes de curta duração são feitas perto de alocações de longa duração.

Agrupe as alocações com base na vida útil. O ideal é que as alocações de longa duração sejam feitas juntas, no início do ciclo de vida do aplicativo.

Observadores e gerentes de eventos

  • Além do problema mencionado na seção Vazamentos de memória, com o tempo, os vazamentos de memória podem contribuir para a fragmentação, deixando memória não utilizada alocada para objetos que não estão mais em uso.
  • Verifique se a destruição de objetos em pool anula totalmente as referências a componentes de malha de texto, texturas e GameObjects pai.
  • Os gerenciadores de eventos geralmente criam e armazenam listas ou dicionários para gerenciar inscrições de eventos. Se eles aumentarem e diminuírem dinamicamente durante o tempo de execução, poderão contribuir para a fragmentação da memória devido a alocações e desalocações frequentes.

Código

  • As corrotinas às vezes alocam memória, o que pode ser evitado armazenando em cache a instrução de retorno do IEnumerator em vez de declarar uma nova sempre.
  • Monitore continuamente os estados do ciclo de vida dos objetos em pool para evitar manter referências fantasmas de UnityEngine.Object.

Recursos

  • Use sistemas de substituição dinâmica para experiências de jogo baseadas em texto para evitar o pré-carregamento de todas as fontes em casos multilíngues.
  • Organize os recursos (por exemplo, texturas e partículas) por tipo e ciclo de vida esperado.
  • Condense recursos com atributos de ciclo de vida inativos, como imagens de interface redundantes e malhas estáticas.

Alocações com base no ciclo de vida

  • Aloque recursos de longa duração no início do ciclo de vida do aplicativo para garantir alocações compactas.
  • Use NativeCollections ou alocadores personalizados para estruturas de dados temporárias ou que consomem muita memória (por exemplo, clusters de física).

O executável e os plug-ins do jogo também afetam o uso da memória.

Metadados do IL2CPP

O IL2CPP gera metadados para cada tipo (por exemplo, classes, genéricos e delegados) no momento da criação, que são usados no momento da execução para reflexão, verificação de tipo e outras operações específicas do momento da execução. Esses metadados são armazenados na memória e podem contribuir significativamente para o consumo total de memória do aplicativo. O cache de metadados do IL2CPP contribui significativamente para os tempos de inicialização e carregamento. Além disso, o IL2CPP não elimina a duplicação de determinados elementos de metadados (por exemplo, tipos genéricos ou informações serializadas), o que pode resultar em um uso excessivo de memória. Isso é agravado pelo uso repetitivo ou redundante de tipos no projeto.

Os metadados do IL2CPP podem ser reduzidos:

  • Evite o uso de APIs de reflexão, porque elas podem contribuir significativamente para as alocações de metadados do IL2CPP.
  • Desativar pacotes integrados
  • Implementação do compartilhamento genérico completo do Unity 2022, que deve ajudar a reduzir a sobrecarga causada por genéricos. No entanto, para reduzir ainda mais as alocações, diminua o uso de genéricos.

Remoção de código

Além de reduzir o tamanho do build, a remoção de código também diminui o uso da memória. Ao criar no back-end de script IL2CPP, a remoção de bytecode gerenciado (que é ativada por padrão) remove o código não utilizado dos assemblies gerenciados. O processo funciona definindo assemblies raiz e, em seguida, usando a análise de código estático para determinar quais outros códigos gerenciados esses assemblies raiz usam. Qualquer código que não seja acessível é removido. Para mais informações sobre a remoção de código gerenciado, consulte a postagem do blog Tales from the optimization trenches: Better managed code stripping with Unity 2020 LTS e a documentação sobre remoção de código gerenciado (links em inglês).

Alocadores nativos

Teste alocadores de memória nativos para ajustar os alocadores de memória. Se o jogo estiver com pouca memória, use blocos de memória menores, mesmo que isso envolva alocadores mais lentos. Consulte o exemplo de alocador de heap dinâmico para saber mais.

Gerenciar plug-ins e SDKs nativos

  • Encontre o plug-in problemático: remova cada plug-in e compare os snapshots de memória do jogo. Isso envolve desativar muitas funcionalidades de código com Scripting Define Symbols e refatorar classes altamente acopladas com interfaces. Confira PRÓXIMO NÍVEL seu código com padrões de programação de jogos para facilitar o processo de desativação de dependências externas sem tornar o jogo impossível de jogar.

  • Entre em contato com o autor do plug-in ou do SDK: a maioria dos plug-ins não é de código aberto.

  • Reproduza o uso da memória do plug-in: escreva um plug-in pequeno (use este plug-in do Unity como referência) que faça alocações de memória. Inspecione os snapshots de memória usando o Android Studio (já que o Unity não rastreia essas alocações) ou chame a classe MemoryInfo e o método Runtime.totalMemory() no mesmo projeto.

Um plug-in do Unity aloca memória Java e nativa. Veja como fazer isso:

Java

byte[] largeObject = new byte[1024 * 1024 * megaBytes];
list.add(largeObject);

Nativo

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
}