Como posso encontrar um vazamento de memória de um processo em execução?

Question

Existe uma maneira, eu posso encontrar o vazamento de memória de um processo em execução? Eu posso usar Valgrind para encontrar vazamentos de memória antes do início de um processo. Eu posso usar o GDB para anexá-lo a um processo em execução. Como depurar um vazamento de memória de um processo em execução?

    

Answer 1

Eu acho que memleax é exatamente o que você quer.

Ele depura o vazamento de memória de um processo em execução, anexando-o, sem recompilar o programa ou reiniciar o processo de destino. É muito conveniente e adequado para o ambiente de produção.

Funciona no GNU / Linux e no FreeBSD.

NOTA: Sou o autor, qualquer sugestão é bem-vinda

== EDIT ==

Eu escrevo outra ferramenta libleak , que conecta funções de memória por LD_PRELOAD.

Também não há necessidade de modificar o programa de destino. Embora você tenha que reiniciar o progresso com LD_PRELOAD, você pode ativar / desativar a detecção durante a execução.

Há muito menos impacto no desempenho, já que não há interceptação de sinal.

Em comparação com ferramentas semelhantes (como o mtrace), imprima a pilha de chamadas completa no ponto de vazamento de memória suspeito.

    

Answer 2

No Linux, você pode ativar o mtrace em seu programa, mas é uma alteração de código.

No OpenBSD, você pode tentar as estatísticas do malloc .

O verificador de vazamentos do Google também pode valer a pena, e ao contrário do mtrace, você pode ser capaz de usar LD_PRELOAD para evitar a recompilação.

    

Answer 3

Aqui estão quase etapas garantidas para descobrir quem está vazando a memória:

1. Descubra o PID do processo que causa vazamento de memória.

   ps -aux
   

2. capture o /proc/PID/smaps e salve em algum arquivo como BeforeMemInc.txt .

3. espere até que a memória seja aumentada.
4. capture novamente /proc/PID/smaps e salve-o tem afterMemInc.txt

5. encontre a diferença entre o primeiro smaps e o 2º smaps , e. g. com

   diff -u beforeMemInc.txt afterMemInc.txt

6. anote o intervalo de endereços em que a memória foi aumentada, por exemplo:

      beforeMemInc.txt            afterMemInc.txt
   ---------------------------------------------------
   2b3289290000-2b3289343000   2b3289290000-2b3289343000  #ADDRESS
   Shared_Clean:    0 kB       Shared_Clean:    0 kB          
   Shared_Dirty:    0 kB       Shared_Dirty:    0 kB
   Private_Clean:   0 kB       Private_Clean:   0 kB
   Private_Dirty:  28 kB       Private_Dirty:  36 kB  
   Referenced:     28 kB       Referenced:     36 kB
   Anonymous:      28 kB       Anonymous:      36 kB  #INCREASE MEM
   AnonHugePages:   0 kB       AnonHugePages:   0 kB
   Swap:            0 kB       Swap:            0 kB
   KernelPageSize:  4 kB       KernelPageSize:  4 kB
   MMUPageSize:     4 kB       MMUPageSize:     4 kB
   Locked:          0 kB       Locked:          0 kB
   VmFlags: rd wr mr mw me ac  VmFlags: rd wr mr mw me ac
   

7. use o GDB para despejar memória no processo em execução ou obter o coredump usando gcore -o process

8. Eu usei o gdb no processo em execução para despejar a memória em algum arquivo.

   gdb -p PID
   dump memory ./dump_outputfile.dump 0x2b3289290000 0x2b3289343000
   

9. agora, use o comando strings ou hexdump -C para imprimir o dump_outputfile.dump

   strings outputfile.dump
   

10. Você obtém um formato legível no qual é possível localizar essas cadeias de caracteres seu código-fonte.

11. Analise sua fonte para encontrar o vazamento.

Answer 4

Acho que, sem fornecer suporte para o monitoramento de alocação após o início do programa diretamente no código-fonte, você está sem sorte. Aqui estão dois motivos pelos quais posso pensar:

• Os verificadores de heap são inicializados quando o programa é iniciado. Alguns oferecem a capacidade de ajustar o tempo exato, mas as variáveis de ambiente que as iniciam devem ser definidas quando o programa é executado. Isso ocorre porque eles observam para garantir que cada alocação tenha uma desalocação correspondente e, caso contrário, perderiam alguma coisa.
A verificação de heap geralmente requer privilégios elevados, ou ganchos, a serem fornecidos pelo sistema operacional. Se esses ganchos não forem fornecidos no momento do início do programa, os verificadores de heap não poderão aproveitá-los. Não acredito que os sistemas operacionais forneçam esses privilégios após o início do programa em questão.

Se, no entanto, o seu programa estiver sendo executado em uma máquina virtual, esse ambiente poderá fornecer suporte para monitoramento de alocações. Eu sei que o Java tem várias ferramentas de monitoramento de alocação e coleta de lixo (como visualVM ) que são anexadas a programas ou VMs em execução.

    

Answer 5

Purify é provavelmente a ferramenta mais antiga e sofisticada de todas. Ele sinalizará o número da linha no código que causa o vazamento de memória.