Para otimizar o consumo de memória do jogo, primeiro você precisa entender como a plataforma Android mede a memória e como usar a telemetria do sistema, as APIs de diagnóstico e as ferramentas de criação de perfil. Este guia detalha como monitorar, capturar e analisar as alocações de memória do jogo de acordo com as novas diretrizes da plataforma.
Noções básicas sobre métricas de RSS e troca
Para analisar e depurar de forma eficaz o comportamento da memória do jogo, é preciso entender as métricas técnicas exatas que a plataforma Android usa para o gerenciamento de memória. Para informações detalhadas sobre como esse parâmetro de telemetria é processado e monitorado na prática, consulte a documentação do Android vitals: uso da memória (RSS anônimo e espaço de troca).
1. RSS anônimo (RssAnon)
O tamanho do conjunto residente (RSS, na sigla em inglês) mede a parte da memória ocupada por um processo que é mantida na RAM física do dispositivo. O RSS é dividido em memória com backup de arquivos e memória anônima. A métrica de memória do Android se concentra estritamente no RSS anônimo:
- O que inclui: páginas de memória alocadas diretamente pelo processo do jogo que não estão vinculadas a um arquivo físico no armazenamento. Essas páginas incluem heaps Java ou Kotlin, pilhas de execução de linhas de execução e, principalmente, alocações de memória nativa, como alocadores de mecanismo C++ personalizados ou blocos de memória solicitados usando malloc nativo ou novos e sujos pela lógica do jogo. Saiba mais sobre essa métrica no dicionário Memória do processo (RSS).
- Por que isso é importante: os mecanismos de jogos usam pools de memória nativa enormes para lidar com física, renderização e lógica. Como esses pools não são apoiados por arquivos, eles residem inteiramente no RSS anônimo e formam a maior parte da pegada física do jogo.
2. Troca não compactada (VmSwap)
O Android não oferece suporte a um espaço de troca tradicional baseado em disco devido ao desgaste do armazenamento flash e às restrições de latência. Em vez disso, ele usa a zRAM (troca não compactada):
- O que inclui: quando a pressão da RAM física aumenta, o daemon de gerenciamento de memória do kernel compacta páginas anônimas inativas e as move para uma parte dedicada e não compactada da RAM física (zRAM).
- O cálculo da métrica: o sistema rastreia isso com base no tamanho descompactado (VmSwap) para avaliar a demanda real de memória física do jogo. Se o jogo alocar memória e o sistema a trocar para a zRAM, ela ainda vai contar para o consumo total de memória do jogo.
3. Estados do processo
O uso da memória é dividido por estados de processo no Android vitals. Para desenvolvedores de jogos, SDKs ou jogos de terceiros também podem acionar serviços percebidos pelo usuário ou serviços em segundo plano de forma inesperada.
- O que inclui: serviços em primeiro plano, perceptíveis, em segundo plano e em cache.
- Por que isso é importante: estados de processo diferentes têm impactos distintos no
gerenciamento de memória do SO Android. Talvez você não saiba que o jogo está sendo executado com um
estado de processo sensível se algum SDK de terceiros acionar uma tarefa em segundo plano
sem querer. Monitore se o jogo está sendo executado em segundo plano
usando
RunningAppProcessInfo.
Interfaces de programação dos aplicativos (APIs)
O Android oferece APIs do sistema que permitem que o jogo responda dinamicamente à pressão de memória e capture diagnósticos detalhados de memória no momento da execução.
Responder a eventos de corte de memória
O sistema usa onTrimMemory para notificar o app sobre eventos de ciclo de vida que
apresentam uma boa oportunidade para reduzir voluntariamente o uso da memória
e evitar que ele seja encerrado pelo low-memory killer (LMK) para liberar memória para
outros apps.
Se o sistema encerrar o app em segundo plano, o usuário vai notar uma inicialização a frio lenta ao retomar. Reduzir o uso da memória em segundo plano ajuda a evitar essas finalizações.
Ao responder a eventos de corte, libere alocações de memória grandes e reconstruíveis que não sejam necessárias imediatamente:
Exemplo: corte ou limpe bitmaps em cache (decodificados do armazenamento local) em resposta a
TRIM_MEMORY_UI_HIDDEN.
Kotlin
class MainActivity : AppCompatActivity(), ComponentCallbacks2 {
override fun onTrimMemory(level: Int) {
if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
// Release memory related to UI elements, such as bitmap caches.
}
if (level >= ComponentCallbacks2.TRIM_MEMORY_BACKGROUND) {
// Release memory related to background processing, such as by
// closing a database connection.
}
}
}
Java
public class MainActivity extends AppCompatActivity implements ComponentCallbacks2 {
@Override
public void onTrimMemory(int level) {
if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
// Release memory related to UI elements, such as bitmap caches.
}
if (level >= ComponentCallbacks2.TRIM_MEMORY_BACKGROUND) {
// Release memory related to background processing, such as by
// closing a database connection.
}
}
}
ProfilingManager
Introduzida no Android 15 (nível 35 da API), a API ProfilingManager permite que
os aplicativos capturem snapshots definidos de forma programática (como perfis de alocação heap,
rastreamentos do sistema e heap dumps do Java) diretamente no ambiente de execução.
Os desenvolvedores podem acionar capturas manualmente em cenas específicas ou registrar
acionadores automatizados, como TRIGGER_TYPE_ANOMALY, para disparar automaticamente uma
captura quando o processo do jogo violar os limites do limitador de memória. No entanto,
os desenvolvedores de jogos precisam considerar limitações críticas nos mecanismos de jogos modernos:
Observação: os mecanismos de jogo modernos (como Unity ou Unreal) gerenciam o desempenho de execução pré-alocando blocos de memória virtual massivos do kernel usando mmap com a flag MAP_ANONYMOUS. Em seguida, os mecanismos usam subalocadores personalizados (por exemplo, o gerenciamento de memória nativo do Unity ou os BinnedAllocators do Unreal) para subdividir e alocar blocos de memória internamente.
ApplicationExitInfo
Se o jogo for encerrado em segundo plano ou por violar os limites de memória de processos individuais, os mecanismos padrão de crash dump nativas ou Java (como o Firebase Crashlytics) não vão registrar o evento. Para consultar e registrar esses
encerramento de forma programática, os desenvolvedores precisam usar a
API ApplicationExitInfo na inicialização do jogo.
- Implementação: ao iniciar, chame
ActivityManager.getHistoricalProcessExitReasons()para recuperar os motivos de saída de sessões recentes. - Principais motivos para a saída da memória:
REASON_LOW_MEMORY: indica que o processo foi encerrado pelo Low Memory Killer (LMK) do sistema. Isso ocorre quando a pressão de memória em todo o dispositivo está alta e o SO precisa recuperar RAM. Esse motivo de saída indica que o consumo em segundo plano do jogo é muito grande para coexistir com outros aplicativos.REASON_MEMORY_LIMITER(Android 17 QPR2, nível 37.2 da API /Build.VERSION_CODES_FULL.CINNAMON_BUN_2e versões mais recentes): indica que o processo foi encerrado especificamente porque excedeu o limite de memória do cgroup (RssAnon + VmSwap) atribuído pelo limitador de memória da plataforma. Isso pode acontecer mesmo que haja bastante memória física restante no dispositivo. Em builds anteriores do Android 17,getReason()retornaREASON_OTHERcom"MemoryLimiter:AnonSwap"emgetDescription().
Use as ferramentas disponíveis
Use as ferramentas de plataforma a seguir durante o desenvolvimento e o controle de qualidade para medir com precisão o uso da memória do jogo.
meminfo
Essa ferramenta coleta estatísticas sobre a memória para mostrar quanta memória PSS foi alocada e as categorias para as quais ela foi usada.
Veja as estatísticas do meminfo de uma das seguintes maneiras:
- Use o comando
adb shell dumpsys meminfo package-name; - Use a chamada
MemoryInfoda API Android Debug.
A estatística PrivateDirty mostra a quantidade de RAM dentro do processo que não pode ser paginada no disco e não é compartilhada com outros processos. A maior parte desse valor fica disponível para o sistema quando esse processo é encerrado.
Tracepoints de memória
Os tracepoints de memória rastreiam a quantidade de memória RSS que seu jogo está usando. Calcular o uso da memória RSS é muito mais rápido do que calcular o uso do PSS. Como é mais rápido de calcular, o RSS mostra uma granularidade mais refinada nas alterações no tamanho da memória para medições mais precisas do uso da memória de pico. Portanto, é mais fácil observar picos que possam fazer com que o jogo fique sem memória.
Perfetto
O Perfetto (link em inglês) é um pacote de ferramentas para coletar informações de desempenho e memória de um dispositivo e exibi-las em uma IU baseada na Web. É compatível com
rastreamentos arbitrariamente longos para que você possa visualizar como o RSS muda ao longo do tempo. Também é possível
emitir consultas SQL dos dados produzidos para processamento off-line. Ative os rastreamentos longos no app Rastreamento do sistema. Verifique se a categoria memory:Memory está ativada para o rastreamento. Para instrumentação de memória personalizada em desenvolvimento e
teste, use também a API heapprofd (Beta).
Inspecionar RssAnon e trocar no Perfetto
Para verificar o impacto da memória anônima e da troca de zRAM do jogo, carregue o arquivo de rastreamento na interface baseada na Web em ui.perfetto.dev (link em inglês) e siga estas técnicas analíticas, projetadas para estudos de caso de memória profunda (consulte Estudos de caso de análise de memória do Perfetto para mais detalhes):
1. Como visualizar contadores de memória na linha do tempo
- Localize o processo: na lista de navegação, pesquise o nome do pacote ou do processo do jogo.
- Expandir o grupo de faixas: clique na linha do processo para expandir as faixas de linhas de execução e localize o subgrupo chamado "Memory".
- Analise as faixas:
- mem.rss.anon (RSS anônimo): esse gráfico de linhas mostra a RAM física em tempo real ocupada pelos pools de memória não gerenciados do jogo. Monitore essa linha do tempo durante carregamentos de cena, pop-ups de IU ou transições de jogabilidade para verificar se há picos de alocação altos.
- mem.swap (troca compactada ou VmSwap): esse gráfico mostra o tamanho pré-compactado dos blocos de memória movidos para a zRAM. Uma alta atividade de troca coincidindo com o jogo indica que ele está sendo executado em um dispositivo com memória limitada e que o sistema está compactando ativamente recursos em segundo plano.
2. Executar consultas SQL (processador de trace): para uma análise off-line detalhada, é possível executar consultas SQL diretamente no console da interface do Perfetto ou usar a biblioteca Python independente do processador de trace para calcular picos estatísticos.
Encontre o pico de alocação de RSS anônimo:
SELECT max(value) / 1024 / 1024 AS max_rss_anon_mb FROM counter JOIN counter_track ON counter.track_id = counter_track.id WHERE counter_track.name = 'mem.rss.anon' AND counter_track.upid IN ( SELECT upid FROM process WHERE name = 'your.game.package.name' );Correlacione RssAnon e VmSwap em qualquer carimbo de data/hora:
SELECT ts, track.name AS metric_type, value / 1024 / 1024 AS size_mb FROM counter JOIN counter_track track ON counter.track_id = track.id WHERE (track.name = 'mem.rss.anon' OR track.name = 'mem.swap') AND track.upid IN ( SELECT upid FROM process WHERE name = 'your.game.package.name' ) ORDER BY ts ASC;
Para mais detalhes sobre como inspecionar arquivos de rastreamento usando o Android Studio, consulte Inspecionar rastreamentos do sistema: memória do processo (RSS). Para detalhes sobre como criar scripts de perfis de memória, consulte Gravar alocações nativas.
Heapprofd
heapprofd é uma ferramenta de rastreamento de memória que faz parte do Perfetto. Essa ferramenta
pode ajudar a encontrar vazamentos de memória ao mostrar onde a memória foi alocada usando
malloc. O heapprofd pode ser iniciado usando um script Python. Como a ferramenta tem baixa sobrecarga, isso não afeta o desempenho como outras ferramentas, como a depuração malloc.
Relatório de bugs
bugreport é uma ferramenta de geração de registros para descobrir se o jogo falhou porque ficou sem memória. A saída da ferramenta é muito mais detalhada do que a do
logcat. Ele é útil para depuração de memória porque mostra se o jogo falhou por memória insuficiente ou se foi encerrado pelo LMK.
Para mais informações, consulte Capturar e ler relatórios de bugs.
Verificar o estado do UID e os ajustes de OOM
O Android gerencia a prioridade do processo e a recuperação de memória com base na hierarquia de
Processos e ciclo de vida do app,
Vinculações de serviço e estados do processo e na API pública
RunningAppProcessInfo. Ao diagnosticar o comportamento da memória em segundo plano
com adb ou verificar por que o Android vitals atribui amostras a um bucket de estado
específico, faça a distinção entre estas duas camadas:
- Estado do processo (
procState) eoom_score_adj:procStateé o estado do ciclo de vida do Activity Manager informado para um processo individual por comandos de diagnósticoadb(cmd activityedumpsys activity). Por exemplo,2 (TOP)quando uma atividade está visível,4 (FOREGROUND_SERVICE)enquanto executa um serviço em primeiro plano ou15 (LAST_ACTIVITY)imediatamente depois que o jogador sai de uma atividade. OOomAdjusterdo Android combina o estado do ciclo de vida com componentes ativos e regras de transição para atribuir a cada processo uma pontuação de prioridadeoom_score_adj. Os quatro buckets de memória de nível superior do Android vitals (Em primeiro plano, Serviços percebidos pelo usuário, Em segundo plano e Em cache) são baseados emoom_score_adjpor processo, em vez do estado do UID. - Estado do UID: o estado do processo agregado informado por
adbpara o ID do usuário (UID) do Linux do seu jogo. Ele reflete o estado do processo de maior prioridade (menor número) entre todos os processos ativos que compartilham esse UID.
Por que RunningAppProcessInfo e oom_score_adj divergem
No código de execução do jogo, a API pública RunningAppProcessInfo.importance
recolhe os estados pós-primeiro plano e em cache, incluindo o que adb informa como
15 (LAST_ACTIVITY), em IMPORTANCE_CACHED (400).
Enquanto isso, quando um jogador sai do jogo (por exemplo, pressionando
o botão home), o OomAdjuster mantém brevemente o processo de interrupção da atividade em
oom_score_adj 200 (PERCEPTIBLE_APP_ADJ) de acordo com os motivos de ajuste pause-activity e
stop-activity até que onPause() e onStop() sejam concluídos,
antes de reduzir oom_score_adj para 700 (PREVIOUS_APP_ADJ). Como os quatro
buckets gerais de nível superior do Android vitals são baseados em oom_score_adj
por processo, em vez do estado do UID, um jogo de processo único mantido brevemente em
oom_score_adj = 200 (PERCEPTIBLE_APP_ADJ) durante pause-activity ou
stop-activity chega aos Serviços percebidos pelo usuário. Durante stop-activity,
isso acontece mesmo quando adb já informa o UID state como
15 (LAST_ACTIVITY).
Como RunningAppProcessInfo.importance recolhe LAST_ACTIVITY e
estados armazenados em cache em IMPORTANCE_CACHED (400), ele não pode distinguir
LAST_ACTIVITY de CACHED_ACTIVITY. Enquanto isso, o oom_score_adj = 200 bruto
se sobrepõe entre as transições de atividade temporárias (pause-activity e
stop-activity) e os serviços em primeiro plano ativos, que são mapeados para
IMPORTANCE_FOREGROUND_SERVICE (125) em RunningAppProcessInfo. Use
adb para inspecionar o estado do UID e as transições de OomAdjuster diretamente
no dispositivo.
Inspecione o estado do UID em tempo real e os ajustes de OOM com adb.
Encontre o UID numérico do seu jogo:
adb shell pm list packages -U <PACKAGE_NAME>Consulte o estado atual do UID: transmita o
<UID>numérico retornado na etapa anterior (transmitir<PACKAGE_NAME>geraNumberFormatException). Durante uma transição normal de parada de atividade sem um serviço em primeiro plano ativo, isso gera15 (LAST_ACTIVITY):adb shell cmd activity get-uid-state <UID>Compare o estado bruto do processo com o bucket da API pública: combine
get-uid-statecompackage-importancepara comparar oprocStatebruto (15 (LAST_ACTIVITY)) com o valor público mapeadoRunningAppProcessInfo.importance(400IMPORTANCE_CACHED):adb shell cmd activity package-importance <PACKAGE_NAME>Transmitir o estado do UID em tempo real e as mudanças de
oom_score_adj: use o subcomando pluralwatch-uidscom--oom <UID>para transmitir as transições de estado do processo do UID com as mensagens# OomAdjusterenquanto minimiza e retoma o jogo:adb shell cmd activity watch-uids --oom <UID>Inspecionar o estado completo de
OomAdjuster: despeje a tabela completa de ajuste de OOM para confirmar se uma entradacur=200é causada porpause-activityoustop-activityem vez defg-service(um serviço em primeiro plano ativo):adb shell dumpsys activity oom
Ferramentas de mecanismo de jogo
Embora os registros no nível da plataforma e a telemetria do sistema sejam vitais para rastrear limites e conformidade do SO, as ferramentas específicas do mecanismo de jogo ajudam a atribuir alocações diretamente aos objetos do jogo, comportamentos de script e hierarquias de cena ativas.
Unity
Em um ambiente do Unity Engine, é possível estimar com precisão o consumo de memória RSS anônima + Swap do Android no momento da execução com alta confiabilidade (normalmente mostrando uma variação de menos de 10% em comparação com os valores reais do SO) usando as ferramentas e classes de criação de perfil nativas do Unity.
Para ver um tutorial completo, incluindo regras de configuração e scripts de ambiente de execução, consulte Como verificar a memória com as ferramentas do Unity.
- API Profiler do Unity: é possível aproximar de forma programática o consumo de memória não gerenciada do jogo no ambiente de execução consultando as métricas principais do mecanismo:
- Usando a classe Profiler: some os valores de
Profiler.GetTotalReservedMemoryLong()eProfiler.GetMonoHeapSizeLong()para monitorar o total de alocações de memória. - Usar a classe
ProfilerRecorder: monitorar as categorias de memória dinamicamente. Para estabelecer uma aproximação confiável, busque a memória reservada total (em builds de lançamento) ou subtraia a memória reservada do Gfx (em builds de desenvolvimento) para remover os componentes de memória gráfica com suporte de arquivo.
- Usando a classe Profiler: some os valores de
- Memory Profiler do Unity: para identificar e depurar vazamentos de memória off-line,
capture um snapshot de memória e inspecione o gráfico "Resident Memory on Device"
na seção "All of Memory". Para calcular o consumo aproximado,
some os totais das seguintes categorias: Não rastreado, Android
Runtime, Nativo e Gerenciado.
- Limitação de zRAM: em condições de memória restrita, o kernel do Android pode compactar páginas de memória inativas no espaço de troca (zRAM). Como o Unity Memory Profiler não consegue detectar parâmetros de troca no nível do SO, talvez você veja pequenas discrepâncias de consumo durante cenas com muita memória. Compare suas estimativas com o Perfetto para confirmar os valores exatos.
Unreal
Em um ambiente do Unreal Engine, é possível avaliar o consumo de memória do jogo combinando diagnósticos do mecanismo com telemetria da plataforma. Para instruções detalhadas e fluxos de trabalho de criação de perfil, consulte Verificar o uso da memória com o Unreal Engine.
As principais ferramentas e interfaces de diagnóstico incluem:
- API Diagnostics para C++: use
GetMemoryUsedFastpara consultas de memória leves e a interfaceGetStatspara estatísticas de memória no nível do hardware. - Comandos do console: monitore as tendências de alocação de memória em tempo real no hardware do dispositivo usando os comandos do mecanismo
stat unitestat unitmax. - Unreal Insights: inspecione capturas de linha do tempo com precisão de frame para analisar métricas no nível da plataforma e contadores de memória personalizados.