perf-script-python - Online sa Cloud

PROGRAMA:

NAME

perf-script-python - Iproseso ang trace data gamit ang Python script

SINOPSIS

perpekto script [-s [Python]:script[.py] ]

DESCRIPTION

Ang opsyong perf script na ito ay ginagamit upang iproseso ang data ng perf script gamit ang built-in na Python ng perf
interpreter. Binabasa at pinoproseso nito ang input file at ipinapakita ang mga resulta ng bakas
pagsusuri na ipinatupad sa ibinigay na script ng Python, kung mayroon man.

A Mabilis Halimbawa

Ipinapakita ng seksyong ito ang proseso, simula hanggang matapos, ng paggawa ng gumaganang Python script na
pinagsasama-sama at kinukuha ang kapaki-pakinabang na impormasyon mula sa isang raw perf script stream. Maaari mong iwasan
pagbabasa ng natitirang bahagi ng dokumentong ito kung sapat na para sa iyo ang isang halimbawa; ang natitira sa
Ang dokumento ay nagbibigay ng higit pang mga detalye sa bawat hakbang at naglilista ng mga function ng library na magagamit
mga manunulat ng iskrip.

Ang halimbawang ito ay talagang nagdedetalye ng mga hakbang na ginamit upang lumikha ng syscall-counts script
makikita mo kapag inilista mo ang mga magagamit na script ng perf script sa pamamagitan ng perpekto script -l. Tulad nito, ito
Ipinapakita rin ng script kung paano isama ang iyong script sa listahan ng pangkalahatang layunin perpekto
script mga script na nakalista sa command na iyon.

Ang script ng syscall-counts ay isang simpleng script, ngunit ipinapakita ang lahat ng mga pangunahing ideya
kinakailangan upang lumikha ng isang kapaki-pakinabang na script. Narito ang isang halimbawa ng output nito (ang mga pangalan ng syscall ay
hindi pa sinusuportahan, lalabas ang mga ito bilang mga numero):

.ft C
mga kaganapan sa syscall:

bilang ng kaganapan
--------------------------------------- ----------- -
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_setimer 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

Karaniwang ang aming gawain ay panatilihin ang isang per-syscall tally na naa-update sa tuwing may isang system
Ang tawag ay nangyayari sa system. Gagawin iyon ng aming script, ngunit kailangan muna naming i-record ang data
na ipoproseso ng script na iyon. Sa teoryang, may ilang mga paraan na magagawa natin
gawin mo yan:

· maaari naming paganahin ang bawat kaganapan sa ilalim ng direktoryo ng pagsubaybay/mga kaganapan/syscalls, ngunit ito ay
higit sa 600 syscalls, higit pa sa bilang na pinapayagan ng perf. Ang mga indibidwal na syscall na ito
gayunpaman ay magiging kapaki-pakinabang ang mga kaganapan kung gusto nating gamitin sa ibang pagkakataon ang patnubay na makukuha natin mula sa
pangkalahatang layunin na mga script upang mag-drill down at makakuha ng higit pang detalye tungkol sa mga indibidwal na syscall ng
interes.

· maaari naming paganahin ang sys_enter at/o sys_exit syscall na makikita sa ilalim
pagsubaybay/mga kaganapan/raw_syscalls. Ang mga ito ay tinatawag para sa lahat ng syscall; ang id field ay maaaring
ginagamit upang makilala sa pagitan ng mga indibidwal na numero ng syscall.

Para sa script na ito, kailangan lang nating malaman na may ipinasok na syscall; wala kaming pakialam kung paano ito
lumabas, kaya gagamitin namin perpekto talaan upang itala lamang ang mga kaganapan sa sys_enter:

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

^C[ perf record: Nagising ng 1 beses para magsulat ng data ]
[ perf record: Nakuha at nagsulat ng 56.545 MB perf.data (~2470503 sample) ]
.ft

Karaniwang sinasabi ng mga opsyon na mangolekta ng data para sa bawat syscall event sa buong system at
multiplex ang per-cpu output sa iisang stream. Ire-record ang solong stream na iyon
isang file sa kasalukuyang direktoryo na tinatawag na perf.data.

Kapag mayroon na kaming perf.data file na naglalaman ng aming data, magagamit namin ang -g perpekto script pagpipilian sa
bumuo ng script ng Python na maglalaman ng callback handler para sa bawat uri ng kaganapan na makikita sa
ang perf.data trace stream (para sa higit pang mga detalye, tingnan ang seksyong STARTER SCRIPTS).

.ft C
# perf script -g python
nabuong Python script: perf-script.py

Ang output file na nilikha din sa kasalukuyang direktoryo ay pinangalanan
perf-script.py. Narito ang file sa kabuuan nito:

# perf script event handler, na binuo ng perf script -g python
# Licensed sa ilalim ng mga tuntunin ng GNU GPL License version 2

# Ang common_* event handler field ay ang pinakakapaki-pakinabang na field na karaniwan sa
# lahat ng kaganapan. Hindi kinakailangang tumutugma ang mga ito sa mga field na 'common_*'
# sa mga format na file. Hindi available ang mga field na iyon gaya ng kaya ng mga handler params
# ay makukuha gamit ang Python function ng form na common_*(context).
# Tingnan ang perf-script-python Documentation para sa listahan ng mga magagamit na function.

i-import ka
import sys

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

mula sa perf_trace_context import *
mula sa Core import *

def trace_begin():
i-print ang "in trace_begin"

def trace_end():
i-print ang "sa trace_end"

def raw_syscalls__sys_enter(pangalan_kaganapan, konteksto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, args):
print_header(pangalan_kaganapan, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)

print "id=%d, args=%s\n" % \
(id, args),

def trace_unhandled(pangalan_kaganapan, konteksto, common_cpu, common_secs, common_nsecs,
common_pid, common_comm):
print_header(pangalan_kaganapan, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)

def print_header(pangalan_kaganapan, cpu, secs, nsecs, pid, comm):
print "%-20s %5u %05u.%09u %8u %-20s " % \
(pangalan_kaganapan, cpu, secs, nsecs, pid, comm),
.ft

Sa itaas ay isang bloke ng komento na sinusundan ng ilang mga pahayag sa pag-import at isang path na nakadugtong kung saan
dapat isama ang bawat script ng perf script.

Kasunod nito ay ang ilang nabuong function, trace_begin() at trace_end(), which are
tinatawag sa simula at dulo ng script ayon sa pagkakabanggit (para sa higit pang mga detalye, tingnan ang
SCRIPT_LAYOUT seksyon sa ibaba).

Ang mga sumusunod ay ang pangyayari Handler mga function na nakabuo ng isa para sa bawat kaganapan sa perpekto
talaan output. Ang mga function ng handler ay nasa form na subsystempangalan ng pangyayari, at may pinangalanan
mga parameter, isa para bawat parang in ang kaganapan; in ito kaso, mayroon lamang isa kaganapan,
raw_syscallssys_enter(). (tingnan ang seksyong EVENT HANDLERS sa ibaba para sa higit pang impormasyon sa kaganapan
mga humahawak).

Ang huling pares ng mga function ay, tulad ng simula at end function, na nabuo para sa bawat
iskrip. Ang una, trace_unhandled(), ay tinatawag sa tuwing makakahanap ang script ng isang kaganapan sa
ang perf.data file na hindi tumutugma sa anumang event handler sa script. Ito ay maaaring
ibig sabihin, ang record step ay nagtala ng mga uri ng kaganapan na hindi talaga ito interesado,
o ang script ay pinatakbo laban sa isang trace file na hindi tumutugma sa script.

Ang script na binuo ng -g na opsyon ay nagpi-print lamang ng isang linya para sa bawat kaganapan na makikita sa bakas
stream ie karaniwang itinatambak lang nito ang kaganapan at ang mga halaga ng parameter nito sa stdout. Ang
print_header() function ay simpleng utility function na ginagamit para sa layuning iyon. Palitan natin ang pangalan
ang script at patakbuhin ito upang makita ang default na output:

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

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

Siyempre, para sa script na ito, hindi kami interesado sa pag-print ng bawat trace na kaganapan, ngunit sa halip
pagsasama-sama nito sa isang kapaki-pakinabang na paraan. Kaya aalisin din namin ang lahat ng gagawin sa pag-print
bilang trace_begin() at trace_unhandled() function, na hindi namin gagamitin. Aalis yan
sa amin na may ganitong minimalistic na balangkas:

.ft C
i-import ka
import sys

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

mula sa perf_trace_context import *
mula sa Core import *

def trace_end():
i-print ang "sa trace_end"

def raw_syscalls__sys_enter(pangalan_kaganapan, konteksto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, args):
.ft

Sa trace_end(), ipi-print lang namin ang mga resulta, ngunit kailangan muna naming bumuo ng ilang mga resulta
upang i-print. Upang magawa iyon, kailangan nating ipagawa sa ating sys_enter() handler ang kinakailangang tallying
hanggang sa mabilang ang lahat ng pangyayari. Ang hash table na na-index ng syscall id ay isang magandang paraan upang
mag-imbak ng impormasyong iyon; sa tuwing tinatawag ang sys_enter() handler, dinadagdagan lang namin
isang bilang na nauugnay sa hash entry na iyon na na-index ng syscall id na iyon:

.ft C
syscalls = autodict()

subukan:
syscalls[id] += 1
maliban sa TypeError:
syscalls[id] = 1
.ft

Ang syscalls autodict object ay isang espesyal na uri ng Python dictionary (ipinatupad sa
Core.py) na nagpapatupad ng Perl's autovivifying hash sa Python ibig sabihin, may autovivifying
mga hash, maaari kang magtalaga ng mga nested hash value nang hindi nahihirapang gumawa
mga intermediate na antas kung wala ang mga ito hal. syscalls[comm][pid][id] = 1 ay lilikha ng
mga intermediate na antas ng hash at sa wakas ay italaga ang value 1 sa hash entry para sa id (kasi
ang value na itinatalaga ay hindi hash object mismo, ang inisyal na value ay itinalaga sa
TypeError exception. Well, maaaring mayroong isang mas mahusay na paraan upang gawin ito sa Python ngunit iyon ay kung ano
gumagana sa ngayon).

Ang paglalagay ng code na iyon sa raw_syscalls__sys_enter() handler, epektibo tayong napupunta sa isang
single-level na diksyunaryo na naka-key sa syscall id at pagkakaroon ng mga bilang na aming na-tally bilang mga halaga.

Ang print_syscall_totals() function ay umuulit sa mga entry sa diksyunaryo at
nagpapakita ng linya para sa bawat entry na naglalaman ng pangalan ng syscall (ang mga key ng diksyunaryo ay naglalaman ng
ang mga syscall id, na ipinapasa sa Util function na syscall_name(), na nagsasalin
ang mga raw syscall na numero sa kaukulang mga string ng pangalan ng syscall). Ang output ay
ipinapakita pagkatapos maproseso ang lahat ng mga kaganapan sa bakas, sa pamamagitan ng pagtawag sa
print_syscall_totals() function mula sa trace_end() handler na tinatawag sa dulo ng script
pagpoproseso.

Ang huling script na gumagawa ng output na ipinakita sa itaas ay ipinapakita sa kabuuan nito sa ibaba
(syscall_name() helper ay hindi pa magagamit, maaari mo lamang harapin ang mga id sa ngayon):

.ft C
i-import ka
import sys

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

mula sa perf_trace_context import *
mula sa Core import *
mula sa Util import *

syscalls = autodict()

def trace_end():
print_syscall_totals()

def raw_syscalls__sys_enter(pangalan_kaganapan, konteksto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, args):
subukan:
syscalls[id] += 1
maliban sa TypeError:
syscalls[id] = 1

def print_syscall_totals():
kung ang for_comm ay hindi Wala:
i-print ang "\nsyscall na mga kaganapan para sa %s:\n\n" % (for_comm),
kung hindi:
i-print ang "\nsyscall events:\n\n",

i-print ang "%-40s %10s\n" % ("kaganapan", "bilang"),
i-print ang "%-40s %10s\n" % ("------------------------------------- ---", \
"-----------"),

para sa id, val in sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
baligtad = True):
i-print ang "%-40s %10d\n" % (syscall_name(id), val),
.ft

Ang script ay maaaring patakbuhin tulad ng dati:

# perf script -s syscall-counts.py

Kaya iyon ang mga mahahalagang hakbang sa pagsulat at pagpapatakbo ng isang script. Ang proseso ay maaaring
pangkalahatan sa anumang tracepoint o hanay ng mga tracepoint na interesado ka - karaniwang hanapin
ang (mga) tracepoint na interesado ka sa pamamagitan ng pagtingin sa listahan ng mga available na kaganapan na ipinakita ni
perpekto listahan at/o tumingin sa /sys/kernel/debug/tracing na mga kaganapan para sa detalyadong kaganapan at field
impormasyon, itala ang kaukulang trace data gamit ang perpekto talaan, ipinapasa ito sa listahan ng
kawili-wiling mga kaganapan, bumuo ng isang skeleton script gamit perpekto script -g python at baguhin ang
code upang pagsama-samahin at ipakita ito para sa iyong mga partikular na pangangailangan.

Pagkatapos mong gawin iyon, maaari kang magkaroon ng pangkalahatang layunin na script na gusto mong panatilihin
sa paligid at magagamit para magamit sa hinaharap. Sa pamamagitan ng pagsulat ng ilang napakasimpleng shell script
at paglalagay ng mga ito sa tamang lugar, maaari mong ilista ang iyong script sa tabi ng isa
mga script na nakalista ng perpekto script -l utos hal:

.ft C
ugat@tropicana:~# perf script -l
Listahan ng mga available na trace script:
wakeup-latency system-wide min/max/avg wakeup latency
rw-by-file r/w aktibidad para sa isang programa, sa pamamagitan ng file
rw-by-pid system-wide r/w aktibidad
.ft

Ang isang magandang side effect ng paggawa nito ay nakuha mo rin ang malamang na mahaba perpekto
talaan utos na kailangan upang maitala ang mga kaganapan para sa script.

Upang ipakita ang script bilang a built-in script, sumulat ka ng dalawang simpleng script, isa para sa
recording at isa para sa -uulat.

Ang talaan Ang script ay isang shell script na may parehong base name gaya ng iyong script, ngunit may
-record na idinagdag. Ang script ng shell ay dapat ilagay sa perf/scripts/python/bin
direktoryo sa kernel source tree. Sa script na iyon, isulat mo ang perpekto talaan
command-line na kailangan para sa iyong script:

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

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

Ang ulat Ang script ay isa ring shell script na may parehong base na pangalan gaya ng iyong script, ngunit may
-ulat na idinagdag. Dapat din itong matatagpuan sa direktoryo ng perf/scripts/python/bin. Sa
ang script na iyon, isulat mo ang perpekto script -s command-line na kailangan para sa pagpapatakbo ng iyong script:

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

#!/ basahan / bash
# paglalarawan: mga bilang ng syscall sa buong system
perf script -s ~/libexec/perf-core/scripts/python/syscall-counts.py
.ft

Tandaan na ang lokasyon ng script ng Python na ibinigay sa script ng shell ay nasa
libexec/perf-core/scripts/python directory - dito kokopyahin ang script ng
gumawa install kapag nag-install ka ng perf. Para sa pag-install upang mai-install ang iyong script doon,
ang iyong script ay kailangang matatagpuan sa perf/scripts/python directory sa kernel source
puno:

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

root@tropicana:/home/trz/src/tip# ls -al tools/perf/scripts/python
Kabuuang 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

Kapag nagawa mo na iyon (huwag kalimutang gumawa ng bago gumawa install, kung hindi, ang iyong script ay hindi
ipakita sa run-time), perpekto script -l dapat magpakita ng bagong entry para sa iyong script:

.ft C
ugat@tropicana:~# perf script -l
Listahan ng mga available na trace script:
wakeup-latency system-wide min/max/avg wakeup latency
rw-by-file r/w aktibidad para sa isang programa, sa pamamagitan ng file
rw-by-pid system-wide r/w aktibidad
syscall-counts system-wide syscall counts
.ft

Maaari mo na ngayong isagawa ang record step sa pamamagitan ng perpekto script talaan:

# perf script record syscall-counts

at ipakita ang output gamit perpekto script ulat:

# perf script report syscall-counts

Starter KASULATAN

Mabilis kang makakapagsimulang magsulat ng script para sa isang partikular na hanay ng trace data sa pamamagitan ng
pagbuo ng skeleton script gamit ang perpekto script -g python sa parehong direktoryo bilang isang
umiiral na perf.data trace file. Bubuo iyon ng starter script na naglalaman ng handler
para sa bawat isa sa mga uri ng kaganapan sa trace file; ito ay nagpi-print lamang ng bawat magagamit na field para sa
bawat kaganapan sa trace file.

Maaari mo ring tingnan ang mga kasalukuyang script sa ~/libexec/perf-core/scripts/python para
karaniwang mga halimbawa na nagpapakita kung paano gawin ang mga pangunahing bagay tulad ng pinagsama-samang data ng kaganapan, mga resulta ng pag-print,
atbp. Gayundin, ang check-perf-script.py script, habang hindi kawili-wili para sa mga resulta nito,
sumusubok na gamitin ang lahat ng pangunahing tampok ng scripting.

EVENT MGA HANDLERS

Kapag ang perf script ay na-invoke gamit ang isang trace script, isang user-defined Handler tungkulin is
tinawag para sa bawat kaganapan sa bakas. Kung walang function ng handler na tinukoy para sa isang naibigay
uri ng kaganapan, binabalewala ang kaganapan (o ipinasa sa a trace_handled function, tingnan sa ibaba) at
ang susunod na kaganapan ay naproseso.

Karamihan sa mga value ng field ng kaganapan ay ipinapasa bilang mga argumento sa function ng handler; ilan sa
ang hindi gaanong karaniwan ay hindi - available ang mga iyon bilang mga tawag pabalik sa perf executable
(tingnan sa ibaba).

Bilang halimbawa, maaaring gamitin ang sumusunod na perf record command para i-record ang lahat ng sched_wakeup
mga kaganapan sa system:

# perf record -a -e sched:sched_wakeup

Ang mga bakas na sinadya upang iproseso gamit ang isang script ay dapat na naitala gamit ang opsyon sa itaas: -a
upang paganahin ang koleksyon sa buong sistema.

Tinutukoy ng format na file para sa kaganapang sched_wakep ang mga sumusunod na field (tingnan ang
/sys/kernel/debug/tracing/events/sched/sched_wakeup/format):

.ft C
format:
field:unsigned short common_type;
field:unsigned char common_flags;
field:unsigned char common_preempt_count;
field:int common_pid;

field:char comm[TASK_COMM_LEN];
field:pid_t pid;
field:int prio;
field:int tagumpay;
field:int target_cpu;
.ft

Ang handler function para sa kaganapang ito ay tutukuyin bilang:

.ft C
def sched__sched_wakeup(pangalan_kaganapan, konteksto, common_cpu, common_secs,
common_nsecs, common_pid, common_comm,
comm, pid, prio, tagumpay, target_cpu):
pumasa
.ft

Kinukuha ng handler function ang form na subsystem__event_name.

Ang common_* na mga argumento sa listahan ng argumento ng handler ay ang hanay ng mga argumento na ipinasa sa
lahat ng mga tagapangasiwa ng kaganapan; ang ilan sa mga field ay tumutugma sa common_* na mga field sa format
file, ngunit ang ilan ay na-synthesize, at ang ilan sa mga common_* na mga patlang ay hindi pangkaraniwan para sa
maipapasa sa bawat kaganapan bilang mga argumento ngunit magagamit bilang mga function ng library.

Narito ang isang maikling paglalarawan ng bawat isa sa mga hindi nagbabagong argumento ng kaganapan:

event_name ang pangalan ng event bilang text
konteksto isang opaque na 'cookie' na ginagamit sa mga tawag pabalik sa perf
common_cpu ang cpu kung saan naganap ang kaganapan
common_secs ang secs na bahagi ng timestamp ng event
common_nsecs ang nsecs na bahagi ng timestamp ng event
common_pid ang pid ng kasalukuyang gawain
common_comm ang pangalan ng kasalukuyang proseso

Ang lahat ng natitirang mga patlang sa format ng file ng kaganapan ay may mga katapat bilang tagapangasiwa
function arguments ng parehong pangalan, tulad ng makikita sa halimbawa sa itaas.

Ang nasa itaas ay nagbibigay ng mga pangunahing kailangan para direktang ma-access ang bawat field ng bawat kaganapan sa a
trace, na sumasaklaw sa 90% ng kailangan mong malaman para makapagsulat ng kapaki-pakinabang na trace script. Ang
ang mga seksyon sa ibaba ay sumasaklaw sa iba pa.

sCRIPT Layout

Ang bawat perf script na Python script ay dapat magsimula sa pamamagitan ng pag-set up ng Python module search path at
'pag-import' ng ilang mga module ng suporta (tingnan ang mga paglalarawan ng module sa ibaba):

.ft C
i-import ka
import sys

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

mula sa perf_trace_context import *
mula sa Core import *
.ft

Ang natitirang bahagi ng script ay maaaring maglaman ng mga function ng handler at mga function ng suporta sa anumang pagkakasunud-sunod.

Bukod sa mga function ng handler ng kaganapan na tinalakay sa itaas, ang bawat script ay maaaring magpatupad ng isang set
ng mga opsyonal na function:

trace_begin, kung tinukoy, ay tinatawag bago ang anumang kaganapan ay naproseso at nagbibigay ng mga script a
pagkakataong gawin ang mga gawain sa pag-setup:

.ft C
def trace_begin:
pumasa
.ft

trace_end, kung tinukoy, ay tinatawag pagkatapos maproseso ang lahat ng mga kaganapan at magbigay ng mga script a
pagkakataong gumawa ng mga end-of-script na gawain, tulad ng mga resulta ng pagpapakita:

.ft C
def trace_end:
pumasa
.ft

trace_unhandled, kung tinukoy, ay tinatawag pagkatapos para sa anumang kaganapan na walang handler
tahasang tinukoy para dito. Ang karaniwang hanay ng mga karaniwang argumento ay ipinapasa dito:

.ft C
def trace_unhandled(pangalan_kaganapan, konteksto, common_cpu, common_secs,
common_nsecs, common_pid, common_comm):
pumasa
.ft

Ang natitirang mga seksyon ay nagbibigay ng mga paglalarawan ng bawat isa sa mga magagamit na built-in na perf script
Mga module ng Python at ang mga nauugnay na function nito.

MAGAGAMIT MGA MODULO AT Mga function

Inilalarawan ng mga sumusunod na seksyon ang mga function at variable na magagamit sa pamamagitan ng iba't ibang perf
script Python modules. Para magamit ang mga function at variable mula sa ibinigay na module, idagdag ang
katumbas mula XXXX angkat linya sa iyong perf script script.

Core.py Module
Nagbibigay ang mga function na ito ng ilang mahahalagang function sa mga script ng user.

Ang flag_str at symbol_str nagbibigay ang mga function ng mga string na nababasa ng tao para sa flag at symbolic
mga patlang. Ang mga ito ay tumutugma sa mga string at value na na-parse mula sa i-print fmt mga patlang ng
mga file ng format ng kaganapan:

flag_str(event_name, field_name, field_value) - ibinabalik ang string na representasyon na tumutugma sa field_value para sa flag field na field_name ng event_name
symbol_str(event_name, field_name, field_value) - ibinabalik ang string representation na tumutugma sa field_value para sa symbolic field na field_name ng event_name

Ang autodict function ay nagbabalik ng isang espesyal na uri ng Python na diksyunaryo na nagpapatupad ng Perl's
autovivifying hashes sa Python ibig sabihin, may autovivifying hash, maaari kang magtalaga ng nested hash
mga halaga nang hindi nahihirapang gumawa ng mga intermediate na antas kung hindi nila gagawin
umiiral.

autodict() - nagbabalik ng autovivifying na halimbawa ng diksyunaryo

perf_trace_context Module
Ang ilan sa mga pangkaraniwan ang mga field sa file ng format ng kaganapan ay hindi gaanong karaniwan, ngunit kailangang maging
ginawang accessible sa mga script ng user gayunpaman.

Ang perf_trace_context ay tumutukoy sa isang set ng mga function na maaaring magamit upang ma-access ang data na ito sa
konteksto ng kasalukuyang kaganapan. Ang bawat isa sa mga function na ito ay umaasa ng isang variable ng konteksto, na
kapareho ng variable ng konteksto na ipinasa sa bawat handler ng kaganapan bilang pangalawang argumento.

common_pc(context) - nagbabalik ng common_preempt count para sa kasalukuyang kaganapan
common_flags(context) - nagbabalik ng common_flags para sa kasalukuyang kaganapan
common_lock_depth(context) - nagbabalik ng common_lock_depth para sa kasalukuyang kaganapan

Util.py Module
Iba't ibang mga function ng utility para gamitin sa perf script:

nsecs(secs, nsecs) - nagbabalik ng kabuuang nsecs na ibinigay na secs/nsecs pares
nsecs_secs(nsecs) - nagbabalik ng buong secs na bahagi na ibinigay sa nsecs
nsecs_nsecs(nsecs) - ibinabalik ang nsecs na natitira na ibinigay sa nsecs
nsecs_str(nsecs) - nagbabalik ng napi-print na string sa form na secs.nsecs
avg(total, n) - nagbabalik ng average na ibinigay ng kabuuan at kabuuang bilang ng mga halaga

Gumamit ng perf-script-python online gamit ang mga serbisyo ng onworks.net