perf-script-python — online w chmurze

PROGRAM:

IMIĘ

perf-script-python — Przetwarzaj dane śledzenia za pomocą skryptu Pythona

STRESZCZENIE

perf scenariusz [-s [Python]:skrypt[.py] ]

OPIS

Ta opcja skryptu perf jest używana do przetwarzania danych skryptu perf przy użyciu wbudowanego Pythona perf
interpretator. Odczytuje i przetwarza plik wejściowy oraz wyświetla wyniki śledzenia
analiza zaimplementowana w danym skrypcie Pythona, jeśli taka istnieje.

A SZYBKI PRZYKŁAD

W tej sekcji przedstawiono proces, od początku do końca, tworzenia działającego skryptu w języku Python
agreguje i wyodrębnia przydatne informacje z surowego strumienia skryptów perf. Możesz uniknąć
przeczytaj resztę tego dokumentu, jeśli wystarczy ci przykład; reszta
dokument zawiera więcej szczegółów na temat każdego kroku i zawiera listę dostępnych funkcji biblioteki
scenarzyści.

W tym przykładzie szczegółowo opisano kroki, które zostały użyte do utworzenia pliku liczba wywołań systemowych scenariusz
widzisz, gdy wyświetlasz listę dostępnych skryptów perf przez perf scenariusz -l. Jako takie, to
skrypt pokazuje również, jak zintegrować swój skrypt z listą ogólnego przeznaczenia perf
scenariusz skrypty wymienione przez to polecenie.

Skrypt syscall-counts jest prostym skryptem, ale demonstruje wszystkie podstawowe idee
niezbędne do stworzenia użytecznego skryptu. Oto przykład jego danych wyjściowych (nazwy wywołań systemowych to
jeszcze nieobsługiwane, będą wyświetlane jako liczby):

ft C
zdarzenia wywołania systemowego:

liczba zdarzeń
---------------------------------------- ---------- -
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_settimer 12
sys_writev 8
15 8
sys_lseek 7
sys_rt_sigprocmmaska ​​6
sys_wait4 3
sys_ioctl 3
sys_set_robust_list 1
sys_exit 1
56 1
dostęp_sys 1
stopy

Zasadniczo naszym zadaniem jest prowadzenie rejestru per-syscall, który jest aktualizowany za każdym razem, gdy system jest uruchamiany
w systemie następuje wywołanie. Nasz skrypt to zrobi, ale najpierw musimy zarejestrować dane
które będą przetwarzane przez ten skrypt. Teoretycznie możemy to zrobić na kilka sposobów
Zrób to:

· moglibyśmy włączyć każde zdarzenie w katalogu tracing/events/syscalls, ale tak jest
ponad 600 wywołań systemowych, znacznie przekraczających liczbę dozwoloną przez perf. Te indywidualne wywołania systemowe
zdarzenia będą jednak przydatne, jeśli będziemy chcieli później skorzystać ze wskazówek, które otrzymamy od
skrypty ogólnego przeznaczenia do drążenia i uzyskiwania więcej szczegółów na temat poszczególnych wywołań systemowych
procentowych.

· możemy włączyć wywołania systemowe sys_enter i/lub sys_exit, które można znaleźć w
śledzenie/zdarzenia/raw_syscalls. Są one wywoływane dla wszystkich wywołań systemowych; the id pole może być
używany do rozróżniania poszczególnych numerów wywołań systemowych.

W przypadku tego skryptu musimy tylko wiedzieć, że wprowadzono wywołanie systemowe; nie obchodzi nas jak
wyszedł, więc użyjemy perf rekord aby nagrać tylko zdarzenia sys_enter:

ft C
# rekord perf -a -e raw_syscalls:sys_enter

^ C [ rekord perf: Budzony 1 razy, aby zapisać dane ]
[ rekord perf: przechwycono i zapisano 56.545 MB perf.data (~2470503 próbek)]
stopy

Opcje zasadniczo mówią o zbieraniu danych dla każdego zdarzenia syscall w całym systemie i
multipleksować wyjście per-cpu do jednego strumienia. Ten pojedynczy strumień zostanie nagrany w
plik w bieżącym katalogu o nazwie perf.data.

Kiedy już mamy plik perf.data zawierający nasze dane, możemy użyć opcji -g perf scenariusz opcja do
wygeneruj skrypt Pythona, który będzie zawierał procedurę obsługi wywołania zwrotnego dla każdego znalezionego typu zdarzenia
strumień śledzenia perf.data (więcej informacji można znaleźć w sekcji SKRYPTY STARTOWE).

ft C
# skrypt perf -g python
wygenerowany skrypt Pythona: perf-script.py

Plik wyjściowy utworzony również w bieżącym katalogu ma nazwę
perf-script.py. Oto plik w całości:

# procedury obsługi zdarzeń skryptu perf, generowane przez skrypt perf -g python
# Licencjonowany zgodnie z warunkami licencji GNU GPL w wersji 2

# Pola procedury obsługi zdarzeń common_* są najbardziej użytecznymi polami wspólnymi dla
# wszystkie zdarzenia. Niekoniecznie odpowiadają one polom „common_*”.
# w plikach formatu. Te pola nie są dostępne jako parametry obsługi
# zostać pobrane za pomocą funkcji Pythona w postaci common_*(context).
# Zobacz dokumentację perf-script-python, aby zapoznać się z listą dostępnych funkcji.

zaimportować cię
import sys

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

z importu perf_trace_context *
z importu podstawowego *

def trace_begin():
drukuj „w trace_begin”

def trace_end():
drukuj „w trace_end”

def raw_syscalls__sys_enter(nazwa_zdarzenia, kontekst, wspólny_procesor,
common_secs, common_nsecs, common_pid, common_comm,
identyfikator, argumenty):
print_header(nazwa_zdarzenia, wspólny_procesor, wspólne_sek, wspólne_nsec,
wspólny_pid, wspólny_comm)

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

def trace_unhandled(nazwa_zdarzenia, kontekst, wspólny_procesor, wspólne_sekundy, wspólne_nsecs,
wspólny_pid, wspólny_comm):
print_header(nazwa_zdarzenia, wspólny_procesor, wspólne_sek, wspólne_nsec,
wspólny_pid, wspólny_comm)

def print_header(nazwa_zdarzenia, procesor, s, ns, pid, comm):
print "%-20s %5u %05u.%09u %8u %-20s "% \
(nazwa_zdarzenia, procesor, sek, nsec, pid, comm),
stopy

Na górze znajduje się blok komentarza, po którym następuje kilka instrukcji importu i ścieżka dołączania której
każdy skrypt perf powinien zawierać.

Po tym następuje kilka generowanych funkcji, trace_begin() i trace_end(), które są
wywoływane odpowiednio na początku i na końcu skryptu (więcej informacji można znaleźć w sekcji
SCRIPT_LAYOUT poniżej).

Następni są wydarzenie treser funkcje wygenerowały po jednym dla każdego zdarzenia w perf
rekord wyjście. Funkcje obsługi przyjmują postać podsystemuNazwa wydarzenia, i zawierać o imieniu
parametry, pierwszej dla każdy pole in dotychczasowy wydarzenie; in to walizka, nie ma tylko pierwszej zdarzenie,
raw_syscallssys_enter(). (więcej informacji na temat zdarzenia znajduje się w sekcji OBSŁUGA ZDARZEŃ poniżej
obsługi).

Ostatnie kilka funkcji, podobnie jak funkcje begin i end, jest generowanych dla każdego
scenariusz. Pierwsza, trace_unhandled(), jest wywoływana za każdym razem, gdy skrypt znajdzie zdarzenie w
plik perf.data, który nie odpowiada żadnej procedurze obsługi zdarzeń w skrypcie. To mogłoby
oznaczać albo, że rekordowy krok rejestrował typy zdarzeń, którymi tak naprawdę nie był zainteresowany,
lub skrypt został uruchomiony na pliku śledzenia, który nie odpowiada skryptowi.

Skrypt wygenerowany przez opcję -g po prostu drukuje wiersz dla każdego zdarzenia znalezionego w śladzie
stream, czyli po prostu zrzuca zdarzenie i wartości jego parametrów na standardowe wyjście. The
Funkcja print_header() jest po prostu funkcją użytkową używaną do tego celu. Zmieńmy nazwę
skrypt i uruchom go, aby zobaczyć domyślne wyjście:

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

raw_syscalls__sys_enter 1 00840.847582083 7506 id wydajności=1, args=
raw_syscalls__sys_enter 1 00840.847595764 7506 id wydajności=1, args=
raw_syscalls__sys_enter 1 00840.847620860 7506 id wydajności=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=
.
.
.
stopy

Oczywiście w tym skrypcie nie jesteśmy zainteresowani drukowaniem każdego zdarzenia śledzenia, ale raczej
agregując je w użyteczny sposób. Pozbędziemy się więc wszystkiego, co ma związek z drukowaniem
jako funkcje trace_begin() i trace_unhandled(), których nie będziemy używać. To pozostawia
nas tym minimalistycznym szkieletem:

ft C
zaimportować cię
import sys

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

z importu perf_trace_context *
z importu podstawowego *

def trace_end():
drukuj „w trace_end”

def raw_syscalls__sys_enter(nazwa_zdarzenia, kontekst, wspólny_procesor,
common_secs, common_nsecs, common_pid, common_comm,
identyfikator, argumenty):
stopy

W trace_end() po prostu wydrukujemy wyniki, ale najpierw musimy wygenerować kilka wyników
drukować. Aby to zrobić, musimy mieć nasz program obsługi sys_enter() do wykonania niezbędnych obliczeń
aż wszystkie zdarzenia zostaną policzone. Dobrym sposobem jest tablica skrótów indeksowana przez identyfikator syscall
przechowywać te informacje; za każdym razem, gdy wywoływany jest program obsługi sys_enter(), po prostu zwiększamy
liczba powiązana z tym wpisem skrótu indeksowana przez ten identyfikator wywołania systemowego:

ft C
wywołania syscall = autodict()

spróbuj:
wywołania systemowe[identyfikator] += 1
z wyjątkiem błędu typu:
wywołania systemowe[identyfikator] = 1
stopy

Wywołania systemowe autodykt obiekt to specjalny rodzaj słownika Pythona (zaimplementowany w
Core.py), który implementuje język Perla autoożywianie hashe w Pythonie, czyli z autovivifying
hashe, możesz przypisywać zagnieżdżone wartości hash bez konieczności tworzenia
poziomy pośrednie, jeśli nie istnieją, np. syscalls[comm][pid][id] = 1 utworzy
pośrednie poziomy skrótu i ​​ostatecznie przypisz wartość 1 do wpisu skrótu dla id (ponieważ
przypisana wartość nie jest samym obiektem mieszania, wartość początkowa jest przypisywana w pliku
Wyjątek TypeError. Cóż, może istnieć lepszy sposób na zrobienie tego w Pythonie, ale to wszystko
na razie działa).

Umieszczając ten kod w module obsługi raw_syscalls__sys_enter(), w rzeczywistości otrzymujemy
słownik jednopoziomowy oparty na identyfikatorze syscall i posiadający liczby, które policzyliśmy jako wartości.

Funkcja print_syscall_totals() iteruje po wpisach w słowniku i
wyświetla linię dla każdego wpisu zawierającego nazwę wywołania systemowego (klawisze słownika zawierają
identyfikatory syscall, które są przekazywane do funkcji Util syscall_name(), która tłumaczy
surowe numery wywołań systemowych do odpowiednich ciągów nazw wywołań systemowych). Wyjście jest
wyświetlane po przetworzeniu wszystkich zdarzeń w śledzeniu przez wywołanie metody
funkcja print_syscall_totals() z modułu obsługi trace_end() wywoływana na końcu skryptu
przetwarzanie.

Końcowy skrypt generujący dane wyjściowe pokazane powyżej pokazano w całości poniżej
(pomocnik syscall_name() nie jest jeszcze dostępny, na razie możesz zajmować się tylko identyfikatorami):

ft C
zaimportować cię
import sys

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

z importu perf_trace_context *
z importu podstawowego *
z importu Util *

wywołania syscall = autodict()

def trace_end():
print_syscall_totals()

def raw_syscalls__sys_enter(nazwa_zdarzenia, kontekst, wspólny_procesor,
common_secs, common_nsecs, common_pid, common_comm,
identyfikator, argumenty):
spróbuj:
wywołania systemowe[identyfikator] += 1
z wyjątkiem błędu typu:
wywołania systemowe[identyfikator] = 1

def print_syscall_totals():
jeśli for_comm nie jest Brak:
print "\nsyscall zdarzenia dla %s:\n\n" % (for_comm),
jeszcze:
print "\nsyscall zdarzenia:\n\n",

print "%-40s %10s\n" % ("zdarzenie", "liczba"),
print "%-40s %10s\n" % ("--------------------------------------------------- ---", \
"-----------"),

dla id, val w sorted(syscalls.iritems(), key = lambda(k, v): (v, k), \
odwrotność = Prawda):
print "%-40s %10d\n" % (syscall_name(id), val),
stopy

Skrypt można uruchomić tak samo jak poprzednio:

# perf skrypt -s syscall-counts.py

Są to więc podstawowe kroki w pisaniu i uruchamianiu skryptu. Proces może być
uogólnione na dowolny punkt śledzenia lub zestaw punktów śledzenia, którymi jesteś zainteresowany - po prostu znajdź
interesujące Cię punkty śledzenia, przeglądając listę dostępnych zdarzeń pokazaną przez
perf podstęp i/lub zajrzyj do /sys/kernel/debug/tracing events, aby uzyskać szczegółowe informacje o zdarzeniu i polu
info, zapisz odpowiednie dane śledzenia za pomocą perf rekord, przekazując mu listę
ciekawe wydarzenia, wygeneruj szkielet skryptu za pomocą perf scenariusz -g pyton i zmodyfikuj
kod do agregacji i wyświetlania go dla konkretnych potrzeb.

Po wykonaniu tej czynności możesz otrzymać skrypt ogólnego przeznaczenia, który chcesz zachować
wokół i mieć dostępne do wykorzystania w przyszłości. Pisząc kilka bardzo prostych skryptów powłoki
i umieszczając je we właściwym miejscu, możesz mieć swój skrypt na liście obok drugiego
skrypty wymienione przez perf scenariusz -l polecenie np.:

ft C
root@tropicana:~# skrypt perf -l
Lista dostępnych skryptów śledzenia:
opóźnienie wybudzenia w całym systemie min./maks./śr. opóźnienie wybudzenia
rw według pliku r/w aktywność dla programu według pliku
rw-by-pid aktywność r/w obejmująca cały system
stopy

Miłym efektem ubocznym takiego działania jest to, że następnie przechwytujesz prawdopodobnie długie perf
rekord polecenie potrzebne do zarejestrowania zdarzeń dla skryptu.

Aby skrypt pojawił się jako wbudowany script, piszesz dwa proste skrypty, jeden dla
nagranie i jedno dla raportowanie.

Kurs rekord script to skrypt powłoki o tej samej nazwie podstawowej co twój skrypt, ale z
- załączony rekord. Skrypt powłoki należy umieścić w perf/scripts/python/bin
katalog w drzewie źródeł jądra. W tym skrypcie piszesz perf rekord
wiersz poleceń potrzebny do twojego skryptu:

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

#!/ bin / bash
perf rekord -a -e raw_syscalls:sys_enter
stopy

Kurs raport script jest również skryptem powłoki o tej samej nazwie podstawowej co twój skrypt, ale z
-załączony raport. Powinien również znajdować się w katalogu perf/scripts/python/bin. W
ten skrypt, piszesz perf scenariusz -s wiersz poleceń potrzebny do uruchomienia skryptu:

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

#!/ bin / bash
# opis: ogólnosystemowe zliczanie wywołań systemowych
skrypt perf -s ~/libexec/perf-core/scripts/python/syscall-counts.py
stopy

Zauważ, że lokalizacja skryptu Pythona podana w skrypcie powłoki jest w
katalog libexec/perf-core/scripts/python - w tym miejscu zostanie skopiowany skrypt
robić zainstalować kiedy instalujesz perf. Aby instalacja zainstalowała tam twój skrypt,
twój skrypt musi znajdować się w katalogu perf/scripts/python w źródle jądra
drzewo:

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

root@tropicana:/home/trz/src/tip# ls -al Tools/perf/scripts/python
Razem 32
drwxr-xr-x 4 trz trz 4096 2010 01:26 .
drwxr-xr-x 4 trz trz 4096 2010 01:26 ..
drwxr-xr-x 2 trz trz 4096 2010-01-26 22:29 kosz
-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
stopy

Gdy już to zrobisz (nie zapomnij zrobić new robić zainstalować, w przeciwnym razie twój skrypt tego nie zrobi
pojawiać się w czasie wykonywania), perf scenariusz -l powinien pokazać nowy wpis dla twojego skryptu:

ft C
root@tropicana:~# skrypt perf -l
Lista dostępnych skryptów śledzenia:
opóźnienie wybudzenia w całym systemie min./maks./śr. opóźnienie wybudzenia
rw według pliku r/w aktywność dla programu według pliku
rw-by-pid aktywność r/w obejmująca cały system
syscall-counts systemowa liczba wywołań systemowych
stopy

Możesz teraz wykonać krok nagrywania przez perf scenariusz rekord:

# perf script rekord liczby syscall-counts

i wyświetlić dane wyjściowe za pomocą perf scenariusz raport:

# raport skryptu perf liczba wywołań syscall

ROZRUSZNIK SKRYPTY

Możesz szybko rozpocząć pisanie skryptu dla określonego zestawu danych śledzenia przez
generowanie skryptu szkieletowego za pomocą perf scenariusz -g pyton w tym samym katalogu co plik
istniejący plik śledzenia perf.data. Spowoduje to wygenerowanie skryptu startowego zawierającego program obsługi
dla każdego typu zdarzenia w pliku śledzenia; po prostu drukuje każde dostępne pole dla
każde zdarzenie w pliku śledzenia.

Możesz także przejrzeć istniejące skrypty w ~/libexec/perf-core/scripts/python dla
typowe przykłady pokazujące, jak wykonywać podstawowe czynności, takie jak agregowanie danych o zdarzeniach, drukowanie wyników,
itp. Również skrypt check-perf-script.py, chociaż nie jest interesujący ze względu na swoje wyniki,
próbuje wykonać wszystkie główne funkcje skryptów.

EVENT MANIPULATORZY

Gdy skrypt perf jest wywoływany przy użyciu skryptu śledzenia, zdefiniowany przez użytkownika treser funkcjonować is
wywołane dla każdego zdarzenia w śladzie. Jeśli nie ma zdefiniowanej funkcji obsługi dla danego
typ zdarzenia, zdarzenie jest ignorowane (lub przekazywane do pliku śledzenie_obsługiwane funkcja, patrz poniżej) i
przetwarzane jest następne zdarzenie.

Większość wartości pól zdarzenia jest przekazywana jako argumenty do funkcji obsługi; niektóre z
mniej powszechne nie są - są one dostępne jako wywołania zwrotne do pliku wykonywalnego perf
(Patrz niżej).

Na przykład następujące polecenie perf record może służyć do rejestrowania wszystkich sched_wakeup
zdarzenia w systemie:

# perf record -a -e sched:sched_wakeup

Ślady, które mają być przetwarzane za pomocą skryptu, powinny być rejestrowane z powyższą opcją: -a
aby umożliwić gromadzenie danych w całym systemie.

Plik formatu dla zdarzenia sched_wakep definiuje następujące pola (patrz
/sys/kernel/debug/tracing/events/sched/sched_wakeup/format):

ft C
format:
pole: unsigned short common_type;
pole: znak unsigned wspólne_flagi;
pole: znak bez znaku common_preempt_count;
pole:int wspólny_pid;

pole:char comm [TASK_COMM_LEN];
pole:pid_t pid;
pole:int prio;
pole:int sukces;
pole:int docelowy_procesor;
stopy

Funkcja obsługi dla tego zdarzenia byłaby zdefiniowana jako:

ft C
def sched__sched_wakeup(nazwa_zdarzenia, kontekst, wspólny_procesor, wspólne_sekundy,
common_nsecs, common_pid, common_comm,
comm, pid, prio, sukces, docelowy_procesor):
przechodzić
stopy

Funkcja obsługi przyjmuje postać nazwa_podsystemu_zdarzenia.

Argumenty common_* na liście argumentów modułu obsługi to zestaw argumentów przekazanych do
wszystkie procedury obsługi zdarzeń; niektóre pola odpowiadają wspólnym_* polom w formacie
plik, ale niektóre są syntetyzowane, a niektóre pola common_* nie są wystarczająco powszechne
być przekazywane do każdego zdarzenia jako argumenty, ale są dostępne jako funkcje biblioteczne.

Oto krótki opis każdego z niezmiennych argumentów zdarzenia:

nazwa_zdarzenia nazwa zdarzenia jako tekst
kontekst nieprzejrzystego „ciasteczka” używanego w wywołaniach z powrotem do perf
common_cpu procesor, na którym wystąpiło zdarzenie
common_secs część sekund znacznika czasu zdarzenia
common_nsecs część nsecs znacznika czasu zdarzenia
common_pid pid bieżącego zadania
common_comm nazwa bieżącego procesu

Wszystkie pozostałe pola w pliku formatu zdarzenia mają odpowiedniki jako moduł obsługi
argumenty funkcji o tej samej nazwie, jak widać w powyższym przykładzie.

Powyższe zapewnia podstawy potrzebne do bezpośredniego dostępu do każdego pola każdego zdarzenia w
trace, który obejmuje 90% tego, co musisz wiedzieć, aby napisać użyteczny skrypt śledzenia. The
sekcje poniżej obejmują resztę.

SCRIPT UKŁAD

Każdy skrypt perf w języku Python powinien rozpoczynać się od skonfigurowania ścieżki wyszukiwania modułu Pythona i
„import” kilku modułów wsparcia (patrz opisy modułów poniżej):

ft C
zaimportować cię
import sys

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

z importu perf_trace_context *
z importu podstawowego *
stopy

Pozostała część skryptu może zawierać funkcje obsługi i funkcje pomocnicze w dowolnej kolejności.

Oprócz omówionych powyżej funkcji obsługi zdarzeń, każdy skrypt może implementować zestaw
opcjonalnych funkcji:

początek_śledzenia, jeśli jest zdefiniowana, jest wywoływana przed przetworzeniem jakiegokolwiek zdarzenia i nadaje skryptom a
szansa na wykonanie zadań konfiguracyjnych:

ft C
def trace_begin:
przechodzić
stopy

koniec_śledzenia, jeśli jest zdefiniowana, jest wywoływana po przetworzeniu wszystkich zdarzeń i nadaje skryptom a
szansa na wykonanie zadań końca skryptu, takich jak wyświetlenie wyników:

ft C
def trace_end:
przechodzić
stopy

śledzenie_nieobsługiwane, jeśli jest zdefiniowana, jest wywoływana po każdym zdarzeniu, które nie ma procedury obsługi
dla niego wyraźnie określone. Przekazywany jest do niego standardowy zestaw typowych argumentów:

ft C
def trace_unhandled(nazwa_zdarzenia, kontekst, wspólny_procesor, wspólne_sekundy,
wspólne_nsecs, wspólne_pid, wspólne_comm):
przechodzić
stopy

Pozostałe sekcje zawierają opisy każdego z dostępnych wbudowanych skryptów perf
Moduły Pythona i związane z nimi funkcje.

DOSTĘPNY MODUŁY ROLNICZE FUNKCJE

W poniższych sekcjach opisano funkcje i zmienne dostępne za pośrednictwem różnych perf
skryptowe moduły Pythona. Aby korzystać z funkcji i zmiennych z danego modułu, dodaj plik
odpowiedni od XXXX importować line do skryptu perf.

rdzeń.py Moduł
Te funkcje udostępniają niektóre podstawowe funkcje skryptom użytkownika.

Kurs flaga_str i symbol_str funkcje zapewniają czytelne dla człowieka ciągi dla flag i symboli
pola. Odpowiadają one ciągom i wartościom przeanalizowanym z pliku fmt pola
pliki formatu zdarzeń:

flag_str(nazwa_zdarzenia, nazwa_pola, wartość_pola) - zwraca reprezentację łańcuchową odpowiadającą wartości_pola dla pola flagi nazwa_pola zdarzenia nazwa_zdarzenia
symbol_str(nazwa_zdarzenia, nazwa_pola, wartość_pola) - zwraca reprezentację łańcuchową odpowiadającą wartości_pola dla pola symbolicznego nazwa_pola zdarzenia nazwa_zdarzenia

Kurs autodykt funkcja zwraca specjalny rodzaj słownika Pythona, który implementuje język Perla
autoożywianie hashe w Pythonie, tj. z haszami autoożywiającymi, możesz przypisać zagnieżdżony skrót
wartości bez konieczności zadawania sobie trudu tworzenia poziomów pośrednich, jeśli tego nie robią
istnieć.

autodict() - zwraca instancję słownika autoożywiającego

perf_trace_context Moduł
Niektóre z pospolity pola w pliku formatu zdarzeń nie są tak powszechne, ale muszą być
udostępnione skryptom użytkownika.

perf_trace_context definiuje zestaw funkcji, których można użyć do uzyskania dostępu do tych danych w
kontekst aktualnego wydarzenia. Każda z tych funkcji oczekuje zmiennej kontekstowej, czyli
taka sama jak zmienna kontekstowa przekazywana do każdego programu obsługi zdarzeń jako drugi argument.

common_pc(context) — zwraca liczbę common_preempt dla bieżącego zdarzenia
common_flags(context) - zwraca common_flags dla bieżącego zdarzenia
common_lock_depth(context) — zwraca common_lock_głębokość dla bieżącego zdarzenia

Util.py Moduł
Różne funkcje użytkowe do użytku ze skryptem perf:

nsecs(secs, nsecs) - zwraca sumę nsecs dla danej pary secs/nseks
nsecs_secs(nsecs) - zwraca całą część sekund podanych nsecs
nsecs_nsecs(nsecs) - zwraca resztę nsecs zadaną nsecs
nsecs_str(nsecs) - zwraca drukowalny napis w postaci secs.nsecs
avg(total, n) - zwraca średnią z podanej sumy i całkowitej liczby wartości

Użyj perf-script-python online, korzystając z usług onworks.net