sprof - Online en la nube

PROGRAMA:

NOMBRE

sprof: lee y muestra datos de perfiles de objetos compartidos

SINOPSIS

sprof [opción] ... ruta-objeto-compartido [ruta de datos de perfil]

DESCRIPCIÓN

La sprof El comando muestra un resumen de creación de perfiles para el objeto compartido (biblioteca compartida)
especificado como su primer argumento de línea de comandos. El resumen de perfiles se crea utilizando
datos de generación de perfiles previamente generados en el segundo argumento de línea de comandos (opcional). Si
se omite el nombre de la ruta de datos de generación de perfiles, luego sprof intentará deducirlo utilizando el
nombre del objeto compartido, buscando un archivo con el nombre .perfil en la sección de
directorio actual.

OPCIONES

Las siguientes opciones de la línea de comandos especifican la salida del perfil que se generará:

-c, - pares de llamadas
Imprima una lista de pares de rutas de llamadas para las interfaces exportadas por el
objeto, junto con el número de veces que se utiliza cada ruta.

-p, - perfil plano
Genere un perfil plano de todas las funciones en el objeto monitoreado, con
recuentos y garrapatas.

-q, --grafico
Genere un gráfico de llamadas.

Si no se especifica ninguna de las opciones anteriores, el comportamiento predeterminado es mostrar un plano
perfil y un gráfico de llamadas.

Están disponibles las siguientes opciones adicionales de la línea de comandos:

-?, --ayuda
Muestre un resumen de las opciones y argumentos de la línea de comandos y salga.

--uso
Muestre un mensaje de uso breve y salga.

-V, --versión
Muestre la versión del programa y salga.

CONFORME A

La sprof El comando es una extensión GNU, no presente en POSIX.1.

EJEMPLO

El siguiente ejemplo demuestra el uso de sprof. El ejemplo consta de una
programa que llama a dos funciones en un objeto compartido. Primero, el código del programa principal:

$ gato prog.c
#incluir

vacío x1 (vacío);
vacío x2 (vacío);

int
principal (int argc, char * argv [])
{
x1 ();
x2 ();
salir (EXIT_SUCCESS);
}

Las funciones x1 () y x2 () se definen en el siguiente archivo fuente que se utiliza para
construir el objeto compartido:

$ gato libdemo.c
#incluir

vacío
consumeCpu1 (int lim)
{
intj;

para (j = 0; j <lim; j ++)
getppid ();
}

vacío
x1 (vacío) {
intj;

para (j = 0; j <100; j ++)
consumirCpu1(200000);
}

vacío
consumeCpu2 (int lim)
{
intj;

para (j = 0; j <lim; j ++)
getppid ();
}

vacío
x2 (vacío)
{
intj;

para (j = 0; j <1000; j ++)
consumirCpu2(10000);
}

Ahora construimos el objeto compartido con el nombre real. libdemo.so.1.0.1y el soname
libdemo.so.1:

$ cc -g -fPIC -compartido -Wl, -soname, libdemo.so.1 \
-o libdemo.so.1.0.1 libdemo.c

Luego construimos enlaces simbólicos para el nombre de la biblioteca y el nombre del enlazador de la biblioteca:

$ ln -sf libdemo.so.1.0.1 libdemo.so.1
$ ln -sf libdemo.so.1 libdemo.so

A continuación, compilamos el programa principal, vinculándolo con el objeto compartido y luego enumeramos los
dependencias dinámicas del programa:

$ cc -g -o prog prog.c -l -ldemo
$ ldd prog
linux-vdso.so.1 => (0x00007fff86d66000)
libdemo.so.1 => no encontrado
libc.so.6 => /lib64/libc.so.6 (0x00007fd4dc138000)
/lib64/ld-linux-x86-64.so.2 (0x00007fd4dc51f000)

Para obtener información de perfil para el objeto compartido, definimos el entorno
variable PERFIL_LD con el soname de la biblioteca:

$ exportar LD_PROFILE = libdemo.so.1

Luego definimos la variable de entorno LD_PROFILE_SALIDA con el nombre de ruta del
directorio donde se debe escribir la salida del perfil, y cree ese directorio si no lo hace
ya existe:

$ exportar LD_PROFILE_OUTPUT = $ (pwd) / prof_data
$ mkdir -p $ LD_PROFILE_OUTPUT

PERFIL_LD hace que la salida de perfiles sea anexado al archivo de salida si ya existe,
por lo que nos aseguramos de que no haya datos de creación de perfiles preexistentes:

$ rm -f $ LD_PROFILE_OUTPUT / $ LD_PROFILE.profile

Luego ejecutamos el programa para producir la salida del perfil, que se escribe en un archivo en el
directorio especificado en LD_PROFILE_SALIDA:

$ LD_LIBRARY_PATH =. ./prog
$ ls prof_datos
libdemo.so.1.perfil

Luego usamos el sprof -p opción para generar un perfil plano con recuentos y ticks:

$ sprof -p libdemo.so.1 $ LD_PROFILE_OUTPUT / libdemo.so.1.profile
Perfil plano:

Cada muestra cuenta como 0.01 segundos.
% total de uno mismo acumulativo
tiempo segundos segundos nos llama / llámanos / llama al nombre
60.00 0.06 0.06 100 consumirCpu600.00
40.00 0.10 0.04 1000 consumirCpu40.00
0.00 0.10 0.00 1 0.00 x1
0.00 0.10 0.00 1 0.00 x2

La sprof -q La opción genera un gráfico de llamadas:

$ sprof -q libdemo.so.1 $ LD_PROFILE_OUTPUT / libdemo.so.1.profile

índice% tiempo que los propios hijos llaman nombre

0.00 0.00 100/100 x1 [1]
[0] 100.0 0.00 0.00 100 consumirCpu1 [0]
-----------------------------------------------
0.00 0.00 1/1
[1] 0.0 0.00 0.00 1 x1 [1]
0.00 0.00 100/100 consumeCpu1 [0]
-----------------------------------------------
0.00 0.00 1000/1000 x2 [3]
[2] 0.0 0.00 0.00 1000 consumirCpu2 [2]
-----------------------------------------------
0.00 0.00 1/1
[3] 0.0 0.00 0.00 1 x2 [3]
0.00 0.00 1000/1000 consumeCpu2 [2]
-----------------------------------------------

Arriba y abajo, el " "las cadenas representan identificadores que están fuera del
objeto perfilado (en este ejemplo, son instancias de principal()).

La sprof -c La opción genera una lista de pares de llamadas y el número de sus ocurrencias:

$ sprof -c libdemo.so.1 $ LD_PROFILE_OUTPUT / libdemo.so.1.profile
x1 1
x1 consumirCpu1 100
x2 1
x2 consumirCpu2 1000

Usa sprof en línea usando los servicios de onworks.net