perf-script-python - מקוון בענן

תָכְנִית:

שֵׁם

perf-script-python - עיבוד נתוני מעקב עם סקריפט Python

תַקצִיר

perf תסריט [-s [Python]:script[.py] ]

תיאור

אפשרות זו של perf script משמשת לעיבוד נתוני perf script באמצעות Python המובנה של perf
מְתוּרגְמָן. הוא קורא ומעבד את קובץ הקלט ומציג את תוצאות המעקב
ניתוח מיושם בסקריפט הנתון של Python, אם בכלל.

A מָהִיר דוגמא

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

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

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

.ft C
אירועי syscall:

ספירת אירועים
-------------------------------------------------------- -
sys_write 455067
sys_getdents 4072
sys_close 3037
sys_swapoff 1769
sys_read 923
sys_sched_setparam 826
sys_open 331
sys_newfstat 326
sys_mmap 217
sys_munmap 216
sys_futex 141
sys_select 102
sys_poll 84
sys_setitimer 12
sys_writev 8
15 8
sys_lseek 7
sys_rt_sigprocmask 6
sys_wait4 3
sys_ioctl 3
sys_set_robust_list 1
sys_exit 1
56 1
sys_access 1
.ft

ביסודו של דבר המשימה שלנו היא לשמור על סיכום לכל מערכת שמתעדכן בכל פעם שמערכת
שיחה מתרחשת במערכת. הסקריפט שלנו יעשה את זה, אבל קודם כל עלינו לתעד את הנתונים
שיעובד על ידי הסקריפט הזה. תיאורטית, יש כמה דרכים שאנחנו יכולים
לעשות את זה:

· נוכל להפעיל כל אירוע תחת ספריית tracing/events/syscalls, אבל זהו
למעלה מ-600 שיחות סיסמה, הרבה מעבר למספר המותר על-ידי Perf. מערכות מערכות בודדות אלה
אולם אירועים יהיו שימושיים אם נרצה מאוחר יותר להשתמש בהדרכה שאנו מקבלים מה-
סקריפטים למטרות כלליות כדי להתעמק ולקבל פרטים נוספים על מערכות מערכות בודדות של
עניין.

· אנו יכולים להפעיל את sys_enter ו/או sys_exit syscalls שנמצאו תחת
tracing/events/raw_syscalls. אלה נקראים עבור כל מערכות ההפעלה; ה id שדה יכול להיות
משמש כדי להבחין בין מספרי סיקול בודדים.

עבור סקריפט זה, אנו רק צריכים לדעת שהוזנה סיסקל; לא אכפת לנו איך זה
יצא, אז נשתמש perf שיא כדי להקליט רק את אירועי sys_enter:

.ft C
# perf record -a -e raw_syscalls:sys_enter

^C[ רשומה מומלצת: התעוררו פעם אחת כדי לכתוב נתונים]
[ רשומת ביצוע: נלכדה וכתבה 56.545 MB perf.data (~2470503 דוגמאות) ]
.ft

האפשרויות בעצם אומרות לאסוף נתונים עבור כל אירוע syscall בכל מערכת ו
מרבה את הפלט לכל מעבד לזרם יחיד. הזרם היחיד הזה יוקלט ב
קובץ בספרייה הנוכחית בשם perf.data.

ברגע שיש לנו קובץ perf.data המכיל את הנתונים שלנו, נוכל להשתמש ב-g perf תסריט אפשרות ל
ליצור סקריפט Python שיכיל מטפל להתקשרות חוזרת עבור כל סוג אירוע שנמצא ב
זרם המעקב perf.data (לפרטים נוספים, עיין בסעיף STARTER SCRIPTS).

.ft C
# perf script -g python
סקריפט Python שנוצר: perf-script.py

שם קובץ הפלט שנוצר גם בספרייה הנוכחית
perf-script.py. הנה הקובץ בשלמותו:

# מטפלי אירועי perf script, שנוצרו על ידי perf script -g python
# מורשה תחת תנאי רישיון GNU GPL גרסה 2

# שדות מטפל האירועים common_* הם השדות השימושיים ביותר המשותפים להם
# כל האירועים. הם לא בהכרח תואמים לשדות 'משותף_*'
# בקבצי הפורמט. שדות אלה אינם זמינים כפי שפאראמים של מטפל יכולים
# ניתן לאחזר באמצעות פונקציות Python בצורת common_*(context).
# עיין בתיעוד perf-script-python עבור רשימת הפונקציות הזמינות.

יבוא os
ייבוא

sys.path.append(os.environ['PERF_EXEC_PATH'] + \
'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')

מ-perf_trace_context import *
מייבוא ​​ליבה *

def trace_begin():
הדפס "ב-trace_begin"

def trace_end():
הדפס "ב-trace_end"

def raw_syscalls__sys_enter(שם_אירוע, הקשר, מעבד_משותף,
common_secs, common_nsecs, common_pid, common_comm,
id, args):
print_header(event_name, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)

הדפס "id=%d, args=%s\n" % \
(מזהה, args),

def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
common_pid, common_comm):
print_header(event_name, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)

def print_header(event_name, cpu, secs, nsecs, pid, comm):
הדפס "%-20s %5u %05u.%09u %8u %-20s " % \
(שם_אירוע, מעבד, שניות, nsecs, pid, comm),
.ft

בחלק העליון יש בלוק הערות ואחריו כמה הצהרות ייבוא ​​וצרף נתיב אשר
כל סקריפט perf צריך לכלול.

לאחר מכן יש כמה פונקציות שנוצרו, trace_begin() ו-trace_end(), שהן
נקרא בתחילת התסריט ובסוף בהתאמה (לפרטים נוספים, ראה את
קטע SCRIPT_LAYOUT למטה).

בעקבות אלה הם אירוע מטפל פונקציות שנוצרו עבור כל אירוע ב- perf
שיא תְפוּקָה. פונקציות המטפל לוקחות את תת-מערכת הטופסשם אירוע, ו להכיל בשם
פרמטרים, אחד ל כל אחד שדה in מה היא מִקרֶה; in זֶה מקרה, יש רק אחד מִקרֶה,
raw_syscallssys_enter(). (ראה סעיף מטפלי אירועים למטה למידע נוסף על האירוע
מטפלים).

צמד הפונקציות האחרון נוצר, כמו פונקציות ההתחלה והסיום, עבור כל אחת
תַסרִיט. הראשון, trace_unhandled(), נקרא בכל פעם שהסקריפט מוצא אירוע ב
קובץ perf.data שאינו מתאים לאף מטפל באירועים בסקריפט. זה יכול
כלומר, שלב ההקלטה תיעד סוגי אירועים שהוא לא באמת מעוניין בהם,
או שהסקריפט הופעל מול קובץ מעקב שאינו תואם לסקריפט.

הסקריפט שנוצר על ידי אפשרות -g פשוט מדפיס שורה עבור כל אירוע שנמצא במעקב
זרם כלומר, זה בעצם פשוט משליך את האירוע ואת ערכי הפרמטרים שלו ל-stdout. ה
הפונקציה print_header() היא פשוט פונקציית עזר המשמשת למטרה זו. בוא נשנה שם
את הסקריפט והפעל אותו כדי לראות את פלט ברירת המחדל:

.ft C
# mv perf-script.py syscall-counts.py
# perf script -s syscall-counts.py

raw_syscalls__sys_enter 1 00840.847582083 7506 perf id=1, args=
raw_syscalls__sys_enter 1 00840.847595764 7506 perf id=1, args=
raw_syscalls__sys_enter 1 00840.847620860 7506 perf id=1, args=
raw_syscalls__sys_enter 1 00840.847710478 6533 npviewer.bin id=78, args=
raw_syscalls__sys_enter 1 00840.847719204 6533 npviewer.bin id=142, args=
raw_syscalls__sys_enter 1 00840.847755445 6533 npviewer.bin id=3, args=
raw_syscalls__sys_enter 1 00840.847775601 6533 npviewer.bin id=3, args=
raw_syscalls__sys_enter 1 00840.847781820 6533 npviewer.bin id=3, args=
.
.
.
.ft

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

.ft C
יבוא os
ייבוא

sys.path.append(os.environ['PERF_EXEC_PATH'] + \
'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')

מ-perf_trace_context import *
מייבוא ​​ליבה *

def trace_end():
הדפס "ב-trace_end"

def raw_syscalls__sys_enter(שם_אירוע, הקשר, מעבד_משותף,
common_secs, common_nsecs, common_pid, common_comm,
id, args):
.ft

ב-trace_end(), אנחנו פשוט נדפיס את התוצאות, אבל תחילה עלינו ליצור כמה תוצאות
להדפיס. כדי לעשות זאת, אנחנו צריכים שהמטפל שלנו ב-sys_enter() יבצע את ההתאמה הנדרשת
עד שכל האירועים נספרו. טבלת hash שנוספה לאינדקס על ידי syscall id היא דרך טובה לעשות זאת
לאחסן מידע זה; בכל פעם שהמטפל sys_enter() נקרא, אנו פשוט מגדילים
ספירה המשויכת לערך ה-hash שנוסף לאינדקס על ידי מזהה syscall זה:

.ft C
syscalls = autodict()

נסה:
syscalls[id] += 1
מלבד TypeError:
syscalls[id] = 1
.ft

מערכות המערכות אוטומט אובייקט הוא סוג מיוחד של מילון Python (מיושם ב
Core.py) שמיישם את זה של Perl מחייה אוטומטית hashes ב- Python כלומר עם autovivifying
hashes, אתה יכול להקצות ערכי hash מקוננים מבלי שתצטרך לטרוח ביצירת
רמות ביניים אם הן לא קיימות, למשל syscalls[comm][pid][id] = 1 תיצור את
רמות גיבוב ביניים ולבסוף הקצה את הערך 1 לערך הגיבוב עבור id (כי
הערך המוקצה אינו אובייקט גיבוב עצמו, הערך הראשוני מוקצה ב-
חריג TypeError. ובכן, אולי יש דרך טובה יותר לעשות את זה ב-Python אבל זה מה
עובד בינתיים).

כשמכניסים את הקוד הזה ל-raw_syscalls__sys_enter() המטפל, אנחנו למעשה מקבלים
מילון ברמה אחת הממוקם על מזהה syscall ויש לו את הספירות שספרנו כערכים.

הפונקציה print_syscall_totals() חוזרת על הערכים במילון ו
מציג שורה עבור כל רשומה המכילה את שם syscall (מקשי המילון מכילים
ה-syscall ids, המועברים לפונקציה Util syscall_name(), שמתרגמת
את המספרים הגולמיים של ה-Syscall למחרוזות השמות המתאימות). הפלט הוא
מוצג לאחר עיבוד כל האירועים במעקב, על ידי קריאה ל-
הפונקציה print_syscall_totals() מהמטפל trace_end() שנקראת בסוף הסקריפט
מעבד.

התסריט הסופי שמפיק את הפלט המוצג לעיל מוצג במלואו למטה
(syscall_name() עוזר עדיין לא זמין, אתה יכול להתמודד רק עם מזהים לעת עתה):

.ft C
יבוא os
ייבוא

sys.path.append(os.environ['PERF_EXEC_PATH'] + \
'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')

מ-perf_trace_context import *
מייבוא ​​ליבה *
מ-Util import *

syscalls = autodict()

def trace_end():
print_syscall_totals()

def raw_syscalls__sys_enter(שם_אירוע, הקשר, מעבד_משותף,
common_secs, common_nsecs, common_pid, common_comm,
id, args):
נסה:
syscalls[id] += 1
מלבד TypeError:
syscalls[id] = 1

def print_syscall_totals():
אם for_comm אינו None:
הדפס "\nsyscall events for %s:\n\n" % (for_comm),
else
הדפס "\nאירועי התקשרות:\n\n",

הדפס "%-40s %10s\n" % ("אירוע", "ספירה"),
הדפס "%-40s %10s\n" % ("------------------------------------------------ ---", \
"-----------"),

עבור id, val ב- sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
הפוך = נכון):
הדפס "%-40s %10d\n" % (syscall_name(id), val),
.ft

ניתן להריץ את הסקריפט בדיוק כמו קודם:

# perf script -s syscall-counts.py

אז אלו הם השלבים החיוניים בכתיבת תסריט והפעלתו. התהליך יכול להיות
מוכלל לכל נקודת מעקב או קבוצה של נקודות מעקב שאתה מעוניין בהן - בעצם מצא
נקודות העקיבה בהן אתה מעוניין על ידי עיון ברשימת האירועים הזמינים המוצגים על ידי
perf רשימה ו/או חפש ב-/sys/kernel/debug/tracing events עבור אירוע ושדה מפורטים
מידע, רשום את נתוני המעקב התואמים באמצעות perf שיא, מעביר את הרשימה של
אירועים מעניינים, צור סקריפט שלד באמצעות perf תסריט -g פִּיתוֹן ולשנות את
קוד כדי לצבור ולהציג אותו לצרכים הספציפיים שלך.

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

.ft C
root@tropicana:~# perf script -l
רשימת תסריטי מעקב זמינים:
משך השכמה מינימלי/מקסימלי/ממוצע של המערכת כולה
rw-by-file פעילות r/w עבור תוכנית, לפי קובץ
rw-by-pid פעילות r/w בכל המערכת
.ft

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

כדי שהסקריפט יופיע בתור א מובנה תסריט, אתה כותב שני תסריטים פשוטים, אחד עבור
הקלטה ואחד עבור דיווח.

אל האני שיא script הוא סקריפט מעטפת עם אותו שם בסיס כמו הסקריפט שלך, אבל עם
-הרשומה צורפה. יש להכניס את סקריפט המעטפת ל-perf/scripts/python/bin
ספרייה בעץ המקור של הליבה. בתסריט הזה, אתה כותב את ה perf שיא
שורת הפקודה הדרושה עבור הסקריפט שלך:

.ft C
# cat kernel-source/tools/perf/scripts/python/bin/syscall-counts-record

#!/ bin / bash
perf record -a -e raw_syscalls:sys_enter
.ft

אל האני לדווח script הוא גם סקריפט מעטפת עם אותו שם בסיס כמו הסקריפט שלך, אבל עם
-דוח צורף. זה צריך להיות ממוקם גם בספריית perf/scripts/python/bin. ב
את התסריט הזה, אתה כותב את perf תסריט -s שורת הפקודה הדרושה להפעלת הסקריפט שלך:

.ft C
# cat kernel-source/tools/perf/scripts/python/bin/syscall-counts-report

#!/ bin / bash
# תיאור: ספירת שיחות מערכתיות בכל המערכת
perf script -s ~/libexec/perf-core/scripts/python/syscall-counts.py
.ft

שימו לב שהמיקום של סקריפט Python המופיע בסקריפט המעטפת נמצא ב-
ספריית libexec/perf-core/scripts/python - זה המקום שבו הסקריפט יועתק על ידי
לעשות להתקין כאשר אתה מתקין perf. כדי שההתקנה תתקין את הסקריפט שלך שם,
הסקריפט שלך צריך להיות ממוקם בספריית perf/scripts/python במקור הליבה
עֵץ:

.ft C
# ls -al kernel-source/tools/perf/scripts/python

root@tropicana:/home/trz/src/tip# ls -al tools/perf/scripts/python
סה"כ 32
drwxr-xr-x 4 trz trz 4096 2010-01-26 22:30 .
drwxr-xr-x 4 trz trz 4096 2010-01-26 22:29 ..
drwxr-xr-x 2 trz trz 4096 2010-01-26 22:29 bin
-rw-r--r-- 1 trz trz 2548 2010-01-26 22:29 check-perf-script.py
drwxr-xr-x 3 trz trz 4096 2010-01-26 22:49 Perf-Trace-Util
-rw-r--r-- 1 trz trz 1462 2010-01-26 22:30 syscall-counts.py
.ft

לאחר שעשית את זה (אל תשכח לעשות חדש לעשות להתקין, אחרת התסריט שלך לא
להופיע בזמן ריצה), perf תסריט -l צריך להציג ערך חדש עבור הסקריפט שלך:

.ft C
root@tropicana:~# perf script -l
רשימת תסריטי מעקב זמינים:
משך השכמה מינימלי/מקסימלי/ממוצע של המערכת כולה
rw-by-file פעילות r/w עבור תוכנית, לפי קובץ
rw-by-pid פעילות r/w בכל המערכת
ספירת syscall ספירת מערכות מערכת כולה
.ft

כעת תוכל לבצע את שלב ההקלטה באמצעות perf תסריט שיא:

# ספירת סיסמאות של רשומת סקריפט

והצג את הפלט באמצעות perf תסריט לדווח:

# ספירות של דיווחי סקריפט מומלצים

מַתנֵעַ סקריפטים

אתה יכול להתחיל במהירות לכתוב סקריפט עבור קבוצה מסוימת של נתוני מעקב על ידי
יצירת סקריפט שלד באמצעות perf תסריט -g פִּיתוֹן באותה ספרייה כמו an
קובץ מעקב perf.data קיים. זה יפיק סקריפט מתחיל המכיל מטפל
עבור כל אחד מסוגי האירועים בקובץ המעקב; זה פשוט מדפיס כל שדה זמין עבור
כל אירוע בקובץ המעקב.

אתה יכול גם להסתכל על הסקריפטים הקיימים ב ~/libexec/perf-core/scripts/python ל
דוגמאות טיפוסיות המראות כיצד לעשות דברים בסיסיים כמו נתוני אירועים מצטברים, תוצאות הדפסה,
וכו'. כמו כן, הסקריפט check-perf-script.py, למרות שאינו מעניין עבור התוצאות שלו,
מנסה לממש את כל תכונות הסקריפט העיקריות.

מקרה מטפלים

כאשר סקריפט perf מופעל באמצעות סקריפט מעקב, מוגדר על ידי משתמש מטפל פונקציה is
נקרא לכל אירוע במעקב. אם לא מוגדרת פונקציית מטפל עבור נתון
סוג האירוע, מתעלמים מהאירוע (או מועבר ל-a trace_handed פונקציה, ראה להלן) ו
האירוע הבא מעובד.

רוב ערכי השדות של האירוע מועברים כארגומנטים לפונקציית המטפל; חלק מ
הפחות נפוצים אינם - אלה זמינים כשיחות חזרה לקובץ ההפעלה perf
(ראה למטה).

כדוגמה, ניתן להשתמש בפקודה הבאה perf record כדי להקליט את כל sched_wakeup
אירועים במערכת:

# perf record -a -e sched:sched_wakeup

יש לרשום עקבות המיועדים לעיבוד באמצעות סקריפט עם האפשרות שלמעלה: -א
כדי לאפשר איסוף מערכתי.

קובץ הפורמט של אירוע sched_wakep מגדיר את השדות הבאים (ראה
/sys/kernel/debug/tracing/events/sched/sched_wakeup/format):

.ft C
פורמט:
field:unsigned short common_type;
field: char common_flags ללא חתימה;
field: char unsigned common_preempt_count;
field:int common_pid;

field:char comm[TASK_COMM_LEN];
field:pid_t pid;
field:int prio;
field:int הצלחה;
field:int target_cpu;
.ft

פונקציית המטפל עבור אירוע זה תוגדר כ:

.ft C
def sched__sched_wakeup(שם_אירוע, הקשר, מעבד_משותף, שניות_נפוץ,
common_nsecs, common_pid, common_comm,
comm, pid, prio, success, target_cpu):
לעבור
.ft

פונקציית המטפל מקבלת את הצורה subsystem__event_name.

הארגומנטים common_* ברשימת הארגומנטים של המטפל הם קבוצת הארגומנטים המועברים אליהם
כל מטפלי האירועים; חלק מהשדות תואמים לשדות common_* בפורמט
קובץ, אך חלקם מסונתזים, וחלק מהשדות הנפוצים_* אינם נפוצים מספיק כדי
מועברים לכל אירוע כארגומנטים אך זמינים כפונקציות ספרייה.

להלן תיאור קצר של כל אחת מהארגומנטים של האירוע הבלתי משתנה:

event_name שם האירוע כטקסט
הקשר 'עוגייה' אטומה המשמשת בשיחות חזרה ל-perf
common_cpu המעבד בו התרחש האירוע
common_secs החלק השניות של חותמת הזמן של האירוע
common_nsecs החלק nsecs של חותמת הזמן של האירוע
common_pid ה-pid של המשימה הנוכחית
common_comm השם של התהליך הנוכחי

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

האמור לעיל מספק את היסודות הדרושים לגישה ישירה לכל תחום של כל אירוע ב
trace, המכסה 90% ממה שאתה צריך לדעת כדי לכתוב סקריפט מעקב שימושי. ה
הסעיפים למטה מכסים את השאר.

SCRIPT מערך

כל סקריפט perf Python צריך להתחיל בהגדרת נתיב חיפוש של מודול Python ו
'ייבוא' של כמה מודולי תמיכה (ראה תיאורי מודול להלן):

.ft C
יבוא os
ייבוא

sys.path.append(os.environ['PERF_EXEC_PATH'] + \
'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')

מ-perf_trace_context import *
מייבוא ​​ליבה *
.ft

שאר הסקריפט יכול להכיל פונקציות מטפל ופונקציות תמיכה בכל סדר.

מלבד פונקציות המטפל באירועים שנדונו לעיל, כל סקריפט יכול ליישם סט
של פונקציות אופציונליות:

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

.ft C
def trace_begin:
לעבור
.ft

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

.ft C
def trace_end:
לעבור
.ft

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

.ft C
def trace_unhandled(name_event, context, common_cpu, common_secs,
common_nsecs, common_pid, common_comm):
לעבור
.ft

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

זמין מודולים ו פונקציות

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

Core.py מודול
פונקציות אלו מספקות כמה פונקציות חיוניות לסקריפטים של משתמשים.

אל האני flag_str ו symbol_str פונקציות מספקות מחרוזות הניתנות לקריאה עבור דגל וסמל
שדות. אלה תואמים את המחרוזות והערכים שמנותחו מה- הדפסה fmt שדות של
קבצי פורמט אירועים:

flag_str(event_name, field_name, field_value) - מחזיר את ייצוג המחרוזת התואם לשדה_ערך עבור שדה הדגל field_name של האירוע_name
symbol_str(event_name, field_name, field_value) - מחזירה את ייצוג המחרוזת התואם לשדה_ערך עבור השדה הסמלי field_name של האירוע_name

אל האני אוטומט הפונקציה מחזירה סוג מיוחד של מילון Python שמיישם את זה של Perl
מחייה אוטומטית hashes ב- Python, כלומר עם hashes של autovivifying, אתה יכול להקצות hash מקונן
ערכים מבלי לטרוח וליצור רמות ביניים אם לא
קיימים.

autodict() - מחזיר מופע מילון מחייה אוטומטי

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

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

common_pc(context) - מחזיר ספירת common_preempt עבור האירוע הנוכחי
common_flags(context) - מחזיר common_flags עבור האירוע הנוכחי
common_lock_depth(context) - מחזיר common_lock_depth עבור האירוע הנוכחי

Util.py מודול
פונקציות שירות שונות לשימוש עם סקריפט perf:

nsecs(secs, nsecs) - מחזיר סך nsecs נתון צמד שניות/nsecs
nsecs_secs(nsecs) - מחזיר חלק שניות שלם נתון nsecs
nsecs_nsecs(nsecs) - מחזיר nsecs שארית נתון nsecs
nsecs_str(nsecs) - מחזיר מחרוזת ניתנת להדפסה בצורה secs.nsecs
avg(total, n) - מחזיר ממוצע בהינתן סכום ומספר כולל של ערכים

השתמש ב-perf-script-python באינטרנט באמצעות שירותי onworks.net