Valgrind 介绍
Valgrind是一个GPL的软件,用于Linux(For x86, amd64 and ppc32)程序的内存调试和代码剖析。你可以在它的环境中运行你的程序来监视内存的使用情况,比如C 语言中的malloc和free或者 C++中的new和 delete。使用Valgrind的工具包,你可以自动的检测许多内存管理和线程的bug,避免花费太多的时间在bug寻找上,使得你的程序更加稳固。
Valgrind的主要功能
Valgrind工具包包含多个工具,如Memcheck,Cachegrind,Helgrind, Callgrind,Massif。下面分别介绍个工具的作用:
Memcheck 工具主要检查下面的程序错误:
- 使用未初始化的内存 (Use of uninitialised memory)
- 使用已经释放了的内存 (Reading/writing memory after it has been free’d)
- 使用超过 malloc分配的内存空间(Reading/writing off the end of malloc’d blocks)
- 对堆栈的非法访问 (Reading/writing inappropriate areas on the stack)
- 申请的空间是否有释放 (Memory leaks – where pointers to malloc’d blocks are lost forever)
- malloc/free/new/delete申请和释放内存的匹配(Mismatched use of malloc/new/new [] vs free/delete/delete [])
- src和dst的重叠(Overlapping src and dst pointers in memcpy() and related functions)
Callgrind收集程序运行时的一些数据,函数调用关系等信息,还可以有选择地进行cache 模拟。在运行结束时,它会把分析数据写入一个文件。callgrind_annotate可以把这个文件的内容转化成可读的形式。
它模拟 CPU中的一级缓存I1,D1和L2二级缓存,能够精确地指出程序中 cache的丢失和命中。如果需要,它还能够为我们提供cache丢失次数,内存引用次数,以及每行代码,每个函数,每个模块,整个程序产生的指令数。这对优化程序有很大的帮助。
它主要用来检查多线程程序中出现的竞争问题。Helgrind 寻找内存中被多个线程访问,而又没有一贯加锁的区域,这些区域往往是线程之间失去同步的地方,而且会导致难以发掘的错误。Helgrind实现了名为” Eraser” 的竞争检测算法,并做了进一步改进,减少了报告错误的次数。
堆栈分析器,它能测量程序在堆栈中使用了多少内存,告诉我们堆块,堆管理块和栈的大小。Massif能帮助我们减少内存的使用,在带有虚拟内存的现代系统中,它还能够加速我们程序的运行,减少程序停留在交换区中的几率。
Valgrind 安装
1、 到www.valgrind.org下载最新版valgrind-3.2.3.tar.bz2
2、 解压安装包:tar –jxvf valgrind-3.2.3.tar.bz2
3、 解压后生成目录valgrind-3.2.3
4、 cd valgrind-3.2.3
5、 ./configure
6、 Make;make install
Valgrind 使用
用法: valgrind [options] prog-and-args [options]: 常用选项,适用于所有Valgrind工具
- -tool=<name> 最常用的选项。运行 valgrind中名为toolname的工具。默认memcheck。
- h –help 显示帮助信息。
- -version 显示valgrind内核的版本,每个工具都有各自的版本。
- q –quiet 安静地运行,只打印错误信息。
- v –verbose 更详细的信息, 增加错误数统计。
- -trace-children=no|yes 跟踪子线程? [no]
- -track-fds=no|yes 跟踪打开的文件描述?[no]
- -time-stamp=no|yes 增加时间戳到LOG信息? [no]
- -log-fd=<number> 输出LOG到描述符文件 [2=stderr]
- -log-file=<file> 将输出的信息写入到filename.PID的文件里,PID是运行程序的进行ID
- -log-file-exactly=<file> 输出LOG信息到 file
- -log-file-qualifier=<VAR> 取得环境变量的值来做为输出信息的文件名。 [none]
- -log-socket=ipaddr:port 输出LOG到socket ,ipaddr:port
LOG信息输出
- -xml=yes 将信息以xml格式输出,只有memcheck可用
- -num-callers=<number> show <number> callers in stack traces [12]
- -error-limit=no|yes 如果太多错误,则停止显示新错误? [yes]
- -error-exitcode=<number> 如果发现错误则返回错误代码 [0=disable]
- -db-attach=no|yes 当出现错误,valgrind会自动启动调试器gdb。[no]
- -db-command=<command> 启动调试器的命令行选项[gdb -nw %f %p]
适用于Memcheck工具的相关选项:
- -leak-check=no|summary|full 要求对leak给出详细信息? [summary]
- -leak-resolution=low|med|high how much bt merging in leak check [low]
- -show-reachable=no|yes show reachable blocks in leak check? [no]
Valgrind 使用举例
下面是一段有问题的C程序代码test.c
#include <stdlib.h>
void f(void)
{
int* x = malloc(10 * sizeof(int));
x[10] = 0; //问题1: 数组下标越界
} //问题2: 内存没有释放
int main(void)
{
f();
return 0;
}
1、 编译程序test.c
gcc -Wall test.c -g -o test
2、 使用Valgrind检查程序BUG
valgrind --tool=memcheck --leak-check=full ./test
3、 分析输出的调试信息
==3908== Memcheck, a memory error detector.
==3908== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==3908== Using LibVEX rev 1732, a library for dynamic binary translation.
==3908== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==3908== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
==3908== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==3908== For more details, rerun with: -v
==3908==
--3908-- DWARF2 CFI reader: unhandled CFI instruction 0:50
--3908-- DWARF2 CFI reader: unhandled CFI instruction 0:50
/*数组越界错误*/
==3908== Invalid write of size 4
==3908== at 0x8048384: f (test.c:6)
==3908== by 0x80483AC: main (test.c:11)
==3908== Address 0x400C050 is 0 bytes after a block of size 40 alloc'd
==3908== at 0x40046F2: malloc (vg_replace_malloc.c:149)
==3908== by 0x8048377: f (test.c:5)
==3908== by 0x80483AC: main (test.c:11)
==3908==
==3908== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 14 from 1)
==3908== malloc/free: in use at exit: 40 bytes in 1 blocks.
==3908== malloc/free: 1 allocs, 0 frees, 40 bytes allocated.
==3908== For counts of detected errors, rerun with: -v
==3908== searching for pointers to 1 not-freed blocks.
==3908== checked 59,124 bytes.
==3908==
==3908==
/*有内存空间没有释放*/
==3908== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==3908== at 0x40046F2: malloc (vg_replace_malloc.c:149)
==3908== by 0x8048377: f (test.c:5)
==3908== by 0x80483AC: main (test.c:11)
==3908==
==3908== LEAK SUMMARY:
==3908== definitely lost: 40 bytes in 1 blocks.
==3908== possibly lost: 0 bytes in 0 blocks.
==3908== still reachable: 0 bytes in 0 blocks.
==3908== suppressed: 0 bytes in 0
Valgrind
名字:
valgrind是一个调试和剖析的程序工具集。
概要用法:
valgrind [[valgrind] [options]] [your-program] [[your-program-options]]
概述:
不会对静态的数据越界进行检查
Valgrind是一个Linux下灵活的调试和剖析可执行工具。它由在软件层提供综合的
CPU内核,和一系列调试、剖析的工具组成。架构是模块化的,所以可以在不破坏现
有的结构的基础上很容易的创建出新的工具来。
这本手册包括了基本的用法和选项。更多帮助理解的信息,请查看您系统的HTML
文档:
/usr/share/doc/valgrind/html/index.html
或者在线文档:
http://www.valgrind.org/docs/manual/index.html.
用法:
一般像下面这样调用Valgrind:
valgrind program args
这样将在Valgrind使用Memcheck运行程序program(带有参数args)。内存检查
执行一系列的内存检查功能,包括检测访问未初始化的内存,已经分配内存的错误
使用(两次释放,释放后再访问,等等)并检查内存泄漏。
可用--tool指定使用其它工具:
valgrind --tool=toolname program args
可使用的工具如下:
o cachegrind是一个缓冲模拟器。它可以用来标出你的程序每一行执行的指令
数和导致的缓冲不命中数。
o callgrind在cachegrind基础上添加调用追踪。它可以用来得到调用的次数
以及每次函数调用的开销。作为对cachegrind的补充,callgrind可以分别
标注各个线程,以及程序反汇编输出的每条指令的执行次数以及缓存未命中
数。
o helgrind能够发现程序中潜在的条件竞争。
o lackey是一个示例程序,以其为模版可以创建你自己的工具。在程序结束后,
它打印出一些基本的关于程序执行统计数据。
o massif是一个堆剖析器,它测量你的程序使用了多少堆内存。
o memcheck是一个细粒度的的内存检查器。
o none没有任何功能。它它一般用于Valgrind的调试和基准测试。
基本选项:
这些选项对所有工具都有效。
-h --help
显示所有选项的帮助,包括内核和选定的工具两者。
--help-debug
和--help相同,并且还能显示通常只有Valgrind的开发人员使用的调试
选项。
--version
显示Valgrind内核的版本号。工具可以有他们自已的版本号。这是一种
保证工具只在它们可以运行的内核上工作的一种设置。这样可以减少在
工具和内核之间版本兼容性导致奇怪问题的概率。
-q --quiet
安静的运行,只打印错误信息。在进行回归测试或者有其它的自动化测
试机制时会非常有用。
-v --verbose
显示详细信息。在各个方面显示你的程序的额外信息,例如:共享对象
加载,使用的重置,执行引擎和工具的进程,异常行为的警告信息。重
复这个标记可以增加详细的级别。
-d 调试Valgrind自身发出的信息。通常只有Valgrind开发人员对此感兴趣。
重复这个标记可以产生更详细的输出。如果你希望发送一个bug报告,通
过-v -v -d -d生成的输出会使你的报告更加有效。
--tool=<toolname> [default: memcheck]
运行toolname指定的Valgrind,例如,Memcheck, Addrcheck, Cachegrind,
等等。
--trace-children=<yes|no> [default: no]
当这个选项打开时,Valgrind会跟踪到子进程中。这经常会导致困惑,而
且通常不是你所期望的,所以默认这个选项是关闭的。
--track-fds=<yes|no> [default: no]
当这个选项打开时,Valgrind会在退出时打印一个打开文件描述符的列表。
每个文件描述符都会打印出一个文件是在哪里打开的栈回溯,和任何与此
文件描述符相关的详细信息比如文件名或socket信息。
--time-stamp=<yes|no> [default: no]
当这个选项打开时,每条信息之前都有一个从程序开始消逝的时间,用天,
小时,分钟,秒和毫秒表示。
--log-fd=<number> [default: 2, stderr]
指定Valgrind把它所有的消息都输出到一个指定的文件描述符中去。默认值
2, 是标准错误输出(stderr)。注意这可能会干扰到客户端自身对stderr
的使用, Valgrind的输出与客户程序的输出将穿插在一起输出到stderr。
--log-file=<filename>
指定Valgrind把它所有的信息输出到指定的文件中。实际上,被创建文件的
文件名是由filename、'.'和进程号连接起来的(即<filename>.<pid>),
从而每个进程创建不同的文件。
--log-file-exactly=<filename>
类似于--log-file,但是后缀".pid"不会被添加。如果设置了这个选项,
使用Valgrind跟踪多个进程,可能会得到一个乱七八糟的文件。
--log-file-qualifier=<VAR>
当和--log-file一起使用时,日志文件名将通过环境变量$VAR来筛选。这
对于MPI程序是有益的。更多的细节,查看手册2.3节 "注解"。
--log-socket=<ip-address:port-number>
指定Valgrind输出所有的消息到指定的IP,指定的端口。当使用1500端口
时,端口有可能被忽略。如果不能建立一个到指定端口的连接,Valgrind
将输出写到标准错误(stderr)。这个选项经常和一个Valgrind监听程序一
起使用。更多的细节,查看手册2.3节 "注解"。
错误相关选项:
这些选项适用于所有产生错误的工具,比如Memcheck, 但是Cachegrind不行。
--xml=<yes|no> [default: no]
当这个选项打开时,输出将是XML格式。这是为了使用Valgrind的输出做为
输入的工具,例如GUI前端更加容易些。目前这个选项只在Memcheck时生效。
--xml-user-comment=<string>
在XML开头 附加用户注释,仅在指定了--xml=yes时生效,否则忽略。
--demangle=<yes|no> [default: yes]
打开/关闭C++的名字自动解码。默认打开。当打开时,Valgrind将尝试着把
编码过的C++名字自动转回初始状态。这个解码器可以处理g++版本为2.X,
3.X或4.X生成的符号。
一个关于名字编码解码重要的事实是,禁止文件中的解码函数名仍然使用
他们未解码的形式。Valgrind在搜寻可用的禁止条目时不对函数名解码,
因为这将使禁止文件内容依赖于Valgrind的名字解码机制状态, 会使速度
变慢,且无意义。
--num-callers=<number> [default: 12]
默认情况下,Valgrind显示12层函数调用的函数名有助于确定程序的位置。
可以通过这个选项来改变这个数字。这样有助在嵌套调用的层次很深时确定
程序的位置。注意错误信息通常只回溯到最顶上的4个函数。(当前函数,和
它的3个调用者的位置)。所以这并不影响报告的错误总数。
这个值的最大值是50。注意高的设置会使Valgrind运行得慢,并且使用更多
的内存,但是在嵌套调用层次比较高的程序中非常实用。
--error-limit=<yes|no> [default: yes]
当这个选项打开时,在总量达到10,000,000,或者1,000个不同的错误,
Valgrind停止报告错误。这是为了避免错误跟踪机制在错误很多的程序
下变成一个巨大的性能负担。
--error-exitcode=<number> [default: 0]
指定如果Valgrind在运行过程中报告任何错误时的退出返回值,有两种情
况;当设置为默认值(零)时,Valgrind返回的值将是它模拟运行的程序的
返回值。当设置为非零值时,如果Valgrind发现任何错误时则返回这个值。
在Valgrind做为一个测试工具套件的部分使用时这将非常有用,因为使测
试工具套件只检查Valgrind返回值就可以知道哪些测试用例Valgrind报告
了错误。
--show-below-main=<yes|no> [default: no]
默认地,错误时的栈回溯不显示main()之下的任何函数(或者类似的函数像
glibc的__libc_start_main(),如果main()没有出现在栈回溯中);这些大
部分都是令人厌倦的C库函数。如果打开这个选项,在main()之下的函数也
将会显示。
--suppressions=<filename> [default: $PREFIX/lib/valgrind/default.supp]
指定一个额外的文件读取不需要理会的错误;你可以根据需要使用任意多
的额外文件。
--gen-suppressions=<yes|no|all> [default: no]
当设置为yes时,Valgrind将会在每个错误显示之后自动暂停并且打印下
面这一行:
---- Print suppression ? --- [Return/N/n/Y/y/C/c] ----
这个提示的行为和--db-attach选项(见下面)相同。
如果选择是,Valgrind会打印出一个错误的禁止条目,你可以把它剪切然后
粘帖到一个文件,如果不希望在将来再看到这个错误信息。
当设置为all时,Valgrind会对每一个错误打印一条禁止条目,而不向用户
询问。
这个选项对C++程序非常有用,它打印出编译器调整过的名字。
注意打印出来的禁止条目是尽可能的特定的。如果需要把类似的条目归纳
起来,比如在函数名中添加通配符。并且,有些时候两个不同的错误也会
产生同样的禁止条目,这时Valgrind就会输出禁止条目不止一次,但是在
禁止条目的文件中只需要一份拷贝(但是如果多于一份也不会引起什么问
题)。并且,禁止条目的名字像<在这儿输入一个禁止条目的名字>;名字并
不是很重要,它只是和-v选项一起使用打印出所有使用的禁止条目记录。
--db-attach=<yes|no> [default: no]
当这个选项打开时,Valgrind将会在每次打印错误时暂停并打出如下
一行:
---- Attach to debugger ? --- [Return/N/n/Y/y/C/c] ----
按下回车,或者N、回车,n、回车,Valgrind不会对这个错误启动调试器。
按下Y、回车,或者y、回车,Valgrind会启动调试器并设定在程序运行的
这个点。当调试结束时,退出,程序会继续运行。在调试器内部尝试继续
运行程序,将不会生效。
按下C、回车,或者c、回车,Valgrind不会启动一个调试器,并且不会再
次询问。
注意:--db-attach=yes与--trace-children=yes有冲突。你不能同时使用
它们。Valgrind在这种情况下不能启动。
2002.05: 这是一个历史的遗留物,如果这个问题影响到你,请发送邮件并
投诉这个问题。
2002.11:如果你发送输出到日志文件或者到网络端口,我猜这不会让你有
任何感觉。不须理会。
--db-command=<command> [default: gdb -nw %f %p]
通过--db-attach指定如何使用调试器。默认的调试器是gdb.默认的选项
是一个运行时扩展Valgrind的模板。 %f会用可执行文件的文件名替换,
%p会被可执行文件的进程ID替换。
这指定了Valgrind将怎样调用调试器。默认选项不会因为在构造时是否检
测到了GDB而改变,通常是/usr/bin/gdb.使用这个命令,你可以指定一些
调用其它的调试器来替换。
给出的这个命令字串可以包括一个或多个%p %f扩展。每一个%p实例都被
解释成将调试的进程的PID,每一个%f实例都被解释成要调试的进程的可
执行文件路径。
--input-fd=<number> [default: 0, stdin]
使用--db-attach=yes和--gen-suppressions=yes选项,在发现错误时,
Valgrind会停下来去读取键盘输入。默认地,从标准输入读取,所以关闭
了标准输入的程序会有问题。这个选项允许你指定一个文件描述符来替代
标准输入读取。
--max-stackframe=<number> [default: 2000000]
栈的最大值。如果栈指针的偏移超过这个数量,Valgrind则会认为程序是
切换到了另外一个栈执行。
如果在程序中有大量的栈分配的数组,你可能需要使用这个选项。
valgrind保持对程序栈指针的追踪。如果栈指针的偏移超过了这个数量,
Valgrind假定你的程序切换到了另外一个栈,并且Memcheck行为与栈指
针的偏移没有超出这个数量将会不同。通常这种机制运转得很好。然而,
如果你的程序在栈上申请了大的结构,这种机制将会表现得愚蠢,并且
Memcheck将会报告大量的非法栈内存访问。这个选项允许把这个阀值设置
为其它值。
应该只在Valgrind的调试输出中显示需要这么做时才使用这个选项。在这
种情况下,它会告诉你应该指定的新的阀值。
普遍地,在栈中分配大块的内存是一个坏的主意。因为这很容易用光你的
栈空间,尤其是在内存受限的系统或者支持大量小堆栈的线程的系统上,
因为Memcheck执行的错误检查,对于堆上的数据比对栈上的数据要高效
很多。如果你使用这个选项,你可能希望考虑重写代码在堆上分配内存
而不是在栈上分配。
MALLOC()相关的选项:
对于使用自有版本的malloc() (例如Memcheck和massif),下面的选项可以使用。
--alignment=<number> [default: 8]
默认Valgrind的malloc(),realloc(), 等等,是8字节对齐地址的。这
是大部分处理器的标准。然而,一些程序可能假定malloc()等总是返回
16字节或更多对齐的内存。提供的数值必须在8和4096区间之内,并且
必须是2的幂数。
非通用选项:
这些选项可以用于所有的工具,它们影响Valgrind core的几个特性。大部分人不
会用到这些选项。
--run-libc-freeres=<yes|no> [default: yes]
GNU C库(libc.so),所有程序共用的,可能会分配一部分内存自已用。通
常在程序退出时释放内存并不麻烦 -- 这里没什么问题,因为Linux内核在
一个进程退出时会回收进程全部的资源,所以这只是会造成速度慢。
glibc的作者认识到这样会导致内存检查器,像Valgrind,在退出时检查
内存错误的报告glibc的内存泄漏问题,为了避免这个问题,他们提供了
一个__libc_freeres()例程特别用来让glibc释放分配的所有内存。
因此Memcheck在退出时尝试着去运行__libc_freeres()。
不幸的是,在glibc的一些版本中,__libc_freeres是有bug会导致段错误的。
这在Red Hat 7.1上有特别声明。所以,提供这个选项来决定是否运行
__libc_freeres。如果你的程序看起来在Valgrind上运行得很好,但是在
退出时发生段错误,你可能需要指定--run-libc-freeres=no来修正,这将
可能错误的报告libc.so的内存泄漏。
--sim-hints=hint1,hint2,...
传递杂凑的提示给Valgrind,轻微的修改模拟行为的非标准或危险方式,
可能有助于模拟奇怪的特性。默认没有提示打开。小心使用!目前已知
的提示有:
o lax-ioctls: 对ioctl的处理非常不严格,唯一的假定是大小是正确的。
不需要在写时缓冲区完全的初始化。没有这个,用大量的奇怪的ioctl
命令来使用一些设备驱动将会非常烦人。
o enable-inner:打开某些特殊的效果,当运行的程序是Valgrind自身时。
--kernel-variant=variant1,variant2,...
处理系统调用和ioctls在这个平台的默认核心上产生不同的变量。这有助
于运行在改进过的内核或者支持非标准的ioctls上。小心使用。如果你不
理解这个选项做的是什么那你几乎不需要它。已经知道的变量有:
o bproc: 支持X86平台上的sys_broc系统调用。这是为了运行在BProc,
它是标准Linux的一个变种,有时用来构建集群。
--show-emwarns=<yes|no> [default: no]
当这个选项打开时,Valgrind在一些特定的情况下将对CPU仿真产生警告。
通常这些都是不引人注意的。
--smc-check=<none|stack|all> [default: stack]
这个选项控制Valgrind对自我修改的代码的检测。Valgrind可以不做检测,
可以检测栈中自我修改的代码,或者任意地方检测自我修改的代码。注意
默认选项是捕捉绝大多数情况,到目前我们了解的情况为止。使用all选项
时会极大的降低速度。(但是用none选项运行极少影响速度,因为对大多数
程序,非常少的代码被添加到栈中)
调试VALGRIND选项:
还有一些选项是用来调试Valgrind自身的。在运行一般的东西时不应该需要的。
如果你希望看到选项列表,使用--help-debug选项。
内存检查选项:
--leak-check=<no|summary|yes|full> [default: summary]
当这个选项打开时,当客户程序结束时查找内存泄漏。内存泄漏意味着
有用malloc分配内存块,但是没有用free释放,而且没有指针指向这块
内存。这样的内存块永远不能被程序释放,因为没有指针指向它们。如
果设置为summary,Valgrind会报告有多少内存泄漏发生了。如果设置为
full或yes,Valgrind给出每一个独立的泄漏的详细信息。
--show-reachable=<yes|no> [default: no]
当这个选项关闭时,内存泄漏检测器只显示没有指针指向的内存块,或
者只能找到指向块中间的指针。当这个选项打开时,内存泄漏检测器还
报告有指针指向的内存块。这些块是最有可能出现内存泄漏的地方。你
的程序可能,至少在原则上,应该在退出前释放这些内存块。这些有指
针指向的内存块和没有指针指向的内存块,或者只有内部指针指向的块,
都可能产生内存泄漏,因为实际上没有一个指向块起始的指针可以拿来释
放,即使你想去释放它。
--leak-resolution=<low|med|high> [default: low]
在做内存泄漏检查时,确定memcheck将怎么样考虑不同的栈是相同的情况。
当设置为low时,只需要前两层栈匹配就认为是相同的情况;当设置为med,
必须要四层栈匹配,当设置为high时,所有层次的栈都必须匹配。
对于hardcore内存泄漏检查,你很可能需要使用--leak-resolution=high和
--num-callers=40或者更大的数字。注意这将产生巨量的信息,这就是为什
么默认选项是四个调用者匹配和低分辨率的匹配。
注意--leak-resolution= 设置并不影响memcheck查找内存泄漏的能力。它
只是改变了结果如何输出。
--freelist-vol=<number> [default: 5000000]
当客户程序使用free(C中)或者delete(C++)释放内存时,这些内存并不是
马上就可以用来再分配的。这些内存将被标记为不可访问的,并被放到一
个已释放内存的队列中。这样做的目的是,使释放的内存再次被利用的点
尽可能的晚。这有利于memcheck在内存块释放后这段重要的时间检查对块
不合法的访问。
这个选项指定了队列所能容纳的内存总容量,以字节为单位。默认的值是
5000000字节。增大这个数目会增加memcheck使用的内存,但同时也增加了
对已释放内存的非法使用的检测概率。
--workaround-gcc296-bugs=<yes|no> [default: no]
当这个选项打开时,假定读写栈指针以下的一小段距离是gcc 2.96的bug,
并且不报告为错误。距离默认为256字节。注意gcc 2.96是一些比较老的
Linux发行版(RedHat 7.X)的默认编译器,所以你可能需要使用这个选项。
如果不是必要请不要使用这个选项,它可能会使一些真正的错误溜掉。
一个更好的解决办法是使用较新的,修正了这个bug的gcc/g++版本。
--partial-loads-ok=<yes|no> [default: no]
控制memcheck如何处理从地址读取时字长度,字对齐,因此哪些字节是可
以寻址的,哪些是不可以寻址的。当设置为yes是,这样的读取并不抛出
一个寻址错误。而是从非法地址读取的V字节显示为未定义,访问
合法地址仍然是像平常一样映射到内存。
设置为no时,从部分错误的地址读取与从完全错误的地址读取同样处理:
抛出一个非法地址错误,结果的V字节显示为合法数据。
注意这种代码行为是违背ISO C/C++标准,应该被认为是有问题的。如果可
能,这种代码应该修正。这个选项应该只是做为一个最后考虑的方法。
--undef-value-errors=<yes|no> [default: yes]
控制memcheck是否检查未定义值的危险使用。当设为yes时,Memcheck的行
为像Addrcheck, 一个轻量级的内存检查工具,是Valgrind的一个部分,它
并不检查未定义值的错误。使用这个选项,如果你不希望看到未定义值错误。
CACHEGRIND选项:
手动指定I1/D1/L2缓冲配置,大小是用字节表示的。这三个必须用逗号隔开,中间
没有空格,例如:
valgrind --tool=cachegrind --I1=65535,2,64
你可以指定一个,两个或三个I1/D1/L2缓冲。如果没有手动指定,每个级别使用
普通方式(通过CPUID指令得到缓冲配置,如果失败,使用默认值)得到的配置。
--I1=<size>,<associativity>,<line size>
指定第一级指令缓冲的大小,关联度和行大小。
--D1=<size>,<associativity>,<line size>
指定第一级数据缓冲的大小,关联度和行大小。
--L2=<size>,<associativity>,<line size>
指定第二级缓冲的大小,关联度和行大小。
CALLGRIND选项:
--heap=<yes|no> [default: yes]
当这个选项打开时,详细的追踪堆的使用情况。关闭这个选项时,
massif.pid.txt或massif.pid.html将会非常的简短。
--heap-admin=<number> [default: 8]
每个块使用的管理字节数。这只能使用一个平均的估计值,因为它可能变化。
glibc使用的分配器每块需要4~15字节,依赖于各方面的因素。管理已经释放
的块也需要空间,尽管massif不计算这些。
--stacks=<yes|no> [default: yes]
当打开时,在剖析信息中包含栈信息。多线程的程序可能有多个栈。
--depth=<number> [default: 3]
详细的堆信息中调用过程的深度。增加这个值可以给出更多的信息,但是
massif会更使这个程序运行得慢,使用更多的内存,并且产生一个大的
massif.pid.txt或者massif.pid.hp文件。
--alloc-fn=<name>
指定一个分配内存的函数。这对于使用malloc()的包装函数是有用的,可以
用它来填充原来无效的上下文信息。(这些函数会给出无用的上下文信息,
并在图中给出无意义的区域)。指定的函数在上下文中被忽略,例如,像对
malloc()一样处理。这个选项可以在命令行中重复多次,指定多个函数。
--format=<text|html> [default: text]
产生text或者HTML格式的详细堆信息,文件的后缀名使用.txt或者.html。
HELGRIND选项:
--private-stacks=<yes|no> [default: no]
假定线程栈是私有的。
--show-last-access=<yes|some|no> [default: no]
显示最后一次字访问出错的位置。
LACKEY选项:
--fnname=<name> [default: _dl_runtime_resolve()]
对<name>函数计数。
--detailed-counts=<no|yes> [default: no]
对读取,存储和alu操作计数。
参考:
/usr/share/doc/valgrind/html/index.html, 和/或者
http://www.valgrind.org/docs/manual/index.html.
作者信息:
Julian Seward <jseward@acm.org>是Valgrind的初始作者,在
/usr/share/doc/valgrind/AUTHORS还有其他的贡献者的信息。
这份手册由Andres Roldan <aroldan@debian.org>为Debian工程编写,但是可以在
任何其它发行版上使用。
2.4.0版本的更新,重排,和扩展由Robert Walsh <rjwalsh@durables.org>,
后来由其它的Valgrind开发者完成。
本手册的翻译工作由邓杰和庄礼深同学共同完成
Valgrind
Valgrind 已经在 Linux 应用程序开发社区中广泛用来调试应用程序。它尤其擅长发现内存管理的问题。它可以检查程序运行时的内存泄漏问题。这个工具目前正由 Julian Seward 进行开发,并由 Paul Mackerras 移植到了 Power 架构上。
要安装 Valgrind,请从 Valgrind 的 Web 站点上下载源代码(参阅 参考资料)。切换到 Valgrind 目录,并执行下面的命令:
# make # make check # make install |
Valgrind 的错误报告
Valgrind 的输出格式如下:
清单 1. Valgrind 的输出消息
# valgrind du –x –s . . ==29404== Address 0x1189AD84 is 0 bytes after a block of size 12 alloc'd ==29404== at 0xFFB9964: malloc (vg_replace_malloc.c:130) ==29404== by 0xFEE1AD0: strdup (in /lib/tls/libc.so.6) ==29404== by 0xFE94D30: setlocale (in /lib/tls/libc.so.6) ==29404== by 0x10001414: main (in /usr/bin/du) |
==29404== 是进程的 ID。消息 Address 0x1189AD84 is 0 bytes after a block of size 12 alloc'd 说明在这个 12 字节的数组后面没有存储空间了。第二行以及后续几行说明内存是在 130 行(vg_replace_malloc.c)的 strdup() 程序中进行分配的。strdup() 是在 libc.so.6 库的 setlocale() 中调用的;main() 调用了 setlocale()。
未初始化的内存
最为常见的一个 bug 是程序使用了未初始化的内存。未初始化的数据可能来源于:
- 未经初始化的变量
- malloc 函数所分配的数据,在写入值之前使用了
下面这个例子使用了一个未初始化的数组:
清单 2. 使用未初始化的内存
2 { 3 int i[5]; 4 5 if (i[0] == 0) 6 i[1]=1; 7 return 0; 8 } |
在这个例子中,整数数组 i[5] 没有进行初始化;因此,i[0] 包含的是一个随机数。因此使用 i[0] 的值来判断一个条件分支就会导致不可预期的问题。Valgrind 可以很容易捕获这种错误条件。当您使用 Valgrind 运行这个程序时,就会接收到下面的消息:
清单 3. Valgrind 的输出消息
# gcc –g –o test1 test1.c # valgrind ./test1 . . ==31363== ==31363== Conditional jump or move depends on uninitialised value(s) ==31363== at 0x1000041C: main (test1.c:5) ==31363== ==31363== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 7 from 1) ==31363== malloc/free: in use at exit: 0 bytes in 0 blocks. ==31363== malloc/free: 0 allocs, 0 frees, 0 bytes allocated. ==31363== For counts of detected errors, rerun with: -v ==31363== No malloc'd blocks -- no leaks are possible. |
Valgrind 的输出说明,有一个条件分支依赖于文件 test1.c 中第 5 行中的一个未初始化的变量。
内存泄漏
内存泄漏是另外一个常见的问题,也是很多程序中最难判断的问题。内存泄漏的主要表现为:当程序连续运行时,与程序相关的内存(或堆)变得越来越大。结果是,当这个程序所消耗的内存达到系统的上限时,就会自己崩溃;或者会出现更严重的情况:挂起或导致系统崩溃。下面是一个有内存泄漏 bug 的示例程序:
清单 4. 内存泄漏示例
1 int main(void) 2 { 3 char *p1; 4 char *p2; 5 6 p1 = (char *) malloc(512); 7 p2 = (char *) malloc(512); 8 9 p1=p2; 10 11 free(p1); 12 free(p2); 13 } |
上面的代码分别给字符指针 p1 和 p2 分配了两个 512 字节的内存块,然后将指向第一个内存块的指针设置为指向第二个内存块。结果是,第二个内存块的地址丢失了,并导致内存泄漏。在使用 Valgrind 运行这个程序时,会返回如下的消息:
清单 5. Valgrind 的输出消息
# gcc –g –o test2 test2.c # valgrind ./test2 . . ==31468== Invalid free() / delete / delete[] ==31468== at 0xFFB9FF0: free (vg_replace_malloc.c:152) ==31468== by 0x100004B0: main (test2.c:12) ==31468== Address 0x11899258 is 0 bytes inside a block of size 512 free'd ==31468== at 0xFFB9FF0: free (vg_replace_malloc.c:152) ==31468== by 0x100004A4: main (test2.c:11) ==31468== ==31468== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 7 from 1) ==31468== malloc/free: in use at exit: 512 bytes in 1 blocks. ==31468== malloc/free: 2 allocs, 2 frees, 1024 bytes allocated. ==31468== For counts of detected errors, rerun with: -v ==31468== searching for pointers to 1 not-freed blocks. ==31468== checked 167936 bytes. ==31468== ==31468== LEAK SUMMARY: ==31468== definitely lost: 512 bytes in 1 blocks. ==31468== possibly lost: 0 bytes in 0 blocks. ==31468== still reachable: 0 bytes in 0 blocks. ==31468== suppressed: 0 bytes in 0 blocks. ==31468== Use --leak-check=full to see details of leaked memory. |
正如您可以看到的一样,Valgrind 报告说这个程序中有 512 字节的内存丢失了。
非法写/读
这种情况发生在程序试图对一个不属于程序本身的内存地址进行读写时。在有些系统上,在发生这种错误时,程序会异常结束,并产生一个段错误。下面这个例子就是一个常见的 bug,它试图读写一个超出数组边界的元素。
清单 6. 非法读写
1 int main() { 2 int i, *iw, *ir; 3 4 iw = (int *)malloc(10*sizeof(int)); 5 ir = (int *)malloc(10*sizeof(int)); 6 7 8 for (i=0; i<11; i++) 9 iw[i] = i; 10 11 for (i=0; i<11; i++) 12 ir[i] = iw[i]; 13 14 free(iw); 15 free(ir); 16 } |
从这个程序中我们可以看出,对于 iw[10] 和 ir[10] 的访问都是非法的,因为 iw 和 ir 都只有 10 个元素,分别是从 0 到 9。请注意 int iw[10 ] 和 iw = (int *)malloc(10*sizeof(int)) 是等效的 —— 它们都是用来给一个整数数组 iw 分配 10 个元素。
当您使用 Valgrind 运行这个程序时,会返回如下的消息:
清单 7. Valgrind 的输出消息
# gcc –g –o test3 test3.c # valgrind ./test3 . . ==31522== Invalid write of size 4 ==31522== at 0x100004C0: main (test3.c:9) ==31522== Address 0x11899050 is 0 bytes after a block of size 40 alloc'd ==31522== at 0xFFB9964: malloc (vg_replace_malloc.c:130) ==31522== by 0x10000474: main (test10.c:4) ==31522== ==31522== Invalid read of size 4 ==31522== at 0x1000050C: main (test3.c:12) ==31522== Address 0x11899050 is 0 bytes after a block of size 40 alloc'd ==31522== at 0xFFB9964: malloc (vg_replace_malloc.c:130) ==31522== by 0x10000474: main (test10.c:4) ==31522== ==31522== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 7 from 1) ==31522== malloc/free: in use at exit: 0 bytes in 0 blocks. ==31522== malloc/free: 2 allocs, 2 frees, 84 bytes allocated. ==31522== For counts of detected errors, rerun with: -v ==31522== No malloc'd blocks -- no leaks are possible. |
在 test3.c 的第 9 行发现一个非法的 4 字节写操作,在第 12 行发现一个非法的 4 字节读操作。
Valgrind 也可以帮助判断内存误用的问题,例如:
- 读/写已经释放的内存
- C++ 环境中错误地使用 malloc/new 与 free/delete 的配对
下面这个列表介绍了 POWER 架构上 Valgrind 的状态:
- memcheck 和 addrcheck 工具都可以很好地工作。然而,其他工具还没有进行大量的测试。另外,Helgrind (一个数据竞争的检测程序)在 POWER 上尚不能使用。
- 所有的 32 位 PowerPC? 用户模式的指令都可以支持,除了两条非常少用的指令:lswx 和 stswx。具体来说,所有的浮点和 Altivec(VMX)指令都可以支持。
- Valgrind 可以在 32 位或 64 位 PowerPC/Linux 内核上工作,但是只能用于 32 位的可执行程序。
有关 Valgrind 内存调试的更多信息,请访问 Valgrind HOW TO 站点。还可以参阅 Steve Best 的“Debugging Memory Problems”(Linux Magazine,2003 年 5 月)。参考资料 中有它们的链接
除了 Valgrind 之外,还可以使用其他几个内存调试工具;例如,Memwatch 和 Electric Fence。
Valgrind使用说明
Valgrind是运行在Linux上一套基于仿真技术的程序调试和分析工具,是公认的最接近Purify的产品,它包含一个内核——一个软件合成的CPU,和一系列的小工具,每个工具都可以完成一项任务——调试,分析,或测试等。Valgrind可以检测内存泄漏和内存越界,还可以分析cache的使用等,灵活轻巧而又强大。
一 Valgrind概观
Valgrind的最新版是3.2.3,该版本包含下列工具:
1、memcheck:检查程序中的内存问题,如泄漏、越界、非法指针等。
2、callgrind:检测程序代码覆盖,以及分析程序性能。
3、cachegrind:分析CPU的cache命中率、丢失率,用于进行代码优化。
4、helgrind:用于检查多线程程序的竞态条件。
5、massif:堆栈分析器,指示程序中使用了多少堆内存等信息。
6、lackey:
7、nulgrind:
二 Valgrind工具详解
1.Memcheck
最常用的工具,用来检测程序中出现的内存问题,所有对内存的读写都会被检测到,一切对malloc、free、new、delete的调用都会被捕获。所以,它能检测以下问题:
1、对未初始化内存的使用;
2、读/写释放后的内存块;
3、读/写超出malloc分配的内存块;
4、读/写不适当的栈中内存块;
5、内存泄漏,指向一块内存的指针永远丢失;
6、不正确的malloc/free或new/delete匹配;
7、memcpy()相关函数中的dst和src指针重叠。
这些问题往往是C/C++程序员最头疼的问题,Memcheck能在这里帮上大忙。
2.Callgrind
和gprof类似的分析工具,但它对程序的运行观察更是入微,能给我们提供更多的信息。和gprof不同,它不需要在编译源代码时附加特殊选项,但加上调试选项是推荐的。Callgrind收集程序运行时的一些数据,建立函数调用关系图,还可以有选择地进行cache模拟。在运行结束时,它会把分析数据写入一个文件。callgrind_annotate可以把这个文件的内容转化成可读的形式。
说明:这个工具我也没有用会,网上基本没有找到有指导性的文档,暂时留在后面慢慢研究吧。
3.Cachegrind
Cache分析器,它模拟CPU中的一级缓存I1,Dl和二级缓存,能够精确地指出程序中cache的丢失和命中。如果需要,它还能够为我们提供cache丢失次数,内存引用次数,以及每行代码,每个函数,每个模块,整个程序产生的指令数。这对优化程序有很大的帮助。
作一下广告:valgrind自身利用该工具在过去几个月内使性能提高了25%-30%。据早先报道,kde的开发team也对valgrind在提高kde性能方面的帮助表示感谢。
4.Helgrind
它主要用来检查多线程程序中出现的竞争问题。Helgrind寻找内存中被多个线程访问,而又没有一贯加锁的区域,这些区域往往是线程之间失去同步的地方,而且会导致难以发掘的错误。Helgrind实现了名为“Eraser”的竞争检测算法,并做了进一步改进,减少了报告错误的次数。不过,Helgrind仍然处于实验阶段。
5. Massif
堆栈分析器,它能测量程序在堆栈中使用了多少内存,告诉我们堆块,堆管理块和栈的大小。Massif能帮助我们减少内存的使用,在带有虚拟内存的现代系统中,它还能够加速我们程序的运行,减少程序停留在交换区中的几率。
Massif对内存的分配和释放做profile。程序开发者通过它可以深入了解程序的内存使用行为,从而对内存使用进行优化。这个功能对C++尤其有用,因为C++有很多隐藏的内存分配和释放
此外,lackey和nulgrind也会提供。Lackey是小型工具,很少用到;Nulgrind只是为开发者展示如何创建一个工具。我们就不做介绍了。
三 使用Valgrind
Valgrind使用起来非常简单,你甚至不需要重新编译你的程序就可以用它。当然如果要达到最好的效果,获得最准确的信息,还是需要按要求重新编译一下的。比如在使用memcheck的时候,最好关闭优化选项。
valgrind命令的格式如下:
valgrind [valgrind-options] your-prog [your-prog options]
一些常用的选项如下:
选项 | 作用 |
-h --help | 显示帮助信息。 |
--version | 显示valgrind内核的版本,每个工具都有各自的版本。 |
-q --quiet | 安静地运行,只打印错误信息。 |
-v --verbose | 打印更详细的信息。 |
--tool=<toolname> [default: memcheck] | 最常用的选项。运行valgrind中名为toolname的工具。如果省略工具名,默认运行memcheck。 |
--db-attach=<yes|no> [default: no] | 绑定到调试器上,便于调试错误。 |
1、检测内存泄漏
示例代码如下:
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *ptr;
ptr = (char *)malloc(10);
return 0;
}
保存为memleak.c并编译,然后用valgrind检测。
$ gcc -o memleak memleak.c
(valgrind和purify最大的不同在于:valgrind只接管程序执行的过程,编译时不需要valgrind干预,而purify会干预程序编译过程)
$ valgrind --tool=memcheck ./memleak
我们得到如下错误信息:
[konten@tencent test_valgrind]$ valgrind ./memleak
==29646== Memcheck, a memory error detector.
==29646== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==29646== Using LibVEX rev 1732, a library for dynamic binary translation.
==29646== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==29646== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
==29646== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==29646== For more details, rerun with: -v
==29646==
==29646==
==29646== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 15 from 1)
==29646== malloc/free: in use at exit: 10 bytes in 1 blocks. //指示在程序退出时,还有多少内存没有释放。
==29646== malloc/free: 1 allocs, 0 frees, 10 bytes allocated. // 指示该执行过程malloc和free调用的次数。
==29646== For counts of detected errors, rerun with: -v // 提示如果要更详细的信息,用-v选项。
==29646== searching for pointers to 1 not-freed blocks.
==29646== checked 56,164 bytes.
==29646==
==29646== LEAK SUMMARY:
==29646== definitely lost: 10 bytes in 1 blocks.
==29646== possibly lost: 0 bytes in 0 blocks.
==29646== still reachable: 0 bytes in 0 blocks.
==29646== suppressed: 0 bytes in 0 blocks.
==29646== Rerun with --leak-check=full to see details of leaked memory.
[konten@tencent test_valgrind]$
以上结果中,红色的是手工添加的说明信息,其他是valgrind的输出。可以看到,如果我们仅仅用默认方式执行,valgrind只报告内存泄漏,但没有显示具体代码中泄漏的地方。
因此我们需要使用 “--leak-check=full”选项启动 valgrind,我们再执行一次:
[konten@tencent test_valgrind]$ valgrind --leak-check=full ./memleak
==29661== Memcheck, a memory error detector.
==29661== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==29661== Using LibVEX rev 1732, a library for dynamic binary translation.
==29661== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==29661== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
==29661== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==29661== For more details, rerun with: -v
==29661==
==29661==
==29661== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 15 from 1)
==29661== malloc/free: in use at exit: 10 bytes in 1 blocks.
==29661== malloc/free: 1 allocs, 0 frees, 10 bytes allocated.
==29661== For counts of detected errors, rerun with: -v
==29661== searching for pointers to 1 not-freed blocks.
==29661== checked 56,164 bytes.
==29661==
==29661== 10 bytes in 1 blocks are definitely lost in loss record 1 of 1
==29661== at 0x401A846: malloc (vg_replace_malloc.c:149)
==29661== by 0x804835D: main (memleak.c:6)
==29661==
==29661== LEAK SUMMARY:
==29661== definitely lost: 10 bytes in 1 blocks.
==29661== possibly lost: 0 bytes in 0 blocks.
==29661== still reachable: 0 bytes in 0 blocks.
==29661== suppressed: 0 bytes in 0 blocks.
[konten@tencent test_valgrind]$
和上次的执行结果基本相同,只是多了上面蓝色的部分,指明了代码中出现泄漏的具体位置。
以上就是用valgrind检查内存泄漏的方法,用到的例子比较简单,复杂的代码最后结果也都一样。
2、其他内存问题 我们下面的例子中包括常见的几类内存问题:堆中的内存越界、踩内存、栈中的内存越界、非法指针使用、重复free。 #include <stdlib.h> #include <stdio.h> int main(void) { char *ptr = malloc(10); ptr[12] = 'a'; // 内存越界 memcpy(ptr +1, ptr, 5); // 踩内存 char a[10]; a[12] = 'i'; // 数组越界 free(ptr); // 重复释放 free(ptr); char *p1; *p1 = '1'; // 非法指针
return 0; } 编译: gcc -o invalidptr invalidptr.c -g 执行:valgrind --leak-check=full ./invalidptr 结果如下: [konten@tencent test_valgrind]$ valgrind --leak-check=full ./invalidptr ==29776== Memcheck, a memory error detector. ==29776== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al. ==29776== Using LibVEX rev 1732, a library for dynamic binary translation. ==29776== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP. ==29776== Using valgrind-3.2.3, a dynamic binary instrumentation framework. ==29776== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al. ==29776== For more details, rerun with: -v ==29776== ==29776== Invalid write of size 1 //堆内存越界被查出来 ==29776== at 0x80483D2: main (invalidptr.c:7) ==29776== Address 0x4159034 is 2 bytes after a block of size 10 alloc'd ==29776== at 0x401A846: malloc (vg_replace_malloc.c:149) ==29776== by 0x80483C5: main (invalidptr.c:6) ==29776== ==29776== Source and destination overlap in memcpy(0x4159029, 0x4159028, 5) //踩内存 ==29776== at 0x401C96D: memcpy (mc_replace_strmem.c:116) ==29776== by 0x80483E6: main (invalidptr.c:9) ==29776== ==29776== Invalid free() / delete / delete[] //重复释放 ==29776== at 0x401B3FB: free (vg_replace_malloc.c:233) ==29776== by 0x8048406: main (invalidptr.c:16) ==29776== Address 0x4159028 is 0 bytes inside a block of size 10 free'd ==29776== at 0x401B3FB: free (vg_replace_malloc.c:233) ==29776== by 0x80483F8: main (invalidptr.c:15) ==29776== ==29776== Use of uninitialised value of size 4 ==29776== at 0x804840D: main (invalidptr.c:19) ==29776== //非法指针,导致coredump ==29776== Process terminating with default action of signal 11 (SIGSEGV): dumping core ==29776== Bad permissions for mapped region at address 0x80482AD ==29776== at 0x804840D: main (invalidptr.c:19) ==29776== ==29776== ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 15 from 1) ==29776== malloc/free: in use at exit: 0 bytes in 0 blocks. ==29776== malloc/free: 1 allocs, 2 frees, 10 bytes allocated. ==29776== For counts of detected errors, rerun with: -v ==29776== All heap blocks were freed -- no leaks are possible. Segmentation fault [konten@tencent test_valgrind]$ 从上面的结果看出,除了栈内存越界外,其他常见的内存问题都可以用valgrind简单的查出来。 3、显示代码覆盖 用callgrind工具能方便的显示程序执行的代码覆盖情况。 看如下例子:
4、显示线程竞态条件 <该版本暂不支持> 用helgrind工具可以在多线程代码中找到可能产生竞态条件的地方。
四 memcheck 工具的常用选型 1、leak-check --leak-check=<no|summary|yes|full> [default: summary] 用于控制内存泄漏检测力度。 no,不检测内存泄漏; summary,仅报告总共泄漏的数量,不报告具体泄漏位置; yes/full,报告泄漏总数、泄漏的具体位置。 2、show-reachable --show-reachable=<yes|no> [default: no] 用于控制是否检测控制范围之外的泄漏,比如全局指针、static指针等。 #include <stdlib.h> #include <stdio.h> //char *gptr = NULL; int main(void) { gptr = (char *)malloc(10); return 0; } 对应以上代码,若--show-reachable为no,则valgrind不报告内存泄漏,否则会报告。 3、undef-value-errors --undef-value-errors=<yes|no> [default: yes] 用于控制是否检测代码中使用未初始化变量的情况。 对应以下代码: int a; printf("a = %d \n", a); 若 --undef-value-errors=no,则valgrind不报告错误,否则报告“Use of uninitialised value ...”的错误。 4、其他选项 --log-file=filename 将结果输出到文件。 --log-socket=192.168.0.1:12345 输出到网络。 --trace-children=<yes|no> [default: no] --track-fds=<yes|no> [default: no] --log-fd=<number> [default: 2, stderr] --xml=<yes|no> [default: no] --num-callers=<number> [default: 12] --show-below-main=<yes|no> [default: no] |