Valgrind - análise de memória

Um caso interessante que acontece quando começamos a trabalhar com alocação dinâmica em c, é a preocupação em liberar a memória que é feita utilizando a função free(). Contudo nem todos os programas que faremos terão um único ponteiro, podemos ter estruturas complexas com várias operações em seus dados, e como ter certeza nessas ocasiões de que a memória foi liberada? Para essas situações o uso da ferramenta valgrind é o ideal. Esta ferramenta lhe permite ver quantos alocações foram feitas e quantas foram liberadas, além de várias outras aplicações veja mais clicando aqui.

Para instalar a valgrind em sua máquina digite no terminal:

  sudo apt-get install valgrind

Agora, vamos fazer um teste com um programa básico. Digamos que criamos um ponteiro para inteiro e esquecemos de liberar no final da execução do programa, então no relatório da valgrind ao final da execução terá um alerta de quantas alocações fizemos em byte e quanto dessas alocações foram liberadas, segue o código abaixo:

#include<stdio.h>
#include<stdlib.h>

int main(int argc, char *argv[])

{
   int *inteiro;
   inteiro = (int*) malloc(sizeof(int));
   *inteiro = 10;
   printf("%d", *inteiro);
   return 0;

}

Quando for compilar e rodar o seu programa utilize o seguinte comando para ativar a valgrind:

  gcc nomedoprograma.c -o nomedoprograma
  valgrind ./nomedoprograma

Você receberá um relatório parecido com esse ao final do programa:

==5243== HEAP SUMMARY:

==5243==     in use at exit: 4 bytes in 1 blocks

==5243==   total heap usage: 1 allocs, 0 frees, 4 bytes allocated

==5243==

==5243== LEAK SUMMARY:

==5243==    definitely lost: 4 bytes in 1 blocks

==5243==    indirectly lost: 0 bytes in 0 blocks

==5243==      possibly lost: 0 bytes in 0 blocks

==5243==    still reachable: 0 bytes in 0 blocks

==5243==         suppressed: 0 bytes in 0 blocks

==5243== Rerun with --leak-check=full to see details of leaked memory

==5243==

==5243== For counts of detected and suppressed errors, rerun with: -v

==5243== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Note que fizemos uma alocação de 4 bytes e não à liberamos, o que temos que fazer é corrigir o nosso programa para que libere o espaço alocado:

#include<stdio.h>
#include<stdlib.h>

int main(int argc, char *argv[])

{
 int *inteiro;
 inteiro = (int*) malloc(sizeof(int));
 *inteiro = 10;
 printf("%d", *inteiro);
        free(inteiro);
 return 0;
}

E quando recompilar o seu programa verá um relatório diferente, mais otimista, com todos as alocações tendo seu espaço liberado após a execução:

 ==5350== HEAP SUMMARY:

==5350==     in use at exit: 0 bytes in 0 blocks

==5350==   total heap usage: 1 allocs, 1 frees, 4 bytes allocated

==5350==

==5350== All heap blocks were freed -- no leaks are possible

==5350==

==5350== For counts of detected and suppressed errors, rerun with: -v

==5350== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Esse foi um exemplo básico de como usar essa ferramenta, utilize-a em programas mais elaborados com várias estruturas que precisarão serem liberadas e deixe seus comentários sobre sua experiência com essa ferramenta. Até a próxima!

Valgrind: http://valgrind.org