मेमोरी के इस्तेमाल की निगरानी करना

अपने गेम के मेमोरी फ़ुटप्रिंट को बेहतर तरीके से ऑप्टिमाइज़ करने के लिए, आपको सबसे पहले यह समझना होगा कि Android प्लैटफ़ॉर्म, मेमोरी को कैसे मेज़र करता है. साथ ही, सिस्टम टेलीमेट्री, डाइग्नोस्टिक एपीआई, और प्रोफ़ाइलिंग टूल का इस्तेमाल कैसे किया जाता है. इस गाइड में, नए प्लैटफ़ॉर्म के दिशा-निर्देशों के तहत, अपने गेम के मेमोरी बंटवारे की निगरानी करने, उसे कैप्चर करने, और उसका विश्लेषण करने के तरीके के बारे में बताया गया है.

आरएसएस और स्वैप मेट्रिक को समझना

अपने गेम की मेमोरी के इस्तेमाल का बेहतर तरीके से विश्लेषण करने और उसे डीबग करने के लिए, आपको Android प्लैटफ़ॉर्म की उन सटीक तकनीकी मेट्रिक को समझना होगा जिनका इस्तेमाल वह मेमोरी मैनेजमेंट के लिए करता है. इस टेलीमेट्री पैरामीटर को प्रोसेस करने और इसकी निगरानी करने के तरीके के बारे में ज़्यादा जानने के लिए, Android Vitals - मेमोरी का इस्तेमाल (बिना सोर्स फ़ाइल वाली आरएसएस मेमोरी + स्वैप मेमोरी) से जुड़ा दस्तावेज़ देखें.

1. बिना सोर्स फ़ाइल वाली आरएसएस मेमोरी (RssAnon)

रेसिडेंट सेट साइज़ (आरएसएस) से, किसी प्रोसेस के लिए इस्तेमाल की गई मेमोरी के उस हिस्से को मेज़र किया जाता है जो डिवाइस की फ़िज़िकल रैम में सेव होता है. आरएसएस को, फ़ाइल-बैक मेमोरी और बिना सोर्स फ़ाइल वाली मेमोरी में बांटा जाता है. Android की मेमोरी मेट्रिक, सिर्फ़ बिना सोर्स फ़ाइल वाली आरएसएस मेमोरी पर फ़ोकस करती है:

  • इसमें क्या शामिल है: मेमोरी के वे पेज जो सीधे तौर पर आपके गेम की प्रोसेस के लिए असाइन किए जाते हैं जो स्टोरेज में किसी फ़िज़िकल फ़ाइल से लिंक नहीं होते. इन पेजों में Java या Kotlin हीप, थ्रेड एक्ज़ीक्यूशन स्टैक, और सबसे अहम, नेटिव मेमोरी के बंटवारे (जैसे, कस्टम C++ इंजन एलोकेटर या नेटिव malloc या new का इस्तेमाल करके अनुरोध किए गए मेमोरी ब्लॉक और गेम लॉजिक से जुड़े डेटा) शामिल हैं. प्रोसेस मेमोरी (आरएसएस) डिक्शनरी में, इस मेट्रिक के बारे में ज़्यादा जानें.
  • यह क्यों ज़रूरी है: गेम इंजन, फ़िज़िक्स, रेंडरिंग, और लॉजिक को मैनेज करने के लिए, नेटिव मेमोरी के बड़े पूल का इस्तेमाल करते हैं. ये पूल, फ़ाइलों से बैक अप नहीं होते. इसलिए, ये पूरी तरह से बिना सोर्स फ़ाइल वाली आरएसएस मेमोरी में सेव होते हैं और आपके गेम के फ़िज़िकल फ़ुटप्रिंट का ज़्यादातर हिस्सा बनाते हैं.

2. बिना कंप्रेस की गई स्वैप मेमोरी (VmSwap)

फ़्लैश स्टोरेज के इस्तेमाल और इंतज़ार के समय की पाबंदियों की वजह से, Android, डिस्क पर आधारित पारंपरिक स्वैप स्पेस की सुविधा नहीं देता. इसके बजाय, यह zRAM (बिना कंप्रेस की गई स्वैप मेमोरी) का इस्तेमाल करता है:

  • इसमें क्या शामिल है: जब फ़िज़िकल रैम पर दबाव बढ़ता है, तो कर्नल का मेमोरी मैनेजमेंट डेमॉन, इस्तेमाल न किए जा रहे बिना सोर्स फ़ाइल वाले पेजों को कंप्रेस करता है और उन्हें फ़िज़िकल रैम (zRAM) के बिना कंप्रेस किए गए हिस्से में ले जाता है.
  • मेट्रिक की कैलकुलेशन: सिस्टम, गेम की फ़िज़िकल मेमोरी की असल ज़रूरत का आकलन करने के लिए, इसे बिना कंप्रेस किए गए साइज़ (VmSwap) के आधार पर ट्रैक करता है. अगर आपका गेम, मेमोरी असाइन करता है और सिस्टम उसे zRAM में स्वैप करता है, तो भी इसे आपके गेम के कुल मेमोरी फ़ुटप्रिंट में गिना जाता है.

3. प्रोसेस की स्थितियां

Android Vitals में, मेमोरी के इस्तेमाल को प्रोसेस की स्थितियों के हिसाब से बांटा जाता है. गेम डेवलपर के लिए, तीसरे पक्ष के एसडीके या गेम भी, उपयोगकर्ता को दिखने वाली सेवाओं या बैकग्राउंड सेवाओं को अचानक ट्रिगर कर सकते हैं.

  • इसमें क्या शामिल है: फ़ोरग्राउंड, उपयोगकर्ता को दिखने वाली सेवाएं, बैकग्राउंड, और कैश की गई सेवाएं.
  • यह क्यों ज़रूरी है: प्रोसेस की अलग-अलग स्थितियों का, Android OS के मेमोरी मैनेजमेंट पर अलग-अलग असर पड़ता है. अगर तीसरे पक्ष का कोई एसडीके, अनजाने में बैकग्राउंड टास्क को ट्रिगर करता है, तो हो सकता है कि आपको यह पता न हो कि आपका गेम, संवेदनशील प्रोसेस की स्थिति में चल रहा है. `RunningAppProcessInfo` का इस्तेमाल करके, देखें कि आपका गेम बैकग्राउंड में चल रहा है या नहीं. RunningAppProcessInfo

ऐप्लिकेशन प्रोग्रामिंग इंटरफ़ेस (एपीआई)

Android, सिस्टम एपीआई उपलब्ध कराता है. इनकी मदद से, आपका गेम, मेमोरी पर पड़ने वाले दबाव के हिसाब से डाइनैमिक तरीके से काम कर सकता है. साथ ही, रनटाइम में मेमोरी की गड़बड़ियों की पूरी जानकारी कैप्चर की जा सकती है.

मेमोरी ट्रिम इवेंट का जवाब देना

सिस्टम, onTrimMemory का इस्तेमाल करके, आपके ऐप्लिकेशन को लाइफ़साइकल इवेंट के बारे में सूचना देता है. इससे आपके ऐप्लिकेशन को, अपनी मेमोरी के इस्तेमाल को कम करने और लो-मेमोरी किलर (एलएमके) से बंद होने से बचने का मौका मिलता है. ऐसा करने से, अन्य ऐप्लिकेशन के लिए मेमोरी खाली हो जाती है.

अगर सिस्टम, आपके ऐप्लिकेशन को बैकग्राउंड में बंद कर देता है, तो उपयोगकर्ता को फिर से शुरू करने पर, धीमे कोल्ड स्टार्ट की समस्या होती है. बैकग्राउंड में मेमोरी का इस्तेमाल कम करने से, बैकग्राउंड में ऐप्लिकेशन बंद होने की समस्याओं को रोका जा सकता है.

ट्रिम इवेंट का जवाब देते समय, मेमोरी के बड़े और फिर से बनाए जा सकने वाले उन हिस्सों को रिलीज़ करें जिनकी तुरंत ज़रूरत नहीं है:

  • उदाहरण के लिए: लोकल स्टोरेज से डिकोड किए गए कैश किए गए बिटमैप को ट्रिम या साफ़ करें, ताकि 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 {
    public void onTrimMemory(int level) {
        switch (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

Android 15 (एपीआई लेवल 35) में, ProfilingManager एपीआई को लॉन्च किया गया है. इसकी मदद से, ऐप्लिकेशन, प्रोग्राम के हिसाब से तय किए गए स्नैपशॉट (जैसे, हीप प्रोफ़ाइल, सिस्टम ट्रेस, और Java हीप डंप) को सीधे रनटाइम में कैप्चर कर सकते हैं.

डेवलपर, खास सीन पर मैन्युअल तरीके से कैप्चर ट्रिगर कर सकते हैं. इसके अलावा, TRIGGER_TYPE_ANOMALY जैसे ऑटोमेटेड ट्रिगर रजिस्टर किए जा सकते हैं, ताकि गेम की प्रोसेस, मेमोरी लिमिटर के थ्रेशोल्ड का उल्लंघन करने पर, कैप्चर अपने-आप ट्रिगर हो जाए. हालांकि, गेम डेवलपर को आधुनिक गेम इंजन की अहम पाबंदियों के बारे में पता होना चाहिए:

ध्यान दें: आधुनिक गेम इंजन (जैसे, Unity या Unreal), कर्नल से mmap का इस्तेमाल करके, वर्चुअल मेमोरी के बड़े ब्लॉक को पहले से असाइन करके, एक्ज़ीक्यूशन की परफ़ॉर्मेंस को मैनेज करते हैं. इसके लिए, MAP_ANONYMOUS फ़्लैग का इस्तेमाल किया जाता है. इसके बाद, इंजन, मेमोरी ब्लॉक को अंदरूनी तौर पर बांटने और असाइन करने के लिए, कस्टम सब-एलोकेटर (उदाहरण के लिए, Unity का नेटिव मेमोरी मैनेजर या Unreal का BinnedAllocators) का इस्तेमाल करते हैं.

ApplicationExitInfo

अगर आपका गेम, बैकग्राउंड में बंद हो जाता है या किसी प्रोसेस की मेमोरी की तय सीमा का उल्लंघन करने की वजह से बंद हो जाता है, तो Java या नेटिव क्रैश डंप के स्टैंडर्ड मैकेनिज़्म (जैसे, Firebase Crashlytics) उस इवेंट को रजिस्टर नहीं करते. इन समस्याओं के बारे में क्वेरी करने और इन्हें प्रोग्राम के हिसाब से लॉग करने के लिए, डेवलपर को गेम शुरू होने पर, इन समस्याओं के बारे में क्वेरी करने और इन्हें प्रोग्राम के हिसाब से लॉग करने के लिए, डेवलपर को गेम शुरू होने पर, ApplicationExitInfo एपीआई का इस्तेमाल करना चाहिए.

  • इस्तेमाल करने का तरीका: गेम शुरू होने पर, हाल के सेशन के बंद होने की वजहें पाने के लिए, ActivityManager.getHistoricalProcessExitReasons() को कॉल करें.
  • मेमोरी से जुड़ी समस्याओं की वजहें:
    • REASON_LOW_MEMORY: इससे पता चलता है कि प्रोसेस को सिस्टम के लो मेमोरी किलर (एलएमके) ने बंद किया है. यह समस्या तब होती है, जब डिवाइस की मेमोरी पर दबाव ज़्यादा होता है और ओएस को रैम खाली करनी पड़ती है. इस एग्ज़िट की वजह से पता चलता है कि आपके गेम का बैकग्राउंड फ़ुटप्रिंट इतना बड़ा है कि वह अन्य ऐप्लिकेशन के साथ नहीं चल सकता.
    • REASON_MEMORY_LIMITER (Android 17 (एपीआई लेवल 37) और इसके बाद के वर्शन): इससे पता चलता है कि प्रोसेस को खास तौर पर इसलिए बंद किया गया, क्योंकि उसने प्लैटफ़ॉर्म के मेमोरी लिमिटर से असाइन की गई cgroup मेमोरी की तय सीमा (RssAnon + VmSwap) को पार कर लिया था. यह समस्या तब भी हो सकती है, जब डिवाइस में फ़िज़िकल मेमोरी काफ़ी बची हो. इससे पता चलता है कि किसी प्रोसेस की मेमोरी की तय सीमा का सीधे तौर पर उल्लंघन हुआ है.

उपलब्ध टूल इस्तेमाल करना

अपने गेम की मेमोरी के इस्तेमाल को सटीक तरीके से मेज़र करने के लिए, डेवलपमेंट और क्वालिटी अश्योरेंस के दौरान, प्लैटफ़ॉर्म के इन टूल का इस्तेमाल करें.

meminfo

यह टूल, मेमोरी के आंकड़े इकट्ठा करता है. इससे पता चलता है कि पीएसएस मेमोरी कितनी असाइन की गई थी और इसका इस्तेमाल किन कैटगरी के लिए किया गया था.

meminfo के आंकड़े, इनमें से किसी एक तरीके से प्रिंट करें:

  • adb shell dumpsys meminfo package-name कमांड का इस्तेमाल करें.
  • Android Debug API से MemoryInfo कॉल का इस्तेमाल करें.

PrivateDirty के आंकड़े से, प्रोसेस में मौजूद रैम की उस मात्रा का पता चलता है जिसे डिस्क पर पेज नहीं किया जा सकता और जिसे किसी अन्य प्रोसेस के साथ शेयर नहीं किया जा सकता. जब उस प्रोसेस को बंद किया जाता है, तो इस रकम का ज़्यादातर हिस्सा सिस्टम के लिए उपलब्ध हो जाता है.

मेमोरी ट्रेसपॉइंट

मेमोरी ट्रेसपॉइंट, आपके गेम के लिए इस्तेमाल की जा रही आरएसएस मेमोरी की मात्रा को ट्रैक करते हैं. आरएसएस मेमोरी के इस्तेमाल की कैलकुलेशन, पीएसएस के इस्तेमाल की कैलकुलेशन से ज़्यादा तेज़ होती है. आरएसएस की कैलकुलेशन तेज़ होने की वजह से, मेमोरी के साइज़ में होने वाले बदलावों को ज़्यादा सटीक तरीके से दिखाया जाता है. इससे, मेमोरी के सबसे ज़्यादा इस्तेमाल को सटीक तरीके से मेज़र किया जा सकता है. इसलिए, उन समस्याओं को नोटिस करना आसान हो जाता है जिनकी वजह से गेम में मेमोरी खत्म हो सकती है.

Perfetto

Perfetto, डिवाइस पर परफ़ॉर्मेंस और मेमोरी की जानकारी इकट्ठा करने और उसे वेब-आधारित यूज़र इंटरफ़ेस (यूआई) में दिखाने के लिए, टूल का एक सुइट है. यह लंबे समय तक के ट्रेस को सपोर्ट करता है. इसलिए, यह देखा जा सकता है कि समय के साथ आरएसएस में कैसे बदलाव होते हैं. ऑफ़लाइन प्रोसेसिंग के लिए, इसके जनरेट किए गए डेटा पर एसक्यूएल क्वेरी भी चलाई जा सकती हैं. System Tracing ऐप्लिकेशन से, लंबे समय तक के ट्रेस की सुविधा चालू करें. पक्का करें कि ट्रेस के लिए, memory:Memory कैटगरी चालू हो. डेवलपमेंट और टेस्टिंग में, कस्टम मेमोरी इंस्ट्रूमेंटेशन के लिए, (बीटा) heapprofd एपीआई का भी इस्तेमाल किया जा सकता है.

Perfetto में RssAnon और स्वैप की जांच करना

अपने गेम की बिना सोर्स फ़ाइल वाली मेमोरी और zRAM स्वैप के असर की जांच करने के लिए, अपनी ट्रेस फ़ाइल को ui.perfetto.dev पर वेब-आधारित यूज़र इंटरफ़ेस (यूआई) में लोड करें. इसके बाद, विश्लेषण के इन तरीकों को अपनाएं. इन्हें मेमोरी के इस्तेमाल से जुड़ी समस्याओं के डीप केस स्टडी के लिए डिज़ाइन किया गया है. ज़्यादा जानकारी के लिए, Perfetto Memory Analysis Case Studies देखें:

1. टाइमलाइन पर मेमोरी काउंटर को विज़ुअलाइज़ करना

  • अपनी प्रोसेस ढूंढना: नेविगेशन सूची में, अपने गेम के पैकेज या प्रोसेस का नाम खोजें.
  • ट्रैक ग्रुप को बड़ा करना: अपने प्रोसेस की लाइन पर क्लिक करके, उसके थ्रेड ट्रैक को बड़ा करें. इसके बाद, मेमोरी नाम का सब-ग्रुप ढूंढें.
  • ट्रैक का विश्लेषण करना:
    • mem.rss.anon (बिना सोर्स फ़ाइल वाली आरएसएस मेमोरी): यह लाइन ग्राफ़, आपके गेम के बिना मैनेज किए गए मेमोरी पूल के लिए, रीयल-टाइम में इस्तेमाल की गई फ़िज़िकल रैम को दिखाता है. ज़्यादा मेमोरी असाइन होने की समस्याओं की जांच करने के लिए, सीन लोड होने, यूज़र इंटरफ़ेस (यूआई) के पॉप-अप दिखने या गेमप्ले में बदलाव होने के दौरान, इस टाइमलाइन की निगरानी करें.
    • mem.swap (कंप्रेस की गई स्वैप मेमोरी या VmSwap): यह ग्राफ़, zRAM में ले जाए गए मेमोरी ब्लॉक के पहले से कंप्रेस किए गए साइज़ को दिखाता है. गेमप्ले के साथ-साथ, स्वैप की ज़्यादा गतिविधि से पता चलता है कि आपका गेम, सीमित मेमोरी वाले डिवाइस पर चल रहा है और सिस्टम, बैकग्राउंड में मौजूद ऐसेट को कंप्रेस कर रहा है.

2. एसक्यूएल क्वेरी चलाना (ट्रेस प्रोसेसर) ऑफ़लाइन विश्लेषण के लिए, Perfetto यूज़र इंटरफ़ेस (यूआई) कंसोल में सीधे तौर पर एसक्यूएल क्वेरी चलाई जा सकती हैं. इसके अलावा, आंकड़ों के हिसाब से सबसे ज़्यादा इस्तेमाल की गई मेमोरी की कैलकुलेशन करने के लिए, Trace Processor Python लाइब्रेरी का इस्तेमाल किया जा सकता है.

  • बिना सोर्स फ़ाइल वाली आरएसएस मेमोरी के सबसे ज़्यादा इस्तेमाल की गई मात्रा ढूंढना:

    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'
  );

  • किसी भी टाइमस्टैंप पर, RssAnon और VmSwap के बीच संबंध ढूंढना:

    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;

Android Studio का इस्तेमाल करके, ट्रेस फ़ाइलों की जांच करने के बारे में ज़्यादा जानने के लिए, सिस्टम ट्रेस की जांच करना: प्रोसेस मेमोरी (आरएसएस) देखें. मेमोरी प्रोफ़ाइल की स्क्रिप्टिंग के बारे में जानने के लिए, नेटिव मेमोरी के बंटवारे को रिकॉर्ड करना देखें.

heapprofd

heapprofd , मेमोरी को ट्रैक करने वाला एक टूल है. यह Perfetto का हिस्सा है. यह टूल, malloc का इस्तेमाल करके, मेमोरी कहां असाइन की गई थी, यह दिखाकर मेमोरी लीक ढूंढने में आपकी मदद कर सकता है. heapprofd को Python स्क्रिप्ट का इस्तेमाल करके शुरू किया जा सकता है. साथ ही, इस टूल का ओवरहेड कम होता है. इसलिए, यह Malloc Debug जैसे अन्य टूल की तरह, परफ़ॉर्मेंस पर असर नहीं डालता.

bugreport

bugreport , लॉगिंग का एक टूल है. इसकी मदद से यह पता लगाया जा सकता है कि आपका गेम, आउट ऑफ़ मेमोरी होने की वजह से क्रैश हुआ है या नहीं. इस टूल का आउटपुट, logcat का इस्तेमाल करने के मुकाबले ज़्यादा जानकारी देता है. यह मेमोरी को डीबग करने के लिए काम का है, क्योंकि इससे पता चलता है कि आपका गेम, आउट ऑफ़ मेमोरी होने की वजह से क्रैश हुआ है या एलएमके ने उसे बंद किया है.

ज़्यादा जानकारी के लिए, गड़बड़ी की रिपोर्ट कैप्चर करना और पढ़ना देखें.

गेम इंजन के टूल

ओएस के थ्रेशोल्ड और कंप्लायंस को ट्रैक करने के लिए, प्लैटफ़ॉर्म-लेवल के लॉग और सिस्टम टेलीमेट्री ज़रूरी हैं. वहीं, गेम इंजन के खास टूल की मदद से, असाइनमेंट को सीधे तौर पर आपके गेम ऑब्जेक्ट, स्क्रिप्ट के व्यवहार, और ऐक्टिव सीन के क्रम से जोड़ा जा सकता है.

Unity

Unity Engine के एनवायरमेंट में, Unity के नेटिव प्रोफ़ाइलिंग टूल और क्लास का इस्तेमाल करके, रनटाइम में Android की बिना सोर्स फ़ाइल वाली आरएसएस मेमोरी + स्वैप मेमोरी के फ़ुटप्रिंट का सटीक अनुमान लगाया जा सकता है. आम तौर पर, यह ओएस-लेवल की असल वैल्यू की तुलना में 10% से कम अंतर दिखाता है.

कॉन्फ़िगरेशन के नियमों और रनटाइम स्क्रिप्ट के साथ, सिलसिलेवार ट्यूटोरियल के लिए, Unity टूल की मदद से मेमोरी की जांच करना देखें.

  • Unity profiler API: कोर इंजन की मेट्रिक के बारे में क्वेरी करके, रनटाइम में अपने गेम के बिना मैनेज किए गए मेमोरी फ़ुटप्रिंट का अनुमान लगाया जा सकता है:
    • Profiler क्लास का इस्तेमाल करना: Profiler.GetTotalReservedMemoryLong() और Profiler.GetMonoHeapSizeLong() की वैल्यू को जोड़कर, मेमोरी के कुल असाइनमेंट को ट्रैक करें.
    • ProfilerRecorder क्लास का इस्तेमाल करना: मेमोरी की कैटगरी की डाइनैमिक तरीके से निगरानी करें. बेहतर अनुमान लगाने के लिए, रिलीज़ बिल्ड पर, कुल रिज़र्व की गई मेमोरी फ़ेच करें. वहीं, डेवलपमेंट बिल्ड पर, फ़ाइल-बैक ग्राफ़िक्स मेमोरी कॉम्पोनेंट को हटाने के लिए, इसमें से Gfx रिज़र्व की गई मेमोरी घटाएं.
  • Unity memory profiler: ऑफ़लाइन मेमोरी लीक की पहचान करने और उसे डीबग करने के लिए, मेमोरी का स्नैपशॉट कैप्चर करें. इसके बाद, All of Memory सेक्शन में मौजूद, Resident Memory on Device चार्ट की जांच करें. अनुमानित फ़ुटप्रिंट की कैलकुलेशन करने के लिए, इन कैटगरी के कुल योग को जोड़ें: Untracked, Android Runtime, Native, और Managed.
    • zRAM की सीमा: मेमोरी की कमी होने पर, Android कर्नल इस्तेमाल न किए जा रहे मेमोरी पेजों को स्वैप स्पेस (zRAM) में कंप्रेस कर सकता है. Unity Memory Profiler, ओएस-लेवल के स्वैप पैरामीटर का पता नहीं लगा सकता. इसलिए, मेमोरी के ज़्यादा इस्तेमाल वाले सीन के दौरान, फ़ुटप्रिंट में मामूली अंतर दिख सकता है. सटीक वैल्यू की पुष्टि करने के लिए, अपने अनुमानों को Perfetto से क्रॉस-रेफ़रंस करें.

Unreal

Unreal Engine के एनवायरमेंट में, इंजन के डाइग्नोस्टिक्स को प्लैटफ़ॉर्म टेलीमेट्री के साथ जोड़कर, अपने गेम के मेमोरी फ़ुटप्रिंट का आकलन किया जा सकता है. सिलसिलेवार निर्देशों और प्रोफ़ाइलिंग वर्कफ़्लो के लिए, Unreal Engine की मदद से मेमोरी के इस्तेमाल की जांच करना देखें.

डाइग्नोस्टिक के अहम टूल और इंटरफ़ेस में ये शामिल हैं:

  • C++ Diagnostics API: मेमोरी से जुड़ी सामान्य क्वेरी के लिए GetMemoryUsedFast और हार्डवेयर-लेवल की मेमोरी के आंकड़ों के लिए GetStats इंटरफ़ेस का इस्तेमाल करें.
  • Console Commands: डिवाइस के हार्डवेयर पर रीयल-टाइम में मेमोरी के बंटवारे के ट्रेंड की निगरानी करने के लिए, stat unit और stat unitmax इंजन कमांड का इस्तेमाल करें.
  • Unreal Insights: प्लैटफ़ॉर्म-लेवल की मेट्रिक और मेमोरी के कस्टम काउंटर का विश्लेषण करने के लिए, फ़्रेम-सटीक टाइमलाइन कैप्चर की जांच करें.