La risoluzione dei LMK nel tuo gioco Unity è un processo sistematico:
Ottieni uno snapshot della memoria
Utilizza Unity Profiler per ottenere un'istantanea della memoria gestita da Unity. La Figura 2 mostra i livelli di gestione della memoria utilizzati da Unity per gestire la memoria nel gioco.
Memoria gestita
La gestione della memoria di Unity implementa un livello di memoria controllato che utilizza un heap gestito e un garbage collector per allocare e assegnare la memoria automaticamente. Il sistema di memoria gestita è un ambiente di scripting C# basato su Mono o IL2CPP. Il vantaggio del sistema di memoria gestita è che utilizza un garbage collector per liberare automaticamente le allocazioni della memoria.
Memoria non gestita C#
Il livello di memoria C# non gestito fornisce l'accesso al livello di memoria nativo, consentendo un controllo preciso sulle allocazioni della memoria durante l'utilizzo del codice C#. È possibile accedere a questo livello di gestione della memoria tramite lo spazio dei nomi Unity.Collections e tramite funzioni come UnsafeUtility.Malloc e UnsafeUtility.Free.
Memoria nativa
Il core C/C++ interno di Unity utilizza un sistema di memoria nativo per gestire scene, asset, API grafiche, driver, sottosistemi e buffer dei plug-in. Sebbene l'accesso diretto sia limitato, puoi manipolare i dati in sicurezza con l'API C# di Unity e sfruttare un codice nativo efficiente. La memoria nativa raramente richiede un'interazione diretta, ma puoi monitorare l'impatto della memoria nativa sulle prestazioni utilizzando Profiler e regolare le impostazioni per ottimizzare le prestazioni.
La memoria non è condivisa tra C# e il codice nativo, come mostrato nella figura 3. I dati richiesti da C# vengono allocati nello spazio di memoria gestito ogni volta che sono necessari.
Affinché il codice del gioco gestito (C#) possa accedere ai dati della memoria nativa del motore, ad esempio, una chiamata a GameObject.transform effettua una chiamata nativa per accedere ai dati della memoria nell'area nativa e poi restituisce i valori a C# utilizzando Bindings. Le associazioni garantiscono convenzioni di chiamata appropriate per ogni piattaforma e gestiscono il marshalling automatico dei tipi gestiti nei loro equivalenti nativi.
Questo accade solo la prima volta, poiché la shell gestita per accedere alla proprietà transform viene conservata nel codice nativo. La memorizzazione nella cache della proprietà transform può ridurre il numero di chiamate avanti e indietro tra il codice gestito e quello nativo, ma l'utilità della memorizzazione nella cache dipende dalla frequenza con cui viene utilizzata la proprietà. Inoltre, tieni presente che Unity non copia parti della memoria nativa nella memoria gestita quando accedi a queste API.
Per saperne di più, consulta Introduzione alla memoria in Unity.
Inoltre, è fondamentale stabilire un budget di memoria per garantire il corretto funzionamento del gioco e l'implementazione di un sistema di analisi o reportistica sul consumo di memoria garantisce che ogni nuova release non superi il budget di memoria. Un'altra strategia per ottenere informazioni più dettagliate è l'integrazione dei test della modalità di gioco con l'integrazione continua (CI) per verificare il consumo di memoria in aree specifiche del gioco.
Gestione asset
Questa è la parte più impattante e pratica del consumo di memoria. Profile il prima possibile.
La memoria utilizzata nei giochi per Android può variare in modo significativo a seconda del tipo di gioco, del numero e dei tipi di asset e delle strategie di ottimizzazione della memoria. Tuttavia, i fattori che contribuiscono comunemente alla memoria utilizzata includono texture, mesh, file audio, shader, animazioni e script.
Rileva gli asset duplicati
Il primo passaggio consiste nel rilevare asset configurati in modo errato e asset duplicati utilizzando il Memory Profiler, uno strumento di report di build o Project Auditor.
Texture
Analizza il supporto dei dispositivi per il tuo gioco e decidi il formato delle texture corretto. Puoi suddividere i bundle di texture per dispositivi di fascia alta e di fascia bassa utilizzando Play Asset Delivery, Addressable o un processo più manuale con un AssetBundle.
Segui i consigli più noti disponibili in Ottimizza le prestazioni del tuo gioco mobile e nel post di discussione Ottimizzazione delle impostazioni di importazione delle texture di Unity. Poi prova queste soluzioni:
Comprimi le texture con i formati ASTC per ridurre il footprint della memoria e sperimenta con una frequenza di blocco più elevata, ad esempio 8x8.
Se è necessario utilizzare ETC2, pacchettizza le texture in Atlas. L'inserimento di più texture in un'unica texture garantisce la potenza di due (POT), può ridurre le chiamate di disegno e può velocizzare il rendering.
Ottimizza il formato e le dimensioni della texture RenderTarget. Evita texture con risoluzione inutilmente elevata. L'utilizzo di texture più piccole sui dispositivi mobili consente di risparmiare memoria.
Utilizza il packing dei canali delle texture per risparmiare memoria per le texture.
Mesh e modelli
Inizia controllando le impostazioni fondamentali (pagina 27) e verifica queste impostazioni di importazione delle mesh:
- Unisci le mesh ridondanti e più piccole.
- Riduci il numero di vertici per gli oggetti nelle scene (ad esempio, oggetti statici o distanti).
- Genera gruppi di livelli di dettaglio (LOD) per asset con geometria elevata.
Materiali e shader
- Rimuovi le varianti di shader non utilizzate in modo programmatico durante il processo di build.
- Consolida le varianti di shader utilizzate di frequente in uber shader per evitare la duplicazione degli shader.
- Abilita il caricamento dinamico degli shader per risolvere il problema del footprint della memoria elevato degli shader precaricati nella VRAM/RAM. Tuttavia, presta attenzione se la compilazione degli shader causa problemi di frame.
- Utilizza il caricamento dinamico degli shader per evitare che vengano caricate tutte le varianti. Per saperne di più, consulta il blog post Miglioramenti ai tempi di build e alla memoria utilizzata degli shader.
- Utilizza correttamente l'instancing dei materiali sfruttando
MaterialPropertyBlocks.
Audio
Inizia controllando le impostazioni fondamentali (pagina 41) e verifica queste impostazioni di importazione delle mesh:
- Rimuovi i riferimenti
AudioClipinutilizzati o ridondanti quando utilizzi motori audio di terze parti come FMOD o Wwise. - Precarica i dati audio. Disattiva il precaricamento per i clip che non sono immediatamente necessari durante il runtime o l'avvio della scena. In questo modo, l'overhead di memoria viene ridotto durante l'inizializzazione della scena.
Animazioni
- Regola le impostazioni di compressione delle animazioni di Unity per ridurre al minimo il numero di keyframe ed eliminare i dati ridondanti.
- Riduzione dei fotogrammi chiave: rimuove automaticamente i fotogrammi chiave non necessari
- Compressione dei quaternioni: comprime i dati di rotazione per ridurre la memoria utilizzata
Puoi regolare le impostazioni di compressione in Animation Import Settings (Impostazioni di importazione dell'animazione) nella scheda Rig o Animation (Animazione).
Riutilizza i clip di animazione anziché duplicarli per oggetti diversi.
Utilizza gli Animator Override Controller per riutilizzare un Animator Controller e sostituire clip specifiche per personaggi diversi.
Esegui il baking delle animazioni basate sulla fisica: se le tue animazioni sono basate sulla fisica o procedurali, esegui il baking in clip di animazione per evitare calcoli di runtime.
Ottimizza il rig dello scheletro: utilizza meno ossa nel rig per ridurre la complessità e il consumo di memoria.
- Evita un numero eccessivo di ossa per oggetti piccoli o statici.
- Se alcune ossa non sono animate o necessarie, rimuovile dal rig.
Riduci la durata del clip animato.
- Taglia i clip di animazione per includere solo i frame necessari. Evita di archiviare animazioni inutilizzate o eccessivamente lunghe.
- Utilizza animazioni in loop anziché creare clip lunghe per i movimenti ripetuti.
Assicurati che sia collegato o attivato un solo componente di animazione. Ad esempio, disattiva o rimuovi i componenti Legacy animation se utilizzi Animator.
Evita di utilizzare l'Animator se non è necessario. Per gli effetti visivi di base, utilizza le librerie di tweening o implementa l'effetto visivo in uno script. Il sistema di animazione può richiedere molte risorse, in particolare sui dispositivi mobili di fascia bassa.
Utilizza il sistema di job per le animazioni quando gestisci un numero elevato di animazioni, poiché questo sistema è stato completamente riprogettato per essere più efficiente in termini di memoria.
Scene
Quando vengono caricate nuove scene, queste importano gli asset come dipendenze. Tuttavia, senza una corretta gestione del ciclo di vita degli asset, queste dipendenze non vengono monitorate dai contatori di riferimento. Di conseguenza, gli asset potrebbero rimanere in memoria anche dopo che le scene inutilizzate sono state scaricate, causando la frammentazione della memoria.
- Utilizza l'Object Pooling di Unity per riutilizzare le istanze di GameObject per gli elementi di gameplay ricorrenti, perché l'object pooling utilizza uno stack per contenere una raccolta di istanze di oggetti da riutilizzare e non è thread-safe. La riduzione al minimo di
InstantiateeDestroymigliora sia le prestazioni della CPU sia la stabilità della memoria. - Scaricamento degli asset:
- Scarica gli asset in modo strategico durante i momenti meno critici, come le schermate iniziali o di caricamento.
- L'uso frequente di
Resources.UnloadUnusedAssetscausa picchi nell'elaborazione della CPU a causa di operazioni di monitoraggio delle dipendenze interne di grandi dimensioni. - Verifica la presenza di picchi elevati della CPU nell'indicatore del profilo GC.MarkDependencies.
Rimuovi o riduci la frequenza di esecuzione e scarica manualmente risorse specifiche utilizzando Resources.UnloadAsset anziché fare affidamento su
Resources.UnloadUnusedAssets(), che è onnicomprensivo.
- Ristruttura le scene anziché utilizzare costantemente Resources.UnloadUnusedAssets.
- La chiamata di
Resources.UnloadUnusedAssets()perAddressablespuò scaricare involontariamente i bundle caricati dinamicamente. Gestisci con attenzione il ciclo di vita degli asset caricati dinamicamente.
Varie
Frammentazione causata dalle transizioni di scena: quando viene chiamato il metodo
Resources.UnloadUnusedAssets(), Unity esegue le seguenti operazioni:- Libera memoria per gli asset non più in uso
- Esegue un'operazione simile a un garbage collector per controllare l'heap degli oggetti gestiti e nativi alla ricerca di asset inutilizzati e li scarica
- Pulisce la memoria di texture, mesh e asset, a condizione che non esista alcun riferimento attivo
AssetBundleoAddressable: apportare modifiche in quest'area è complesso e richiede uno sforzo collettivo da parte del team per implementare le strategie. Tuttavia, una volta acquisite, queste strategie migliorano notevolmente la memoria utilizzata, riducono le dimensioni dei download e abbassano i costi del cloud. Per saperne di più sulla gestione degli asset in Unity, consultaAddressables.Dipendenze condivise centralizzate: raggruppa sistematicamente le dipendenze condivise, come shader, texture e caratteri, in bundle dedicati o gruppi
Addressable. In questo modo si riducono le duplicazioni e si garantisce che gli asset non necessari vengano scaricati in modo efficiente.Utilizza
Addressablesper il monitoraggio delle dipendenze: gli Addressables semplificano il caricamento e lo scaricamento e possono scaricare automaticamente le dipendenze che non sono più referenziate. La transizione aAddressablesper la gestione dei contenuti e la risoluzione delle dipendenze potrebbe essere una soluzione praticabile, a seconda del caso specifico del gioco. Analizza le catene di dipendenze con lo strumento Analyze per identificare duplicati o dipendenze non necessari. In alternativa, consulta gli strumenti per i dati di Unity se utilizzi gli AssetBundle.TypeTrees: seAddressableseAssetBundlesdel tuo gioco vengono creati e distribuiti utilizzando la stessa versione di Unity del player e non richiedono la compatibilità con le versioni precedenti di altre build del player, valuta la possibilità di disattivare la scrittura diTypeTree, in modo da ridurre le dimensioni del bundle e il footprint della memoria degli oggetti dei file serializzati. Modifica il processo di build nell'impostazione locale del pacchetto Addressables ContentBuildFlags in DisableWriteTypeTree.
Scrivi codice compatibile con il garbage collector
Unity utilizza la garbage collection (GC) per gestire la memoria identificando e liberando automaticamente la memoria inutilizzata. Seb picco della frequenza fotogrammi) se non viene gestito correttamente, in quanto questo processo può mettere momentaneamente in pausa il gioco, causando problemi di prestazioni e un'esperienza utente non ottimale.
Consulta il manuale di Unity per tecniche utili su come ridurre la frequenza delle allocazioni heap gestite e la UnityPerformanceTuningBible, pagina 271, per esempi.
Riduci le allocazioni del garbage collector:
- Evita LINQ, lambda e chiusure, che allocano memoria heap.
- Utilizza
StringBuilderper le stringhe modificabili anziché la concatenazione di stringhe. - Riutilizza le raccolte chiamando
COLLECTIONS.Clear()anziché crearne di nuovo un'istanza.
Per saperne di più, consulta l'e-book Ultimate Guide to Profiling Unity games.
Gestisci gli aggiornamenti del canvas della UI:
- Modifiche dinamiche agli elementi UI: quando vengono aggiornati elementi UI come le proprietà di testo, immagine o
RectTransform(ad esempio, modifica dei contenuti di testo, ridimensionamento degli elementi o animazione delle posizioni), il motore potrebbe allocare memoria per gli oggetti temporanei. - Allocazioni di stringhe: gli elementi UI come Text spesso richiedono aggiornamenti delle stringhe, poiché le stringhe sono immutabili nella maggior parte dei linguaggi di programmazione.
- Canvas non aggiornato: quando un elemento di un canvas cambia (ad esempio, ridimensionamento, attivazione e disattivazione di elementi o modifica delle proprietà del layout), l'intero canvas o una parte di questo potrebbe essere contrassegnato come non aggiornato e venire ricostruito. Ciò può attivare la creazione di strutture di dati temporanee (ad esempio dati mesh, buffer di vertici o calcoli di layout), che si aggiungono alla generazione di dati inutili.
- Aggiornamenti complessi o frequenti: se il canvas contiene un numero elevato di elementi o viene aggiornato di frequente (ad esempio, ogni frame), queste ricostruzioni possono causare una saturazione della memoria significativa.
- Modifiche dinamiche agli elementi UI: quando vengono aggiornati elementi UI come le proprietà di testo, immagine o
Attiva il GC incrementale per ridurre i picchi di raccolta di grandi dimensioni distribuendo le pulizie delle allocazioni su più frame. Esegui la profilazione per verificare se questa opzione migliora le prestazioni e il footprint della memoria del tuo gioco.
Se il tuo gioco richiede un approccio controllato, imposta la modalità di garbage collection su manuale. Poi, durante un cambio di livello o in un altro momento senza gameplay attivo, chiama la garbage collection.
Richiama le chiamate manuali di garbage collection GC.Collect() per le transizioni di stato del gioco (ad esempio, il cambio di livello).
Ottimizza gli array partendo dalle pratiche di codice di base e, se necessario, utilizzando array nativi o altri container nativi per array di grandi dimensioni.
Monitora gli oggetti gestiti utilizzando strumenti come Memory Profiler di Unity per monitorare i riferimenti agli oggetti non gestiti che persistono dopo la distruzione.
Utilizza un indicatore del profiler per inviare i dati allo strumento di segnalazione dei problemi di prestazioni per un approccio automatizzato.
Evita perdite di memoria e frammentazione
Perdite di memoria
Nel codice C#, quando un riferimento a un oggetto Unity esiste dopo che l'oggetto è stato eliminato, l'oggetto wrapper gestito, noto come Managed Shell, rimane in memoria. La memoria nativa associata al riferimento viene rilasciata quando la scena viene scaricata o quando il GameObject a cui è collegata la memoria, o uno dei suoi oggetti principali, viene eliminato tramite il metodo Destroy(). Tuttavia, se altri riferimenti alla scena o al GameObject non sono stati cancellati, la memoria gestita potrebbe persistere come oggetto shell con leak. Per ulteriori dettagli sugli oggetti Managed Shell, consulta il manuale Managed Shell Objects.
Inoltre, le perdite di memoria possono essere causate da sottoscrizioni di eventi, funzioni lambda e chiusure, concatenazioni di stringhe e gestione impropria degli oggetti in pool:
- Per iniziare, consulta Trova perdite di memoria per confrontare correttamente gli snapshot della memoria di Unity.
- Controlla le iscrizioni agli eventi e le perdite di memoria. Se gli oggetti si iscrivono agli eventi (ad esempio tramite delegati o UnityEvent) ma non annullano l'iscrizione correttamente prima di essere eliminati, il gestore o il publisher degli eventi potrebbe conservare i riferimenti a questi oggetti. In questo modo, questi oggetti non vengono sottoposti alla garbage collection, il che causa perdite di memoria.
- Monitora gli eventi di classe globali o singleton di cui non viene annullata la registrazione alla distruzione dell'oggetto. Ad esempio, annulla l'iscrizione o scollega i delegati nei distruttori di oggetti.
- Assicurati che l'eliminazione degli oggetti in pool annulli completamente i riferimenti ai componenti della mesh di testo, alle texture e ai GameObject principali.
- Tieni presente che quando confronti gli snapshot di Unity Memory Profiler e osservi una differenza nel consumo di memoria senza un motivo chiaro, la differenza potrebbe essere causata dal driver grafico o dal sistema operativo stesso.
Frammentazione della memoria
La frammentazione della memoria si verifica quando molte piccole allocazioni vengono liberate in un ordine casuale. Le allocazioni heap vengono eseguite in sequenza, il che significa che vengono creati nuovi blocchi di memoria quando lo spazio del blocco precedente si esaurisce. Di conseguenza, i nuovi oggetti non riempiono le aree vuote dei vecchi chunk, il che porta alla frammentazione. Inoltre, allocazioni temporanee di grandi dimensioni possono causare una frammentazione permanente per la durata di una sessione di gioco.
Questo problema è particolarmente problematico quando vengono effettuate allocazioni di grandi dimensioni di breve durata vicino ad allocazioni di lunga durata.
Raggruppa le allocazioni in base alla loro durata. Idealmente, le allocazioni di lunga durata dovrebbero essere effettuate insieme, all'inizio del ciclo di vita dell'applicazione.
Osservatori e gestori di eventi
- Oltre al problema menzionato nella sezione Perdite di memoria, nel tempo le perdite di memoria possono contribuire alla frammentazione lasciando la memoria inutilizzata allocata a oggetti che non sono più in uso.
- Assicurati che la distruzione degli oggetti in pool annulli completamente i riferimenti ai componenti della mesh di testo, alle texture e all'elemento
GameObjectsprincipale. - I gestori di eventi spesso creano e archiviano elenchi o dizionari per gestire le iscrizioni agli eventi. Se queste crescono e si riducono dinamicamente durante il runtime, possono contribuire alla frammentazione della memoria a causa di allocazioni e deallocazioni frequenti.
Codice
- Le coroutine a volte allocano memoria, il che può essere evitato memorizzando nella cache l'istruzione return di IEnumerator anziché dichiararne una nuova ogni volta.
- Monitora continuamente gli stati del ciclo di vita degli oggetti in pool per evitare di mantenere riferimenti fantasma di
UnityEngine.Object.
Asset
- Utilizza sistemi di fallback dinamici per le esperienze di gioco basate su testo per evitare di precaricare tutti i caratteri per i casi multilingue.
- Organizza gli asset (ad esempio, texture e particelle) per tipo e ciclo di vita previsto.
- Condensa gli asset con attributi del ciclo di vita inattivi, come immagini UI ridondanti e mesh statiche.
Allocazioni basate sulla durata
- Alloca gli asset di lunga durata all'inizio del ciclo di vita dell'applicazione per garantire allocazioni compatte.
- Utilizza NativeCollections o allocatori personalizzati per strutture di dati temporanee o che richiedono molta memoria (ad esempio, cluster fisici).
Azione di memoria relativa al codice e agli eseguibili
Anche l'eseguibile e i plug-in del gioco influiscono sulla memoria utilizzata.
Metadati IL2CPP
IL2CPP genera metadati per ogni tipo (ad esempio classi, generici e delegati) in fase di build, che vengono poi utilizzati in fase di runtime per la riflessione, il controllo del tipo e altre operazioni specifiche del runtime. Questi metadati vengono archiviati nella memoria e possono contribuire in modo significativo al footprint della memoria totale dell'applicazione. La cache dei metadati di IL2CPP contribuisce in modo significativo ai tempi di inizializzazione e caricamento. Inoltre, IL2CPP non deduplica alcuni elementi dei metadati (ad esempio, tipi generici o informazioni serializzate), il che può comportare un utilizzo eccessivo della memoria utilizzata. Questo problema è aggravato dall'utilizzo di tipi ripetitivi o ridondanti nel progetto.
I metadati IL2CPP possono essere ridotti:
- Evita l'utilizzo di API di riflessione, in quanto possono contribuire in modo significativo alle allocazioni dei metadati IL2CPP.
- Disattivazione dei pacchetti integrati
- Implementazione della condivisione generica completa di Unity 2022, che dovrebbe contribuire a ridurre l'overhead causato dai generici. Tuttavia, per ridurre ulteriormente le allocazioni, riduci l'uso dei generici.
Code stripping
Oltre a ridurre le dimensioni della build, lo stripping del codice riduce anche la memoria utilizzata. Quando si esegue la build con il backend di scripting IL2CPP, lo stripping del bytecode gestito (attivato per impostazione predefinita) rimuove il codice inutilizzato dagli assembly gestiti. Il processo funziona definendo gli assembly radice e utilizzando l'analisi statica del codice per determinare quale altro codice gestito viene utilizzato da questi assembly radice. Qualsiasi codice non raggiungibile viene rimosso. Per saperne di più sulla rimozione del codice gestito, consulta il blog post Tales from the optimization trenches: Better managed code stripping with Unity 2020 LTS e la documentazione relativa alla rimozione del codice gestito.
Allocatori nativi
Sperimenta con gli allocatori di memoria nativi per ottimizzare gli allocatori di memoria. Se il gioco ha poca memoria, utilizza blocchi di memoria più piccoli, anche se ciò comporta allocatori più lenti. Per saperne di più, consulta l'esempio di allocatore heap dinamico.
Gestisci plug-in e SDK nativi
Trova il plug-in problematico: rimuovi ogni plug-in e confronta gli snapshot della memoria del gioco. Ciò comporta la disattivazione di molte funzionalità del codice con Scripting Define Symbols e il refactoring di classi altamente accoppiate con le interfacce. Consulta l'articolo Level up your code with game programming patterns per facilitare il processo di disattivazione delle dipendenze esterne senza rendere il gioco non giocabile.
Contatta l'autore del plug-in o dell'SDK: la maggior parte dei plug-in non è open source.
Riproduci la memoria utilizzata dal plug-in: puoi scrivere un piccolo plug-in (utilizza questo plug-in Unity come riferimento) che esegue allocazioni della memoria. Esamina gli snapshot della memoria utilizzando Android Studio (poiché Unity non monitora queste allocazioni) o chiama la classe
MemoryInfoe il metodoRuntime.totalMemory()nello stesso progetto.
Un plug-in Unity alloca memoria Java e nativa; ecco come fare:
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
}