Existe um bom substituto do Valgrind para o Windows?

Eu estava olhando para Valgrind para ajudar a melhorar minha codificação / debugging C quando descobri que é apenas para Linux – eu não tenho outra necessidade ou interesse em mover meu sistema operacional para o Linux, então eu queria saber se há um programa igualmente bom para o Windows.

Mais algumas boas ferramentas comerciais:

  • Purificar
  • Segure ++

Como jakobengblom2 apontou, valgrind tem um conjunto de ferramentas. Dependendo de qual você está falando, existem diferentes partes do contador de janelas. Eu mencionarei apenas o OSS ou ferramentas gratuitas aqui.

1. MemCheck:

Dr. memory. É uma ferramenta relativamente nova, funciona muito bem no Windows 7. Meu recurso favorito é agrupar as pilhas de alocação dos mesmos vazamentos no relatório.

http://code.google.com/p/drmemory/

Eu também usei UMDH ( http://support.microsoft.com/kb/268343 ) e achei muito útil e fácil de configurar. Trabalha do Win2000 ao Win7.

AppVerifier é um deve ter swissknife para desenvolvedores de código nativo do Windows, seu verificador de “memory” faz trabalho semelhante http://msdn.microsoft.com/en-us/library/dd371695%28v=vs.85%29.aspx

2. Callgrind:

Meu favorito é verysleepy ( http://www.codersnotes.com/sleepy ) É pequeno, mas muito útil e fácil de usar.

Se você precisar de mais resources, o Analisador de Desempenho AMD CodeAnalyst ™ é gratuito: http://developer.amd.com/documentation/videos/pages/introductiontoamdcodeanalystperformanceanalyzer.aspx

As ferramentas de Análise de Desempenho do Windows são gratuitas da Microsoft, não são muito fáceis de usar, mas podem executar o trabalho se você estiver disposto a gastar o tempo. http://blogs.microsoft.co.il/blogs/sasha/archive/2008/03/15/xperf-windows-performance-toolkit.aspx Download: http://msdn.microsoft.com/pt-br/performance / cc752957

3. Maciço:

Ferramentas gratuitas semelhantes (não exatamente iguais) no Windows são:

VMMap da sysinternals: http://technet.microsoft.com/pt-br/sysinternals/dd535533

comando! heap no windbg: http://hacksoflife.blogspot.com/2009/06/heap-debugging-memoryresource-leak-with.html

4. Cachegrind:

As Ferramentas de Desempenho do Windows acima mencionadas têm certo nível de capacidade de criação de perfil de falta de cache L2, mas não tão bom e fácil de usar quanto o Cachegrind.

5. DRD:

Ainda não encontrei nada livre e tão poderoso no Windows, a única ferramenta gratuita para Windows que eu acho que é um pouco próxima é o verificador de “bloqueio” no AppVerifier: http://msdn.microsoft.com/en-us/library /dd371695%28v=vs.85%29.aspx

Por que não usar o Valgrind + Wine para depurar seu aplicativo do Windows? Veja http://wiki.winehq.org/Wine_and_Valgrind

(O Chromium usa isso para verificar a versão do Windows em busca de erros de memory; veja build.chromium.org e veja as cachoeiras experimentais ou de memory e pesquise por vinho.)

Há também o Dr. Memory, veja dynamorio.org/drmemory.html

Para Visual C ++, tente Visual Leak Detector . Quando eu usei, ele detectou um memory leaks de uma new chamada e retornou a linha real no código-fonte do vazamento. A versão mais recente pode ser encontrada em http://vld.codeplex.com/ .

O ambiente de desenvolvimento para o Windows que você está usando pode conter suas próprias ferramentas. O Visual Studio, por exemplo, permite detectar e isolar vazamentos de memory em seus programas

Eu gostaria de listar algumas ferramentas, espero que seja útil

leia este artigo para mais detalhes

  1. Purificar
  2. Verificador de limites
  3. Coverity (basicamente é um analisador de código, mas, ele pegará memory leaks na estática)
  4. Código Glow
  5. dmalloc
  6. ccmalloc
  7. NJAMD
  8. YAMD
  9. Valgrind
  10. mpatrol
  11. Segure ++

Tente DUMA

Há PageHeap.exe parte das ferramentas de debugging para o Windows. É gratuito e é basicamente um alocador / desalocador de memory personalizado.

Consulte http://support.microsoft.com/kb/286470

Em combinação com o Visual Studio, geralmente uso o Visual Leak Detector ou simplesmente _CrtDumpMemoryLeaks (), que é uma chamada de API do win32. Ambos são nada extravagante, mas eles fazem o trabalho.

Eu tive a chance de usar o Compuware DevPartner Studio no passado e isso foi muito bom, mas é muito caro. Uma solução mais barata poderia ser o GlowCode , eu apenas trabalhei com uma versão 5.xe, apesar de alguns problemas em append a um processo que eu precisava depurar, funcionou muito bem.

Eu tenho amado o Memory Validator , de uma empresa chamada Software Verification.

O Viusual Studio pode ajudar a detectar vazamentos de memory. Consulte Dicas e truques do Microsoft Visual C ++ -> seção “Vazamentos de memory”. Veja também este post em SO

Embora o rastreamento real só seja possível com o Team Edtion do Visual Studio.

Consulte o link ” Ferramentas de teste de origem ” na página Recursos de ferramenta de teste e teste de controle de qualidade de software para obter uma lista de ferramentas semelhantes.

Eu usei BoundsChecker, DevPartner Studio e Intel V-Tune no passado para perfil. Eu gostei do V-Tune o melhor; você pode emular vários chipsets da Intel e fornecer dicas sobre como otimizar essa plataforma.

O Detector de Vazamento de Memória de Jochen Kalmbach está qualificado?

PS: O URL para a versão mais recente está enterrado em algum lugar no encadeamento de comentários do artigo.

LeakDiag, UMDH, App Verifier, DebugDiag, são ferramentas úteis para melhorar a robustez do código e encontrar vazamentos de memory.

A biblioteca Boost Test pode detectar vazamentos de memory.

Como sobre o Purify ?

Experimente o produto Inspector XE da Intel, que pode ajudá-lo a detectar problemas de memory e de encadeamento: http://software.intel.com/pt-br/articles/intel-inspector-xe/

Talvez o CodeSnitch seja algo que você está procurando? http://www.entrek.com/codesnitch.html

Se você está desenvolvendo com o Borland / CodeGear / Embarcadero C ++ Builder, você pode usar o CodeGuard.

Mais ou menos todos os Profilers incluem verificar se há vazamentos de memory e mostrar a pilha quando a memory foi alocada.

Eu posso recomendar o Intels Parallel Inspector . Simples de usar e sem necessidade de recompilation. A versão experimental é executada por 30 dias.

GlowCode e AtromatedQA também incluem tais capacidades. Todos eles oferecem testes gratuitos.

O Compuware DevPartner (também conhecido como BoundsChecker) em Contrast precisa de uma recompilation de “instrumentação” mais lenta e o aplicativo também é executado mais lentamente ao verificar erros. E o BoundsChecker não pode trabalhar com 64 Bits de todo. Nós desistimos dessa ferramenta.

A melhor ferramenta que já usei é o DevPartner BoundsChecker – não é grátis, mas tem um período de avaliação.

Outra ferramenta de memory para sua lista: o Validador de Memória .

Não é livre, mas nem de longe tão caro quanto Purify ou Boundschecker.

Se você não tem medo do mingw, aqui estão alguns links (alguns podem funcionar com o MSVC) … http://betterlogic.com/roger/?p=1140

Estamos apenas concluindo uma ferramenta de verificação de segurança de memory para o Windows, que lida com o GCC e o Micrsoft Visual C (ainda sem o C ++) e que estão procurando testadores Beta.

EDIT 12 de junho de 2011: Não mais Beta, agora produção para GCC e Microsoft Visual Studio C.

Eu encontrei este projeto SF hoje:

http://sourceforge.net/p/valgrind4win/wiki/Home/

Eles estão portando valgrind para o Windows. Provavelmente, em vários anos, teremos um valgrind confiável no Windows.

Confira esta pergunta: Existe um bom substituto do Valgrind para o Windows? . Embora seja solicitado um substituto geral para o valgrind, ele discute principalmente os detectores de memory leaks e não as detecções de condições de corrida.

Eu usei Insure ++ que faz excelente trabalho em encontrar vazamentos de memory c + + / corrupções e muitos outros erros como variables ​​não inicializadas, erros de ponteiro, cordas etc., Ele também faz visual “cobertura de código” e uso de memory de tempo de execução etc. seu código .. Você pode experimentá-lo para a versão trail ..

Você pode querer ler o que a Mozilla está fazendo em relação a vazamentos de memory. Uma ferramenta em sua checkbox de ferramentas é o coletor de lixo Hans Boehm usado como detector de memory leaks.

Você pode tentar testar o RuntimeChecker no teste do IBM Purify .

Uma solução gratuita seria usar o seguinte código no Visual Studio:

 #ifdef _DEBUG #define new DEBUG_NEW #endif 

Basta escrever isso no topo de todos os seus arquivos cpp. Isso detectará vazamentos de memory de seu aplicativo ao interromper a execução de debugging e listá-los na janela de saída. Clicar duas vezes em uma linha de vazamentos de memory mostrará a linha onde a memory está alocada e nunca liberada. Isso pode ajudá-lo: http://www.flipcode.com/archives/How_To_Find_Memory_Leaks.shtml