סשנים איטיים

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

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

מידע נוסף על המדד זמין במרכז העזרה.

גרפיקה שדומה לתרשים עוגה, שבה מוצג מספר הפריימים האיטיים והפריימים הלא איטיים.
איור 1. סשן איטי ב'נתונים על תפקוד האפליקציה' ב-Android.

איך מודדים את שיעור הפריימים לשנייה ומזהים פריימים איטיים

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

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

    adb shell dumpsys SurfaceFlinger --timestats -clear -enable

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

    adb shell dumpsys SurfaceFlinger --timestats -dump

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

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

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

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

    totalFrames = 274
...
presentToPresent histogram is as below:
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

    גם מספר הפריימים הממוצע לשנייה בכל שכבה מוצג בדמפ:

    ...
averageFPS = 30.179
...

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

    adb shell dumpsys SurfaceFlinger --timestats -disable

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

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

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

מה זה Swappy

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

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

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

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

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

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

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

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

תיבת הדו-שיח של הגדרות הפרויקט.
איור 2. מפעילים את Frame Pacing ב-Unity Engine.

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

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

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

מה זה Vulkan

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

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

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

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

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

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

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

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

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

תיבת הדו-שיח של הגדרות הפרויקט.
איור 4. בוחרים ידנית את Vulkan כ-Graphics API הראשי ב-Unity.

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

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

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

תיבת הדו-שיח של הגדרות הפרויקט.
איור 5. מפעילים את Vulkan ב-Unreal Engine.

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

מהו ADPF

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

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

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

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

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

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

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

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

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

Adaptive Performance Android provider מציג הנחיות להטמעת ADPF ב-Unity.

תיבת הדו-שיח של הגדרות הפרויקט.
איור 6. משלבים את ADPF ב-Unity Engine.

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

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

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