סשנים איטיים

בתפקוד האפליקציה, סשן איטי הוא סשן שבו יותר מ-25% מהפריימים איטיים. פריים נחשב לאיטי אם הוא לא מוצג תוך פחות מ-50 אלפיות השנייה אחרי הפריים הקודם (שווה ערך ל-20 FPS). בתפקוד האפליקציה מדווח גם מדד שני של סשנים איטיים עם יעד של 34 אלפיות השנייה (שווה ערך ל-‎30 FPS). המדד "סשנים איטיים" מאפשר לכם להבין את הביצועים של קצב הפריימים במשחק, שמשפיעים על מידת החלקות והזרימה של המשחק למשתמשים.

בשלב מסוים, מערכת Play תתחיל להרחיק משתמשים ממשחקים שלא יכולים להגיע ל-20 FPS בטלפונים שלהם. שימו לב: תפקוד האפליקציה מתחיל לעקוב אחרי קצב הפריימים רק אחרי שהמשחק פועל במשך דקה.

פרטים נוספים על המדד זמינים במרכז העזרה.

איך מודדים את קצב הפריימים ומזהים פריימים איטיים

הפקודה dumpsys SurfaceFlinger --timestats ב-Android מספקת היסטוגרמות של קצב פריימים ממוצע ושל תזמון מפריים לפריים לכל השכבות שעוברות רינדור. זמן ההצגה להצגה של פריים הוא המרווח בין הפריים הנוכחי לפריים הקודם ששורטט. כדי להשתמש בפקודה לאיסוף נתוני ה-FPS של המשחק, פועלים לפי השלבים הבאים:

1. מריצים את הפקודה עם הדגלים enable ו-clear כדי להתחיל לתעד מידע:

   adb shell dumpsys SurfaceFlinger --timestats -clear -enable
   

2. כשהמשחק פועל מספיק זמן, מריצים שוב את הפקודה עם הדגל dump כדי להעביר את המידע:

   adb shell dumpsys SurfaceFlinger --timestats -dump
   

   המידע שנשמר מספק את סך כל הפריימים וpresentToPresent היסטוגרמה לכל השכבות שעובדו על ידי SurfaceFlinger. כדי למצוא את הקטע של המשחק, צריך לסנן לפי layerName:

   layerName = SurfaceView[com.google.test/com.devrel.MainActivity]@0(BLAST)#132833
   

   אפשר לחשב את קצב הפריימים האיטי של הסשן על סמך המידע של כל שכבה.

   לדוגמה, אחוז הפריימים האיטיים של 20‎ FPS = (סכום הערכים מ-54 אלפיות השנייה עד 1,000 אלפיות השנייה) / totalFrames x ‏100

   totalFrames = 274
   ...
   presentToPresent histogram:
   0ms=0 1ms=0 2ms=0 3ms=0 4ms=0 5ms=0 6ms=0 7ms=0 8ms=0 9ms=0 10ms=0 11ms=0 12ms=0
   13ms=0 14ms=0 15ms=0 16ms=1 17ms=0 18ms=0 19ms=0 20ms=0 21ms=0 22ms=0 23ms=0
   24ms=0 25ms=0 26ms=0 27ms=0 28ms=0 29ms=0 30ms=0 31ms=0 32ms=0 33ms=269 34ms=0
   36ms=0 38ms=0 40ms=0 42ms=0 44ms=0 46ms=0 48ms=0 50ms=1 54ms=0 58ms=0 62ms=0
   66ms=0 70ms=1 74ms=0 78ms=0 82ms=0 86ms=0 90ms=0 94ms=0 98ms=0 102ms=0 106ms=0
   110ms=0 114ms=0 118ms=0 122ms=0 126ms=0 130ms=0 134ms=0 138ms=0 142ms=0 146ms=0
   150ms=0 200ms=0 250ms=0 300ms=0 350ms=0 400ms=0 450ms=0 500ms=0 550ms=0 600ms=0
   650ms=0 700ms=0 750ms=0 800ms=0 850ms=0 900ms=0 950ms=0 1000ms=0
   

   הקצב הממוצע של FPS בכל שכבה מוצג גם ב-dump:

   ...
   averageFPS = 30.179
   ...
   

3. אחרי שאוספים את כל המידע, משביתים את timestats באמצעות הדגל disable:

   adb shell dumpsys SurfaceFlinger --timestats -disable
   

סיבות ופתרונות לפריימים איטיים

יש הרבה סיבות לכך שפריים מוצג או מעובד על המסך במשך זמן ארוך יותר מהיעד. יכול להיות שהמשחק מוגבל על ידי המעבד (CPU) או המעבד הגרפי (GPU), שהמכשיר מתחמם יתר על המידה ומפעיל מצב של ויסות תרמי, או שיש חוסר התאמה בין קצב הפריימים של המשחק לבין קצב הרענון של המסך במכשיר.

כדי לפתור את הבעיות האלה ולשפר את ביצועי המשחק, אתם יכולים להשתמש ב-Android Frame Pacing‏ (Swappy), ב-Vulkan וב-ADPF.

מה זה Swappy

ספריית Frame Pacing של Android, שנקראת גם Swappy, היא חלק מספריות AGDK. ‫Swappy עוזר למשחקי OpenGL ו-Vulkan להשיג רינדור חלק וקצב פריימים נכון ב-Android.

קצב הפריימים הוא הסנכרון של הלוגיקה של המשחק ולולאת הרינדור עם תת-מערכת התצוגה של מערכת ההפעלה וחומרת התצוגה הבסיסית. תת-המערכת של התצוגה ב-Android תוכננה כדי למנוע פגמים חזותיים (שנקראים "קריעה") שיכולים להתרחש כשחומרת התצוגה עוברת לפריים חדש באמצע העדכון. כדי למנוע את התופעות האלה, תת-המערכת של התצוגה מבצעת את הפעולות הבאות:

• שומר בזיכרון המטמון הפנימי פריימים קודמים.
• זיהוי של שליחת פריימים באיחור.
• חזרה על התצוגה של פריימים קודמים כשמזוהים פריימים מאוחרים.

איך חברת Mir 2 השתמשה ב-Swappy כדי להפחית את שיעור הסשנים האיטיים מ-40% ל-10%.

איך משתמשים ב-Swappy בפרויקטים מקוריים

כדי לשלב את ספריית Android Frame Pacing במשחק, אפשר לעיין במדריכים הבאים:

• איך משלבים את Android Frame Pacing בכלי הרינדור של OpenGL
• שילוב של Android Frame Pacing בכלי הרינדור של Vulkan

איך משתמשים ב-Swappy במנוע המשחק Unity

‫Unity שילבה את Android Frame Pacing במנוע שלה. כדי להפעיל את התכונה הזו ב-Unity מגרסה 2019.2 ואילך, מסמנים את התיבה Optimized Frame Pacing בקטע הגדרות הפרויקט > Player > Settings for Android > Resolution and Presentation:

לחלופין, אפשר להפעיל באופן פרוגרמטי את האפשרות Optimized Frame Pacing בקוד הלוגיקה כדי לאפשר ל-Unity לפזר את הפריימים באופן שווה, וכך להפחית את השונות בקצב הפריימים וליצור גיימפליי חלק יותר.

איך משתמשים ב-Swappy במנוע המשחק Unreal

בגרסה Unreal 4.25 ואילך משולבת Android Frame Pacing Library, שהיא חלק מ-Android Game Development Kit. במאמר Mobile Frame Pacing מוסבר איך להפעיל את Android Frame Pacing Library ואיך לשלוט בקצב הפריימים באמצעות קוד C++‎.

מה זה Vulkan

‫Vulkan הוא ממשק API מודרני לגרפיקה תלת-ממדית בפלטפורמות שונות, שנועד לצמצם את ההפשטה בין חומרת הגרפיקה של המכשיר לבין המשחק. ‫Vulkan הוא ממשק ה-API הראשי לגרפיקה ברמה נמוכה ב-Android, והוא מחליף את OpenGL ES. יש עדיין תמיכה ב-OpenGL ES ב-Android, אבל אנחנו כבר לא מפתחים תכונות חדשות בשבילו.

ל-Vulkan יש את היתרונות הבאים על פני OpenGL ES:

• ארכיטקטורה יעילה יותר עם פחות עומס על המעבד (CPU) במנהל ההתקן הגרפי
• אסטרטגיות אופטימיזציה חדשות לשיפור הביצועים של המעבד (CPU)
• תכונות גרפיות חדשות שלא זמינות ב-OpenGL ES, כמו ממשקי API ללא קישור וניתוב קרניים

איך משתמשים ב-Vulkan בפרויקטים מקוריים ל-Android

ב-Codelab תחילת השימוש ב-Vulkan ב-Android מוסבר איך להגדיר את צינור עיבוד הנתונים (pipeline) לעיבוד ב-Vulkan, ואז לעבד משולש מסתובב עם טקסטורה על המסך. ב-Codelab מוסבר איך לעבד את הגרפיקה של המשחק.

איך משתמשים ב-Vulkan במנוע המשחק Unity

כדי להפעיל בחירת מכשיר אוטומטית ב-Unity, פועלים לפי השלבים להגדרת Auto Graphics API.

לחלופין, אפשר להפעיל את Vulkan באופן ידני על ידי השבתת Auto Graphics API, ולהגדיר את Vulkan בעדיפות הגבוהה ביותר ברשימה Graphics APIs. אם אתם משתמשים ב-Unity בגרסה 2021.1 או בגרסה קודמת, זו הדרך היחידה להשתמש ב-Vulkan.

אתם יכולים להשתמש בפלאגין VkQuality למנוע Unity כדי לספק המלצות בזמן ההפעלה לגבי ממשק ה-API לגרפיקה שבו המשחק שלכם צריך להשתמש במכשירים ספציפיים.

איך משתמשים ב-Vulkan במנוע המשחק Unreal

כדי להפעיל את Vulkan Graphics API, עוברים אל הגדרות הפרויקט > Platforms > Android > Build ובוחרים באפשרות Support Vulkan. כשבוחרים גם את Support Vulkan וגם את Support OpenGL ES3.2, ‏Unreal משתמש ב-Vulkan כברירת מחדל. אם המכשיר לא תומך ב-Vulkan, ‏ Unreal חוזר ל-OpenGL ES 3.2.

אם אתם משתמשים בתכונות ספציפיות של Vulkan שידוע שהן לא פועלות כמו שצריך במכשירים מסוימים, אתם יכולים להתאים אישית את קובץ BaseDeviceProfile.ini כדי להחריג את המכשירים האלה. במאמר Customizing Device Profiles and Scalability for Android מוסבר איך להתאים אישית את BaseDeviceProfile.ini. מנהלי התקנים חדשים עשויים לתקן מכשירים פגומים שהיו ידועים בעבר, לכן חשוב לעדכן את הקובץ BaseDeviceProfile.ini כדי לקבל את כל האופטימיזציות.

מה זה ADPF

‫Android Dynamic Performance Framework‏ (ADPF) מבצע אופטימיזציה של משחקים על סמך תכונות הניהול הדינמיות של הטמפרטורה, המעבד (CPU) והמעבד הגרפי (GPU) ב-Android. התכונות האלה מתמקדות במשחקים, אבל אפשר להשתמש בהן גם באפליקציות אחרות שדורשות ביצועים גבוהים.

‫ADPF היא קבוצה של ממשקי API שמאפשרים למשחקים ולאפליקציות שדורשות ביצועים גבוהים לתקשר באופן ישיר יותר עם מערכות החשמל והטמפרטורה של מכשירי Android. בעזרת ממשקי ה-API האלה, אתם יכולים לעקוב אחרי ההתנהגות הדינמית במערכות Android ולשפר את ביצועי המשחק לרמה יציבה שלא גורמת להתחממות יתר של המכשירים.

אלה התכונות העיקריות של ADPF:

• Thermal API: מעקב אחרי המצב התרמי של המכשיר כדי שהאפליקציה תוכל להתאים באופן יזום את עומס העבודה לפני שהוא הופך לבלתי נסבל.
• ‫CPU Performance Hint API: מספק רמזים לגבי הביצועים שמאפשרים ל-Android לבחור את הגדרות הביצועים המתאימות (לדוגמה, נקודת ההפעלה או הליבה של המעבד) לעומס העבודה.
• ‫Game Mode API ו-Game State API: מאפשרים לבצע אופטימיזציה של הגיימפליי על ידי מתן עדיפות למאפייני ביצועים או חיי סוללה, על סמך הגדרות המשתמש והגדרות ספציפיות למשחק.
• מצב ביצועים קבועים: הפעילו את מצב הביצועים הקבועים במכשיר במהלך ההשוואה כדי לקבל מדידות שלא משתנות בגלל תזמון דינמי של המעבד.
• מצב חיסכון באנרגיה: מציין לסשן שאפשר לתזמן בבטחה את השרשורים ב-Performance Hint Session כך שיעדיפו חיסכון באנרגיה על פני ביצועים. זמין ב-Android מגרסה 15 (רמת API ‏35).

איך משתמשים ב-ADPF בפרויקטים מקוריים של Android

ב-Codelab בנושא שילוב תכונות של יכולת התאמה במשחק מקורי מוסבר איך לשלב תכונות של ADPF במשחק, בשלבים שאפשר לבצע בקצב שלכם. בסוף ה-Codelab, תשלבו את התכונות הבאות:

• ‫Thermal API: האזנה למצב הטמפרטורה של המכשיר ותגובה לפני שהמכשיר נכנס למצב של ויסות טמפרטורה.
• Game Mode API: הבנת העדפות האופטימיזציה של השחקנים (מיקסום הביצועים או חיסכון בסוללה) וביצוע התאמות בהתאם.
• ‫Game State API: מאפשר למערכת לדעת מה מצב המשחק (בטעינה, משחקים, ממשק משתמש וכו'), כדי שהיא תוכל להתאים את המשאבים בהתאם (להגביר את הקלט/פלט, או את המעבד, המעבד הגרפי וכו').
• ‫Performance Hint API: מאפשר למערכת לדעת מהו מודל ה-threading ועומס העבודה שלכם, כדי שהיא תוכל להקצות משאבים בהתאם.

איך משתמשים ב-ADPF במנוע המשחק Unity

Adaptive Performance של Unity הוא כלי למפתחי משחקים שרוצים לבצע אופטימיזציה של המשחקים שלהם במכשירים ניידים, במיוחד בסביבה העסקית המגוונת של Android. התכונה "ביצועים מותאמים" מאפשרת למשחק להתאים את עצמו לביצועים ולמאפיינים התרמיים של המכשיר בזמן אמת, כדי להבטיח חוויית משחק חלקה ויעילה.

ספק Adaptive Performance ל-Android מדריך אתכם בשלבים להטמעת ADPF ב-Unity. אפשר גם לעיין במאמר ADPF Unity Adaptive Performance and Android provider.

איך משתמשים ב-ADPF במנוע המשחק Unreal

1. מורידים את הפלאגין.
2. מעתיקים את הפלאגין לתיקיית הפלאגינים של הפרויקט.
3. מפעילים את הפלאגין של ADPF Unreal Engine ב-Unreal Editor.
4. מפעילים מחדש את Unreal Editor.
5. מבצעים build ו-cook למשחק.

הפלאגין Android Dynamic Performance Framework‏ (ADPF) ל-Unreal Engine מספק ביצועים יציבים ומונע ויסות תרמי. מורידים את הפלאגין מ-GitHub. הפלאגין הזה משנה תכונות על ידי הגדרת ערכי מסוף Unreal. פרטים נוספים זמינים במאמר הפלאגין של ADPF ל-Unreal Engine.