memusage - Online na nuvem

PROGRAMA:

NOME

memusage - uso de memória de perfil de um programa

SINOPSE

mensagem [opção] ... programa [opção de programação] ...

DESCRIÇÃO

mensagem é um script bash que traça o perfil do uso de memória do programa, programa. Ele
pré-carrega o libmemusage.so biblioteca no ambiente do chamador (por meio do LD_PRELOAD
variável de ambiente; Vejo ld.so(8)). o libmemusage.so biblioteca rastreia alocação de memória
interceptando chamadas para Malloc(3) calloc(3) sem(3), e realocar(3); opcionalmente, chamadas
para mmap(2) mremap(2), e mapa numérico(2) também pode ser interceptado.

mensagem pode produzir os dados coletados na forma textual ou pode usar memusagestat(1) (ver
que o -p opção, abaixo) para criar um arquivo PNG contendo uma representação gráfica do
Dados coletados.

Memória uso resumo
A linha de saída "Resumo do uso de memória" por mensagem contém três campos:

montão total
Soma de tamanho argumentos de todos Malloc(3) chamadas, produtos de argumentos
(nome*tamanho) de tudo calloc(3) chamadas e soma de comprimento argumentos de todos mmap(2)
chamadas. No caso de realocar(3) e mremap(2), se o novo tamanho de um
alocação é maior do que o tamanho anterior, a soma de todas essas diferenças
(novo tamanho menos o tamanho antigo) é adicionado.

montão pico
Máximo de tudo tamanho argumentos de Malloc(3), todos os produtos de nome*tamanho of
calloc(3), todos tamanho argumentos de realocar(3) comprimento argumentos de mmap(2), e
novo_size argumentos de mremap(2).

pilha pico
Antes da primeira chamada para qualquer função monitorada, o endereço do ponteiro da pilha
(ponteiro da pilha de base) é salvo. Após cada chamada de função, a pilha real
o endereço do ponteiro é lido e a diferença do ponteiro da pilha de base
computado. O máximo dessas diferenças é, então, o pico da pilha.

Imediatamente após esta linha de resumo, uma tabela mostra o número de chamadas, memória total
alocado ou desalocado e número de chamadas com falha para cada função interceptada. Para
realocar(3) e mremap(2), o campo adicional "nomove" mostra realocações que mudaram
o endereço de um bloco, e o campo adicional "dec" mostra realocações que diminuíram
o tamanho do bloco. Para realocar(3), o campo adicional "livre" mostra as realocações
que fez com que um bloco fosse liberado (ou seja, o tamanho realocado era 0).

A "realocação / memória total" da saída da tabela por mensagem não reflete casos onde
realocar(3) é usado para realocar um bloco de memória para ter um tamanho menor do que o anterior.
Isso pode fazer com que a soma de todas as células de "memória total" (excluindo "livre") seja maior do que o
célula de "memória livre / total".

Histograma para quadra tamanhos
O "Histograma para tamanhos de bloco" fornece uma divisão das alocações de memória em vários
tamanhos de balde.

OPÇÕES

-n nome, --progname =nome
Nome do arquivo de programa para o perfil.

-p lima, --png =lima
Gerar gráfico PNG e armazená-lo em lima.

-d lima, --data =lima
Gerar arquivo de dados binários e armazená-lo em lima.

-u, --sem buffer
Não armazene a saída em buffer.

-b tamanho, --buffer =tamanho
Recolha tamanho entradas antes de escrevê-las.

--sem temporizador
Desativar baseado em cronômetro (SIGPROF) amostragem do valor do ponteiro da pilha.

-m, --mmap
Também rastrear mmap(2) mremap(2), e mapa numérico(2).

-?, --Socorro
Imprimir ajuda e sair.

--uso
Imprima uma mensagem curta de uso e saia.

-V, --versão
Imprime informações sobre a versão e sai.

As seguintes opções se aplicam apenas ao gerar saída gráfica:

-t, - baseado em tempo
Use o tempo (em vez do número de chamadas de função) como escala para o eixo X.

-T, --total
Desenhe também um gráfico do uso total da memória.

--title =nome
Use nome como o título do gráfico.

-x tamanho, --x-size =tamanho
Faça o gráfico tamanho pixels de largura.

-y tamanho, --y-size =tamanho
Faça o gráfico tamanho pixels de altura.

SAIR STATUS

O status de saída é igual ao status de saída do programa com perfil.

EXEMPLO

Abaixo está um programa simples que realoca um bloco de memória em ciclos que atingem o pico
antes de então realocar ciclicamente a memória em blocos menores que voltam a zero.
Depois de compilar o programa e executar os seguintes comandos, um gráfico da memória
o uso do programa pode ser encontrado no arquivo memusage.png:

$ mensagem --data = memusage.dat ./a.fora
...
Resumo do uso de memória: heap total: 45200, pico de heap: 6440, pico de pilha: 224
total de chamadas memória total de chamadas com falha
malloc | 1 400 0
realloc | 40 44800 0 (nomear: 40, dez: 19, gratuito: 0)
calloc | 0 0 0
grátis | 1 440
Histograma para tamanhos de bloco:
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% =================
$ memusagestat memusage.dat memusage.png

Agenda fonte
#includes
#incluir

# define CICLOS 20

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

printf ("malloc:% zd \ n", sizeof (int) * 100);
p = malloc (sizeof (int) * 100);

para (i = 0; i <CICLOS; i ++) {
if (i <CICLOS / 2)
j = eu;
outro
j--;

printf ("realocar:% zd \ n", sizeof (int) * (j * 50 + 110));
p = realocar (p, sizeof (int) * (j * 50 + 100));

printf ("realloc:% zd \ n", sizeof (int) * ((j + 1) * 150 + 110));
p = realocar (p, sizeof (int) * ((j + 1) * 150 + 110));
}

livre (p);
sair (EXIT_SUCCESS);
}

Use memusage online usando serviços onworks.net