תצוגת המעקב ב-CPU Profiler מספקת כמה דרכים להצגת מידע ממעקבים מתועדים.
עבור תיעוד method ומעקבי פונקציות, אפשר לראות את תרשים הקריאות ישירות בציר הזמן של השרשורים ואת הכרטיסיות תרשים להבה, מלמעלה למטה, מלמטה למעלה ואירועים מהחלונית ניתוח. במסגרות של מחסנית קריאות, אפשר לראות את החלק בקוד שהופעל ואת הסיבה להפעלה. בעקבות המערכת, אפשר לראות את אירועי העקבות ישירות בציר הזמן Threads, ואת הכרטיסיות Flame Chart, Top Down, Bottom Up ו-Events בחלונית Analysis.
אפשר להשתמש במקשי קיצור בעכבר ובמקלדת כדי לנווט בקלות בתרשימי קריאות או באירועי מעקב.
בדיקת עקבות באמצעות תרשים הקריאות
תרשים הקריאות מספק ייצוג גרפי של מעקב אחר שיטות או פונקציות, שבו התקופה והתזמון של הקריאה מיוצגים בציר האופקי, והקריאות שלה מוצגות לאורך הציר האנכי. קריאות לממשקי API של המערכת מוצגות בכתום, קריאות לשיטות של האפליקציה מוצגות בירוק וקריאות לממשקי API של צד שלישי (כולל ממשקי API של שפת Java) מוצגות בכחול. תמונה 4 מציגה תרשים קריאות לדוגמה וממחישה את המושגים "זמן עצמי", "זמן צאצאים" ו"זמן כולל" של שיטה או פונקציה נתונה. בקטע בדיקת נתוני מעקב באמצעות Top Down ו-Bottom Up מוסבר בהרחבה על המושגים האלה.
בדיקת המעקבים באמצעות הכרטיסייה Flame Chart
בכרטיסייה Flame Chart מוצג תרשים קריאות הפוך שצובר סטאקי ביצוע זהים. כלומר, פונקציות או שיטות זהות שחולקות את אותו רצף של קריאות נאספות ומיוצגות כעמודה אחת ארוכה יותר בתרשים להבה (במקום להציג אותן ככמה עמודות קצרות יותר, כמו שמוצג בתרשים קריאות). כך קל יותר לראות אילו שיטות או פונקציות צורכות הכי הרבה זמן. עם זאת, המשמעות היא גם שהציר האופקי לא מייצג ציר זמן, אלא את משך הזמן היחסי שלוקח לכל שיטה או פונקציה לפעול.
כדי להמחיש את הקונספט הזה, נסתכל על תרשים הקריאות באיור 2. שימו לב ש-method D מבצע כמה קריאות ל-B (B1, B2 ו-B3), וחלק מהקריאות האלה ל-B מבצעות קריאה ל-C (C1 ו-C3).
מכיוון ש-B1, B2 ו-B3 חולקים את אותו רצף של פונקציות קוראות (A ← D ← B), הם נצברים, כמו שמוצג באיור 3. באופן דומה, C1 ו-C3 נצברים כי יש להם אותו רצף של גורמים מבצעים (A ← D ← B ← C). שימו לב ש-C2 לא נכלל כי יש לו רצף שונה של גורמים מבצעים (A ← D ← C).
הקריאות המצטברות משמשות ליצירת תרשים הלהבה, כפי שמוצג באיור 4. שימו לב שבכל קריאה בתרשים להבה, הפונקציות שצורכות הכי הרבה זמן מעבד מופיעות ראשונות.
בדיקת עקבות באמצעות Top Down ו-Bottom Up
בכרטיסייה Top Down מוצגת רשימה של קריאות, שבהן הרחבה של צומת פונקציה או שיטה מציגה את הנקראים שלה. באיור 5 מוצג תרשים מלמעלה למטה של תרשים הקריאות שבאיור 1. כל חץ בתרשים מצביע מהפונקציה הקוראת לפונקציה הנקראת.
כמו שמוצג באיור 5, הרחבת הצומת של מתודה א' בכרטיסייה Top Down מציגה את המתודות שנקראות על ידה, מתודות ב' וד'. אחרי זה, הרחבת הצומת של שיטה D חושפת את השיטות שנקראות על ידה, שיטות B ו-C. בדומה לכרטיסייה Flame chart, העץ מלמעלה למטה צובר מידע על מעקב אחר שיטות זהות שחולקות את אותו סטאק ביצוע. כלומר, הכרטיסייה Flame chart מספקת ייצוג גרפי של הכרטיסייה Top down.
בכרטיסייה Top Down מוצג המידע הבא, שמתאר את זמן המעבד (CPU) שהושקע בכל קריאה (הזמנים מיוצגים גם כאחוז מהזמן הכולל של ה-thread בטווח שנבחר):
- עצמי: הזמן שבו ה-method או הבקשה להפעלת פונקציה הפעילו את הקוד שלהן, ולא את הקוד של ה-callees שלהן, כמו שמוצג באיור 1 לגבי method D.
- צאצאים: הזמן שבו השיטה או הבקשה להפעלת פונקציה הפעילו את הצאצאים שלהן ולא את הקוד שלהן, כמו שמוצג באיור 1 לגבי שיטה ד'.
- סה"כ: סכום הזמן של עצמי וצאצאים של השיטה. זהו משך הזמן הכולל שבו האפליקציה ביצעה קריאה, כמו שמוצג באיור 1 למתודה D.
איור 5. עץ מלמעלה למטה.
איור 6. עץ מלמטה למעלה של method C מאיור 5.
בכרטיסייה Bottom Up מוצגת רשימה של קריאות, שבהן הרחבה של צומת של פונקציה או שיטה מציגה את הגורמים שקראו להן. באיור 6 מוצג עץ מלמטה למעלה של מתודה C, על סמך המעקב לדוגמה שמוצג באיור 5. כשפותחים את הצומת של שיטה C בעץ מלמטה למעלה, מוצגות כל השיטות הייחודיות שקוראות לה, שיטות B ו-D. שימו לב שלמרות ש-B קורא ל-C פעמיים, B מופיע רק פעם אחת כשמרחיבים את הצומת של השיטה C בעץ מלמטה למעלה. אחרי זה, הרחבת הצומת של B תציג את המתקשר שלו, methods A ו-D.
הכרטיסייה Bottom Up שימושית למיון שיטות או פונקציות לפי אלה שצורכות הכי הרבה (או הכי פחות) זמן מעבד. אפשר לבדוק כל צומת כדי לקבוע אילו מבצעי קריאה משתמשים בזמן המעבד (CPU) הרב ביותר להפעלת השיטות או הפונקציות האלה. בהשוואה לעץ מלמעלה למטה, פרטי התזמון של כל שיטה או פונקציה בעץ מלמטה למעלה מתייחסים לשיטה שבראש כל עץ (הצומת העליון). זמן ה-CPU מיוצג גם כאחוז מהזמן הכולל של ה-thread במהלך ההקלטה. הטבלה הבאה מסבירה איך לפרש את פרטי התזמון של הצומת העליון ושל הקריאות שלו (צומתי משנה).
| עצמי | ילדים | סה"כ | |
|---|---|---|---|
| השיטה או הפונקציה בחלק העליון של העץ מלמטה למעלה (הצומת העליון) | מייצג את משך הזמן הכולל שבו השיטה או הפונקציה הריצו את הקוד שלהן, ולא את הקוד של הנמענים שלהן. בהשוואה לעץ מלמעלה למטה, פרטי התזמון האלה מייצגים סכום של כל הקריאות לשיטה או לפונקציה הזו במהלך ההקלטה. | מייצג את משך הזמן הכולל שבו ה-method או הפונקציה ביצעו את ה-callees שלהן, ולא את הקוד שלהן. בהשוואה לעץ מלמעלה למטה, פרטי התזמון האלה מייצגים את הסכום של כל הקריאות לשיטה הזו או לפונקציות שנקראות במהלך ההקלטה. | הסכום של הזמן העצמי וזמן הצאצאים. |
| מתקשרים (צומתי משנה) | מייצג את הזמן העצמי הכולל של הפונקציה שנקראה, כשהיא נקראת על ידי הפונקציה הקוראת. לדוגמה, בעץ מלמטה למעלה באיור 6, זמן הריצה של שיטה B יהיה שווה לסכום זמני הריצה של כל הפעלה של שיטה C כששיטה B קוראת לה. | מייצג את זמן הצאצאים הכולל של הפונקציה שנקראה, כשהיא מופעלת על ידי הפונקציה שקוראת לה. לדוגמה, בעץ מלמטה למעלה באיור 6, זמן הצאצאים של שיטה B יהיה שווה לסכום זמני הצאצאים של כל הפעלה של שיטה C כש-B קוראת לה. | הסכום של הזמן העצמי וזמן הצאצאים. |
בדיקת המעקבים באמצעות הטבלה "אירועים"
בטבלה Events מפורטות כל הקריאות בשרשור שנבחר. כדי למיין את הרשימה, לוחצים על כותרות העמודות. אם תבחרו שורה בטבלה, תוכלו לנווט בציר הזמן לשעת ההתחלה והסיום של השיחה שנבחרה. כך אפשר לאתר אירועים בציר הזמן בצורה מדויקת.
בדיקת פריימים של מחסנית קריאות
מחסניות קריאות עוזרות להבין איזה חלק בקוד הופעל ולמה. אם נאספת הקלטה של דגימת מחסנית קריאות לתוכנית Java או Kotlin, מחסנית הקריאות בדרך כלל כוללת לא רק קוד Java או Kotlin, אלא גם פריימים מקוד ה-Native של JNI, מהמכונה הווירטואלית של Java (למשל android::AndroidRuntime::start) ומליבת המערכת ([kernel.kallsyms]+offset). הסיבה לכך היא שתוכנית Java או Kotlin בדרך כלל פועלת דרך מכונה וירטואלית של Java. קוד Native נדרש כדי להריץ את התוכנה עצמה וכדי שהתוכנה תתקשר עם המערכת והחומרה.
ה-profiler מציג את הפריימים האלה כדי לדייק, אבל יכול להיות שהם לא יהיו שימושיים, בהתאם למה שאתם בודקים. כלי הפרופיילינג מאפשר לכווץ פריימים שלא מעניינים אתכם, כדי להסתיר מידע שלא רלוונטי לבדיקה.
בדוגמה הבאה, למעקב יש הרבה פריימים עם התווית [kernel.kallsyms]+offset, שלא מועילים כרגע לפיתוח.
כדי לכווץ את הפריימים האלה לפריים אחד, לוחצים על הלחצן Collapse frames בסרגל הכלים, בוחרים את הנתיבים שרוצים לכווץ ולוחצים על הלחצן Apply כדי להחיל את השינויים. בדוגמה הזו, הנתיב הוא [kernel.kallsyms].
הפעולה הזו מכווצת את הפריימים שתואמים לנתיב שנבחר גם בחלונית הימנית וגם בחלונית השמאלית, כמו שמוצג בהמשך.
בדיקת עקבות המערכת
כשבודקים את עקבות המערכת, אפשר לבחון את אירועי המעקב בציר הזמן של השרשורים כדי לראות את פרטי האירועים שמתרחשים בכל שרשור. כדי לראות את שם האירוע ואת משך הזמן בכל מצב, מעבירים את סמן העכבר מעל האירוע. לוחצים על אירוע כדי לראות מידע נוסף בחלונית Analysis.
בדיקת עקבות המערכת: ליבות מעבד (CPU)
בנוסף לנתוני התזמון של המעבד, עקבות המערכת כוללים גם את תדירות המעבד לפי ליבה. כך אפשר לראות את כמות הפעילות בכל ליבה, ולקבל מושג אילו מהן הן הליבות "הגדולות" או "הקטנות" במעבדים מודרניים לניידים.
בחלונית CPU Cores (כמו שמוצג באיור 8) מוצגת פעילות השרשורים שתוזמנה בכל ליבה. מעבירים את סמן העכבר מעל פעילות של שרשור כדי לראות באיזה שרשור הליבה הזו פועלת באותו זמן.
מידע נוסף על בדיקת פרטי עקבות המערכת זמין בקטע בדיקת בעיות בביצועים של ממשק המשתמש במסמכי התיעוד של systrace.
בדיקת עקבות המערכת: ציר הזמן של רינדור הפריימים
אתם יכולים לבדוק כמה זמן לוקח לאפליקציה לעבד כל פריים ב-thread הראשי וב-RenderThread כדי לחקור צווארי בקבוק שגורמים לבעיות בממשק המשתמש ולקצב פריימים נמוך. במאמר זיהוי תקלות בממשק המשתמש מוסבר איך להשתמש בעקבות המערכת כדי לחקור ולצמצם תקלות בממשק המשתמש.
בדיקת עקבות המערכת: זיכרון התהליך (RSS)
באפליקציות שמותקנות במכשירים עם Android בגרסה 9 ואילך, בקטע זיכרון התהליך (RSS) מוצגת כמות הזיכרון הפיזי שהאפליקציה משתמשת בו כרגע.
סה"כ
זהו הנפח הכולל של הזיכרון הפיזי שנמצא כרגע בשימוש על ידי התהליך. במערכות מבוססות Unix, המדד הזה נקרא Resident Set Size (גודל קבוצת הזיכרון הפעיל), והוא שילוב של כל הזיכרון שבו משתמשים הקצאות אנונימיות, מיפויי קבצים והקצאות זיכרון משותפות.
למפתחי Windows, גודל קבוצת התושבים מקביל לגודל קבוצת העבודה.
הוקצו
המונה הזה עוקב אחרי נפח הזיכרון הפיזי שמשמש כרגע להקצאות הזיכרון הרגילות של התהליך. אלה הקצאות אנונימיות (לא מגובות בקובץ ספציפי) ופרטיות (לא משותפות). ברוב האפליקציות, הן מורכבות מהקצאות זיכרון בערימה (heap allocation) (עם malloc או new) ומזיכרון מחסנית (stack memory). כשההקצאות האלה מוחלפות מהזיכרון הפיזי, הן נכתבות בקובץ ההחלפה של המערכת.
מיפוי קבצים
המונה הזה עוקב אחרי כמות הזיכרון הפיזי שהתהליך משתמש בו למיפוי קבצים – כלומר, זיכרון שממופה מקבצים לאזור של זיכרון על ידי מנהל הזיכרון.
משותף
המונה הזה עוקב אחרי נפח הזיכרון הפיזי שמשמש לשיתוף זיכרון בין התהליך הזה לתהליכים אחרים במערכת.