כדי לפתור בעיות שקשורות לLMK במשחק Unity, צריך לפעול לפי השלבים הבאים:
איך מקבלים תמונת מצב של הזיכרון
משתמשים ב-Unity Profiler כדי לקבל תמונת מצב של הזיכרון שמנוהל על ידי Unity. באיור 2 מוצגות שכבות ניהול הזיכרון שבהן Unity משתמשת כדי לנהל את הזיכרון במשחק.
זיכרון מנוהל
ניהול הזיכרון של Unity מטמיע שכבת זיכרון מנוהלת שמשתמשת בערימה מנוהלת ובאיסוף אשפה כדי להקצות זיכרון באופן אוטומטי. מערכת הזיכרון המנוהל היא סביבת סקריפטים של C# שמבוססת על Mono או על IL2CPP. היתרון של מערכת הזיכרון המנוהל הוא שהיא משתמשת במנגנון לאיסוף זבל כדי לפנות באופן אוטומטי הקצאות זיכרון.
זיכרון לא מנוהל ב-C#
שכבת הזיכרון הלא מנוהלת של C# מספקת גישה לשכבת הזיכרון המקורית, ומאפשרת שליטה מדויקת בהקצאות הזיכרון בזמן השימוש בקוד C#. אפשר לגשת לשכבת ניהול הזיכרון הזו דרך מרחב השמות Unity.Collections ודרך פונקציות כמו UnsafeUtility.Malloc ו-UnsafeUtility.Free.
זיכרון מקומי
הליבה הפנימית של Unity ב-C/C++ משתמשת במערכת זיכרון מקומית כדי לנהל סצנות, נכסים, ממשקי API של גרפיקה, מנהלי התקנים, תת-מערכות ומאגרי נתונים זמניים של פלאגינים. למרות שהגישה הישירה מוגבלת, אתם יכולים לשנות נתונים בצורה בטוחה באמצעות ה-API של Unity ב-C# וליהנות מקוד Native יעיל. זיכרון מקורי דורש אינטראקציה ישירה רק לעיתים רחוקות, אבל אתם יכולים לעקוב אחרי ההשפעה של הזיכרון המקורי על הביצועים באמצעות הכלי לניתוח ביצועים ולשנות את ההגדרות כדי לשפר את הביצועים.
הזיכרון לא משותף בין C# לבין קוד Native, כמו שמוצג באיור 3. הנתונים שנדרשים ל-C# מוקצים במרחב הזיכרון המנוהל בכל פעם שיש בהם צורך.
כדי שהקוד של המשחק המנוהל (C#) יוכל לגשת לנתוני הזיכרון המקוריים של המנוע, למשל, קריאה ל-GameObject.transform מבצעת קריאה מקורית כדי לגשת לנתוני הזיכרון באזור המקורי, ואז מחזירה ערכים ל-C# באמצעות Bindings. הקישורים מבטיחים מוסכמות קריאה תקינות לכל פלטפורמה, ומטפלים במרשלינג אוטומטי של סוגים מנוהלים למקבילים המקוריים שלהם.
זה קורה רק בפעם הראשונה, כי המעטפת המנוהלת לגישה למאפיין transform נשמרת בקוד Native. שמירת המאפיין transform במטמון יכולה להפחית את מספר הקריאות הלוך ושוב בין קוד מנוהל לקוד Native, אבל התועלת של השמירה במטמון תלויה בתדירות השימוש במאפיין. בנוסף, חשוב לשים לב ש-Unity לא מעתיקה חלקים מהזיכרון המקורי לזיכרון המנוהל כשניגשים לממשקי ה-API האלה.
מידע נוסף זמין במאמר מבוא לזיכרון ב-Unity.
בנוסף, חשוב להגדיר תקציב זיכרון כדי שהמשחק יפעל בצורה חלקה, ולהטמיע מערכת לניתוח או לדיווח על צריכת הזיכרון כדי לוודא שכל גרסה חדשה לא חורגת מתקציב הזיכרון. אסטרטגיה נוספת לקבלת תובנות טובות יותר היא לשלב בדיקות של מצב הפעלה עם שילוב רציף (CI) כדי לאמת את צריכת הזיכרון באזורים ספציפיים במשחק.
ניהול הנכסים
זה החלק הכי משמעותי וניתן לפעולה בצריכת הזיכרון. בהקדם האפשרי.
השימוש בזיכרון במשחקי Android יכול להשתנות באופן משמעותי בהתאם לסוג המשחק, למספר ולסוגי הנכסים ולאסטרטגיות האופטימיזציה של הזיכרון. עם זאת, הגורמים הנפוצים לשימוש בזיכרון כוללים בדרך כלל טקסטורות, רשתות, קובצי אודיו, הצללות, אנימציות וסקריפטים.
זיהוי נכסים כפולים
השלב הראשון הוא לזהות נכסים שהוגדרו בצורה לא נכונה ונכסים כפולים באמצעות Memory Profiler, כלי לדוחות build או Project Auditor.
מרקמים
לנתח את התמיכה של המשחק במכשירים ולהחליט מהו פורמט הטקסטורה הנכון. אתם יכולים לפצל את חבילות הטקסטורות למכשירים מתקדמים ולמכשירים פשוטים באמצעות Play Asset Delivery, Addressable או תהליך ידני יותר עם AssetBundle.
כדאי לפעול לפי ההמלצות המוכרות ביותר שזמינות במאמר Optimize Your Mobile Game Performance ובפוסט Optimising Unity Texture Import Settings. ואז נסו את הפתרונות הבאים:
דוחסים טקסטורות באמצעות פורמטים של ASTC כדי להקטין את הזיכרון שבשימוש, ומנסים קצב בלוקים גבוה יותר, כמו 8x8.
אם אתם חייבים להשתמש ב-ETC2, ארזו את הטקסטורות ב-Atlas. אם תמקמו כמה טקסטורות בטקסטורה אחת, תוכלו לוודא שהיא חזקה פי שניים (POT), להפחית את מספר הבקשות להזזת פריטים גרפיים ולהאיץ את הרינדור.
מבצעים אופטימיזציה של הפורמט והגודל של הטקסטורה של RenderTarget. הימנעו ממרקמים ברזולוציה גבוהה שלא לצורך. שימוש בטקסטורות קטנות יותר במכשירים ניידים חוסך בזיכרון.
כדי לחסוך בזיכרון של הטקסטורה, השתמשו באריזת ערוצי טקסטורה.
רשתות ומודלים
קודם כל, בודקים את ההגדרות הבסיסיות (עמוד 27) ומוודאים שהגדרות הייבוא של הרשת הן:
- למזג רשתות מיותרות וקטנות יותר.
- להפחית את מספר הקודקודים של אובייקטים בסצנות (לדוגמה, אובייקטים סטטיים או מרוחקים).
- יוצרים קבוצות של רמות פירוט (LOD) לנכסים עם גיאומטריה מורכבת.
חומרים והצללות
- הסירו וריאנטים של שיידרים שלא בשימוש באופן פרוגרמטי במהלך תהליך ה-build.
- כדי למנוע כפילויות של שיידרים, כדאי לאחד וריאציות של שיידרים שמשתמשים בהן לעיתים קרובות לשיידרים מסוג uber.
- הפעלת טעינת הצללה דינמית כדי לטפל בזיכרון שבשימוש הגדול של הצללות שנטענו מראש ב-VRAM או ב-RAM. עם זאת, שימו לב אם הידור של הצללה גורם לבעיות בפריימים.
- כדי למנוע טעינה של כל הווריאציות, השתמשו בטעינה דינמית של הצללה. מידע נוסף זמין בפוסט בבלוג שיפורים בזמני היצירה של תוכניות הצללה ובשימוש בזיכרון.
- כדי להשתמש נכון במופעי חומרים, כדאי להיעזר ב-
MaterialPropertyBlocks.
אודיו
קודם כל, בודקים את ההגדרות הבסיסיות (עמוד 41) ומוודאים שהגדרות הייבוא של הרשת הן:
- אם אתם משתמשים במנועי אודיו של צד שלישי כמו FMOD או Wwise, הסירו הפניות מיותרות או לא משומשות ל-
AudioClip. - טעינה מראש של נתוני אודיו. השביתו את הטעינה מראש של קליפים שלא נדרשים באופן מיידי במהלך זמן הריצה או הפעלת הסצנה. כך אפשר להפחית את התקורה של הזיכרון במהלך האתחול של הסצנה.
אנימציות
- משנים את הגדרות דחיסת האנימציה של Unity כדי לצמצם את מספר הפריימים המרכזיים ולמחוק נתונים מיותרים.
- הפחתת קיפריימים: הסרה אוטומטית של קיפריימים מיותרים
- דחיסת קווטרניון: דחיסת נתוני סיבוב כדי להפחית את השימוש בזיכרון
אפשר לשנות את הגדרות הדחיסה ב-Animation Import Settings (הגדרות ייבוא אנימציה) בכרטיסייה Rig (שלד) או Animation (אנימציה).
כדאי לעשות שימוש חוזר בקליפים של אנימציה במקום לשכפל אותם לאובייקטים שונים.
משתמשים ב-Animator Override Controllers כדי להשתמש שוב ב-Animator Controller ולהחליף קליפים ספציפיים לדמויות שונות.
הטמעת אנימציות שמבוססות על פיזיקה: אם האנימציות מבוססות על פיזיקה או על פרוצדורות, כדאי להטמיע אותן בקליפים של אנימציה כדי להימנע מחישובים בזמן ריצה.
אופטימיזציה של שלד הדמות: כדאי להשתמש בפחות עצמות בשלד כדי להפחית את המורכבות ואת צריכת הזיכרון.
- אל תשתמשו ביותר מדי עצמות באובייקטים קטנים או סטטיים.
- אם עצמות מסוימות לא מונפשות או לא נחוצות, הסירו אותן מהשלד.
מקצרים את האורך של קליפ האנימציה.
- חותכים קליפים של אנימציה כך שיכללו רק את הפריימים הנחוצים. אל תשמרו אנימציות שלא בשימוש או אנימציות ארוכות מדי.
- השתמשו באנימציות בלופ במקום ליצור קליפים ארוכים לתנועות חוזרות.
צריך לוודא שרק רכיב אנימציה אחד מצורף או מופעל. לדוגמה, אם אתם משתמשים ב-Animator, השביתו או הסירו רכיבים של Legacy animation.
אם אין צורך, עדיף לא להשתמש ב-Animator. לאפקטים חזותיים בסיסיים, אפשר להשתמש בספריות tweening או להטמיע את האפקט החזותי בסקריפט. מערכת האנימציה יכולה לצרוך הרבה משאבים, במיוחד במכשירים ניידים פשוטים.
כדי לטפל במספר גדול של אנימציות, השתמשו ב-Job System לאנימציות, כי המערכת הזו תוכננה מחדש כדי להיות יעילה יותר מבחינת הזיכרון.
סצנות
כשסצנות חדשות נטענות, הן מביאות איתן נכסים כתלויות. עם זאת, בלי ניהול תקין של מחזור החיים של הנכסים, מוני ההפניות לא עוקבים אחרי יחסי התלות האלה. כתוצאה מכך, יכול להיות שנכסים יישארו בזיכרון גם אחרי שהסצנות שלא בשימוש נפרקו, מה שגורם לפרגמנטציה של הזיכרון.
- השתמשו ב-Object Pooling של Unity כדי לעשות שימוש חוזר במופעים של GameObject לאלמנטים חוזרים של גיימפליי, כי Object Pooling משתמש במחסנית כדי להחזיק אוסף של מופעי אובייקטים לשימוש חוזר והוא לא thread safe. צמצום השימוש ב-
Instantiateוב-Destroyמשפר את ביצועי המעבד (CPU) ואת יציבות הזיכרון. - הסרת נכסים:
- כדאי לפרוק נכסים באופן אסטרטגי ברגעים פחות קריטיים, כמו מסכי פתיחה או מסכי טעינה.
- שימוש תכוף ב-
Resources.UnloadUnusedAssetsגורם לעליות חדות בעיבוד של המעבד (CPU) בגלל פעולות גדולות של מעקב אחרי תלויות פנימיות. - בודקים אם יש קפיצות גדולות בשימוש במעבד (CPU) בסמן הפרופיל GC.MarkDependencies.
הסירו או הפחיתו את תדירות ההפעלה שלו, ופרקו באופן ידני משאבים ספציפיים באמצעות Resources.UnloadAsset במקום להסתמך על
Resources.UnloadUnusedAssets()שמקיף את הכול.
- כדאי לשנות את מבנה הסצנות במקום להשתמש כל הזמן ב-Resources.UnloadUnusedAssets.
- קריאה ל-
Resources.UnloadUnusedAssets()עבורAddressablesיכולה לפרוק בטעות חבילות שנטענו באופן דינמי. לנהל בקפידה את מחזור החיים של נכסים שנטענים באופן דינמי.
שונות
פרגמנטציה שנגרמת בגלל מעברים בין סצנות – כששולחים קריאה ל-method
Resources.UnloadUnusedAssets(), Unity מבצעת את הפעולות הבאות:- פינוי זיכרון מנכסים שלא בשימוש יותר
- מפעילה פעולה שדומה לאיסוף אשפה כדי לבדוק אם יש נכסים שלא בשימוש בערימת האובייקטים המנוהלים והמקוריים, ופורקת אותם
- מנקה את הזיכרון של הטקסטורה, הרשת והנכס, בתנאי שאין קובץ עזר פעיל
AssetBundleאוAddressable– ביצוע שינויים בתחום הזה הוא מורכב ודורש מאמץ קולקטיבי של הצוות כדי ליישם את האסטרטגיות. עם זאת, אחרי ששולטים באסטרטגיות האלה, הן משפרות באופן משמעותי את השימוש בזיכרון, מקטינות את גודל ההורדה ומפחיתות את עלויות הענן. למידע נוסף על ניהול נכסים ב-Unity, ראוAddressables.תלויות משותפות מרוכזות: מקבצים תלויות משותפות, כמו הצללות, טקסטורות וגופנים, באופן שיטתי לחבילות ייעודיות או לקבוצות
Addressable. כך אפשר לצמצם את הכפילויות ולוודא שנכסים מיותרים נמחקים מהזיכרון ביעילות.משתמשים ב-
Addressablesלמעקב אחרי יחסי תלות – Addressables מפשט את הטעינה והפריקה, ויכול לפרוק באופן אוטומטי יחסי תלות שאין להם יותר הפניות. בהתאם למקרה הספציפי של המשחק, יכול להיות שכדאי לעבור ל-Addressablesכדי לנהל את התוכן ולפתור את בעיות התלות. מנתחים את שרשראות יחסי התלות באמצעות כלי הניתוח כדי לזהות כפילויות או יחסי תלות מיותרים. לחלופין, אם אתם משתמשים ב-AssetBundles, עיינו ב-Unity Data Tools.TypeTrees– אםAddressablesו-AssetBundlesשל המשחק נוצרו ונפרסו באמצעות אותה גרסה של Unity כמו הנגן, ואין צורך בתאימות לדורות קודמים עם גרסאות build אחרות של הנגן, כדאי להשבית את הכתיבה שלTypeTree. הפעולה הזו אמורה להקטין את גודל החבילה ואת הזיכרון שבשימוש של אובייקט הקובץ שעבר סריאליזציה. משנים את תהליך ה-build בהגדרה ContentBuildFlags של חבילת Addressables המקומית ל-DisableWriteTypeTree.
כתיבת קוד שמתאים לאיסוף אשפה
ב-Unity משתמשים באיסוף אשפה (GC) כדי לנהל את הזיכרון על ידי זיהוי אוטומטי של זיכרון שלא בשימוש ושחרור שלו. למרות ש-GC הוא חיוני, הוא יכול לגרום לבעיות בביצועים (לדוגמה, קפיצות בקצב הפריימים) אם לא מטפלים בו כמו שצריך, כי התהליך הזה יכול להשהות את המשחק לרגע, וכתוצאה מכך לגרום לבעיות בביצועים ולחוויית משתמש לא אופטימלית.
במדריך של Unity מפורטות שיטות שימושיות להפחתת התדירות של הקצאות זיכרון בערימה מנוהלת, ובעמוד 271 של UnityPerformanceTuningBible מופיעות דוגמאות.
הפחתת ההקצאות של אוסף האשפה:
- הימנעו מ-LINQ, מביטויי למבדה ומסגורים (closures), שמקצים זיכרון ערימה.
- השתמשו ב-
StringBuilderלמחרוזות ניתנות לשינוי במקום שרשור מחרוזות. - כדי לעשות שימוש חוזר באוספים, צריך להפעיל את
COLLECTIONS.Clear()במקום ליצור אותם מחדש.
מידע נוסף זמין בספר האלקטרוני Ultimate Guide to Profiling Unity games.
ניהול העדכונים של ממשק המשתמש בפריסה החכמה:
- שינויים דינמיים ברכיבים בממשק המשתמש – כשמעדכנים מאפיינים של רכיבים בממשק המשתמש כמו טקסט, תמונה או
RectTransform(לדוגמה, שינוי תוכן הטקסט, שינוי גודל הרכיבים או הוספת אנימציה למיקומים), יכול להיות שהמנוע יקצה זיכרון לאובייקטים זמניים. - הקצאות של מחרוזות – רכיבים בממשק המשתמש כמו טקסט דורשים לעיתים קרובות עדכונים של מחרוזות, כי מחרוזות הן בלתי ניתנות לשינוי ברוב שפות התכנות.
- אזור עריכה מלוכלך – כשמשהו באזור העריכה משתנה (לדוגמה, שינוי גודל, הפעלה והשבתה של רכיבים או שינוי מאפייני פריסה), יכול להיות שכל אזור העריכה או חלק ממנו יסומנו כמלוכלכים וייבנו מחדש. זה יכול לגרום ליצירה של מבני נתונים זמניים (לדוגמה, נתוני רשת, מאגרי קודקודים או חישובי פריסה), שמוסיפים ליצירת אשפה.
- עדכונים מורכבים או תכופים – אם יש בקנבס הרבה אלמנטים או שהוא מתעדכן בתדירות גבוהה (למשל, בכל פריים), הבנייה מחדש יכולה לגרום להעמסת זיכרון משמעותית.
- שינויים דינמיים ברכיבים בממשק המשתמש – כשמעדכנים מאפיינים של רכיבים בממשק המשתמש כמו טקסט, תמונה או
הפעילו את התכונה Incremental GC כדי להפחית את העליות החדות באיסוף הנתונים על ידי פיזור ניקוי ההקצאות על פני כמה פריימים. כדאי ליצור פרופיל כדי לבדוק אם האפשרות הזו משפרת את הביצועים ואת הזיכרון שבשימוש של המשחק.
אם המשחק דורש גישה מבוקרת, צריך להגדיר את מצב איסוף האשפה לידני. אחר כך, כשעוברים שלב או ברגע אחר שבו אין גיימפליי פעיל, מפעילים את איסוף הזבל.
הפעילו קריאות ידניות לאיסוף אשפה GC.Collect() למעברים בין מצבי משחק (לדוגמה, מעבר בין שלבים).
כדאי לבצע אופטימיזציה של מערכים, החל משיטות בסיסיות לכתיבת קוד, ואם צריך, להשתמש במערכים מקוריים או במאגרים מקוריים אחרים למערכים גדולים.
כדי לעקוב אחרי הפניות לאובייקטים לא מנוהלים שנשארות אחרי ההשמדה, אפשר לעקוב אחרי אובייקטים מנוהלים באמצעות כלים כמו Unity Memory Profiler.
כדי להשתמש בגישה אוטומטית, אפשר להשתמש בסמן פרופיל כדי לשלוח לכלי לדיווח על ביצועים.
איך להימנע מדליפות זיכרון ומפרגמנטציה
דליפות זיכרון
בקוד C# , אם יש הפניה לאובייקט Unity אחרי שהאובייקט נהרס, אובייקט ה-wrapper המנוהל, שנקרא Managed Shell, נשאר בזיכרון. הזיכרון המקורי שמשויך לקובץ העזר משתחרר כשהסצנה נפרקת, או כשה-GameObject שאליו הזיכרון משויך, או כל אחד מהאובייקטים ההורים שלו, נהרסים באמצעות השיטה Destroy(). עם זאת, אם הפניות אחרות ל-Scene או ל-GameObject לא נמחקו, הזיכרון המנוהל עשוי להישאר בתור Leaked Shell Object. לפרטים נוספים על Managed Shell Objects, עיינו במדריך Managed Shell Objects.
בנוסף, דליפות זיכרון יכולות להיגרם על ידי מינויים לאירועים, פונקציות למבדה וסגירות, שרשור מחרוזות וניהול לא תקין של אובייקטים מאוגדים:
- כדי להתחיל, עיינו במאמר איתור דליפות זיכרון כדי להשוות בצורה נכונה בין תמונות מצב של זיכרון ב-Unity.
- בודקים אם יש מינויים לאירועים ודליפות זיכרון. אם אובייקטים נרשמים לאירועים (לדוגמה, באמצעות נציגים או UnityEvents) אבל לא מבטלים את ההרשמה כמו שצריך לפני שהם מושמדים, יכול להיות שמנהל האירועים או המפרסם ישמרו הפניות לאובייקטים האלה. כך נמנעת האפשרות לאסוף את האובייקטים האלה כזבל, מה שמוביל לדליפות זיכרון.
- מעקב אחרי אירועים גלובליים או אירועים של מחלקת סינגלטון שלא בוטל הרישום שלהם בזמן השמדת האובייקט. לדוגמה, לבטל את ההרשמה או את הקישור של נציגים ב-destructors של אובייקטים.
- חשוב לוודא שהשמדה של אובייקטים מאוגדים מבטלת לחלוטין את ההפניות לרכיבי רשת טקסט, לטקסטורות ול-GameObjects הורה.
- חשוב לזכור: כשמשווים בין תמונות מצב של Unity Memory Profiler ורואים הבדל בצריכת הזיכרון בלי סיבה ברורה, יכול להיות שההבדל נגרם על ידי מנהל ההתקן הגרפי או מערכת ההפעלה עצמה.
פרגמנטציה של הזיכרון
פרגמנטציה של הזיכרון מתרחשת כשהרבה הקצאות קטנות משתחררות בסדר אקראי. הקצאות הזיכרון בערימה מתבצעות ברצף, כלומר נוצרים מקטעי זיכרון חדשים כשנגמר המקום במקטע הקודם. לכן, אובייקטים חדשים לא ממלאים את האזורים הריקים של מקטעים ישנים, מה שמוביל לפרגמנטציה. בנוסף, הקצאות זמניות גדולות יכולות לגרום לפרגמנטציה קבועה במהלך הסשן של המשחק.
הבעיה הזו חמורה במיוחד כשמקצים מקום גדול לטווח קצר ליד מקום לטווח ארוך.
כדאי לקבץ הקצאות לפי משך החיים שלהן. באופן אידיאלי, הקצאות לטווח ארוך צריכות להתבצע יחד, בשלב מוקדם במחזור החיים של האפליקציה.
צופים ומנהלי אירועים
- בנוסף לבעיה שצוינה בקטע דליפות זיכרון, עם הזמן דליפות זיכרון יכולות לתרום לפרגמנטציה כי הן משאירות זיכרון לא מנוצל שמוקצה לאובייקטים שכבר לא בשימוש.
- חשוב לוודא שהשמדה של אובייקטים מאוגדים מבטלת לחלוטין את ההפניות לרכיבי רשת טקסט, למרקמים ול-
GameObjectsהורה. - מנהלי אירועים יוצרים ומאחסנים לעיתים קרובות רשימות או מילונים כדי לנהל מינויים לאירועים. אם הם גדלים ומתכווצים באופן דינמי בזמן הריצה, הם יכולים לתרום לפרגמנטציה של הזיכרון בגלל הקצאות וביטולי הקצאות תכופים.
קוד
- פונקציות Coroutine מקצות לפעמים זיכרון. אפשר להימנע מכך על ידי שמירת פקודת החזרה של IEnumerator במטמון, במקום להצהיר על פקודה חדשה בכל פעם.
- עוקבים באופן רציף אחרי מצבי מחזור החיים של אובייקטים במאגר כדי להימנע משמירת הפניות רפאים ב-
UnityEngine.Object.
נכסים
- במשחקים שמבוססים על טקסט, כדאי להשתמש במערכות דינמיות של גופני ברירת מחדל כדי להימנע מטעינה מראש של כל הגופנים במקרים של ריבוי שפות.
- כדאי לארגן נכסים (למשל, טקסטורות וחלקיקים) לפי סוג ומחזור חיים צפוי.
- לצמצם נכסים עם מאפייני מחזור חיים לא פעילים, כמו תמונות מיותרות של ממשק המשתמש ורשתות סטטיות.
הקצאות מבוססות-תקופת-חיים
- כדי להבטיח הקצאות קומפקטיות, הקצו נכסים לטווח ארוך בתחילת מחזור החיים של האפליקציה.
- השתמשו ב-NativeCollections או במקציבים מותאמים אישית למבני נתונים זמניים או שצורכים הרבה זיכרון (לדוגמה, אשכולות פיזיים).
פעולת זיכרון שקשורה לקוד ולקובצי הפעלה
גם קובצי ההפעלה והפלאגינים של המשחק משפיעים על השימוש בזיכרון.
מטא-נתונים של IL2CPP
IL2CPP יוצר מטא-נתונים לכל סוג (לדוגמה, מחלקות, גנריות ונציגים) בזמן ה-build, שמשמשים לאחר מכן בזמן הריצה לשיקוף, לבדיקת סוגים ולפעולות אחרות שספציפיות לזמן הריצה. המטא-נתונים האלה מאוחסנים בזיכרון ויכולים לתרום באופן משמעותי לזיכרון שבשימוש הכולל של האפליקציה. מטמון המטא-נתונים של IL2CPP תורם באופן משמעותי לזמני האתחול והטעינה. בנוסף, IL2CPP לא מבטל כפילויות של רכיבי מטא-נתונים מסוימים (לדוגמה, סוגים גנריים או מידע שעבר סריאליזציה), מה שעלול לגרום לשימוש מוגבר בזיכרון. הבעיה הזו מחמירה אם משתמשים בסוגים חוזרים או מיותרים בפרויקט.
אפשר לצמצם את המטא-נתונים של IL2CPP בדרכים הבאות:
- הימנעות משימוש ב-Reflection APIs, כי הם יכולים לתרום באופן משמעותי להקצאות של מטא-נתונים ב-IL2CPP.
- השבתת חבילות מובנות
- הטמעת שיתוף גנרי מלא של Unity 2022, שאמור לעזור להפחית את התקורה שנגרמת על ידי גנריות. עם זאת, כדי לצמצם עוד יותר את ההקצאות, כדאי להפחית את השימוש בגנריות.
הסרת קוד
בנוסף להקטנת גודל ה-build, הפשטת הקוד גם מפחיתה את השימוש בזיכרון. כשמפתחים באמצעות הקצה העורפי של הסקריפטים של IL2CPP, הפשטה של קוד בייט מנוהל (שמופעלת כברירת מחדל) מסירה קוד שלא בשימוש ממכלולים מנוהלים. התהליך פועל על ידי הגדרת הרכבי בסיס (root assemblies) ולאחר מכן שימוש בניתוח קוד סטטי כדי לקבוע באילו קודים מנוהלים אחרים משתמשים הרכבי הבסיס האלה. כל קוד שלא ניתן להגיע אליו מוסר. למידע נוסף על Managed Code Stripping, קראו את הפוסט בבלוג Tales from the optimization trenches: Better managed code stripping with Unity 2020 LTS ואת המאמר Managed code stripping.
מקציבי זיכרון מקוריים
כדאי להתנסות עם מקציבי זיכרון נייטיב כדי לשפר את מקציבי הזיכרון. אם הזיכרון של המשחק עומד להיגמר, כדאי להשתמש בבלוקים קטנים יותר של זיכרון, גם אם זה כרוך במקציבי זיכרון איטיים יותר. מידע נוסף זמין בדוגמה למקצה זיכרון דינמי בערימה.
ניהול פלאגינים וערכות SDK מקומיים
מאתרים את הפלאגין הבעייתי – מסירים כל פלאגין ומשווים בין תמונות המצב של זיכרון המשחק. כדי לעשות את זה, צריך להשבית הרבה פונקציות בקוד באמצעות Scripting Define Symbols ולשנות את המבנה של מחלקות עם צימוד גבוה באמצעות ממשקים. כדי להקל על תהליך ההשבתה של יחסי תלות חיצוניים בלי להפוך את המשחק לבלתי ניתן להפעלה, כדאי לעיין במאמר Level up your code with game programming patterns.
פנו ליוצר של הפלאגין או ה-SDK – רוב הפלאגינים הם לא בקוד פתוח.
שחזור השימוש בזיכרון של הפלאגין – אתם יכולים לכתוב פלאגין קטן (השתמשו בפלאגין Unity הזה כהפניה) שמבצע הקצאות זיכרון. בודקים את תמונות המצב של הזיכרון באמצעות Android Studio (כי Unity לא עוקבת אחרי ההקצאות האלה) או קוראים לכיתה
MemoryInfoולשיטהRuntime.totalMemory()באותו פרויקט.
פלאגין של Unity מקצה זיכרון Java וזיכרון מקורי. כך עושים את זה:
Java
byte[] largeObject = new byte[1024 * 1024 * megaBytes];
list.add(largeObject);
מודעות מותאמות
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
}