perf-script-python - Online nel cloud

PROGRAMMA:

NOME

perf-script-python: elabora i dati di traccia con uno script Python

SINOSSI

perf copione [-s [Python]:script[.py] ]

DESCRIZIONE

Questa opzione di script perf viene utilizzata per elaborare i dati dello script perf utilizzando il Python integrato di perf
interprete. Legge ed elabora il file di input e visualizza i risultati della traccia
analisi implementata nello script Python fornito, se presente.

A VELOCE ESEMPIO

Questa sezione mostra il processo, dall'inizio alla fine, per creare uno script Python funzionante che
aggrega ed estrae informazioni utili da un flusso di script perf non elaborato. Puoi evitare
leggi il resto di questo documento se ti basta un esempio; il resto di
Il documento fornisce maggiori dettagli su ogni passaggio ed elenca le funzioni della libreria disponibili
sceneggiatori.

Questo esempio descrive in realtà i passaggi utilizzati per creare il file conteggi delle chiamate di sistema copione
vedi quando elenchi gli script di script perf disponibili tramite perf copione -l. In quanto tale, questo
script mostra anche come integrare il tuo script nell'elenco di usi generali perf
copione script elencati da quel comando.

Lo script syscall-counts è uno script semplice, ma dimostra tutte le idee di base
necessario per creare uno script utile. Ecco un esempio del suo output (i nomi delle chiamate di sistema sono
non ancora supportati, appariranno come numeri):

.ft C
eventi di chiamata di sistema:

conteggio degli eventi
---------------------------------------- ---------- -
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_writev8
15/8
sys_lseek 7
sys_rt_sigprocmask 6
sys_wait4 3
sys_ioctl 3
sys_set_robust_list 1
sys_uscita 1
56/1
accesso_sistema 1
.ft

Fondamentalmente il nostro compito è mantenere un conteggio per chiamata di sistema che venga aggiornato ogni volta che un sistema
la chiamata avviene nel sistema. Il nostro script lo farà, ma prima dobbiamo registrare i dati
che verrà elaborato da quello script. In teoria, ci sono un paio di modi in cui potremmo farlo
Fai quello:

· potremmo abilitare ogni evento nella directory tracing/events/syscalls, ma così è
oltre 600 chiamate di sistema, ben oltre il numero consentito da perf. Queste chiamate di sistema individuali
events sarà comunque utile se vorremo utilizzare in seguito le indicazioni che otterremo da
script generici per approfondire e ottenere maggiori dettagli sulle singole chiamate di sistema di
interesse.

· possiamo abilitare le chiamate di sistema sys_enter e/o sys_exit che si trovano sotto
tracing/events/raw_syscalls. Questi sono chiamati per tutte le chiamate di sistema; IL id il campo può essere
utilizzato per distinguere tra i singoli numeri di chiamata di sistema.

Per questo script, dobbiamo solo sapere che è stata inserita una chiamata di sistema; non ci interessa come
uscito, quindi useremo perf record per registrare solo gli eventi sys_enter:

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

^C[record perf: svegliato 1 volta per scrivere i dati]
[perf record: catturato e scritto 56.545 MB perf.data (~2470503 campioni)]
.ft

Le opzioni fondamentalmente dicono di raccogliere dati per ogni evento di chiamata di sistema a livello di sistema e
multiplexare l'output per CPU in un unico flusso. Quel singolo flusso verrà registrato in
un file nella directory corrente chiamato perf.data.

Una volta che abbiamo un file perf.data contenente i nostri dati, possiamo usare -g perf copione opzione a
generare uno script Python che conterrà un gestore di callback per ogni tipo di evento trovato in
il flusso di traccia perf.data (per maggiori dettagli, vedere la sezione SCRIPT STARTER).

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

Viene nominato il file di output creato anche nella directory corrente
perf-script.py. Ecco il file nella sua interezza:

# gestori di eventi perf script, generati da perf script -g python
# Concesso in licenza secondo i termini della licenza GNU GPL versione 2

# I campi del gestore eventi common_* sono i campi più utili comuni a
# Tutti gli eventi. Non corrispondono necessariamente ai campi 'common_*'
# nei file di formato. Quei campi non sono disponibili come possono farlo i parametri del gestore
# essere recuperato utilizzando le funzioni Python nella forma common_*(context).
# Consulta la documentazione di perf-script-python per l'elenco delle funzioni disponibili.

import os
importa sys

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

dall'importazione perf_trace_context *
dall'importazione Core *

def traccia_inizio():
stampa "in trace_begin"

def traccia_end():
stampa "in trace_end"

def raw_syscalls__sys_enter(nome_evento, contesto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, argomenti):
print_header(nome_evento, common_cpu, common_secs, common_nsecs,
pid_comune, comm_comune)

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

def trace_unhandled(nome_evento, contesto, common_cpu, common_secs, common_nsecs,
pid_comune, comm_comune):
print_header(nome_evento, common_cpu, common_secs, common_nsecs,
pid_comune, comm_comune)

def stampa_intestazione(nome_evento, CPU, secondi, nsec, pid, comm):
print "%-20s %5u %05u.%09u %8u %-20s " % \
(nome_evento, CPU, secondi, nsec, pid, comm),
.ft

In alto c'è un blocco di commenti seguito da alcune istruzioni di importazione e un percorso che aggiunge quale
ogni script perf script dovrebbe includere.

Seguono un paio di funzioni generate, trace_begin() e trace_end(), che sono
chiamato rispettivamente all'inizio e alla fine dello script (per maggiori dettagli, vedere il file
sezione SCRIPT_LAYOUT di seguito).

Di seguito sono riportati i evento Handler le funzioni ne hanno generato uno per ogni evento nel file perf
record produzione. Le funzioni del gestore assumono la forma del sottosistemanome dell'evento, ed contenere detto
parametri, prima per ogni campo in , il evento; in questo caso, c'è esclusivamente prima evento,
raw_syscallssys_enter(). (vedi la sezione GESTORI DI EVENTI di seguito per maggiori informazioni sull'evento
gestori).

L'ultima coppia di funzioni, come le funzioni di inizio e di fine, viene generata per ogni
sceneggiatura. Il primo, trace_unhandled(), viene chiamato ogni volta che lo script trova un evento in
il file perf.data che non corrisponde ad alcun gestore di eventi nello script. Questo potrebbe
significa che la fase di registrazione ha registrato tipi di eventi a cui non era realmente interessato,
oppure lo script è stato eseguito su un file di traccia che non corrisponde allo script.

Lo script generato dall'opzione -g stampa semplicemente una riga per ogni evento trovato nella traccia
stream, ovvero in pratica scarica semplicemente l'evento e i relativi valori dei parametri su stdout. IL
La funzione print_header() è semplicemente una funzione di utilità utilizzata a tale scopo. Rinominiamo
lo script ed eseguilo per vedere l'output predefinito:

.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

Naturalmente, per questo script, non siamo interessati a stampare ogni evento traccia, ma piuttosto
aggregandolo in modo utile. Quindi elimineremo anche tutto ciò che ha a che fare con la stampa
come le funzioni trace_begin() e trace_unhandled(), che non utilizzeremo. Questo lascia
noi con questo scheletro minimalista:

.ft C
import os
importa sys

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

dall'importazione perf_trace_context *
dall'importazione Core *

def traccia_end():
stampa "in trace_end"

def raw_syscalls__sys_enter(nome_evento, contesto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, argomenti):
.ft

In trace_end() stamperemo semplicemente i risultati, ma prima dobbiamo generare alcuni risultati
stampare. Per fare ciò dobbiamo fare in modo che il nostro gestore sys_enter() esegua il conteggio necessario
finché tutti gli eventi non saranno stati contati. Una tabella hash indicizzata dall'id della chiamata di sistema è un buon modo per farlo
memorizzare tali informazioni; ogni volta che viene chiamato il gestore sys_enter(), incrementiamo semplicemente
un conteggio associato a quella voce hash indicizzata da quell'id syscall:

.ft C
chiamate di sistema = autodict()

provare:
chiamate di sistema[id] += 1
tranne TypeError:
chiamate di sistema[id] = 1
.ft

Le chiamate di sistema autodict object è un tipo speciale di dizionario Python (implementato in
Core.py) che implementa Perl autovivificante hash in Python cioè con autovivificazione
hash, puoi assegnare valori hash nidificati senza doverti preoccupare di crearli
livelli intermedi se non esistono, ad esempio syscalls[comm][pid][id] = 1 creerà il
livelli di hash intermedi e infine assegnare il valore 1 alla voce hash per id (perché
il valore assegnato non è un oggetto hash stesso, il valore iniziale viene assegnato nel file
Eccezione TypeError. Bene, potrebbe esserci un modo migliore per farlo in Python, ma questo è ciò che
funziona per ora).

Inserendo quel codice nel gestore raw_syscalls__sys_enter(), ci ritroveremo effettivamente con a
dizionario a livello singolo digitato sull'ID syscall e con i conteggi che abbiamo conteggiato come valori.

La funzione print_syscall_totals() esegue un'iterazione sulle voci nel dizionario e
visualizza una riga per ogni voce contenente il nome della chiamata di sistema (i tasti del dizionario contengono
gli ID delle chiamate di sistema, che vengono passati alla funzione Util syscall_name(), che traduce
i numeri grezzi delle chiamate di sistema alle stringhe dei nomi delle chiamate di sistema corrispondenti). L'uscita è
visualizzato dopo che tutti gli eventi nella traccia sono stati elaborati, chiamando il file
funzione print_syscall_totals() dal gestore trace_end() chiamato alla fine dello script
trattamento.

Lo script finale che produce l'output mostrato sopra è mostrato nella sua interezza di seguito
(l'helper syscall_name() non è ancora disponibile, per ora puoi gestire solo gli ID):

.ft C
import os
importa sys

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

dall'importazione perf_trace_context *
dall'importazione Core *
da importazione Util *

chiamate di sistema = autodict()

def traccia_end():
print_syscall_totals()

def raw_syscalls__sys_enter(nome_evento, contesto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, argomenti):
provare:
chiamate di sistema[id] += 1
tranne TypeError:
chiamate di sistema[id] = 1

def print_syscall_totals():
se for_comm non è Nessuno:
print "\neventi syscall per %s:\n\n" % (for_comm),
altro:
print "\neventi syscall:\n\n",

print "%-40s %10s\n" % ("evento", "conteggio"),
print "%-40s %10s\n" % ("------------------------------------ ---", \
"-----------"),

for id, val in sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
inverso = Vero):
print "%-40s %10d\n" % (syscall_name(id), val),
.ft

Lo script può essere eseguito proprio come prima:

# perf script -s syscall-counts.py

Quindi questi sono i passaggi essenziali per scrivere ed eseguire uno script. Il processo può essere
generalizzato a qualsiasi tracepoint o insieme di tracepoint a cui sei interessato: in pratica find
i tracepoint a cui sei interessato guardando l'elenco degli eventi disponibili mostrato da
perf stratagemma e/o cercare in /sys/kernel/debug/tracing events per eventi e campi dettagliati
info, registrare i dati di traccia corrispondenti utilizzando perf record, passandogli l'elenco di
eventi interessanti, genera uno script scheletro utilizzando perf copione -g python e modificare il
codice per aggregarlo e visualizzarlo per le tue esigenze particolari.

Dopo averlo fatto potresti ritrovarti con uno script generico che desideri mantenere
in giro e averli a disposizione per un uso futuro. Scrivendo un paio di script di shell molto semplici
e inserendoli nel posto giusto, puoi avere il tuo script elencato insieme agli altri
script elencati da perf copione -l comando ad esempio:

.ft C
root@tropicana:~# perf script -l
Elenco degli script di traccia disponibili:
latenza di riattivazione latenza di riattivazione minima/massima/media a livello di sistema
rw-per-file attività di lettura/scrittura per un programma, per file
rw-by-pid attività r/w a livello di sistema
.ft

Un bell'effetto collaterale di questo è che catturi anche il probabilmente lungo perf
record comando necessario per registrare gli eventi per lo script.

Per far sì che lo script venga visualizzato come a incassato script, scrivi due semplici script, uno per
registrazione e uno per segnalazione.

I record script è uno script di shell con lo stesso nome di base del tuo script, ma con
-record allegato. Lo script della shell dovrebbe essere inserito in perf/scripts/python/bin
directory nell'albero dei sorgenti del kernel. In quello script, scrivi il perf record
riga di comando necessaria per il tuo script:

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

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

I rapporto script è anche uno script di shell con lo stesso nome di base del tuo script, ma con
-relazione in allegato. Dovrebbe anche trovarsi nella directory perf/scripts/python/bin. In
quella sceneggiatura, tu scrivi il perf copione -s riga di comando necessaria per eseguire lo script:

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

#!/ bin / bash
# descrizione: conta le chiamate di sistema a livello di sistema
script perf -s ~/libexec/perf-core/scripts/python/syscall-counts.py
.ft

Tieni presente che la posizione dello script Python fornita nello script di shell è nel file
Directory libexec/perf-core/scripts/python: è qui che verrà copiato lo script
make install quando installi perf. Per l'installazione, installa il tuo script lì,
il tuo script deve trovarsi nella directory perf/scripts/python nel sorgente del kernel
albero:

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

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

Dopo averlo fatto (non dimenticare di fare un nuovo file make install, altrimenti il ​​tuo script non lo farà
presentarsi in fase di esecuzione), perf copione -l dovrebbe mostrare una nuova voce per il tuo script:

.ft C
root@tropicana:~# perf script -l
Elenco degli script di traccia disponibili:
latenza di riattivazione latenza di riattivazione minima/massima/media a livello di sistema
rw-per-file attività di lettura/scrittura per un programma, per file
rw-by-pid attività r/w a livello di sistema
conta-syscall Conteggi delle chiamate di sistema a livello di sistema
.ft

Ora puoi eseguire la fase di registrazione tramite perf copione record:

# perf script registra i conteggi delle chiamate di sistema

e visualizzare l'output utilizzando perf copione rapporto:

# script perf riporta i conteggi delle chiamate di sistema

ANTIPASTO SCRIPT

Puoi iniziare rapidamente a scrivere uno script per un particolare set di dati di traccia tramite
generando uno script scheletro utilizzando perf copione -g python nella stessa directory di an
file di traccia perf.data esistente. Ciò genererà uno script iniziale contenente un gestore
per ciascuno dei tipi di evento nel file di traccia; stampa semplicemente ogni campo disponibile per
ogni evento nel file di traccia.

Puoi anche guardare gli script esistenti in ~/libexec/perf-core/scripts/python per
esempi tipici che mostrano come eseguire operazioni di base come aggregare dati di eventi, stampare risultati,
ecc. Inoltre, lo script check-perf-script.py, sebbene non sia interessante per i suoi risultati,
tenta di esercitare tutte le principali funzionalità di scripting.

EVENTO HANDLER

Quando lo script perf viene richiamato utilizzando uno script di traccia, un file definito dall'utente Handler function is
chiamato per ogni evento nella traccia. Se non è stata definita alcuna funzione di gestione per un dato oggetto
tipo di evento, l'evento viene ignorato (o passato a a trace_handled funzione, vedere sotto) e
viene elaborato l'evento successivo.

La maggior parte dei valori dei campi dell'evento vengono passati come argomenti alla funzione del gestore; alcuni
quelli meno comuni non lo sono: sono disponibili come richiamate nell'eseguibile perf
(vedi sotto).

Ad esempio, il seguente comando perf record può essere utilizzato per registrare tutti i file sched_wakeup
eventi nel sistema:

# perf record -a -e sched:sched_wakeup

Le tracce destinate ad essere elaborate utilizzando uno script devono essere registrate con l'opzione precedente: -a
per consentire la raccolta a livello di sistema.

Il file di formato per l'evento sched_wakep definisce i seguenti campi (vedi
/sys/kernel/debug/tracing/events/sched/sched_wakeup/format):

.ft C
formato:
campo: tipo_comune breve senza segno;
campo:carattere senza segno common_flags;
campo:carattere senza segno common_preempt_count;
campo:int common_pid;

campo:char comm[TASK_COMM_LEN];
campo:pid_t pid;
campo:int prio;
campo:int successo;
campo:int target_cpu;
.ft

La funzione del gestore per questo evento sarebbe definita come:

.ft C
def sched__sched_wakeup(nome_evento, contesto, common_cpu, common_secs,
common_nsecs, common_pid, common_comm,
comm, pid, prio, successo, target_cpu):
passare
.ft

La funzione del gestore assume la forma subsystem__event_name.

Gli argomenti common_* nell'elenco degli argomenti del gestore sono l'insieme di argomenti passati a
tutti i gestori di eventi; alcuni campi corrispondono ai campi common_* nel formato
file, ma alcuni sono sintetizzati e alcuni dei campi common_* non sono abbastanza comuni da poterlo fare
essere passati a ogni evento come argomenti ma sono disponibili come funzioni di libreria.

Ecco una breve descrizione di ciascuno degli argomenti dell'evento invariante:

event_name il nome dell'evento come testo
contesto un "cookie" opaco utilizzato nelle richiamate in perf
common_cpu la CPU su cui si è verificato l'evento
common_secs la parte relativa ai secondi del timestamp dell'evento
common_nsecs la porzione in nsec del timestamp dell'evento
common_pid il pid dell'attività corrente
common_comm il nome del processo corrente

Tutti i restanti campi nel file di formato dell'evento hanno controparti come gestore
argomenti di funzione con lo stesso nome, come si può vedere nell'esempio sopra.

Quanto sopra fornisce le nozioni di base necessarie per accedere direttamente a ogni campo di ogni evento in a
trace, che copre il 90% di ciò che è necessario sapere per scrivere uno script di traccia utile. IL
le sezioni seguenti coprono il resto.

SCRIPT LAYOUT

Ogni script Python perf dovrebbe iniziare impostando un percorso di ricerca del modulo Python e
'importando' alcuni moduli di supporto (vedi le descrizioni dei moduli di seguito):

.ft C
import os
importa sys

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

dall'importazione perf_trace_context *
dall'importazione Core *
.ft

Il resto dello script può contenere funzioni di gestione e funzioni di supporto in qualsiasi ordine.

A parte le funzioni del gestore eventi discusse sopra, ogni script può implementare un set
di funzioni opzionali:

traccia_inizio, se definito, viene chiamato prima che qualsiasi evento venga elaborato e fornisce agli script a
possibilità di eseguire attività di configurazione:

.ft C
def traccia_inizio:
passare
.ft

trace_end, se definito, viene chiamato dopo che tutti gli eventi sono stati elaborati e fornisce agli script a
possibilità di eseguire attività di fine script, come visualizzare i risultati:

.ft C
def traccia_fine:
passare
.ft

trace_unhandled, se definito, viene chiamato per qualsiasi evento che non dispone di un gestore
esplicitamente definito per esso. Viene passato l'insieme standard di argomenti comuni:

.ft C
def trace_unhandled(nome_evento, contesto, common_cpu, common_secs,
common_nsecs, common_pid, common_comm):
passare
.ft

Le restanti sezioni forniscono le descrizioni di ciascuno degli script perf integrati disponibili
Moduli Python e loro funzioni associate.

DISPONIBILE MODULI E FUNZIONI

Le sezioni seguenti descrivono le funzioni e le variabili disponibili tramite i vari perf
moduli Python di script. Per utilizzare le funzioni e le variabili del modulo specificato, aggiungere il file
corrispondente da XXXX importare linea allo script perf script.

Core.py Moduli
Queste funzioni forniscono alcune funzioni essenziali agli script utente.

I flag_str ed simbolo_str le funzioni forniscono stringhe leggibili dall'uomo per flag e simbolico
campi. Questi corrispondono alle stringhe e ai valori analizzati dal file stampare FMT campi della
file in formato evento:

flag_str(event_name, field_name, field_value) - restituisce la rappresentazione della stringa corrispondente a field_value per il campo flag field_name dell'evento event_name
symbol_str(event_name, field_name, field_value) - restituisce la rappresentazione della stringa corrispondente a field_value per il campo simbolico field_name dell'evento event_name

I autodict restituisce un tipo speciale di dizionario Python che implementa quello di Perl
autovivificante hash in Python, ovvero con hash autovivificanti, è possibile assegnare hash annidati
valori senza doversi prendere la briga di creare livelli intermedi se non lo fanno
esistere.

autodict() - restituisce un'istanza del dizionario autovivificante

perf_trace_context Moduli
Alcuni dei comune i campi nel file del formato evento non sono così comuni, ma devono esserlo
reso comunque accessibile agli script utente.

perf_trace_context definisce un insieme di funzioni che possono essere utilizzate per accedere a questi dati nel file
contesto dell’evento attuale. Ognuna di queste funzioni prevede una variabile di contesto, che è
lo stesso della variabile di contesto passata a ogni gestore di eventi come secondo argomento.

common_pc(context) - restituisce il conteggio common_preempt per l'evento corrente
common_flags(context) - restituisce common_flags per l'evento corrente
common_lock_length(context) - restituisce common_lock_length per l'evento corrente

Utili.py Moduli
Varie funzioni di utilità da utilizzare con lo script perf:

nsecs(sec, nsec) - restituisce il totale di nsec data la coppia sec/nsec
nsecs_secs(nsecs) - restituisce l'intera porzione di secondi fornita in nsec
nsecs_nsecs(nsecs) - restituisce nsec di resto dati nsec
nsecs_str(nsecs) - restituisce una stringa stampabile nel formato secs.nsecs
avg(total, n) - restituisce la media data una somma e un numero totale di valori

Utilizza perf-script-python online utilizzando i servizi onworks.net