memusage: en línea en la nube

PROGRAMA:

NOMBRE

memusage - uso de memoria de perfil de un programa

SINOPSIS

memusaje [opción] ... programa [programacion] ...

DESCRIPCIÓN

memusaje es un script bash que perfila el uso de memoria del programa, programa. Lo
precarga el libmemusage.so biblioteca en el entorno de la persona que llama (a través de la LD_PRELOAD
Variable ambiental; ver ld.so(8)). los libmemusage.so la biblioteca rastrea la asignación de memoria
interceptando llamadas a malloc(3) llamar(3) gratuita,(3), y reasignar(3); opcionalmente, llama
a mmap(2) mremapa(2), y mapamundi(2) también se puede interceptar.

memusaje puede generar los datos recopilados en forma textual, o puede utilizar memesagestat(1) (ver
las -p opción, a continuación) para crear un archivo PNG que contenga una representación gráfica de la
informacion recolectada.

Salud Cerebral personal resumen
La salida de línea "Resumen de uso de memoria" por memusaje contiene tres campos:

montón total
La suma de tamaño argumentos de todos malloc(3) llamadas, productos de argumentos
(nombre*tamaño) de todo llamar(3) llamadas y suma de de largo argumentos de todos mmap(2)
llamadas. En el caso de reasignar(3) y mremapa(2), si el nuevo tamaño de un
la asignación es mayor que el tamaño anterior, la suma de todas esas diferencias
(tamaño nuevo menos tamaño antiguo) se agrega.

montón pico
Máximo de todos tamaño argumentos de malloc(3), todos los productos de nombre*tamaño of
llamar(3), todos tamaño argumentos de reasignar(3) de largo argumentos de mmap(2), y
nuevo_tamaño argumentos de mremapa(2).

montón pico
Antes de la primera llamada a cualquier función supervisada, la dirección del puntero de la pila
(puntero de pila base) se guarda. Después de cada llamada de función, la pila real
se lee la dirección del puntero y la diferencia con el puntero de la pila base
calculado. El máximo de estas diferencias es entonces el pico de la pila.

Inmediatamente después de esta línea de resumen, una tabla muestra el número de llamadas, memoria total
asignado o desasignado, y número de llamadas fallidas para cada función interceptada. Para
reasignar(3) y mremapa(2), el campo adicional "nomove" muestra las reasignaciones que cambiaron
la dirección de un bloque, y el campo adicional "dec" muestra reasignaciones que disminuyeron
el tamaño del bloque. Para reasignar(3), el campo adicional "gratis" muestra las reasignaciones
que provocó la liberación de un bloque (es decir, el tamaño reasignado era 0).

La "reasignación / memoria total" de la salida de la tabla por memusaje no refleja los casos en los que
reasignar(3) se utiliza para reasignar un bloque de memoria para que tenga un tamaño más pequeño que antes.
Esto puede hacer que la suma de todas las celdas de "memoria total" (excluyendo "libre") sea mayor que el
celda de "memoria libre / total".

Histograma para bloquear tamaños
El "Histograma para tamaños de bloque" proporciona un desglose de las asignaciones de memoria en varios
tamaños de cubos.

CAMPUS

-n nombre , --progname =nombre
Nombre del archivo de programa a perfilar.

-p presentar, --png =presentar
Genere gráfico PNG y guárdelo en presentar.

-d presentar, --data =presentar
Genere un archivo de datos binarios y guárdelo en presentar.

-u, - sin búfer
No almacene la salida en búfer.

-b tamaño, --buffer =tamaño
Reunir. tamaño entradas antes de escribirlas.

--no temporizador
Deshabilitar basado en temporizador (SIGPROF) muestreo del valor del puntero de pila.

-m, --mmap
También rastrear mmap(2) mremapa(2), y mapamundi(2).

-?, --ayuda
Imprimir ayuda y salir.

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

-V, --versión
Imprime la información de la versión y sal.

Las siguientes opciones se aplican solo al generar una salida gráfica:

-t, - basado en el tiempo
Utilice el tiempo (en lugar del número de llamadas a funciones) como escala para el eje X.

-T, --total
También dibuje un gráfico del uso total de memoria.

--title =nombre
Uso nombre como título del gráfico.

-x tamaño, --x-tamaño =tamaño
Haz la gráfica tamaño píxeles de ancho.

-y tamaño, --y-size =tamaño
Haz la gráfica tamaño píxeles de alto.

SALIR ESTADO

El estado de salida es igual al estado de salida del programa perfilado.

EJEMPLO

A continuación se muestra un programa simple que reasigna un bloque de memoria en ciclos que se elevan a un pico
antes de luego reasignar cíclicamente la memoria en bloques más pequeños que vuelven a cero.
Después de compilar el programa y ejecutar los siguientes comandos, un gráfico de la memoria
el uso del programa se puede encontrar en el archivo memesage.png:

$ memusaje --data = memusage.dat ./a.fuera
...
Resumen de uso de memoria: total de pila: 45200, pico de pila: 6440, pico de pila: 224
total de llamadas total de llamadas fallidas de memoria
malloc | 1 400 0
realloc | 40 44800 0 (nomove: 40, dec: 19, gratis: 0)
calloc | 0 0 0
libre | 1 440
Histograma para tamaños de bloque:
192-207 1 2% ================
...
2192-2207 1 2% ================
2240-2255 2 4% ================================
2832-2847 2 4% ================================
3440-3455 2 4% ================================
4032-4047 2 4% ================================
4640-4655 2 4% ================================
5232-5247 2 4% ================================
5840-5855 2 4% ================================
6432-6447 1 2% ================
$ memesagestat memesage.dat memesage.png

Programa fuente
#incluye
#incluir

#definir CICLOS 20

int
principal (int argc, char * argv [])
{
i, j;
int * p;

printf ("malloc:% zd \ n", tamaño de (int) * 100);
p = malloc (tamaño de (int) * 100);

para (i = 0; i <CICLOS; i ++) {
si (i <CICLOS / 2)
j = yo;
más
j--;

printf ("reasignar:% zd \ n", tamaño de (int) * (j * 50 + 110));
p = reasignar (p, tamaño de (int) * (j * 50 + 100));

printf ("reasignar:% zd \ n", tamaño de (int) * ((j + 1) * 150 + 110));
p = reasignar (p, tamaño de (int) * ((j + 1) * 150 + 110));
}

libre (p);
salir (EXIT_SUCCESS);
}

Use memusage en línea usando los servicios de onworks.net