perf-script-python - Online na nuvem

PROGRAMA:

NOME

perf-script-python - processa dados de rastreamento com um script Python

SINOPSE

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

DESCRIÇÃO

Esta opção de script de perf é usada para processar dados de script de perf usando o Python integrado do perf
intérprete. Ele lê e processa o arquivo de entrada e exibe os resultados do rastreamento
análise implementada no script Python fornecido, se houver.

A QUICK EXEMPLO

Esta seção mostra o processo, do início ao fim, de criação de um script Python funcional que
agrega e extrai informações úteis de um fluxo de script de desempenho bruto. Você pode evitar
ler o restante deste documento se um exemplo for o suficiente para você; o resto do
documento fornece mais detalhes sobre cada etapa e lista as funções de biblioteca disponíveis para
escritores de script.

Este exemplo realmente detalha as etapas que foram usadas para criar o contagens syscall escrita
você vê quando lista os scripts de script de desempenho disponíveis por meio de perf escrita -l. Como tal, este
script também mostra como integrar seu script na lista de uso geral perf
escrita scripts listados por esse comando.

O script syscall-counts é um script simples, mas demonstra todas as ideias básicas
necessário para criar um script útil. Aqui está um exemplo de sua saída (nomes de syscall são
ainda não compatível, eles aparecerão como números):

.ft C
eventos syscall:

contagem de eventos
---------------------------------------- ---------- -
sys_write455067
sys_getdents4072
sys_close 3037
sys_swapoff 1769
sys_read 923
sys_sched_setparam 826
sys_open 331
sys_newfstat326
sys_mmap 217
sys_munmap 216
sys_futex 141
sys_select 102
sys_poll 84
sys_settimer 12
sys_writev8
15 8
sys_lseek7
sys_rt_sigprocmask6
sys_wait4 3
sys_ioctl3
sys_set_robust_list1
saída_sys 1
56 1
acesso_sys 1
.ft

Basicamente, nossa tarefa é manter um registro por escala que é atualizado toda vez que um sistema
a chamada ocorre no sistema. Nosso script fará isso, mas primeiro precisamos registrar os dados
que será processado por esse script. Teoricamente, existem algumas maneiras de podermos
faça isso:

· Poderíamos habilitar todos os eventos no diretório tracing / events / syscalls, mas isso é
mais de 600 syscalls, muito além do número permitido pelo perf. Estes syscall individuais
eventos serão, no entanto, úteis se quisermos mais tarde usar a orientação que recebemos do
scripts de uso geral para aprofundar e obter mais detalhes sobre syscalls individuais de
interesse.

· Podemos habilitar o sys_enter e / ou sys_exit syscalls encontrados em
rastreamento / eventos / raw_syscalls. Eles são chamados para todas as syscalls; a id campo pode ser
usado para distinguir entre números de syscall individuais.

Para este script, só precisamos saber se uma syscall foi inserida; não nos importamos como
saiu, então vamos usar perf registro para registrar apenas os eventos sys_enter:

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

^ C [registro de desempenho: acordado 1 vez para gravar dados]
[registro de perf: capturado e gravado 56.545 MB perf.data (~ 2470503 amostras)]
.ft

As opções basicamente dizem para coletar dados para cada evento syscall em todo o sistema e
multiplexar a saída por CPU em um único fluxo. Esse único stream será gravado em
um arquivo no diretório atual denominado perf.data.

Assim que tivermos um arquivo perf.data contendo nossos dados, podemos usar o -g perf escrita opção para
gerar um script Python que conterá um manipulador de retorno de chamada para cada tipo de evento encontrado em
o fluxo de rastreamento perf.data (para obter mais detalhes, consulte a seção STARTER SCRIPTS).

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

O arquivo de saída criado também no diretório atual é denominado
perf-script.py. Este é o arquivo completo:

# manipuladores de eventos de script de perf, gerados por perf script -g python
# Licenciado sob os termos da GNU GPL License versão 2

# Os campos do manipulador de eventos common_ * são os campos mais úteis comuns para
# todos os eventos. Eles não correspondem necessariamente aos campos 'common_ *'
# nos arquivos de formato. Esses campos não disponíveis como parâmetros do manipulador podem
# ser recuperado usando funções Python da forma common _ * (contexto).
# Consulte a documentação perf-script-python para obter a lista de funções disponíveis.

importar os
import sys

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

da importação perf_trace_context *
da importação do Core *

def trace_begin ():
imprimir "em trace_begin"

def trace_end ():
imprimir "em trace_end"

def raw_syscalls__sys_enter (event_name, contexto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, argumentos):
print_header (event_name, common_cpu, common_secs, common_nsecs,
common_pid, common_comm)

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

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

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

No topo está um bloco de comentário seguido por algumas instruções de importação e um anexo de caminho que
todo script de perf script deve incluir.

A seguir estão algumas funções geradas, trace_begin () e trace_end (), que são
chamado no início e no final do script, respectivamente (para obter mais detalhes, consulte o
Seção SCRIPT_LAYOUT abaixo).

Em seguida, estão os evento treinador funções geradas uma para cada evento no perf
registro saída. As funções do manipulador assumem a forma de subsistemanome do evento, e não contenho nomeado
parâmetros, um para cada campo in que o evento; in isto caso, há só um evento,
raw_syscalllssys_enter (). (veja a seção MANIPULADORES DE EVENTO abaixo para mais informações sobre o evento
manipuladores).

As duas funções finais são, como as funções de início e fim, geradas para cada
roteiro. O primeiro, trace_unhandled (), é chamado sempre que o script encontra um evento em
o arquivo perf.data que não corresponde a nenhum manipulador de eventos no script. Isso poderia
significa que a etapa de registro registrou tipos de eventos nos quais não estava realmente interessado,
ou o script foi executado em um arquivo de rastreamento que não corresponde ao script.

O script gerado pela opção -g simplesmente imprime uma linha para cada evento encontrado no rastreamento
stream, ou seja, basicamente apenas despeja o evento e seus valores de parâmetro em stdout. O
A função print_header () é simplesmente uma função utilitária usada para esse propósito. Vamos renomear
o script e execute-o para ver a saída padrão:

.ft C
# mv perf-script.py syscall-counts.py
# script 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 =
.
.
.
.ft

Claro, para este script, não estamos interessados ​​em imprimir todos os eventos de rastreamento, mas sim
agregando-o de uma forma útil. Então, vamos nos livrar de tudo que tem a ver com impressão também
como as funções trace_begin () e trace_unhandled (), que não usaremos. Isso deixa
nós com este esqueleto minimalista:

.ft C
importar os
import sys

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

da importação perf_trace_context *
da importação do Core *

def trace_end ():
imprimir "em trace_end"

def raw_syscalls__sys_enter (event_name, contexto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, argumentos):
.ft

Em trace_end (), iremos simplesmente imprimir os resultados, mas primeiro precisamos gerar alguns resultados
imprimir. Para fazer isso, precisamos que nosso manipulador sys_enter () faça a contagem necessária
até que todos os eventos tenham sido contados. Uma tabela hash indexada por syscall id é uma boa maneira de
armazene essa informação; toda vez que o manipulador sys_enter () é chamado, simplesmente incrementamos
uma contagem associada a essa entrada hash indexada por esse id syscall:

.ft C
syscalls = autodict ()

tente:
syscalls [id] + = 1
exceto TypeError:
syscalls [id] = 1
.ft

As syscalls autodito objeto é um tipo especial de dicionário Python (implementado em
Core.py) que implementa Perl's autovivificante hashes em Python, ou seja, com autovivificação
hashes, você pode atribuir valores de hash aninhados sem ter que se dar ao trabalho de criar
níveis intermediários, se eles não existirem, por exemplo, syscalls [comm] [pid] [id] = 1 criará o
níveis de hash intermediários e, finalmente, atribua o valor 1 à entrada de hash para id (Porque
o valor que está sendo atribuído não é um objeto hash em si, o valor inicial é atribuído no
Exceção TypeError. Bem, pode haver uma maneira melhor de fazer isso em Python, mas é isso que
funciona por enquanto).

Colocando esse código no manipulador raw_syscalls__sys_enter (), efetivamente acabamos com um
dicionário de nível único digitado em syscall id e tendo as contagens que contamos como valores.

A função print_syscall_totals () itera sobre as entradas no dicionário e
mostra uma linha para cada entrada contendo o nome do syscall (as chaves do dicionário contêm
os ids do syscall, que são passados ​​para a função Util syscall_name (), que traduz
os números brutos de syscall para as sequências de nomes de syscall correspondentes). A saída é
exibido após todos os eventos no rastreamento terem sido processados, chamando o
função print_syscall_totals () do manipulador trace_end () chamada no final do script
processamento.

O script final que produz a saída mostrada acima é mostrado em sua totalidade abaixo
(o auxiliar syscall_name () ainda não está disponível, você só pode lidar com ids por enquanto):

.ft C
importar os
import sys

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

da importação perf_trace_context *
da importação do Core *
da importação Util *

syscalls = autodict ()

def trace_end ():
print_syscall_totals ()

def raw_syscalls__sys_enter (event_name, contexto, common_cpu,
common_secs, common_nsecs, common_pid, common_comm,
id, argumentos):
tente:
syscalls [id] + = 1
exceto TypeError:
syscalls [id] = 1

def print_syscall_totals ():
se for_comm não for Nenhum:
imprimir "\ nsyscall eventos para% s: \ n \ n"% (for_comm),
outro:
imprimir "eventos de \ nescala de escala: \ n \ n",

imprimir "% -40s% 10s \ n"% ("evento", "contagem"),
imprimir "% -40s% 10s \ n"% ("------------------------------------- --- ", \
"-----------"),

para id, val em classificado (syscalls.iteritems (), chave = lambda (k, v): (v, k), \
reverso = verdadeiro):
imprimir "% -40s% 10d \ n"% (syscall_name (id), val),
.ft

O script pode ser executado como antes:

# script perf -s syscall-counts.py

Portanto, essas são as etapas essenciais para escrever e executar um script. O processo pode ser
generalizado para qualquer ponto de rastreamento ou conjunto de pontos de rastreamento em que você esteja interessado - basicamente, encontre
o (s) tracepoint (s) em que você está interessado, olhando a lista de eventos disponíveis mostrada por
perf Lista e / ou procure em / sys / kernel / debug / tracing eventos para eventos e campos detalhados
informações, registre os dados de rastreamento correspondentes usando perf registro, passando a lista de
eventos interessantes, gere um esqueleto de script usando perf escrita -g python e modificar o
código para agregar e exibi-lo para suas necessidades específicas.

Depois de fazer isso, você pode acabar com um script de uso geral que deseja manter
ao redor e tem disponível para uso futuro. Escrevendo alguns scripts de shell muito simples
e colocá-los no lugar certo, você pode ter seu script listado junto com os outros
scripts listados por perf escrita -l comando, por exemplo:

.ft C
root @ tropicana: ~ # perf script -l
Lista de scripts de rastreamento disponíveis:
latência de despertar latência de despertar mín / máx / média em todo o sistema
rw-por-arquivo atividade r / w para um programa, por arquivo
atividade de r / w em todo o sistema rw-by-pid
.ft

Um bom efeito colateral de fazer isso é que você também captura o provavelmente longo perf
registro comando necessário para registrar os eventos para o script.

Para que o script apareça como um construídas em script, você escreve dois scripts simples, um para
gravação e um para relatando.

A registro script é um script de shell com o mesmo nome de base do seu script, mas com
-record anexado. O script de shell deve ser colocado em perf / scripts / python / bin
diretório na árvore de origem do kernel. Nesse script, você escreve o perf registro
linha de comando necessária para o seu script:

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

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

A Denunciar script também é um script de shell com o mesmo nome de base do seu script, mas com
-relatório anexado. Ele também deve estar localizado no diretório perf / scripts / python / bin. Dentro
aquele script, você escreve o perf escrita -s linha de comando necessária para executar seu script:

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

#!/ bin / bash
# descrição: contagens de syscall em todo o sistema
script perf -s ~ / libexec / perf-core / scripts / python / syscall-counts.py
.ft

Observe que a localização do script Python fornecido no script shell está no
diretório libexec / perf-core / scripts / python - é aqui que o script será copiado por
fazer instalar quando você instala o perf. Para a instalação para instalar o seu script lá,
seu script precisa estar localizado no diretório perf / scripts / python na fonte do kernel
árvore:

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

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

Depois de fazer isso (não se esqueça de fazer um novo fazer instalar, caso contrário, seu script não
aparecer no tempo de execução), perf escrita -l deve mostrar uma nova entrada para o seu script:

.ft C
root @ tropicana: ~ # perf script -l
Lista de scripts de rastreamento disponíveis:
latência de despertar latência de despertar mín / máx / média em todo o sistema
rw-por-arquivo atividade r / w para um programa, por arquivo
atividade de r / w em todo o sistema rw-by-pid
syscall-counts contagens syscall em todo o sistema
.ft

Agora você pode realizar a etapa de gravação via perf escrita registro:

# registro de script perf syscall-counts

e exibir a saída usando perf escrita Denunciar:

# relatório de script perf syscall-counts

STARTER CRITÉRIOS

Você pode começar a escrever rapidamente um script para um determinado conjunto de dados de rastreamento por
gerar um esqueleto de script usando perf escrita -g python no mesmo diretório que um
arquivo de rastreamento perf.data existente. Isso irá gerar um script inicial contendo um manipulador
para cada um dos tipos de eventos no arquivo de rastreio; simplesmente imprime todos os campos disponíveis para
cada evento no arquivo de rastreamento.

Você também pode olhar para os scripts existentes em ~ / libexec / perf-core / scripts / python para
exemplos típicos que mostram como fazer coisas básicas como agregar dados de eventos, imprimir resultados,
etc. Além disso, o script check-perf-script.py, embora não seja interessante para seus resultados,
tenta exercitar todos os principais recursos de script.

EVENTO MANIPULADORES

Quando o script de desempenho é invocado usando um script de rastreamento, um script definido pelo usuário treinador função is
chamado para cada evento no rastreamento. Se não houver função de tratamento definida para um determinado
tipo de evento, o evento é ignorado (ou passado para um trace_handled função, veja abaixo) e
o próximo evento é processado.

A maioria dos valores de campo do evento são passados ​​como argumentos para a função do manipulador; alguns
os menos comuns não são - eles estão disponíveis como chamadas de volta para o executável perf
(ver abaixo).

Como exemplo, o seguinte comando perf record pode ser usado para registrar todos os sched_wakeup
eventos no sistema:

# perf record -a -e sched: sched_wakeup

Os rastreamentos destinados a serem processados ​​usando um script devem ser registrados com a opção acima: -a
para habilitar a coleta de todo o sistema.

O arquivo de formato para o evento sched_wakep define os seguintes campos (consulte
/ sys / kernel / debug / tracing / events / sched / sched_wakeup / format):

.ft C
formato:
campo: common_type curto sem sinal;
campo: unsigned char common_flags;
campo: unsigned char common_preempt_count;
campo: int common_pid;

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

A função de manipulador para este evento seria definida como:

.ft C
def sched__sched_wakeup (event_name, context, common_cpu, common_secs,
common_nsecs, common_pid, common_comm,
comm, pid, prio, sucesso, target_cpu):
passar
.ft

A função de manipulador assume a forma subsystem__event_name.

Os argumentos common_ * na lista de argumentos do manipulador são o conjunto de argumentos passados ​​para
todos os manipuladores de eventos; alguns dos campos correspondem aos campos common_ * no formato
arquivo, mas alguns são sintetizados, e alguns dos campos common_ * não são comuns o suficiente para
podem ser passados ​​para todos os eventos como argumentos, mas estão disponíveis como funções de biblioteca.

Aqui está uma breve descrição de cada um dos argumentos invariantes do evento:

event_name o nome do evento como texto
contextualizar um 'cookie' opaco usado em chamadas de volta para o perf
common_cpu a CPU em que o evento ocorreu
common_secs a parte dos segundos do carimbo de data / hora do evento
common_nsecs a parte nsecs do carimbo de data / hora do evento
common_pid o pid da tarefa atual
common_comm o nome do processo atual

Todos os campos restantes no arquivo de formato do evento têm contrapartes como manipuladores
argumentos de função de mesmo nome, como pode ser visto no exemplo acima.

O acima fornece os fundamentos necessários para acessar diretamente todos os campos de cada evento em um
trace, que cobre 90% do que você precisa saber para escrever um script de rastreamento útil. o
as seções abaixo cobrem o resto.

SCRIPT LAYOUT

Cada script de desempenho Python deve começar configurando um caminho de pesquisa de módulo Python e
'importar' alguns módulos de suporte (consulte as descrições dos módulos abaixo):

.ft C
importar os
import sys

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

da importação perf_trace_context *
da importação do Core *
.ft

O restante do script pode conter funções de manipulador e funções de suporte em qualquer ordem.

Além das funções de manipulador de eventos discutidas acima, cada script pode implementar um conjunto
de funções opcionais:

trace_begin, se definido, é chamado antes que qualquer evento seja processado e dá aos scripts um
chance de fazer tarefas de configuração:

.ft C
def trace_begin:
passar
.ft

trace_end, se definido, é chamado após todos os eventos terem sido processados ​​e dá aos scripts um
chance de realizar tarefas de fim de script, como resultados de exibição:

.ft C
def trace_end:
passar
.ft

trace_unhandled, se definido, é chamado depois de qualquer evento que não tenha um manipulador
definido explicitamente para ele. O conjunto padrão de argumentos comuns é passado para ele:

.ft C
def trace_unhandled (event_name, context, common_cpu, common_secs,
common_nsecs, common_pid, common_comm):
passar
.ft

As seções restantes fornecem descrições de cada um dos scripts de desempenho integrados disponíveis
Módulos Python e suas funções associadas.

DISPONÍVEL MÓDULOS E FUNÇÕES

As seções a seguir descrevem as funções e variáveis ​​disponíveis por meio dos vários perf
módulos de script Python. Para usar as funções e variáveis ​​do módulo fornecido, adicione o
correspondente da XXXX importar linha para o seu script de desempenho.

Núcleo.py Módulo
Essas funções fornecem algumas funções essenciais para scripts de usuário.

A bandeira_str e símbolo_str funções fornecem strings legíveis por humanos para sinalização e símbolos
Campos. Eles correspondem às strings e valores analisados ​​a partir do impressão fmt campos do
arquivos de formato de evento:

flag_str (event_name, field_name, field_value) - retorna a representação da string correspondente a field_value para o campo de flag field_name do evento event_name
symbol_str (event_name, field_name, field_value) - retorna a representação da string correspondente a field_value para o campo simbólico field_name do evento event_name

A autodito função retorna um tipo especial de dicionário Python que implementa o de Perl
autovivificante hashes em Python, ou seja, com hashes de autovivificação, você pode atribuir hash aninhados
valores sem ter que se dar ao trabalho de criar níveis intermediários, se eles não
existir.

autodict () - retorna uma instância de dicionário autovivificante

perf_trace_context Módulo
Alguns dos comum campos no arquivo de formato de evento não são tão comuns, mas precisam ser
tornado acessível para scripts de usuário, no entanto.

perf_trace_context define um conjunto de funções que podem ser usadas para acessar esses dados no
contexto do evento atual. Cada uma dessas funções espera uma variável de contexto, que é
o mesmo que a variável de contexto passada para cada manipulador de eventos como o segundo argumento.

common_pc (contexto) - retorna a contagem common_preempt para o evento atual
common_flags (contexto) - retorna common_flags para o evento atual
common_lock_depth (context) - retorna common_lock_depth para o evento atual

Util.py Módulo
Várias funções de utilitário para uso com script de desempenho:

nsecs (segundos, nsecs) - retorna o total de nsecs dado o par de segundos / nsecs
nsecs_secs (nsecs) - retorna a porção de segundos inteira dada nsecs
nsecs_nsecs (nsecs) - retorna o resto nsecs dado nsecs
nsecs_str (nsecs) - retorna uma string imprimível no formato secs.nsecs
avg (total, n) - retorna a média dada uma soma e um número total de valores

Use perf-script-python online usando serviços onworks.net