内存泄漏检查方法(for Linux)
如果你更想读原始文档, 请参考glibc info的"Allocation Debugging"一章 (执行info libc);
glibc提供了一个检查内存泄漏的方法, 前提是你的程序使用glibc的标准函数分配内存(如malloc, alloc...):
1. 在需要内存泄漏检查的代码的开始调用void mtrace(void) (在mcheck.h中有声明). mtrace为malloc等函数安装hook, 用于记录内存分配信息.在需要内存泄漏检查的代码的结束调用void muntrace(void).
注意: 一般情况下不要调用muntrace, 而让程序自然结束. 因为可能有些释放内存的的代码要到muntrace之后才运行.
2. 用debug模式编译被检查代码(-g或-ggdb)
3. 设置环境变量MALLOC_TRACE为一文件名, 这一文件将存有内存分配信息.
4. 运行被检查程序, 直至结束或muntrace被调用.
5. 用mtrace命令解析内存分配Log文件($MALLOC_TRACE)
(mtrace foo $MALLOC_TRACE, where foo is the executible name)
如果有内存泄漏, mtrace会输出分配泄漏内存的代码位置,以及分配数量.
其他东西
1. 可以将mtrace, muntrace放入信号处理函数(USR1, USR2), 以动态地进行内存泄漏检查控制.
2. mtrace是个perl代码, 如果你对符号地址与代码文本的转换感兴趣, 可以读一下.
3. again, 尽量不要用muntrace()
For C++ Leak:
检查内存泄漏的方法除glibc提供外；
还可以试试一些专用的程序；如：
ccmalloc
http://www.inf.ethz.ch/personal/biere/projects/ccmalloc/ccmalloc-english.html
mpatrol
http://www.cbmamiga.demon.co.uk/mpatrol/
这俩个工具的功能相当不错，能对程序进行相当全面的检查
01 #include <stdlib.h>
02 #include <mcheck.h>03
04 void func(void)
05 {
06 int* ptr = malloc(10 * sizeof(int));
07 //free(ptr);
08 }
09
10 int main(void)
11 {
12 setenv("MALLOC_TRACE", "output_file_name", 1);
13 mtrace();
14 func();
15 return 0;
16 }
# gcc test.c -o test -g
# ./test
# more output_file_name
= Start
@ ./test:[0x80483e6] + 0x804a470 0x28
@ /lib/tls/i686/cmov/libc.so.6:(clearenv+0x7c)[0xb7e449ac] - 0x804a008
@ /lib/tls/i686/cmov/libc.so.6:(tdestroy+0x47)[0xb7eec6d7] - 0x804a0c0
@ /lib/tls/i686/cmov/libc.so.6:(tdestroy+0x4f)[0xb7eec6df] - 0x804a0e8
# mtrace output_file_name
- 0x0804a008 Free 3 was never alloc'd 0xb7e449ac
- 0x0804a0c0 Free 4 was never alloc'd 0xb7eec6d7
- 0x0804a0e8 Free 5 was never alloc'd 0xb7eec6df
Memory not freed:
-----------------
0 Address Size Caller
0x0804a470 0x28 at 0x80483e6
01 #include <stdlib.h>
02 #include <mcheck.h>
03
04 void func(void)
05 {
06 int* ptr = malloc(10 * sizeof(int));
07 free(ptr);
08 }
09
10 int main(void)
11 {
12 setenv("MALLOC_TRACE", "output_file_name", 1);
13 mtrace();
14 func();
15 return 0;
16 }
# more output_file_name
= Start
@ ./test:[0x8048426] + 0x804a470 0x28
@ ./test:[0x8048434] - 0x804a470
@ /lib/tls/i686/cmov/libc.so.6:(clearenv+0x7c)[0xb7e149ac] - 0x804a008
@ /lib/tls/i686/cmov/libc.so.6:(tdestroy+0x47)[0xb7ebc6d7] - 0x804a0c0
@ /lib/tls/i686/cmov/libc.so.6:(tdestroy+0x4f)[0xb7ebc6df] - 0x804a0e8
0x8048426 分配内存空间的指令地址
0x804a470 malloc分配的内存空间己地址
+ 表示分配内存
- 表示释放内存
# mtrace output_file_name
- 0x0804a008 Free 4 was never alloc'd 0xb7e149ac
- 0x0804a0c0 Free 5 was never alloc'd 0xb7ebc6d7
- 0x0804a0e8 Free 6 was never alloc'd 0xb7ebc6df
No memory leaks.
--------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
void func(void)
{
int* ptr = malloc(10 * sizeof(int));
//free(ptr);
}
int main(void)
{
setenv("MALLOC_TRACE", "output_file_name", 1);
mtrace();
func();
while (1)
{
muntrace();
}
return 0;
}
$ ./a.out &
$ more output_file_name
= Start
@ ./a.out:[0x8048426] + 0x804a468 0x28
= End
--------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
void func(void)
{
int* ptr = malloc(10 * sizeof(int));
//free(ptr);
}
int main(void)
{
setenv("MALLOC_TRACE", "output_file_name", 1);
mtrace();
func();
while (1)
{
sleep (1);
func ();
muntrace();
}
return 0;
}
= Start
@ ./a.out:[0x8048456] + 0x804a468 0x28
@ ./a.out:[0x8048456] + 0x804a498 0x28
= End
虽然while中反复调用func()但是此处只检测到两次(while外一次，while内一次)
---------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
void func(void)
{
int* ptr = malloc(10 * sizeof(int));
//free(ptr);
}
int main(void)
{
setenv("MALLOC_TRACE", "output_file_name", 1);
mtrace();
func();
while (1)
{
sleep (1);
func ();
//muntrace();
}
return 0;
}
这种使用方式，进程中守护任务，所以output_file_name不会马上有内存，需要等一会儿
函数各自生成自己的内存泄露检测报告，这样比较麻烦
---------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
#include <stdio.h>
void func(void)
{
char buff[128];
snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
setenv("MALLOC_TRACE", buff, 1);
mtrace();
int* ptr = malloc(10 * sizeof(int));
//free(ptr);
muntrace();
}
void test()
{
char buff[128];
snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
setenv("MALLOC_TRACE", buff, 1);
mtrace();
int* ptr = malloc(10 * sizeof(int));
//free(ptr);
muntrace();
}
void task()
{
char buff[128];
snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
setenv("MALLOC_TRACE", buff, 1);
mtrace();
int* ptr = malloc(10 * sizeof(int));
//free(ptr);
while (1)
{
usleep (10);
/* 如果不在这里调用muntrace，将不能生成检测报告 */
muntrace();
}
}
int main(void)
{
//mtrace();
func();
test();
task();
return 0;
}
普通函数统一报告，有无限循环的函数单独生成报告
---------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
#include <stdio.h>
void func(void)
{
int* ptr = malloc(10 * sizeof(int));
}
void test()
{
int* ptr = malloc(10 * sizeof(int));
}
void task()
{
char buff[128];
snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
setenv("MALLOC_TRACE", buff, 1);
mtrace();
int* ptr = malloc(10 * sizeof(int));
while (1)
{
usleep (10);
/* 如果不在这里调用muntrace，将不能生成检测报告 */
muntrace();
}
}
int main(void)
{
char buff[128];
snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
setenv("MALLOC_TRACE", buff, 1);
mtrace();
func();
test();
task();
return 0;
}
创建线程前检测一次，并结束检测；线程自行检测；线程创建后不能再进行检测，
如果需要检测，则不能调用muntrace()，但是检测还是会失效
---------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
#include <stdio.h>
#include <pthread.h>
void func(void)
{
int* ptr = malloc(10 * sizeof(int));
}
void test()
{
int* ptr = malloc(100 * sizeof(int));
}
void task()
{
char buff[128];
snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
setenv("MALLOC_TRACE", buff, 1);
mtrace();
int* ptr = malloc(1000 * sizeof(int));
while (1)
{
usleep (10);
/* 如果不在这里调用muntrace，将不能生成检测报告 */
muntrace();
}
}
int main(void)
{
pthread_t id;
int i, ret;
char buff[128];
snprintf (buff, sizeof (buff), "%s%d", __FUNCTION__, __LINE__);
setenv("MALLOC_TRACE", buff, 1);
mtrace();
func();
test();
muntrace();
ret = pthread_create(&id, NULL, (void *)task, NULL);
if (ret != 0)
{
printf("Create pthread error!\n");
exit(1);
}
#if 0 /* 创建线程(线程自行负责检测)后，就不能再检测了，否则会有段错误 */
snprintf (buff, sizeof (buff), "%s%d", __FUNCTION__, __LINE__);
setenv("MALLOC_TRACE", buff, 1);
mtrace();
test();
//muntrace();
#endif
sleep(1);
//while (1) {}
return 0;
}
Valgrind
内存检测工具1. ccmalloc－Linux和Solaris下对C和C++程序的简单的使用内存泄漏和malloc调试库。
2. Dmalloc－Debug Malloc Library.
3. Electric Fence－Linux分发版中由Bruce Perens编写的malloc()调试库。
4. Leaky－Linux下检测内存泄漏的程序。
5. LeakTracer－Linux、Solaris和HP-UX下跟踪和分析C++程序中的内存泄漏。
6. MEMWATCH－由Johan Lindh编写，是一个开放源代码C语言内存错误检测工具，主要是通过gcc的precessor来进行。
7. Valgrind－Debugging and profiling Linux programs, aiming at programs written in C and C++.
8. KCachegrind－A visualization tool for the profiling data generated by Cachegrind and Calltree.
13. DTrace－即动态跟踪Dynamic Tracing，是一款开源软件，能在Unix类似平台运行，用户能够动态检测操作系统内核和用户进程，以更精确地掌握系统的资源使用状况，提高系统性能，减少支持成本，并进行有效的调节。
14. IBM Rational PurifyPlus－帮助开发人员查明C/C++、托管.NET、Java和VB6代码中的性能和可靠性错误。PurifyPlus 将内存错误和泄漏检测、应用程序性能描述、代码覆盖分析等功能组合在一个单一、完整的工具包中。
15. Parasoft Insure++－针对C/C++应用的运行时错误自动检测工具，它能够自动监测C/C++程序，发现其中存在着的内存破坏、内存泄漏、指针错误和I/O 等错误。并通过使用一系列独特的技术（SCI技术和变异测试等），彻底的检查和测试我们的代码，精确定位错误的准确位置并给出详细的诊断信息。能作为 Microsoft Visual C++的一个插件运行。
16. Compuware DevPartner for Visual C++ BoundsChecker Suite－为C++开发者设计的运行错误检测和调试工具软件。作为Microsoft Visual Studio和C++ 6.0的一个插件运行。
17. Electric Software GlowCode－包括内存泄漏检查，code profiler，函数调用跟踪等功能。给C++和.Net开发者提供完整的错误诊断，和运行时性能分析工具包。
18. Compuware DevPartner Java Edition－包含Java内存检测,代码覆盖率测试,代码性能测试,线程死锁,分布式应用等几大功能模块。
19. Quest JProbe－分析Java的内存泄漏。
20. ej-technologies JProfiler－一个全功能的Java剖析工具，专用于分析J2SE和J2EE应用程序。它把CPU、执行绪和内存的剖析组合在一个强大的应用中。 JProfiler可提供许多IDE整合和应用服务器整合用途。JProfiler直觉式的GUI让你可以找到效能瓶颈、抓出内存泄漏、并解决执行绪的问 题。4.3.2注册码：A-G666#76114F-1olm9mv1i5uuly#0126
21. BEA JRockit－用来诊断Java内存泄漏并指出根本原因，专门针对Intel平台并得到优化，能在Intel硬件上获得最高的性能。
22. SciTech Software AB .NET Memory Profiler－找到内存泄漏并优化内存使用针对C#，VB.Net，或其它.Net程序。
23. YourKit .NET & Java Profiler－业界领先的Java和.NET程序性能分析工具。
26 BChecker6
附录：内存泄漏的发生方式
1. 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。
2. 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。
3. 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块且仅有一块内存发生泄漏。
4. 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但 是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。
什么是系统资源？
当应用程序在Windows中运行时，Windows必须实时"跟踪"该应用程序的运行，并保留与之相关的许多信息，如按钮、光标、菜单的位置和位图、窗 口的状况等，这些信息由Windows保留在一种叫堆的内存块中，堆的英文为Heap。简单地说，堆是采用特殊机制管理的内存块。由Windows的一个 系统内核User.exe管理的堆叫做User资源堆（User Resource Heap），由另一个系统内核Gdi.exe管理的堆叫做GDI资源堆（Graphical Device Interface Resource Heap，简称GDI Resource Heap），User资源堆和GDI资源堆合称为系统资源堆（System Resource Heap），习惯上就把它们叫做系统资源（System Resource）。
微软将Windows的系统资源（堆）分为五个堆，其中User资源堆为三个，而GDI资源堆为两个。
三个User资源堆分别是：16位的用户堆（User Heap，64KB）；32位的窗口堆（Windows Heap，2MB）；32位的用户菜单堆（User Menu Heap，2MB）。
两个GDI资源堆分别是：16位的GDI堆（GDI Heap，64KB）；32位的GDI堆（GDI，2MB）。
从这里的系统资源分类和大小我们应该明白，不管CPU是P4还是486，内存是8M还是1G，所有Windows的用户都拥有同样大小的系统资源（堆），用户不能自已增加或减少系统资源的大小，这是由操作系统决定的，与硬件档次没有任何关系。
Windows的User资源堆和GDI资源堆的可用（Free）空间称为可用 User资源和可用GDI资源，Windows中以百分数表示它们，用户可以选择 "开始/附件/系统工具/系统信息"，来实时查看它们的大小。
各位朋友 给些建议哦(=_=)
c++内存检查函数
在c++中有内存溢出的处理函数，包含在<new>,void nomoreMemory( ) {cerr<<"内存不足\n";abort( );} int main(){ set_new_handler(nomoreMemory);
主要的是set_new_handler函数，传进去的是一个无返回值的无参函数
所有使用动态内存分配(dynamic memory allocation)的程序都有机会遇上内存泄露(memory leakage)问题，在Linux里有三种常用工具来检测内存泄露的情況，包括：
1. mtrace
mtrace是三款工具之中是最简单易用的，mtrace是一个C函數，在<mcheck.h>里声明及定义，函数原型为：
其实mtrace是类似malloc_hook的 malloc handler，只不过mtrace的handler function已由系统为你写好，但既然如此，系统又怎么知道你想将malloc/free的记录写在哪里呢？为此，调用mtrace()前要先设置 MALLOC_TRACE环境变量：
「output_file_name」就是储存检测结果的文件的名称。
但是检测结果的格式是一般人无法理解的，而只要有安装mtrace的话，就会有一名为mtrace的Perl script，在shell输入以下指令：
就会将output_file_name的內容转化成能被理解的语句，例如「No memory leaks」，「0x12345678 Free 10 was never alloc」诸如此类。
例如以下有一函数：(暂且放下single entry single exit的原则)
执行后，再用mtrace 将结果输出：
最后一行标明有一个大小为1 byte的内存尚未释放，大概是指「hello」吧。
结果如下：
mtrace的原理是记录每一对malloc-free的执行，若每一个malloc都有相应的free，则代表没有内存泄露，对于任何非malloc/free情況下所发生的内存泄露问题，mtrace并不能找出来。
Memwatch简介
在三种检测工具当中，设置最简单的算是memwatch，和dmalloc一样，它能检测未释放的内存、同一段内存被释放多次、位址存取错误及不当使用未分配之内存区域。请往http://www.linkdata.se/sourcecode.html下载最新版本的Memwatch。
安装及使用memwatch
很幸运地，memwatch根本是不需要安装的，因为它只是一组C程序代码，只要在你程序中加入memwatch.h，编译时加上-DMEMWATCH -DMW_STDIO及memwatch.c就能使用memwatch，例如：
gcc -DMEMWATCH -DMW_STDIO test.c memwatch.c -o test
memwatch输出結果
memwatch 的输出文件名称为memwatch.log，而且在程序执行期间，所有错误提示都会显示在stdout上，如果memwatch未能写入以上文件，它会尝试写入memwatchNN.log，而NN介于01至99之间，若它仍未能写入memwatchNN.log，则会放弃写入文件。
我们引用第一篇(mtrace)中所使用过的有问题的代码：
然后在shell中输入以下编译指令：
memwatch.log的內容如下：
文件指出，在test.c被执行到第9行时所分配的内存仍未被释放，该段内存的大小为1 byte。
Memwatch使用注意
Memwatch 的优点是无需特別配置，不需安装便能使用，但缺点是它会拖慢程序的运行速度，尤其是释放内存时它会作大量检查。但它比mtrace和dmalloc多了一项功能，就是能模拟系统内存不足的情況，使用者只需用mwLimit(long num_of_byte)函数来限制程式的heap memory大小(以byte单位)。
最详细的使用说明(包括优点缺点，运行原理等)已在README中列出，本人强烈建议各位读者参考该文件。
4091
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
