perf-script-python - ക്ലൗഡിൽ ഓൺലൈനായി

പട്ടിക:

NAME

perf-script-python - ഒരു പൈത്തൺ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ട്രെയ്സ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക

സിനോപ്സിസ്

perf സ്ക്രിപ്റ്റ് [-s [പൈത്തൺ]:സ്ക്രിപ്റ്റ്[.py] ]

വിവരണം

പെർഫിന്റെ ബിൽറ്റ്-ഇൻ പൈത്തൺ ഉപയോഗിച്ച് പെർഫ് സ്ക്രിപ്റ്റ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യാൻ ഈ പെർഫ് സ്ക്രിപ്റ്റ് ഓപ്ഷൻ ഉപയോഗിക്കുന്നു
വ്യാഖ്യാതാവ്. ഇത് ഇൻപുട്ട് ഫയൽ വായിക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ട്രേസിന്റെ ഫലങ്ങൾ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു
നൽകിയിരിക്കുന്ന പൈത്തൺ സ്ക്രിപ്റ്റിൽ നടപ്പിലാക്കിയ വിശകലനം, ഉണ്ടെങ്കിൽ.

A ദ്രുത ഉദാഹരണം

പ്രവർത്തിക്കുന്ന പൈത്തൺ സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിക്കുന്ന പ്രക്രിയ, പൂർത്തിയാക്കാൻ ആരംഭിക്കുന്നത് ഈ വിഭാഗം കാണിക്കുന്നു
ഒരു റോ പെർഫ് സ്‌ക്രിപ്റ്റ് സ്‌ട്രീമിൽ നിന്ന് ഉപയോഗപ്രദമായ വിവരങ്ങൾ സമാഹരിച്ച് എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നു. നിങ്ങൾക്ക് ഒഴിവാക്കാം
നിങ്ങൾക്ക് ഒരു ഉദാഹരണം മതിയെങ്കിൽ ഈ പ്രമാണത്തിന്റെ ബാക്കി ഭാഗം വായിക്കുക; ബാക്കിയുള്ളവ
ഡോക്യുമെന്റ് ഓരോ ഘട്ടത്തിലും കൂടുതൽ വിശദാംശങ്ങൾ നൽകുകയും ലഭ്യമായ ലൈബ്രറി ഫംഗ്‌ഷനുകൾ ലിസ്റ്റുചെയ്യുകയും ചെയ്യുന്നു
തിരക്കഥാകൃത്തുക്കൾ.

ഈ ഉദാഹരണം യഥാർത്ഥത്തിൽ സൃഷ്ടിക്കാൻ ഉപയോഗിച്ച ഘട്ടങ്ങളെ വിശദീകരിക്കുന്നു syscal-counts സ്ക്രിപ്റ്റ്
വഴി ലഭ്യമായ perf സ്ക്രിപ്റ്റ് സ്ക്രിപ്റ്റുകൾ ലിസ്റ്റ് ചെയ്യുമ്പോൾ നിങ്ങൾ കാണും perf സ്ക്രിപ്റ്റ് -l. അതുപോലെ, ഇത്
പൊതു-ഉദ്ദേശ്യത്തിന്റെ പട്ടികയിലേക്ക് നിങ്ങളുടെ സ്ക്രിപ്റ്റ് എങ്ങനെ സംയോജിപ്പിക്കാമെന്നും സ്ക്രിപ്റ്റ് കാണിക്കുന്നു perf
സ്ക്രിപ്റ്റ് ആ കമാൻഡ് പ്രകാരം ലിസ്റ്റ് ചെയ്ത സ്ക്രിപ്റ്റുകൾ.

syscal-counts സ്ക്രിപ്റ്റ് ഒരു ലളിതമായ സ്ക്രിപ്റ്റാണ്, എന്നാൽ എല്ലാ അടിസ്ഥാന ആശയങ്ങളും പ്രകടമാക്കുന്നു
ഉപയോഗപ്രദമായ ഒരു സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കാൻ അത്യാവശ്യമാണ്. അതിന്റെ ഔട്ട്‌പുട്ടിന്റെ ഒരു ഉദാഹരണം ഇതാ (syscall പേരുകൾ
ഇതുവരെ പിന്തുണയ്‌ക്കുന്നില്ല, അവ നമ്പറുകളായി ദൃശ്യമാകും):

.അടി സി
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
.ടി

അടിസ്ഥാനപരമായി ഞങ്ങളുടെ ചുമതല ഓരോ സിസ്റ്റത്തിലും അപ്‌ഡേറ്റ് ചെയ്യുന്ന ഓരോ സൈസ്‌കോൾ ടാലി നിലനിർത്തുക എന്നതാണ്
കോൾ സിസ്റ്റത്തിൽ സംഭവിക്കുന്നു. ഞങ്ങളുടെ സ്ക്രിപ്റ്റ് അത് ചെയ്യും, എന്നാൽ ആദ്യം ഞങ്ങൾ ഡാറ്റ രേഖപ്പെടുത്തേണ്ടതുണ്ട്
അത് ആ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് പ്രോസസ്സ് ചെയ്യും. സൈദ്ധാന്തികമായി, നമുക്ക് സാധ്യമായ രണ്ട് വഴികളുണ്ട്
അത്ചെയ്യൂ:

· ട്രെയ്‌സിംഗ്/ഇവന്റ്‌സ്/സിസ്‌കോൾസ് ഡയറക്‌ടറിക്ക് കീഴിലുള്ള എല്ലാ ഇവന്റുകളും നമുക്ക് പ്രവർത്തനക്ഷമമാക്കാം, പക്ഷേ ഇതാണ്
600-ലധികം syscals, perf അനുവദനീയമായ സംഖ്യയ്ക്ക് അപ്പുറം. ഈ വ്യക്തിഗത syscall
എന്നിരുന്നാലും, ഞങ്ങൾക്ക് ലഭിക്കുന്ന മാർഗ്ഗനിർദ്ദേശം പിന്നീട് ഉപയോഗിക്കണമെങ്കിൽ ഇവന്റുകൾ ഉപയോഗപ്രദമാകും
പൊതുവായ-ഉദ്ദേശ്യ സ്ക്രിപ്റ്റുകൾ തുരത്താനും വ്യക്തിഗത സിസ്കോളുകളെ കുറിച്ച് കൂടുതൽ വിശദാംശങ്ങൾ നേടാനും
പലിശ.

· ഞങ്ങൾ sys_enter പ്രവർത്തനക്ഷമമാക്കുക / അല്ലെങ്കിൽ സ്യ്സ്_എക്സിത് സ്യ്സ്ചല്ല്സ് കീഴെ കണ്ടെത്തി കഴിയും
ട്രെയ്‌സിംഗ്/ഇവന്റ്‌സ്/റോ_സിസ്‌കാളുകൾ. എല്ലാ സിസ്‌കോളുകൾക്കും ഇവയെ വിളിക്കുന്നു; ദി id ഫീൽഡ് ആകാം
വ്യക്തിഗത സൈസ്കാൾ നമ്പറുകൾ തമ്മിൽ വേർതിരിച്ചറിയാൻ ഉപയോഗിക്കുന്നു.

ഈ സ്‌ക്രിപ്റ്റിനായി, ഒരു സൈസ്‌കോൾ നൽകിയിട്ടുണ്ടെന്ന് മാത്രമേ നമ്മൾ അറിയേണ്ടതുള്ളൂ; അതെങ്ങനെയെന്നത് ഞങ്ങൾ കാര്യമാക്കുന്നില്ല
പുറത്തുകടന്നു, അതിനാൽ ഞങ്ങൾ ഉപയോഗിക്കും perf റെക്കോര്ഡ് sys_enter ഇവന്റുകൾ മാത്രം രേഖപ്പെടുത്താൻ:

.അടി സി
# perf റെക്കോർഡ് -a -e raw_syscalls:sys_enter

^C[ പെർഫ് റെക്കോർഡ്: ഡാറ്റ എഴുതാൻ 1 തവണ ഉണർന്നു ]
[ പെർഫ് റെക്കോർഡ്: ക്യാപ്‌ചർ ചെയ്‌ത് 56.545 MB perf.data (~2470503 സാമ്പിളുകൾ)]
.ടി

ഓപ്‌ഷനുകൾ അടിസ്ഥാനപരമായി പറയുന്നത് ഓരോ സിസ്‌കോൾ ഇവന്റിനുമുള്ള ഡാറ്റ ശേഖരിക്കാനാണ്
ഓരോ സിപിയു ഔട്ട്‌പുട്ട് ഒരൊറ്റ സ്ട്രീമിലേക്ക് മൾട്ടിപ്ലക്സ് ചെയ്യുക. ആ ഒരൊറ്റ സ്ട്രീം രേഖപ്പെടുത്തും
നിലവിലെ ഡയറക്‌ടറിയിലെ perf.data എന്ന ഫയൽ.

നമ്മുടെ ഡാറ്റ അടങ്ങിയ ഒരു perf.data ഫയൽ ലഭിച്ചുകഴിഞ്ഞാൽ, നമുക്ക് -g ഉപയോഗിക്കാം perf സ്ക്രിപ്റ്റ് ഓപ്ഷൻ
ഓരോ ഇവന്റ് തരത്തിനും ഒരു കോൾബാക്ക് ഹാൻഡ്‌ലർ അടങ്ങിയിരിക്കുന്ന ഒരു പൈത്തൺ സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിക്കുക
perf.data ട്രെയ്സ് സ്ട്രീം (കൂടുതൽ വിവരങ്ങൾക്ക്, STARTER സ്ക്രിപ്റ്റുകൾ വിഭാഗം കാണുക).

.അടി സി
# പെർഫ് സ്ക്രിപ്റ്റ് -ജി പൈത്തൺ
സൃഷ്ടിച്ച പൈത്തൺ സ്ക്രിപ്റ്റ്: perf-script.py

നിലവിലെ ഡയറക്‌ടറിയിൽ സൃഷ്‌ടിച്ച ഔട്ട്‌പുട്ട് ഫയലിനും പേരുണ്ട്
perf-script.py. ഫയൽ പൂർണ്ണമായി ഇതാ:

# പെർഫ് സ്‌ക്രിപ്റ്റ് ഇവന്റ് ഹാൻഡ്‌ലറുകൾ, പെർഫ് സ്‌ക്രിപ്റ്റ് -ജി പൈത്തൺ സൃഷ്ടിച്ചതാണ്
# GNU GPL ലൈസൻസ് പതിപ്പ് 2 ന്റെ നിബന്ധനകൾക്ക് കീഴിൽ ലൈസൻസ് ചെയ്‌തിരിക്കുന്നു

# പൊതുവായ_* ഇവന്റ് ഹാൻഡ്‌ലർ ഫീൽഡുകൾ പൊതുവായുള്ള ഏറ്റവും ഉപയോഗപ്രദമായ ഫീൽഡുകളാണ്
# എല്ലാ ഇവന്റുകളും. അവ 'പൊതുവായ_*' ഫീൽഡുകളുമായി പൊരുത്തപ്പെടണമെന്നില്ല
# ഫോർമാറ്റ് ഫയലുകളിൽ. ഹാൻഡ്‌ലർ പാരാകൾക്ക് കഴിയുന്നതുപോലെ ആ ഫീൽഡുകൾ ലഭ്യമല്ല
കോമൺ_*(സന്ദർഭം) എന്ന ഫോമിന്റെ പൈത്തൺ ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് # വീണ്ടെടുക്കാം.
# ലഭ്യമായ ഫംഗ്‌ഷനുകളുടെ ലിസ്റ്റിനായി perf-script-python ഡോക്യുമെന്റേഷൻ കാണുക.

ഇറക്കുമതി ചെയ്യുക
sys ഇംപോർട്ട് ചെയ്യുക

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

perf_trace_context ഇറക്കുമതിയിൽ നിന്ന് *
പ്രധാന ഇറക്കുമതിയിൽ നിന്ന് *

def trace_begin():
"in trace_begin" എന്ന് അച്ചടിക്കുക

def trace_end():
"trace_end" പ്രിന്റ് ചെയ്യുക

def raw_syscalls__sys_enter(event_name, സന്ദർഭം, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
ഐഡി, ആർഗ്സ്):
print_header(event_name, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)

പ്രിന്റ് "id=%d, args=%s\n" % \
(ഐഡി, ആർഗ്സ്),

def trace_unhandled(event_name, സന്ദർഭം, 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 " % \
(event_name, cpu, secs, nsecs, pid, comm)
.ടി

മുകളിൽ ഒരു കമന്റ് ബ്ലോക്കും അതിനുശേഷം ചില ഇറക്കുമതി പ്രസ്താവനകളും ഒരു പാത്ത് അനുബന്ധവുമാണ്
എല്ലാ perf സ്ക്രിപ്റ്റ് സ്ക്രിപ്റ്റും ഉൾപ്പെടുത്തണം.

അതിനു ശേഷം, ഒരു ജോഡി ജനറേറ്റഡ് ഫംഗ്‌ഷനുകൾ ഉണ്ട്, ട്രെയ്‌സ്_ബെഗിൻ(), ട്രേസ്_എൻഡ്() എന്നിവ
സ്ക്രിപ്റ്റിന്റെ തുടക്കത്തിലും അവസാനത്തിലും യഥാക്രമം വിളിക്കുന്നു (കൂടുതൽ വിവരങ്ങൾക്ക്, കാണുക
താഴെയുള്ള SCRIPT_LAYOUT വിഭാഗം).

താഴെ പറയുന്നവയാണ് സംഭവം ഹാൻഡ്ലർ ഫംഗ്‌ഷനുകൾ ഓരോ ഇവന്റിനും ഒന്ന് സൃഷ്‌ടിക്കുന്നു perf
റെക്കോര്ഡ് ഔട്ട്പുട്ട്. ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനുകൾ ഫോം സബ്‌സിസ്റ്റം എടുക്കുന്നുസംഭവം_പേര്, ഒപ്പം അടങ്ങിയിട്ടുണ്ട് പേരുനൽകിയത്
പരാമീറ്ററുകൾ, ഒന്ന് വേണ്ടി ഓരോന്നും ഫീൽഡ് in The സംഭവം; in ഈ കേസ്, അവിടെ മാത്രം ഒന്ന് ഇവന്റ്,
raw_syscallssys_enter(). (ഇവന്റിനെക്കുറിച്ച് കൂടുതൽ വിവരങ്ങൾക്ക് താഴെയുള്ള ഇവന്റ് ഹാൻഡ്‌ലർമാർ വിഭാഗം കാണുക
കൈകാര്യം ചെയ്യുന്നവർ).

ഫംഗ്‌ഷനുകളുടെ അവസാന ജോടി, ആരംഭ, അവസാന ഫംഗ്‌ഷനുകൾ പോലെ, ഓരോന്നിനും സൃഷ്‌ടിക്കപ്പെട്ടവയാണ്
സ്ക്രിപ്റ്റ്. സ്ക്രിപ്റ്റ് ഒരു ഇവന്റ് കണ്ടെത്തുമ്പോഴെല്ലാം ആദ്യത്തേത്, trace_unhandled(), എന്ന് വിളിക്കപ്പെടുന്നു
സ്ക്രിപ്റ്റിലെ ഏതെങ്കിലും ഇവന്റ് ഹാൻഡ്‌ലറുമായി പൊരുത്തപ്പെടാത്ത perf.data ഫയൽ. ഇത് കഴിഞ്ഞില്ല
ഒന്നുകിൽ റെക്കോർഡ് സ്റ്റെപ്പ് റെക്കോർഡ് ചെയ്‌ത ഇവന്റ് തരങ്ങൾ അതിന് ശരിക്കും താൽപ്പര്യമില്ലാത്തതായി അർത്ഥമാക്കുന്നു,
അല്ലെങ്കിൽ സ്ക്രിപ്റ്റുമായി പൊരുത്തപ്പെടാത്ത ഒരു ട്രേസ് ഫയലിനെതിരെയാണ് സ്ക്രിപ്റ്റ് പ്രവർത്തിക്കുന്നത്.

-g ഓപ്‌ഷൻ സൃഷ്ടിച്ച സ്‌ക്രിപ്റ്റ്, ട്രെയ്‌സിൽ കാണുന്ന ഓരോ ഇവന്റിനും ഒരു ലൈൻ പ്രിന്റ് ചെയ്യുന്നു
സ്ട്രീം അതായത് ഇത് അടിസ്ഥാനപരമായി ഇവന്റിനെയും അതിന്റെ പാരാമീറ്റർ മൂല്യങ്ങളെയും stdout-ലേക്ക് ഡംപ് ചെയ്യുന്നു. ദി
print_header() ഫംഗ്‌ഷൻ ആ ആവശ്യത്തിനായി ഉപയോഗിക്കുന്ന ഒരു യൂട്ടിലിറ്റി ഫംഗ്‌ഷൻ മാത്രമാണ്. നമുക്ക് പേരുമാറ്റാം
സ്ഥിരസ്ഥിതി ഔട്ട്പുട്ട് കാണുന്നതിന് സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക:

.അടി സി
# mv perf-script.py syscall-counts.py
# perf സ്ക്രിപ്റ്റ് -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=
.
.
.
.ടി

തീർച്ചയായും, ഈ സ്ക്രിപ്റ്റിനായി, എല്ലാ ട്രെയ്സ് ഇവന്റും പ്രിന്റ് ചെയ്യാൻ ഞങ്ങൾക്ക് താൽപ്പര്യമില്ല, മറിച്ച്
ഉപയോഗപ്രദമായ രീതിയിൽ അത് സമാഹരിക്കുന്നു. അതിനാൽ അച്ചടിയുമായി ബന്ധപ്പെട്ട എല്ലാ കാര്യങ്ങളും ഞങ്ങൾ ഒഴിവാക്കും
ഞങ്ങൾ ഉപയോഗിക്കാത്ത ട്രെയ്‌സ്_ബെഗിൻ(), ട്രേസ്_അൺഹാൻഡിൽഡ്() ഫംഗ്‌ഷനുകളായി. അത് വിടുന്നു
ഈ മിനിമലിസ്റ്റിക് അസ്ഥികൂടവുമായി ഞങ്ങൾ:

.അടി സി
ഇറക്കുമതി ചെയ്യുക
sys ഇംപോർട്ട് ചെയ്യുക

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

perf_trace_context ഇറക്കുമതിയിൽ നിന്ന് *
പ്രധാന ഇറക്കുമതിയിൽ നിന്ന് *

def trace_end():
"trace_end" പ്രിന്റ് ചെയ്യുക

def raw_syscalls__sys_enter(event_name, സന്ദർഭം, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
ഐഡി, ആർഗ്സ്):
.ടി

Trace_end() ൽ, ഞങ്ങൾ ഫലങ്ങൾ പ്രിന്റ് ചെയ്യും, എന്നാൽ ആദ്യം നമുക്ക് ചില ഫലങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്
പ്രിന്റ് ചെയ്യാന്. അതിനായി നമ്മുടെ sys_enter() ഹാൻഡ്‌ലർ ആവശ്യമായ ടാലിംഗ് നടത്തേണ്ടതുണ്ട്
എല്ലാ സംഭവങ്ങളും കണക്കാക്കുന്നത് വരെ. syscal id ഇൻഡക്‌സ് ചെയ്‌ത ഒരു ഹാഷ് ടേബിൾ അതിനുള്ള ഒരു നല്ല മാർഗമാണ്
ആ വിവരം സംഭരിക്കുക; ഓരോ തവണയും sys_enter() ഹാൻഡ്‌ലർ വിളിക്കുമ്പോൾ, ഞങ്ങൾ ലളിതമായി വർദ്ധിപ്പിക്കും
ആ syscal id ഇൻഡക്‌സ് ചെയ്‌ത ആ ഹാഷ് എൻട്രിയുമായി ബന്ധപ്പെട്ട ഒരു എണ്ണം:

.അടി സി
syscalls = autodict()

ശ്രമിക്കുക:
syscalls[id] += 1
ടൈപ്പ് പിശക് ഒഴികെ:
syscalls[id] = 1
.ടി

സിസ്കാൾസ് ഓട്ടോഡിക്റ്റ് ഒബ്‌ജക്‌റ്റ് ഒരു പ്രത്യേക തരം പൈത്തൺ നിഘണ്ടുവാണ് (ഇതിൽ നടപ്പിലാക്കിയത്
Core.py) അത് പേൾ നടപ്പിലാക്കുന്നു ഓട്ടോവൈവിഫൈയിംഗ് പൈത്തണിലെ ഹാഷുകൾ അതായത് ഓട്ടോവൈവിഫൈയിംഗ്
ഹാഷുകൾ, സൃഷ്‌ടിക്കുന്നതിനുള്ള പ്രശ്‌നങ്ങളിലേക്ക് പോകാതെ തന്നെ നിങ്ങൾക്ക് നെസ്റ്റഡ് ഹാഷ് മൂല്യങ്ങൾ നൽകാം
ഇന്റർമീഡിയറ്റ് ലെവലുകൾ നിലവിലില്ലെങ്കിൽ ഉദാ syscalls[comm][pid][id] = 1 സൃഷ്ടിക്കും
ഇന്റർമീഡിയറ്റ് ഹാഷ് ലെവലുകൾ അവസാനമായി ഹാഷ് എൻട്രിയിലേക്ക് മൂല്യം 1 നൽകുക id (കാരണം
അസൈൻ ചെയ്യുന്ന മൂല്യം ഒരു ഹാഷ് ഒബ്‌ജക്റ്റ് അല്ല, പ്രാരംഭ മൂല്യം നൽകിയിരിക്കുന്നത്
ടൈപ്പ് പിശക് ഒഴിവാക്കൽ. ശരി, പൈത്തണിൽ ഇത് ചെയ്യാൻ ഒരു മികച്ച മാർഗം ഉണ്ടായിരിക്കാം, പക്ഷേ അതാണ്
ഇപ്പോൾ പ്രവർത്തിക്കുന്നു).

ആ കോഡ് raw_syscalls__sys_enter() ഹാൻഡ്‌ലറിലേക്ക് ഇടുന്നത്, ഞങ്ങൾ ഫലപ്രദമായി ഒരു
സിംഗിൾ-ലെവൽ നിഘണ്ടു syscal id-യിൽ കീ ചെയ്‌തിരിക്കുന്നതും മൂല്യങ്ങളായി ഞങ്ങൾ കണക്കാക്കിയ എണ്ണങ്ങളുള്ളതുമാണ്.

print_syscall_totals() ഫംഗ്‌ഷൻ നിഘണ്ടുവിലെ എൻട്രികളിൽ ആവർത്തിക്കുന്നു
ഓരോ എൻട്രിയിലും syscall പേര് അടങ്ങിയ ഒരു ലൈൻ പ്രദർശിപ്പിക്കുന്നു (നിഘണ്ടു കീകളിൽ അടങ്ങിയിരിക്കുന്നു
വിവർത്തനം ചെയ്യുന്ന syscal_name() എന്ന യൂട്ടിൽ ഫംഗ്‌ഷനിലേക്ക് കൈമാറുന്ന syscall ഐഡികൾ
അസംസ്‌കൃത സൈസ്‌കാൾ നമ്പറുകൾ അനുബന്ധ സിസ്‌കോൾ നെയിം സ്‌ട്രിംഗുകളിലേക്കുള്ള). ഔട്ട്പുട്ട് ആണ്
ട്രെയ്‌സിലെ എല്ലാ ഇവന്റുകളും പ്രോസസ്സ് ചെയ്‌ത ശേഷം, വിളിക്കുന്നതിലൂടെ പ്രദർശിപ്പിക്കും
സ്ക്രിപ്റ്റിന്റെ അവസാനം വിളിക്കപ്പെടുന്ന ട്രേസ്_എൻഡ്() ഹാൻഡ്‌ലറിൽ നിന്നുള്ള print_syscall_totals() ഫംഗ്‌ഷൻ
പ്രോസസ്സ് ചെയ്യുന്നു.

മുകളിൽ കാണിച്ചിരിക്കുന്ന ഔട്ട്പുട്ട് ഉത്പാദിപ്പിക്കുന്ന അവസാന സ്ക്രിപ്റ്റ് അതിന്റെ പൂർണ്ണമായി താഴെ കാണിച്ചിരിക്കുന്നു
(syscall_name() സഹായി ഇതുവരെ ലഭ്യമല്ല, നിങ്ങൾക്ക് ഇപ്പോൾ ഐഡികൾ മാത്രം കൈകാര്യം ചെയ്യാൻ കഴിയും):

.അടി സി
ഇറക്കുമതി ചെയ്യുക
sys ഇംപോർട്ട് ചെയ്യുക

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

perf_trace_context ഇറക്കുമതിയിൽ നിന്ന് *
പ്രധാന ഇറക്കുമതിയിൽ നിന്ന് *
ഇറക്കുമതിയിൽ നിന്ന് *

syscalls = autodict()

def trace_end():
print_syscal_totals()

def raw_syscalls__sys_enter(event_name, സന്ദർഭം, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
ഐഡി, ആർഗ്സ്):
ശ്രമിക്കുക:
syscalls[id] += 1
ടൈപ്പ് പിശക് ഒഴികെ:
syscalls[id] = 1

def print_syscall_totals():
for_comm ഒന്നുമല്ലെങ്കിൽ:
"\n%s-നുള്ള syscall ഇവന്റുകൾ:\n\n" % (for_comm),
വേറെ:
"\nസിസ്‌കാൾ ഇവന്റുകൾ:\n\n", പ്രിന്റ് ചെയ്യുക

അച്ചടിക്കുക "%-40s %10s\n" % ("ഇവന്റ്", "എണ്ണം"),
അച്ചടിക്കുക "%-40s %10s\n" % ("------------------------------------------ ---", \
"------------"),

ഐഡിക്ക്, val in sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
വിപരീതം = ശരി):
"%-40s %10d\n" % (syscal_name(id), val) പ്രിന്റ് ചെയ്യുക
.ടി

സ്ക്രിപ്റ്റ് മുമ്പത്തെ പോലെ പ്രവർത്തിപ്പിക്കാം:

# perf സ്ക്രിപ്റ്റ് -s syscall-counts.py

അതിനാൽ ഒരു സ്ക്രിപ്റ്റ് എഴുതുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള അവശ്യ ഘട്ടങ്ങൾ ഇവയാണ്. പ്രക്രിയ ആകാം
നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള ഏതെങ്കിലും ട്രെയ്‌സ് പോയിന്റിലേക്കോ ട്രെയ്‌സ് പോയിന്റുകളിലേക്കോ സാമാന്യവൽക്കരിക്കുക - അടിസ്ഥാനപരമായി കണ്ടെത്തുക
കാണിക്കുന്ന ലഭ്യമായ ഇവന്റുകളുടെ ലിസ്റ്റ് നോക്കി നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള ട്രേസ് പോയിന്റ്(കൾ).
perf പട്ടിക കൂടാതെ/അല്ലെങ്കിൽ വിശദമായ ഇവന്റിനും ഫീൽഡിനുമായി /sys/kernel/debug/tracing events നോക്കുക
വിവരം, ഉപയോഗിച്ച് അനുബന്ധ ട്രേസ് ഡാറ്റ രേഖപ്പെടുത്തുക perf റെക്കോര്ഡ്, ഇത് പട്ടികയിൽ കടന്നു
രസകരമായ സംഭവങ്ങൾ, ഉപയോഗിച്ച് ഒരു അസ്ഥികൂടം സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുക perf സ്ക്രിപ്റ്റ് -g പൈത്തൺ ഒപ്പം പരിഷ്ക്കരിക്കുക
നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്കായി കോഡ് കൂട്ടിച്ചേർക്കാനും പ്രദർശിപ്പിക്കാനും.

നിങ്ങൾ അത് ചെയ്തുകഴിഞ്ഞാൽ, നിങ്ങൾ സൂക്ഷിക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു പൊതു-ഉദ്ദേശ്യ സ്ക്രിപ്റ്റിൽ നിങ്ങൾക്ക് അവസാനിച്ചേക്കാം
ചുറ്റുപാടും ഭാവിയിലെ ഉപയോഗത്തിനായി ലഭ്യമാണ്. വളരെ ലളിതമായ രണ്ട് ഷെൽ സ്ക്രിപ്റ്റുകൾ എഴുതുന്നതിലൂടെ
അവ ശരിയായ സ്ഥലത്ത് വെച്ചാൽ, നിങ്ങളുടെ സ്ക്രിപ്റ്റ് മറ്റൊന്നിനോടൊപ്പം ലിസ്റ്റ് ചെയ്യാവുന്നതാണ്
ലിസ്റ്റ് ചെയ്ത സ്ക്രിപ്റ്റുകൾ perf സ്ക്രിപ്റ്റ് -l കമാൻഡ് ഉദാ:

.അടി സി
റൂട്ട്@ട്രോപിക്കാന:~# പെർഫ് സ്ക്രിപ്റ്റ് -എൽ
ലഭ്യമായ ട്രെയ്സ് സ്ക്രിപ്റ്റുകളുടെ ലിസ്റ്റ്:
വേക്കപ്പ്-ലേറ്റൻസി സിസ്റ്റം-വൈഡ് മിനി/മാക്സ്/എവിജി വേക്കപ്പ് ലേറ്റൻസി
rw-by-file ഒരു പ്രോഗ്രാമിനായുള്ള r/w പ്രവർത്തനം, ഫയൽ വഴി
rw-by-pid സിസ്റ്റം-വൈഡ് r/w പ്രവർത്തനം
.ടി

ഇത് ചെയ്യുന്നതിന്റെ ഒരു നല്ല സൈഡ് ഇഫക്റ്റ്, നിങ്ങൾ ഒരുപക്ഷേ ദൈർഘ്യമേറിയതും പിടിച്ചെടുക്കുന്നു എന്നതാണ് perf
റെക്കോര്ഡ് സ്ക്രിപ്റ്റിനായി ഇവന്റുകൾ രേഖപ്പെടുത്താൻ കമാൻഡ് ആവശ്യമാണ്.

സ്ക്രിപ്റ്റ് എ ആയി ദൃശ്യമാകാൻ അന്തർനിർമ്മിതമാണ് സ്ക്രിപ്റ്റ്, നിങ്ങൾ രണ്ട് ലളിതമായ സ്ക്രിപ്റ്റുകൾ എഴുതുന്നു, ഒന്ന്
റെക്കോർഡിംഗ് കൂടാതെ ഒന്ന് റിപ്പോർട്ടുചെയ്യുന്നു.

ദി റെക്കോര്ഡ് നിങ്ങളുടെ സ്‌ക്രിപ്‌റ്റിന്റെ അതേ അടിസ്ഥാന നാമമുള്ള ഒരു ഷെൽ സ്‌ക്രിപ്റ്റാണ് സ്‌ക്രിപ്റ്റ്
-രേഖ ചേർത്തു. ഷെൽ സ്ക്രിപ്റ്റ് perf/scripts/python/bin എന്നിവയിൽ ഇടണം
കേർണൽ സോഴ്സ് ട്രീയിലെ ഡയറക്ടറി. ആ സ്ക്രിപ്റ്റിൽ, നിങ്ങൾ എഴുതുന്നു perf റെക്കോര്ഡ്
നിങ്ങളുടെ സ്ക്രിപ്റ്റിന് ആവശ്യമായ കമാൻഡ്-ലൈൻ:

.അടി സി
# cat kernel-source/tools/perf/scripts/python/bin/syscall-counts-record

#!/ ബിൻ / ബാഷ്
perf റെക്കോർഡ് -a -e raw_syscalls:sys_enter
.ടി

ദി റിപ്പോർട്ട് നിങ്ങളുടെ സ്‌ക്രിപ്‌റ്റിന്റെ അതേ അടിസ്ഥാന നാമമുള്ള ഒരു ഷെൽ സ്‌ക്രിപ്റ്റ് കൂടിയാണ് സ്‌ക്രിപ്റ്റ്
- റിപ്പോർട്ട് ചേർത്തു. ഇത് perf/scripts/python/bin ഡയറക്ടറിയിലും സ്ഥിതിചെയ്യണം. ഇൻ
ആ സ്ക്രിപ്റ്റ്, നിങ്ങൾ എഴുതുക perf സ്ക്രിപ്റ്റ് -s നിങ്ങളുടെ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നതിന് ആവശ്യമായ കമാൻഡ്-ലൈൻ:

.അടി സി
# cat kernel-source/tools/perf/scripts/python/bin/syscall-counts-report

#!/ ബിൻ / ബാഷ്
# വിവരണം: സിസ്റ്റം-വൈഡ് സൈസ്‌കോൾ കൗണ്ടുകൾ
perf സ്ക്രിപ്റ്റ് -s ~/libexec/perf-core/scripts/python/syscall-counts.py
.ടി

ഷെൽ സ്‌ക്രിപ്റ്റിൽ നൽകിയിരിക്കുന്ന പൈത്തൺ സ്‌ക്രിപ്റ്റിന്റെ ലൊക്കേഷൻ ഇൻ ആണ് എന്നത് ശ്രദ്ധിക്കുക
libexec/perf-core/scripts/python directory - ഇവിടെയാണ് സ്ക്രിപ്റ്റ് പകർത്തുന്നത്
ഉണ്ടാക്കുക ഇൻസ്റ്റാൾ ചെയ്യുക നിങ്ങൾ perf ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ. നിങ്ങളുടെ സ്ക്രിപ്റ്റ് അവിടെ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുള്ള ഇൻസ്റ്റാളേഷനായി,
നിങ്ങളുടെ സ്‌ക്രിപ്റ്റ് കേർണൽ സോഴ്‌സിലെ perf/scripts/python ഡയറക്‌ടറിയിലായിരിക്കണം
വൃക്ഷം:

.അടി സി
# 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 ബിൻ
-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
.ടി

നിങ്ങൾ അത് ചെയ്തുകഴിഞ്ഞാൽ (പുതിയത് ചെയ്യാൻ മറക്കരുത് ഉണ്ടാക്കുക ഇൻസ്റ്റാൾ ചെയ്യുക, അല്ലെങ്കിൽ നിങ്ങളുടെ സ്ക്രിപ്റ്റ് ചെയ്യില്ല
റൺ-ടൈമിൽ കാണിക്കുക) perf സ്ക്രിപ്റ്റ് -l നിങ്ങളുടെ സ്ക്രിപ്റ്റിനായി ഒരു പുതിയ എൻട്രി കാണിക്കണം:

.അടി സി
റൂട്ട്@ട്രോപിക്കാന:~# പെർഫ് സ്ക്രിപ്റ്റ് -എൽ
ലഭ്യമായ ട്രെയ്സ് സ്ക്രിപ്റ്റുകളുടെ ലിസ്റ്റ്:
വേക്കപ്പ്-ലേറ്റൻസി സിസ്റ്റം-വൈഡ് മിനി/മാക്സ്/എവിജി വേക്കപ്പ് ലേറ്റൻസി
rw-by-file ഒരു പ്രോഗ്രാമിനായുള്ള r/w പ്രവർത്തനം, ഫയൽ വഴി
rw-by-pid സിസ്റ്റം-വൈഡ് r/w പ്രവർത്തനം
syscall-counts സിസ്റ്റം-വൈഡ് syscall കൗണ്ടുകൾ
.ടി

നിങ്ങൾക്ക് ഇപ്പോൾ റെക്കോർഡ് ഘട്ടം ഇതിലൂടെ നിർവഹിക്കാൻ കഴിയും perf സ്ക്രിപ്റ്റ് റെക്കോര്ഡ്:

# perf സ്ക്രിപ്റ്റ് റെക്കോർഡ് syscall-counts

ഉപയോഗിച്ച് ഔട്ട്പുട്ട് പ്രദർശിപ്പിക്കുക perf സ്ക്രിപ്റ്റ് റിപ്പോർട്ട്:

# perf സ്ക്രിപ്റ്റ് റിപ്പോർട്ട് syscall-counts

സ്റ്റാർട്ടർ സ്ക്രിപ്റ്റുകൾ

ഒരു പ്രത്യേക ട്രെയ്‌സ് ഡാറ്റയ്‌ക്കായി നിങ്ങൾക്ക് വേഗത്തിൽ സ്‌ക്രിപ്റ്റ് എഴുതാൻ തുടങ്ങാം
ഉപയോഗിച്ച് ഒരു അസ്ഥികൂടം സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുന്നു perf സ്ക്രിപ്റ്റ് -g പൈത്തൺ എന്ന അതേ ഡയറക്ടറിയിൽ
നിലവിലുള്ള perf.data ട്രെയ്സ് ഫയൽ. അത് ഒരു ഹാൻഡ്‌ലർ അടങ്ങിയ ഒരു സ്റ്റാർട്ടർ സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിക്കും
ട്രേസ് ഫയലിലെ ഓരോ ഇവന്റ് തരങ്ങൾക്കും; ഇത് ലഭ്യമായ എല്ലാ ഫീൽഡുകളും പ്രിന്റ് ചെയ്യുന്നു
ട്രേസ് ഫയലിലെ ഓരോ ഇവന്റും.

നിങ്ങൾക്ക് നിലവിലുള്ള സ്ക്രിപ്റ്റുകൾ നോക്കാനും കഴിയും ~/libexec/perf-core/scripts/python വേണ്ടി
ഇവന്റ് ഡാറ്റ സംഗ്രഹിക്കുക, ഫലങ്ങൾ പ്രിന്റ് ചെയ്യുക, തുടങ്ങിയ അടിസ്ഥാന കാര്യങ്ങൾ എങ്ങനെ ചെയ്യാമെന്ന് കാണിക്കുന്ന സാധാരണ ഉദാഹരണങ്ങൾ
കൂടാതെ, ചെക്ക്-പെർഫ്-സ്ക്രിപ്റ്റ്.പൈ സ്ക്രിപ്റ്റ്, അതിന്റെ ഫലങ്ങൾക്ക് താൽപ്പര്യമില്ലെങ്കിലും,
എല്ലാ പ്രധാന സ്ക്രിപ്റ്റിംഗ് സവിശേഷതകളും പ്രയോഗിക്കാൻ ശ്രമിക്കുന്നു.

പരിപാടി കൈകാര്യം ചെയ്യുന്നവർ

ഒരു ട്രേസ് സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് perf സ്ക്രിപ്റ്റ് ആവശ്യപ്പെടുമ്പോൾ, ഒരു ഉപയോക്താവ് നിർവചിച്ചിരിക്കുന്നത് ഹാൻഡ്ലർ ഫംഗ്ഷൻ is
ട്രെയ്‌സിലെ ഓരോ പരിപാടിക്കും വിളിച്ചു. തന്നിരിക്കുന്നവയ്‌ക്കായി നിർവചിച്ചിരിക്കുന്ന ഹാൻഡ്‌ലർ ഫംഗ്‌ഷൻ ഇല്ലെങ്കിൽ
ഇവന്റ് തരം, ഇവന്റ് അവഗണിക്കപ്പെട്ടു (അല്ലെങ്കിൽ എ ട്രേസ്_ഹാൻഡിൽഡ് പ്രവർത്തനം, താഴെ കാണുക) കൂടാതെ
അടുത്ത ഇവന്റ് പ്രോസസ്സ് ചെയ്യുന്നു.

ഇവന്റിന്റെ മിക്ക ഫീൽഡ് മൂല്യങ്ങളും ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനിലേക്ക് ആർഗ്യുമെന്റുകളായി കൈമാറുന്നു; ചിലത്
സാധാരണമല്ലാത്തവ അല്ല - അവ പെർഫ് എക്‌സിക്യൂട്ടബിളിലേക്ക് തിരികെ വിളിക്കുന്ന രീതിയിൽ ലഭ്യമാണ്
(താഴെ നോക്കുക).

ഒരു ഉദാഹരണമായി, എല്ലാ sched_wakeup-ഉം റെക്കോർഡ് ചെയ്യാൻ ഇനിപ്പറയുന്ന perf റെക്കോർഡ് കമാൻഡ് ഉപയോഗിക്കാം
സിസ്റ്റത്തിലെ ഇവന്റുകൾ:

# പെർഫ് റെക്കോർഡ് -എ -ഇ ഷെഡ്:ഷെഡ്_വേക്കപ്പ്

ഒരു സ്‌ക്രിപ്റ്റ് ഉപയോഗിച്ച് പ്രോസസ്സ് ചെയ്യേണ്ട ട്രെയ്‌സുകൾ മുകളിലുള്ള ഓപ്‌ഷൻ ഉപയോഗിച്ച് റെക്കോർഡ് ചെയ്യണം: -a
സിസ്റ്റം-വൈഡ് കളക്ഷൻ പ്രവർത്തനക്ഷമമാക്കാൻ.

sched_wakep ഇവന്റിനായുള്ള ഫോർമാറ്റ് ഫയൽ ഇനിപ്പറയുന്ന ഫീൽഡുകൾ നിർവചിക്കുന്നു (കാണുക
/sys/kernel/debug/tracing/events/sched/sched_wakeup/format):

.അടി സി
ഫോർമാറ്റ്:
ഫീൽഡ്: ഒപ്പിടാത്ത ഹ്രസ്വ പൊതുവായ_തരം;
ഫീൽഡ്: ഒപ്പിടാത്ത ചാർ കോമൺ_ഫ്ലാഗുകൾ;
ഫീൽഡ്: ഒപ്പിടാത്ത char common_preempt_count;
ഫീൽഡ്: int common_pid;

ഫീൽഡ്:char comm[TASK_COMM_LEN];
ഫീൽഡ്:pid_t pid;
ഫീൽഡ്: int prio;
ഫീൽഡ്: ഇൻറ്റ് വിജയം;
ഫീൽഡ്:int target_cpu;
.ടി

ഈ ഇവന്റിനായുള്ള ഹാൻഡ്‌ലർ ഫംഗ്‌ഷൻ ഇനിപ്പറയുന്നതായി നിർവചിക്കപ്പെടും:

.അടി സി
def sched__sched_wakeup(event_name, സന്ദർഭം, common_cpu, common_secs,
common_secs, common_pid, common_comm,
comm, pid, prio, success, target_cpu):
കടന്നുപോകുക
.ടി

ഹാൻഡ്‌ലർ ഫംഗ്‌ഷൻ subsystem__event_name എന്ന ഫോം എടുക്കുന്നു.

ഹാൻഡ്‌ലറുടെ ആർഗ്യുമെന്റ് ലിസ്റ്റിലെ പൊതുവായ_* ആർഗ്യുമെന്റുകൾ കൈമാറിയ ആർഗ്യുമെന്റുകളുടെ കൂട്ടമാണ്
എല്ലാ ഇവന്റ് കൈകാര്യം ചെയ്യുന്നവരും; ചില ഫീൽഡുകൾ ഫോർമാറ്റിലെ പൊതുവായ_* ഫീൽഡുകളുമായി പൊരുത്തപ്പെടുന്നു
ഫയൽ, എന്നാൽ ചിലത് സമന്വയിപ്പിച്ചവയാണ്, ചില പൊതുവായ_* ഫീൽഡുകൾ വേണ്ടത്ര സാധാരണമല്ല
എല്ലാ ഇവന്റുകളിലേക്കും ആർഗ്യുമെന്റുകളായി കൈമാറും എന്നാൽ ലൈബ്രറി ഫംഗ്‌ഷനുകളായി ലഭ്യമാണ്.

മാറ്റമില്ലാത്ത ഇവന്റ് ആർഗുകളുടെ ഒരു ഹ്രസ്വ വിവരണം ഇതാ:

event_ഇവന്റിൻറെ പേര് വാചകമായി നൽകുക
പെർഫിലേക്കുള്ള കോളുകളിൽ ഉപയോഗിക്കുന്ന അതാര്യമായ 'കുക്കി' സന്ദർഭം
common_cpu ദി സിപിയു ഇവന്റ് സംഭവിച്ചു
ഇവന്റ് ടൈംസ്റ്റാമ്പിന്റെ സെക്കൻഡ് ഭാഗം common_secs
ഇവന്റ് ടൈംസ്റ്റാമ്പിന്റെ nsecs ഭാഗം common_nsecs
പൊതുവായ_പിഡ് നിലവിലെ ടാസ്ക്കിന്റെ പിഡ്
common_com നിലവിലെ പ്രക്രിയയുടെ പേര്

ഇവന്റിന്റെ ഫോർമാറ്റ് ഫയലിൽ ശേഷിക്കുന്ന എല്ലാ ഫീൽഡുകൾക്കും ഹാൻഡ്‌ലറായി എതിരാളികളുണ്ട്
മുകളിലെ ഉദാഹരണത്തിൽ കാണാൻ കഴിയുന്ന അതേ പേരിലുള്ള ഫംഗ്ഷൻ ആർഗ്യുമെന്റുകൾ.

a-യിലെ എല്ലാ ഇവന്റുകളുടെയും എല്ലാ ഫീൽഡുകളും നേരിട്ട് ആക്‌സസ് ചെയ്യുന്നതിന് ആവശ്യമായ അടിസ്ഥാനകാര്യങ്ങൾ മുകളിൽ നൽകിയിരിക്കുന്നു
ട്രെയ്സ്, ഉപയോഗപ്രദമായ ഒരു ട്രേസ് സ്ക്രിപ്റ്റ് എഴുതാൻ നിങ്ങൾ അറിഞ്ഞിരിക്കേണ്ട കാര്യങ്ങളുടെ 90% ഉൾക്കൊള്ളുന്നു. ദി
താഴെയുള്ള ഭാഗങ്ങൾ ബാക്കിയുള്ളവ ഉൾക്കൊള്ളുന്നു.

സ്ക്രിപ്റ്റ് ലേഔട്ട്

ഓരോ പെർഫ് സ്ക്രിപ്റ്റും പൈത്തൺ സ്ക്രിപ്റ്റും ഒരു പൈത്തൺ മൊഡ്യൂൾ സെർച്ച് പാത്ത് സജ്ജീകരിച്ച് ആരംഭിക്കണം
കുറച്ച് പിന്തുണ മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യുന്നു (ചുവടെയുള്ള മൊഡ്യൂൾ വിവരണങ്ങൾ കാണുക):

.അടി സി
ഇറക്കുമതി ചെയ്യുക
sys ഇംപോർട്ട് ചെയ്യുക

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

perf_trace_context ഇറക്കുമതിയിൽ നിന്ന് *
പ്രധാന ഇറക്കുമതിയിൽ നിന്ന് *
.ടി

ബാക്കിയുള്ള സ്‌ക്രിപ്റ്റിൽ ഏത് ക്രമത്തിലും ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനുകളും പിന്തുണാ പ്രവർത്തനങ്ങളും അടങ്ങിയിരിക്കാം.

മുകളിൽ ചർച്ച ചെയ്ത ഇവന്റ് ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനുകൾ ഒഴികെ, ഓരോ സ്‌ക്രിപ്റ്റിനും ഒരു സെറ്റ് നടപ്പിലാക്കാൻ കഴിയും
ഓപ്ഷണൽ ഫംഗ്ഷനുകളുടെ:

ട്രേസ്_ആരംഭം, നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, ഏതെങ്കിലും ഇവന്റ് പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് വിളിക്കുകയും സ്ക്രിപ്റ്റുകൾ നൽകുകയും ചെയ്യുന്നു a
സജ്ജീകരണ ജോലികൾ ചെയ്യാനുള്ള അവസരം:

.അടി സി
def trace_begin:
കടന്നുപോകുക
.ടി

ട്രെയ്സ്_എൻഡ്, നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, എല്ലാ ഇവന്റുകളും പ്രോസസ്സ് ചെയ്തതിന് ശേഷം വിളിക്കുകയും സ്ക്രിപ്റ്റുകൾ നൽകുകയും ചെയ്യുന്നു a
ഡിസ്പ്ലേ ഫലങ്ങൾ പോലുള്ള എൻഡ്-ഓഫ്-സ്ക്രിപ്റ്റ് ടാസ്ക്കുകൾ ചെയ്യാനുള്ള അവസരം:

.അടി സി
def trace_end:
കടന്നുപോകുക
.ടി

കൈകാര്യം ചെയ്യാത്തത്, നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, ഒരു ഹാൻഡ്‌ലർ ഇല്ലാത്ത ഏതെങ്കിലും ഇവന്റിന് ശേഷം വിളിക്കപ്പെടും
അതിനായി വ്യക്തമായി നിർവചിച്ചിരിക്കുന്നു. സാധാരണ ആർഗ്യുമെന്റുകളുടെ സ്റ്റാൻഡേർഡ് സെറ്റ് ഇതിലേക്ക് കടന്നുപോകുന്നു:

.അടി സി
def trace_unhandled(event_name, സന്ദർഭം, common_cpu, common_secs,
common_secs, common_pid, common_comm):
കടന്നുപോകുക
.ടി

ശേഷിക്കുന്ന വിഭാഗങ്ങൾ ലഭ്യമായ ബിൽറ്റ്-ഇൻ പെർഫ് സ്ക്രിപ്റ്റിന്റെ വിവരണങ്ങൾ നൽകുന്നു
പൈത്തൺ മൊഡ്യൂളുകളും അവയുടെ അനുബന്ധ പ്രവർത്തനങ്ങളും.

ലഭ്യമാണ് ഘടകങ്ങൾ ഒപ്പം പ്രവർത്തനങ്ങൾ

ഇനിപ്പറയുന്ന വിഭാഗങ്ങൾ വിവിധ പെർഫുകൾ വഴി ലഭ്യമായ ഫംഗ്ഷനുകളും വേരിയബിളുകളും വിവരിക്കുന്നു
സ്ക്രിപ്റ്റ് പൈത്തൺ മൊഡ്യൂളുകൾ. നൽകിയിരിക്കുന്ന മൊഡ്യൂളിൽ നിന്നുള്ള ഫംഗ്ഷനുകളും വേരിയബിളുകളും ഉപയോഗിക്കുന്നതിന്, ചേർക്കുക
അനുബന്ധം നിന്ന് XXXX എന്ന ഇറക്കുമതി നിങ്ങളുടെ പെർഫ് സ്ക്രിപ്റ്റ് സ്ക്രിപ്റ്റിലേക്കുള്ള വരി.

Core.py മൊഡ്യൂൾ
ഈ ഫംഗ്‌ഷനുകൾ ഉപയോക്തൃ സ്‌ക്രിപ്റ്റുകൾക്ക് ചില അവശ്യ പ്രവർത്തനങ്ങൾ നൽകുന്നു.

ദി പതാക_str ഒപ്പം ചിഹ്നം_str ഫംഗ്‌ഷനുകൾ പതാകയ്‌ക്കും പ്രതീകാത്മകതയ്‌ക്കും മനുഷ്യർക്ക് വായിക്കാവുന്ന സ്ട്രിംഗുകൾ നൽകുന്നു
വയലുകൾ. ഇവയിൽ നിന്ന് പാഴ്‌സ് ചെയ്ത സ്ട്രിംഗുകളോടും മൂല്യങ്ങളോടും യോജിക്കുന്നു അച്ചടിക്കുക fmt യുടെ വയലുകൾ
ഇവന്റ് ഫോർമാറ്റ് ഫയലുകൾ:

flag_str(event_name, field_name, field_value) - event_name-ന്റെ ഫ്ലാഗ് ഫീൽഡ് ഫീൽഡ്_നാമത്തിനായി ഫീൽഡ്_വാല്യൂവിന് അനുയോജ്യമായ സ്ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നു
symbol_str(event_name, field_name, field_value) - event_name-ന്റെ പ്രതീകാത്മക ഫീൽഡ് ഫീൽഡ്_നാമത്തിനായി field_value-യുമായി ബന്ധപ്പെട്ട സ്ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നു

ദി ഓട്ടോഡിക്റ്റ് ഫംഗ്‌ഷൻ പേൾ നടപ്പിലാക്കുന്ന ഒരു പ്രത്യേക തരം പൈത്തൺ നിഘണ്ടു നൽകുന്നു
ഓട്ടോവൈവിഫൈയിംഗ് പൈത്തണിലെ ഹാഷുകൾ അതായത് ഓട്ടോവൈവിഫൈയിംഗ് ഹാഷുകൾ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് നെസ്റ്റഡ് ഹാഷ് നൽകാം
മൂല്യങ്ങൾ ഇല്ലെങ്കിൽ ഇന്റർമീഡിയറ്റ് ലെവലുകൾ സൃഷ്‌ടിക്കുന്ന പ്രശ്‌നത്തിലേക്ക് പോകേണ്ടതില്ല
നിലനിൽക്കുന്നു.

autodict() - ഒരു ഓട്ടോവൈവിഫൈയിംഗ് നിഘണ്ടു ഉദാഹരണം നൽകുന്നു

perf_trace_context മൊഡ്യൂൾ
ചില സാധാരണ ഇവന്റ് ഫോർമാറ്റ് ഫയലിലെ ഫീൽഡുകൾ അത്ര സാധാരണമല്ല, പക്ഷേ അത് ആവശ്യമാണ്
എന്നിരുന്നാലും ഉപയോക്തൃ സ്ക്രിപ്റ്റുകൾക്ക് ആക്സസ് ചെയ്യാവുന്നതാണ്.

perf_trace_context എന്നത് ഈ ഡാറ്റ ആക്‌സസ് ചെയ്യാൻ ഉപയോഗിക്കാവുന്ന ഒരു കൂട്ടം ഫംഗ്‌ഷനുകൾ നിർവ്വചിക്കുന്നു
നിലവിലെ സംഭവത്തിന്റെ സന്ദർഭം. ഈ ഫംഗ്‌ഷനുകൾ ഓരോന്നും ഒരു സന്ദർഭ വേരിയബിൾ പ്രതീക്ഷിക്കുന്നു, അതായത്
രണ്ടാമത്തെ ആർഗ്യുമെന്റായി എല്ലാ ഇവന്റ് ഹാൻഡ്‌ലറുകളിലേക്കും സന്ദർഭ വേരിയബിൾ കടന്നുപോകുന്നത് പോലെ തന്നെ.

common_pc(context) - നിലവിലെ ഇവന്റിനായുള്ള common_preempt എണ്ണം നൽകുന്നു
common_flags(സന്ദർഭം) - നിലവിലെ ഇവന്റിനായി common_flags നൽകുന്നു
common_lock_depth(context) - നിലവിലെ ഇവന്റിനായി common_lock_depth നൽകുന്നു

Util.py മൊഡ്യൂൾ
പെർഫ് സ്ക്രിപ്റ്റിനൊപ്പം ഉപയോഗിക്കുന്നതിനുള്ള വിവിധ യൂട്ടിലിറ്റി ഫംഗ്ഷനുകൾ:

nsecs(secs, nsecs) - നൽകിയിട്ടുള്ള ആകെ nsecs സെക്കൻഡ്/എൻസെക്കുകൾ ജോഡി നൽകുന്നു
nsecs_secs(nsecs) - NSecs നൽകിയ മുഴുവൻ സെക്കന്റ് ഭാഗവും നൽകുന്നു
nsecs_nsecs(nsecs) - നൽകിയ nsecs ബാക്കിയുള്ള nsecs നൽകുന്നു
nsecs_str(nsecs) - secs.nsecs എന്ന രൂപത്തിൽ പ്രിന്റ് ചെയ്യാവുന്ന സ്ട്രിംഗ് നൽകുന്നു
avg(ആകെ, n) - ഒരു തുകയും മൂല്യങ്ങളുടെ ആകെ സംഖ്യയും നൽകിയ ശരാശരി നൽകുന്നു

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് perf-script-python ഓൺലൈനായി ഉപയോഗിക്കുക