> 问题详情
内存级别的管理分析技术其分析窗口是多长时间？（)A.1minB.15minC.5minD.10min
悬赏：0&答案豆
提问人：匿名网友
发布时间：
内存级别的管理分析技术其分析窗口是多长时间？()A.1minB.15minC.5minD.10min
您可能感兴趣的试题
1目前政府自身改革构建的“五张清单一张网”中的网指的是( )。A.纳税申报网B.行政审批网C.社会管理公共服务网2项目的质量管理主要包括质量计划、质量保证和质量控制等几个环节构成。3一个人只有在既具备某一专业领域的知识和技能，又在该领域从事相关的工作，才能称这个人为专业技术人员。4专家判断即德尔菲法，也称专家调查法，是一种采用通讯方式分别将所需解决的问题单独发送到各个专家手中,征询意见，然后回收汇总全部专家的意见，并整理出综合意见。
我有更好的答案
请先输入下方的验证码查看最佳答案
图形验证：
验证码提交中……
每天只需0.4元
选择支付方式
支付宝付款
郑重提醒：支付后，系统自动为您完成注册
请使用微信扫码支付(元)
支付后，系统自动为您完成注册
遇到问题请联系在线客服QQ：
恭喜你被选中为
扫一扫-免费查看答案！
请您不要关闭此页面,支付完成后点击支付完成按钮
遇到问题请联系在线客服QQ：
恭喜您！升级VIP会员成功
提示：请截图保存您的账号信息，以方便日后登录使用。
常用邮箱：
用于找回密码
确认密码：Linux 内存使用方法详细解析 - 文章 - 伯乐在线
& Linux 内存使用方法详细解析
我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。
一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。
Linux在内存管理上份为两级，一级是线性区，类似于00c00，对应于虚拟内存，它实际上不占用实际物理内存；一级是具体的物理页面，它对应我们机器上的物理内存。
这里要提到一个很重要的概念，内存的延迟分配。Linux内核在用户申请内存的时候，只是给它分配了一个线性区（也就是虚存），并没有分配实际物理内存；只有当用户使用这块内存的时候，内核才会分配具体的物理页面给用户，这时候才占用宝贵的物理内存。内核释放物理页面是通过释放线性区，找到其所对应的物理页面，将其全部释放的过程。
char *p=malloc(2048) //这里只是分配了虚拟内存2048，并不占用实际内存。
strcpy(p,”123”) //分配了物理页面，虽然只是使用了3个字节，但内存还是为它分配了2048字节的物理内存。
free(p) //通过虚拟地址，找到其所对应的物理页面，释放物理页面，释放线性区。
char *p=malloc(2048) //这里只是分配了虚拟内存2048，并不占用实际内存。strcpy(p,”123”) //分配了物理页面，虽然只是使用了3个字节，但内存还是为它分配了2048字节的物理内存。free(p) //通过虚拟地址，找到其所对应的物理页面，释放物理页面，释放线性区。
我们知道用户的进程和内核是运行在不同的级别，进程与内核之间的通讯是通过系统调用来完成的。进程在申请和释放内存，主要通过brk,sbrk,mmap,unmmap这几个系统调用，传递的参数主要是对应的虚拟内存。
注意一点，在进程只能访问虚拟内存，它实际上是看不到内核物理内存的使用，这对于进程是完全透明的。
glibc内存管理器
那么我们每次调用malloc来分配一块内存，都进行相应的系统调用呢？
答案是否定的，这里我要引入一个新的概念，glibc的内存管理器。
我们知道malloc和free等函数都是包含在glibc库里面的库函数，我们试想一下，每做一次内存操作，都要调用系统调用的话，那么程序将多么的低效。
实际上glibc采用了一种批发和零售的方式来管理内存。glibc每次通过系统调用的方式申请一大块内存（虚拟内存），当进程申请内存时，glibc就从自己获得的内存中取出一块给进程。
内存管理器面临的困难
我们在写程序的时候，每次申请的内存块大小不规律，而且存在频繁的申请和释放，这样不可避免的就会产生内存碎块。而内存碎块，直接会导致大块内存申请无法满足，从而更多的占用系统资源；如果进行碎块整理的话，又会增加cpu的负荷，很多都是互相矛盾的指标，这里我就不细说了。
我们在写程序时，涉及内存时，有两个概念heap和stack。传统的说法stack的内存地址是向下增长的，heap的内存地址是向上增长的。
函数malloc和free，主要是针对heap进行操作，由程序员自主控制内存的访问。
在这里heap的内存地址向上增长，这句话不完全正确。
glibc对于heap内存申请大于128k的内存申请，glibc采用mmap的方式向内核申请内存，这不能保证内存地址向上增长；小于128k的则采用brk，对于它来讲是正确的。128k的阀值，可以通过glibc的库函数进行设置。
这里我先讲大块内存的申请，也即对应于mmap系统调用。
对于大块内存申请，glibc直接使用mmap系统调用为其划分出另一块虚拟地址，供进程单独使用；在该块内存释放时，使用unmmap系统调用将这块内存释放，这个过程中间不会产生内存碎块等问题。
针对小块内存的申请，在程序启动之后，进程会获得一个heap底端的地址，进程每次进行内存申请时，glibc会将堆顶向上增长来扩展内存空间，也就是我们所说的堆地址向上增长。在对这些小块内存进行操作时，便会产生内存碎块的问题。实际上brk和sbrk系统调用，就是调整heap顶地址指针。
那么heap堆的内存是什么时候释放呢？
当glibc发现堆顶有连续的128k的空间是空闲的时候，它就会通过brk或sbrk系统调用，来调整heap顶的位置，将占用的内存返回给系统。这时，内核会通过删除相应的线性区，来释放占用的物理内存。
下面我要讲一个内存空洞的问题：
一个场景，堆顶有一块正在使用的内存，而下面有很大的连续内存已经被释放掉了，那么这块内存是否能够被释放？其对应的物理内存是否能够被释放？
很遗憾，不能。
这也就是说，只要堆顶的部分申请内存还在占用，我在下面释放的内存再多，都不会被返回到系统中，仍然占用着物理内存。为什么会这样呢？
这主要是与内核在处理堆的时候，过于简单，它只能通过调整堆顶指针的方式来调整调整程序占用的线性区；而又只能通过调整线性区的方式，来释放内存。所以只要堆顶不减小，占用的内存就不会释放。
提一个问题：
char *p=malloc(2);
char *p=malloc(2);free(p)
为什么申请内存的时候，需要两个参数，一个是内存大小，一个是返回的指针；而释放内存的时候，却只要内存的指针呢？
这主要是和glibc的内存管理机制有关。glibc中，为每一块内存维护了一个chunk的结构。glibc在分配内存时，glibc先填写chunk结构中内存块的大小，然后是分配给进程的内存。
chunk ------size
p------------ content
chunk ------sizep------------ content
在进程释放内存时，只要 指针-4 便可以找到该块内存的大小，从而释放掉。
注：glibc在做内存申请时，最少分配16个字节，以便能够维护chunk结构。
glibc提供的调试工具：
为了方便调试，glibc 为用户提供了 malloc 等等函数的钩子（hook），如 __malloc_hook
对应的是一个函数指针，
void *function (size_t size, const void *caller)
void *function (size_t size, const void *caller)
其中 caller 是调用 malloc 返回值的接受者（一个指针的地址）。另外有 __malloc_initialize_hook函数指针，仅仅会调用一次（第一次分配动态内存时）。（malloc.h）
一些使用 malloc 的统计量（SVID 扩展）可以用 struct mallinfo 储存，可调用获得。
struct mallinfo mallinfo (void)
struct mallinfo mallinfo (void)
如何检测 memory leakage？glibc 提供了一个函数
void mtrace (void)及其反作用void muntrace (void)
这时会依赖于一个环境变量 MALLOC_TRACE 所指的文件，把一些信息记录在该文件中
用于侦测 memory leakage，其本质是安装了前面提到的 hook。一般将这些函数用
#ifdef DEBUGGING 包裹以便在非调试态下减少开销。产生的文件据说不建议自己去读，
而使用 mtrace 程序（perl 脚本来进行分析）。下面用一个简单的例子说明这个过程，这是
intmain( int argc, char *argv[] )
#ifdef DEBUGGING
mtrace( ) ;
p = malloc( sizeof( int ) ) ;
q = malloc( sizeof( int ) ) ;
printf( &p = %p\nq = %p\n&, p, q ) ;
free( p ) ;
return 0 ;
1234567891011121314151617
#include#include#includeintmain( int argc, char *argv[] ){&&int *p, *q ;&&#ifdef DEBUGGING&&mtrace( ) ;&&#endif&&p = malloc( sizeof( int ) ) ;&&q = malloc( sizeof( int ) ) ;&&printf( "p = %p\nq = %p\n", p, q ) ;&&*p = 1 ;&&*q = 2 ;&&free( p ) ;&&return 0 ;}
很简单的程序，其中 q 没有被释放。我们设置了环境变量后并且 touch 出该文件
执行结果如下：
p = 0x98c0378q = 0x98c0388
p = 0x98c0378q = 0x98c0388
该文件内容如下
@./test30:[0x8048446] + 0x98c
@./test30:[0x8048455] + 0x98c
@./test30:[0x804848f] - 0x98c0378
= Start@./test30:[0x8048446] + 0x98c0378 0x4@./test30:[0x8048455] + 0x98c0388 0x4@./test30:[0x804848f] - 0x98c0378
到这里我基本上讲完了，我们写程序时，数据部分内存使用的问题。
代码占用的内存
数据部分占用内存，那么我们写的程序是不是也占用内存呢？
在linux中，程序的加载，涉及到两个工具，linker 和loader。Linker主要涉及动态链接库的使用，loader主要涉及软件的加载。
exec执行一个程序
elf为现在非常流行的可执行文件的格式，它为程序运行划分了两个段，一个段是可以执行的代码段，它是只读，可执行；另一个段是数据段，它是可读写，不能执行。
loader会启动，通过mmap系统调用，将代码端和数据段映射到内存中，其实也就是为其分配了虚拟内存，注意这时候，还不占用物理内存；只有程序执行到了相应的地方，内核才会为其分配物理内存。
loader会去查找该程序依赖的链接库，首先看该链接库是否被映射进内存中，如果没有使用mmap，将代码段与数据段映射到内存中，否则只是将其加入进程的地址空间。这样比如glibc等库的内存地址空间是完全一样。
因此一个2M的程序，执行时，并不意味着为其分配了2M的物理内存，这与其运行了的代码量，与其所依赖的动态链接库有关。
运行过程中链接动态链接库与编译过程中链接动态库的区别
我们调用动态链接库有两种方法：一种是编译的时候，指明所依赖的动态链接库，这样loader可以在程序启动的时候，来所有的动态链接映射到内存中；一种是在运行过程中，通过dlopen和dlfree的方式加载动态链接库，动态将动态链接库加载到内存中。
这两种方式，从编程角度来讲，第一种是最方便的，效率上影响也不大，在内存使用上有些差别。
第一种方式，一个库的代码，只要运行过一次，便会占用物理内存，之后即使再也不使用，也会占用物理内存，直到进程的终止。
第二中方式，库代码占用的内存，可以通过dlfree的方式，释放掉，返回给物理内存。
这个差别主要对于那些寿命很长，但又会偶尔调用各种库的进程有关。如果是这类进程，建议采用第二种方式调用动态链接库。
占用内存的测量
测量一个进程占用了多少内存，linux为我们提供了一个很方便的方法，/proc目录为我们提供了所有的信息，实际上top等工具也通过这里来获取相应的信息。
/proc/meminfo 机器的内存使用信息
/proc/pid/maps pid为进程号，显示当前进程所占用的虚拟地址。
/proc/pid/statm 进程所占用的内存
[root@localhost ~]# cat /proc/self/statm
654 57 44 0 0 334 0
/proc/meminfo 机器的内存使用信息/proc/pid/maps pid为进程号，显示当前进程所占用的虚拟地址。/proc/pid/statm 进程所占用的内存[root@localhost ~]# cat /proc/self/statm654 57 44 0 0 334 0
CPU 以及CPU0。。。的每行的每个参数意思（以第一行为例）为：
参数 解释 /proc//status
Size (pages) 任务虚拟地址空间的大小 VmSize/4
Resident(pages) 应用程序正在使用的物理内存的大小 VmRSS/4
Shared(pages) 共享页数 0
Trs(pages) 程序所拥有的可执行虚拟内存的大小 VmExe/4
Lrs(pages) 被映像到任务的虚拟内存空间的库的大小 VmLib/4
Drs(pages) 程序数据段和用户态的栈的大小 （VmData+ VmStk ）4
dt(pages) 04
Size (pages) 任务虚拟地址空间的大小 VmSize/4Resident(pages) 应用程序正在使用的物理内存的大小 VmRSS/4Shared(pages) 共享页数 0Trs(pages) 程序所拥有的可执行虚拟内存的大小 VmExe/4Lrs(pages) 被映像到任务的虚拟内存空间的库的大小 VmLib/4Drs(pages) 程序数据段和用户态的栈的大小 （VmData+ VmStk ）4dt(pages) 04
查看机器可用内存
/proc/28248/&free
total used free shared buffers cached
Mem: 400 668 503688
-/+ buffers/cache: 744
Swap: 08 1870312
/proc/28248/>freetotal used free shared buffers cachedMem: 1023788 926400 97388 0 134668 503688-/+ buffers/cache: 288044 735744Swap: 1959920 89608 1870312
我们通过free命令查看机器空闲内存时，会发现free的值很小。这主要是因为，在linux中有这么一种思想，内存不用白不用，因此它尽可能的cache和buffer一些数据，以方便下次使用。但实际上这些内存也是可以立刻拿来使用的。
所以 空闲内存=free+buffers+cached=total-used
查看进程使用的内存
查看一个进程使用的内存，是一个很令人困惑的事情。因为我们写的程序，必然要用到动态链接库，将其加入到自己的地址空间中，但是/proc/pid/statm统计出来的数据，会将这些动态链接库所占用的内存也简单的算进来。
这样带来的问题，动态链接库占用的内存有些是其他程序使用时占用的，却算在了你这里。你的程序中包含了子进程，那么有些动态链接库重用的内存会被重复计算。
因此要想准确的评估一个程序所占用的内存是十分困难的，通过写一个module的方式，来准确计算某一段虚拟地址所占用的内存，可能对我们有用。(T002)
可能感兴趣的话题
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线内容团队正试图以我们微薄的力量，把优秀的原创文章和译文分享给读者，为“快餐”添加一些“营养”元素。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2018 伯乐在线您所在位置： &
&nbsp&&nbsp&nbsp&&nbsp
2018年绵阳公需科目试题答案.docx 25页
本文档一共被下载：
次 ,您可全文免费在线阅读后下载本文档。
下载提示
1.本站不保证该用户上传的文档完整性，不预览、不比对内容而直接下载产生的反悔问题本站不予受理。
2.该文档所得收入(下载+内容+预览三)归上传者、原创者。
3.登录后可充值，立即自动返金币，充值渠道很便利
你可能关注的文档：
··········
··········
2018年绵阳市公需科目考试试题答案说明：正确答案在每小题题干的最后面。试题1一、判断题(每题2分)1.用随机分析的方法或者用抽样的方法来进行处理的数据叫大数据。( 错误)2.大数据是一种信息资本。(正确 )3.十二五规划，国家把整个大数据定义为国家战略。(错误)4.1946年人类发明了第一台数字计算机，1990年人类发明了互联网。(正确 )?5.实施大数据战略是政府治理现代化的重要路径。(正确 )?正确?错误6.2020年要实现全部脱贫的目标，这是一个很高的标准。( 错误)?正确?错误7.当今社会时代步入了一个信息化助力社会全方位创新的重要时期。(正确 )?正确?错误8.互联网时代必将产生大量的数据，这些数据的集成和未来的挖掘使用，对各个行业都会发生极大的作用。(正确 )?正确?错误9.大数据时代，黑客对数据由原来的破坏变成了窃取和利用。(正确 )?正确?错误10.美国的纽约的证券交易所多次发生系统崩溃，不得不暂停股票的交易。(正确 )?正确?错误11.中国人对微信、微博或者是对互联网金融的支付，使用的习惯或者接受能力远远的超过了欧洲、日本等等，甚至比美国都快，已经成为名副其实的网络大国。(正确 )?正确?错误12.计算机很容易回答为什么的问题。(错误 )?正确?错误13.2004在美国进行了一次无人驾驶汽车的拉力赛，车速还没有骑自行车快。(正确 )?正确?错误14.大数据就是数据量本身和它的处理方法。(正确 )?正确?错误15.大数据处理的数据中心规模越大，反而能耗和成本越低。( 错误)?正确?错误16.第二代信息平台就是以服务器、客户端、应用模式为代表的互联网平台。(正确 )?正确?错误17.提升全社会的数据意识和数据精神是我们今天落实大数据行动纲要的重要基点。( 正确)?正确?错误18.新时代中国特色社会主义思想，是马克思主义中国化最新成果，是党和人民实践经验和集体智慧的结晶。( 正确)?正确?错误19.转变政府职能，深化简政放权，创新监管方式，增强政府公信力和执行力，建设人民满意的管理型政府。(错误 )?正确?错误20.综合分析国际国内形势和我国发展条件，从二〇二〇年到本世纪中叶可以分两个阶段来安排。( 正确)?正确?错误二、单项选择(每题2分)21.全球十大IT企业中国占了三家，不包括(C )。?A.联想?B.华为?C.中国电信?D.中兴通信22.目前政府自身改革构建的“五张清单一张网”中的网指的是(A )。?A.社会管理公共服务网?B.行政审批网?C.纳税申报网23.以下不属于大数据聚类表现的形态是（ B）。?A.不确定的??B.单一的??C.变粒度特性的??D.多层次的?24.目前在国内把大数据用的最好的是（C　）。?A.政府?B.学校?C.电商25.大数据加上机器智能，可以把我们以前所有的行业全部改造一遍，所有未来公司，都是某种程度上的一个（A　）。?A.大数据公司?B.机器人公司?C.无人公司?D.计算机公司26.下列不属于建立政务数据资源目录体系内容的是（C ）。?A.明确政府数据资源管理的责任部门和归口管理部门??B.开展政务数据资源普查登记，摸清政务数据资源底数??C.采取增量先行或增量存量并行的思路，对各部门数据资源进行统筹管理??D.建立政务数据资源目录体系，探索对政务数据资源实行清单管理27.《促进大数据发展行动纲要》的根本出发点和核心主题是（A ）。?A.解决现实中的问题??B.推广大数据应用??C.促进大数据应用的落实?D.宣传大数据思维?28.信息技术经过几十年的扩散储备后，21世纪的前（C ）年可能是信息技术提高生产率的黄金时期。?A.35?B.20??C.30??D.10?29.据有关机构测算在2014年我们国家信息经济总量已经达到了(D )万亿元人民币。?A.12?B.10?C.18?D.16.230.大数据发展行动纲要非常明确地提出了我们大数据发展的目标体系，这个目标体系是分3个时段。第二时段是到( A)年底。?A.2018?B.2017?C.2020?D.1年，（B ）诞生，互联网开始走向标准化、商业化和国际化。?A.SFNET??B.万维网??C.阿帕网??D.nternet32.（A ）从中科院高能物理所发出我国第一封电子邮件，揭开了中国人使用Internet的序幕。?A.1987年??B.1991年??C.1978年??D.1990年?33.在众创空间里面，创业者只需要每人每天点一杯咖啡就可以享用一整天的免费的开放式办公环境，而且可以借助其他的创业者一起去商量面对问题怎么解决。这表现了“互联网+”(B )。?A.推动产业结构升级??B.推动创新方式变革?C.推动跨界融合发展??D.推动发展模式变革?34.(B )是一个国家、一个民族发展中更基本、更深沉、
正在加载中，请稍后...您所在位置： &
&nbsp&&nbsp&nbsp&&nbsp
2018年专业技术人员继续教育公需科目练习题库.pdf 85页
本文档一共被下载：
次 ,您可全文免费在线阅读后下载本文档。
下载提示
1.本站不保证该用户上传的文档完整性，不预览、不比对内容而直接下载产生的反悔问题本站不予受理。
2.该文档所得收入(下载+内容+预览三)归上传者、原创者。
3.登录后可充值，立即自动返金币，充值渠道很便利
你可能关注的文档：
·········
2018 年公需科目考试练习题库
以下题目正确答案用蓝色字体显示
一、判断题
( 每题 2 分 )
1. 中国在电子政务发展由内部办公自动化往外延伸的过程中遇到了很大阻力。
2. 上海的研究表明，行政服务中心放在社区的载体上最合适。
3. 中国社会财富向三个方面集中，从社会和政府来看，财富过多向政府手中集
中，从劳和资来看，财富更多向资方手中集中，从普通行业和垄断行业来看，
财富过多向垄断行业手中集中。
4. 我国的财政支出结构用到老百姓手上的占比是
30%多，大体相当于发达国家平
均水平的一半。
5. 政府数据开放，既包括政府部门之间数据要开放，也包括政府的数据向社会
开放。 ( )
6. 认知科学要有所突破，首先要在大数据聚类上突破，宏观或微观的认知价值
发现无不借助于大数据聚类分析的结果。
7. 大数据可以精细到人类的每一个操作。
8. 以人为本要做到从客体中心向主体中心转变。
9. 数据量越大信息越全面，对于分析结果就越好。
10. 大数据越多，我们的思维就越全面。
11. 过去在管理体制中公共权力部门化，部门权利利益化，部门利益合法化还有
推动信息的融合共享，给推动大数据业务协同带来了现实的障碍。
12. 第二代信息平台就是指的是集中式的大型主机。
13. 互联网的发展最早可以追溯到上世纪八十年代。
14.1990 年 10 月，我们国家正式注册了顶级的域名，
就是我们现在经常用的
这样一个域名，开通了使用自己域名的
电子邮件。 ( )
15. 基于大数据的社会治理更加有效，比如可以运用各个行业的大数据监测品牌
形象。 ( )
16. 道路自信是一个国家、一个民族发展中更基本、更深沉、更持久的力量。
17. 建设经济强国是中华民族伟大复兴的基础工程。
18. 决胜全面建成小康社会，全面建设社会主义现代化国家新征程中需要打的
“攻坚战”有：防范化解重大风险、精准脱贫、污染防治。
19. 全面依法治国是国家治理的一场深刻革命，必须坚持厉行法治，推进科学立
法、严格执法、公正司法、全民守法。
20. 社会主义文艺是人民的文艺，必须坚持以人民为中心的创作导向，要着力提
升文艺原创力，推动文艺创新。倡导讲品位、讲格调、讲责任，抵制低俗、庸
俗、媚俗。 ( )
二、单项选择
21. 中国的网民数量和网络规模位居全球
正在加载中，请稍后...Linux下利用Valgrind工具进行内存泄露检测和性能分析
valgrind --leak-check=full ./程序名
valgrind --tool=callgrind ./tmp
执行完成后在目录下生成"callgrind.out.XXX"的文件这是分析文件，可以直接利用：callgrind_annotate
callgrind.out.XXX 打印结果，也可以使用：gprof2dot.py -f callgrind
callgrind.out.XXX&|dot -Tpng -o
report.png 来生成图形化结果
gcc -pg -o tmp
tmp.c，然后运行该程序./tmp，程序运行完成后会在当前目录下生成gmon.out文件（这个文件gprof在分析程序时需要），
再执行gprof ./tmp | gprof2dot.py |dot -Tpng -o report.png
http://blog.csdn.net/yangzhiloveyou/article/details/7935078
Doxygen:(官方网站:http://www.stack.nl/~dimitri/doxygen/)
apt-get install doxygen doxygen-doc doxygen-gui
注:如果要生成 png 格式的图片,必须安装 Graphviz 软件。
出现如下提示信息的话,则就不要安 doxygen-gui 了:
现在没有可用的软件包 doxygen-gui，但是它被其它的软件包引用了。
E: 软件包 doxygen-gui 还没有可供安装的候选者
apt-get install doxygen doxygen-doc graphviz
Valgrind通常用来成分析程序性能及程序中的内存泄露错误
一&Valgrind工具集简绍
Valgrind包含下列工具：
&&&&1、memcheck：检查程序中的内存问题，如泄漏、越界、非法指针等。
&&&&2、callgrind：检测程序代码的运行时间和调用过程，以及分析程序性能。
&&&&3、cachegrind：分析CPU的cache命中率、丢失率，用于进行代码优化。
&&&&4、helgrind：用于检查多线程程序的竞态条件。
&&&&5、massif：堆栈分析器，指示程序中使用了多少堆内存等信息。
&&&&6、lackey：
7、nulgrind：
这几个工具的使用是通过命令：valgrand --tool=name
程序名来分别调用的，当不指定tool参数时默认是&--tool=memcheck
二&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能在这里帮上大忙。
#include&&&
#include&&&
#include&&&
void&test()&&
&&&&int&*ptr&=&malloc(sizeof(int)*10);&&
&&&&ptr[10]&=&7;&//&内存越界&&
&&&&memcpy(ptr&+1,&ptr,&5);&//&踩内存&&
&&&&free(ptr);&&&
&&&&free(ptr);//&重复释放&&
&&&&int&*p1;&&
&&&&*p1&=&1;&//&非法指针&&
int&main(void)&&
&&&&test();&&
&&&&return&0;&&
将程序编译生成可执行文件后执行：valgrind --leak-check=full ./程序名
输出结果如下：
==4832==&Memcheck,&a&memory&error&detector&&
==4832==&Copyright&(C)&,&and&GNU&GPL'd,&by&Julian&Seward&et&al.&&
==4832==&Using&Valgrind-3.6.1&and&LibVEX;&rerun&with&-h&for&copyright&info&&
==4832==&Command:&./tmp&&
==4832==&&&
==4832==&Invalid&write&of&size&4&&&&&&//&内存越界&&
==4832==&&&&at&0x804843F:&test&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&&by&0x804848D:&main&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&Address&0x41a6050&is&0&bytes&after&a&block&of&size&40&alloc'd&&
==4832==&&&&at&0x4026864:&malloc&(vg_replace_malloc.c:236)&&
==4832==&&&&by&0x8048435:&test&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&&by&0x804848D:&main&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&
==4832==&Source&and&destination&overlap&in&memcpy(0x41a602c,&0x41a6028,&5)&//&踩内存&&
==4832==&&&&at&0x4027BD6:&memcpy&(mc_replace_strmem.c:635)&&
==4832==&&&&by&0x8048461:&test&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&&by&0x804848D:&main&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&
==4832==&Invalid&free()&/&delete&/&delete[]&//&重复释放&&
==4832==&&&&at&0x4025BF0:&free&(vg_replace_malloc.c:366)&&
==4832==&&&&by&0x8048477:&test&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&&by&0x804848D:&main&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&Address&0x41a6028&is&0&bytes&inside&a&block&of&size&40&free'd&&
==4832==&&&&at&0x4025BF0:&free&(vg_replace_malloc.c:366)&&
==4832==&&&&by&0x804846C:&test&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&&by&0x804848D:&main&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&
==4832==&Use&of&uninitialised&value&of&size&4&//&非法指针&&
==4832==&&&&at&0x804847B:&test&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&&by&0x804848D:&main&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&
==4832==&&&
==4832==&Process&terminating&with&default&action&of&signal&11&(SIGSEGV)&//由于非法指针赋值导致的程序崩溃&&
==4832==&&Bad&permissions&for&mapped&region&at&address&0x419FFF4&&
==4832==&&&&at&0x804847B:&test&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&&by&0x804848D:&main&(in&/home/yanghao/Desktop/testC/testmem/tmp)&&
==4832==&&&
==4832==&HEAP&SUMMARY:&&
==4832==&&&&&in&use&at&exit:&0&bytes&in&0&blocks&&
==4832==&&&total&heap&usage:&1&allocs,&2&frees,&40&bytes&allocated&&
==4832==&&&
==4832==&All&heap&blocks&were&freed&--&no&leaks&are&possible&&
==4832==&&&
==4832==&For&counts&of&detected&and&suppressed&errors,&rerun&with:&-v&&
==4832==&Use&--track-origins=yes&to&see&where&uninitialised&values&come&from&&
==4832==&ERROR&SUMMARY:&4&errors&from&4&contexts&(suppressed:&11&from&6)&&
Segmentation&fault&&
从valgrind的检测输出结果看，这几个错误都找了出来。
2.Callgrind
和gprof类似的分析工具，但它对程序的运行观察更是入微，能给我们提供更多的信息。和
gprof不同，它不需要在编译源代码时附加特殊选项，但加上调试选项是推荐的。Callgrind收集程序运行时的一些数据，建立函数调用关系图，还可
以有选择地进行cache模拟。在运���结束时，它会把分析数据写入一个文件。callgrind_annotate可以把这个文件的内容转化成可读的
生成可视化的图形需要下载gprof2dot：
这是个python脚本，把它下载之后修改其权限chmod +7 gprof2dot.py
，并把这个脚本添加到$PATH路径中的任一文件夹下，我是将它放到了/usr/bin目录下，这样就可以直接在终端下执行gprof2dot.py了。
Callgrind可以生成程序性能分析的图形，首先来说说程序性能分析的工具吧，通常可以使用gnu自带的gprof，它的使用方法是：在编译程序时添加-pg参数，例如：
#include&&&
void&test()&&
&&&&sleep(1);&&
void&f()&&
&&&&int&i;&&
&&&&for(&i&=&0;&i&&&5;&i&++)&&
&&&&&&&&test();&&
int&main()&&
&&&&f();&&
&&&&printf("process&is&over!\n");&&
&&&&return&0;&&
首先执行 gcc -pg -o tmp
tmp.c，然后运行该程序./tmp，程序运行完成后会在当前目录下生成gmon.out文件（这个文件gprof在分析程序时需要），
再执行gprof ./tmp | gprof2dot.py |dot -Tpng -o
report.png，打开report.png结果：
显示test被调用了5次，程序中耗时所占百分比最多的是test函数。
再来看&Callgrind
的生成调用图过程吧，执行：valgrind --tool=callgrind
./tmp，执行完成后在目录下生成"callgrind.out.XXX"的文件这是分析文件，可以直接利用：callgrind_annotate
callgrind.out.XXX 打印结果，也可以使用：gprof2dot.py -f callgrind
callgrind.out.XXX&|dot -Tpng -o
report.png 来生成图形化结果:
它生成的结果非常详细，甚至连函数入口，及库函数调用都标识出来了。
调不尽的内存泄漏，用不完的Valgrind
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. 运行./autogen.sh设置环境（需要标准的autoconf工具）（可选）
./配置Valgrind，生成MakeFile文件，具体参数信息详见INSTALL文件。一般只需要设置--prefix=/where/you/want/it/installed
7. Make；编译Valgrind
8. make install；安装Valgrind
Valgrind包含的工具
Valgrind支持很多工具:memcheck，addrcheck，cachegrind，Massif，helgrind和Callgrind等。在运行Valgrind时，你必须指明想用的工具,如果省略工具名，默认运行memcheck。
1、memcheck
memcheck探测程序中内存管理存在的问题。它检查所有对内存的读/写操作，并截取所有的malloc/new/free/delete调用。因此memcheck工具能够探测到以下问题：
1）使用未初始化的内存
2）读/写已经被释放的内存
3）读/写内存越界
4）读/写不恰当的内存栈空间
5）内存泄漏
6）使用malloc/new/new[]和free/delete/delete[]不匹配。
7）src和dst的重叠
2、cachegrind
cachegrind 是一个cache剖析器。它模拟执行CPU中的L1, D1和L2
cache，因此它能很精确的指出代码中的cache未命中。如果你需要，它可以打印出cache未命中的次数，内存引用和发生cache未命中的每一行
代码，每一个函数，每一个模块和整个程序的摘要。如果你要求更细致的信息，它可以打印出每一行机器码的未命中次数。在x86和amd64上，
cachegrind通过CPUID自动探测机器的cache配置，所以在多数情况下它不再需要更多的配置信息了。
3、helgrind
helgrind查找多线程程序中的竞争数据。helgrind查找内存地址，那些被多于一条线程访问的内存地址，但是没有使用一致的锁就会被查出。这表示这些地址在多线程间访问的时候没有进行同步，很可能会引起很难查找的时序问题。
它 主要用来检查多线程程序中出现的竞争问题。Helgrind
寻找内存中被多个线程访问，而又没有一贯加锁的区域，这些区域往往是线程之间失去同步的地方，而且会导致难以发掘的错误。Helgrind实现了名
为”Eraser” 的竞争检测算法，并做了进一步改进，减少了报告错误的次数。
4、Callgrind
Callgrind收集程序运行时的一些数据，函数调用关系等信息，还可以有选择地进行cache
模拟。在运行结束时，它会把分析数据写入一个文件。callgrind_annotate可以把这个文件的内容转化成可读的形式。
$valgrind --tool=callgrind ./sec_infod
会在当前目录下生成callgrind.out.[pid], 如果我们想结束程序, 可以
$killall callgrind
然后我们可以用
$callgrind_annotate --auto=yes callgrind.out.[pid] & log
堆栈分析器，它能测量程序在堆栈中使用了多少内存，告诉我们堆块，堆管理块和栈的大小。Massif能帮助我们减少内存的使用，在带有虚拟内存的现代系统中，它还能够加速我们程序的运行，减少程序停留在交换区中的几率。
lackey是一个示例程序，以其为模版可以创建你自己的工具。在程序结束后，它打印出一些基本的关于程序执行统计数据。
Valgrind的参数
用法: valgrind [options] prog-and-args [options]:
常用选项，适用于所有Valgrind工具
最常用的选项。运行 valgrind中名为toolname的工具。默认memcheck。
显示所有选项的帮助，包括内核和选定的工具两者。
显示valgrind内核的版本，每个工具都有各自的版本。
-q --quiet
安静地运行，只打印错误信息。
更详细的信息。
--trace-children=
跟踪子线程? [default: no]
--track-fds=
跟踪打开的文件描述？[default: no]
--time-stamp=
增加时间戳到LOG信息? [default: no]
输出LOG到描述符文件 [2=stderr]
--log-file=
将输出的信息写入到filename.PID的文件里，PID是运行程序的进行ID
--log-file-exactly=
输出LOG信息到 file
LOG信息输出
将信息以xml格式输出，只有memcheck可用
--num-callers=
show callers in stack traces [12]
--error-exitcode=
如果发现错误则返回错误代码 [0=disable]
--db-attach=
当出现错误，valgrind会自动启动调试器gdb。[default: no]
--db-command=
启动调试器的命令行选项[gdb -nw %f %p]
适用于Memcheck工具的相关选项：
--leak-check=
要 求对leak给出详细信息?
Leak是指，存在一块没有被引用的内存空间，或没有被释放的内存空间，如summary，只反馈一些总结信息，告诉你有多少个malloc，多少个
free 等；如果是full将输出所有的leaks，也就是定位到某一个malloc/free。 [default:
--show-reachable=
如果为no，只输出没有引用的内存leaks，或指向malloc返回的内存块中部某处的leaks [default: no]
更详细的参数指令见附录A。
Valgrind的使用
先，在编译程序的时候打开调试模式（gcc编译器的-g选项）。如果没有调试信息，即使最好的valgrind工具也将中能够猜测特定的代码是属于哪一个
函数。打开调试选项进行编译后再用valgrind检查，valgrind将会给你的个详细的报告，比如哪一行代码出现了内存泄漏。
当 检查的是C++程序的时候，还应该考虑另一个选项
-fno-inline。它使得函数调用链很清晰，这样可以减少你在浏览大型C++程序时的混乱。比如在使用这个选项的时候，用memcheck检查
openoffice就很容易。当然，你可能不会做这项工作，但是使用这一选项使得valgrind生成更精确的错误报告和减少混乱。
一些编译优化选项(比如-O2或者更高的优化选项)，可能会使得memcheck提交错误的未初始化报告，因此，为了使得valgrind的报告更精确，在编译的时候最好不要使用优化选项。
如果程序是通过脚本启动的，可以修改脚本里启动程序的代码，或者使用--trace-children=yes选项来运行脚本。
下面是用memcheck检查sample.c的例子
这里用到的示例程序文件名为：sample.c（如下所示）,选用的编译器为gcc。
生成可执行程序
gcc &g sample.c &o sample
运行Valgrind
valgrind --tool=memcheck ./sample
以下是运行上述命令后的输出
左边显示类似行号的数字（10297）表示的是 Process ID。
最上面的红色方框表示的是 valgrind 的版本信息。
中间的红色方框表示 valgrind 通过运行被测试程序，发现的内存问题。通过阅读这些信息，可以发现：
l 这是一个对内存的非法写操作，非法写操作的内存是4 bytes。
l 发生错误时的函数堆栈，以及具体的源代码行号。
l 非法写操作的具体地址空间。
最下面的红色方框是对发现的内存问题和内存泄漏问题的总结。内存泄漏的大小（40 bytes）也能够被检测出来。
Valgrind的示例
例1．使用未初始化的内存
#include &&/span&stdio.h&
int main()
if(x == 0)
printf("X is zero");
Valgrind提示如下==14222== Conditional jump or move depends on uninitialised value(s)==14222== at 0x400484: main (sample2.c:6)
X is zero==14222====14222== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 5 from 1)==14222== malloc/free: in use at exit: 0 bytes in 0 blocks.==14222== malloc/free: 0 allocs, 0 frees, 0 bytes allocated.==14222== For counts of detected errors, rerun with: -v==14222== All heap blocks were freed -- no leaks are possible.
例2．内存读写越界
#include &&/span&stdlib.h&
#include &&/span&stdio.h&int main(int argc,char *argv[])
int len=5;
int *pt=(int*)malloc(len*sizeof(int));
for(i=0;i&&/span&i++)
printf(“%d”,*p);
Valgrind提示如下==23045== Invalid write of size 4==23045== at 0x40050A: main (sample2.c:11)==23045== Address 0x4C2E044 is 0 bytes after a block of size 20 alloc'd==23045== at 0x4A05809: malloc (vg_replace_malloc.c:149)==23045== by 0x4004DF: main (sample2.c:7)==23045====23045== Invalid read of size 4==23045== at 0x400514: main (sample2.c:12)==23045== Address 0x4C2E044 is 0 bytes after a block of size 20 alloc'd==23045== at 0x4A05809: malloc (vg_replace_malloc.c:149)==23045== by 0x4004DF: main (sample2.c:7)5==23045====23045== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 5 from 1)==23045== malloc/free: in use at exit: 20 bytes in 1 blocks.==23045== malloc/free: 1 allocs, 0 frees, 20 bytes allocated.==23045== For counts of detected errors, rerun with: -v==23045== searching for pointers to 1 not-freed blocks.==23045== checked 66,584 bytes.==23045====23045== LEAK SUMMARY:==23045== definitely lost: 20 bytes in 1 blocks.==23045== possibly lost: 0 bytes in 0 blocks.==23045== still reachable: 0 bytes in 0 blocks.==23045== suppressed: 0 bytes in 0 blocks.==23045== Use --leak-check=full to see details of leaked memory.
例3．src和dst内存覆盖
int main(int argc,char *argv[])
{ char x[50];
for(i=0;i&50;i++)
strncpy(x+20,x,20); //Good
strncpy(x+20,x,21); //Overlap
x[39]=’\0’;
strcpy(x,x+20); //Good
x[40]=’\0’;
strcpy(x,x+20); //Overlap
Valgrind提示如下
==24139== Source and destination overlap in strncpy(0x7FEFFFC09,
0x7FEFFFBF5, 21)
==24139== at 0x4A0724F: strncpy (mc_replace_strmem.c:116)
==24139== by 0x400527: main (sample3.c:10)
==24139== Source and destination overlap in strcpy(0x7FEFFFBE0,
0x7FEFFFBF4)
==24139== at 0x4A06E47: strcpy (mc_replace_strmem.c:106)
==24139== by 0x400555: main (sample3.c:15)
==24139== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 5
==24139== malloc/free: in use at exit: 0 bytes in 0 blocks.
==24139== malloc/free: 0 allocs, 0 frees, 0 bytes allocated.
==24139== For counts of detected errors, rerun with: -v
==24139== All heap blocks were freed -- no leaks are possible.
例4．动态内存管理错误
见的内存分配方式分三种：静态存储，栈上分配，堆上分配。全局变量属于静态存储，它们是在编译时就被分配了存储空间，函数内的局部变量属于栈上分配，而最
灵活的内存使用方式当属堆上分配，也叫做内存动态分配了。常用的内存动态分配函数包括：malloc, alloc, realloc,
new等，动态释放函数包括free, delete。
一旦成功申请了动态内存，我们就需要自己对其进行内存管理，而这又是最容易犯错误的。常见的内存动态管理错误包括：
l 申请和释放不一致
由 于 C++ 兼容 C，而 C 与 C++ 的内存申请和释放函数是不同的，因此在 C++
程序中，就有两套动态内存管理函数。一条不变的规则就是采用 C 方式申请的内存就用 C 方式释放；用 C++ 方式申请的内存，用 C++
方式释放。也就是用 malloc/alloc/realloc 方式申请的内存，用 free 释放；用 new 方式申请的内存用
delete 释放。在上述程序中，用 malloc 方式申请了内存却用 delete
来释放，虽然这在很多情况下不会有问题，但这绝对是潜在的问题。
l 申请和释放不匹配
申请了多少内存，在使用完成后就要释放多少。如果没有释放，或者少释放了就是内存泄露；多释放了也会产生问题。上述程序中，指针p和pt指向的是同一块内存，却被先后释放两次。
l 释放后仍然读写
本质上说，系统会在堆上维护一个动态内存链表，如果被释放，就意味着该块内存可以继续被分配给其他部分，如果内存被释放后再访问，就可能覆盖其他部分的信息，这是一种严重的错误，上述程序第16行中就在释放后仍然写这块内存。
下面的一段程序，就包括了内存动态管理中常见的错误。
int main(int argc,char *argv[])
{ char *p=(char*)malloc(10);
char *pt=p;
for(i=0;i&10;i++)
{p[i]=’z’;}
p[1]=’a’;
Valgrind提示如下
==25811== Mismatched free() / delete / delete []
==25811== at 0x4A05130: operator delete(void*)
(vg_replace_malloc.c:244)
==25811== by 0x400654: main (sample4.c:9)
==25811== Address 0x4C2F030 is 0 bytes inside a block of size 10
==25811== at 0x4A05809: malloc (vg_replace_malloc.c:149)
==25811== by 0x400620: main (sample4.c:4)
==25811== Invalid write of size 1
==25811== at 0x40065D: main (sample4.c:10)
==25811== Address 0x4C2F031 is 1 bytes inside a block of size 10
==25811== at 0x4A05130: operator delete(void*)
(vg_replace_malloc.c:244)
==25811== by 0x400654: main (sample4.c:9)
==25811== Invalid free() / delete / delete[]
==25811== at 0x4A0541E: free (vg_replace_malloc.c:233)
==25811== by 0x400668: main (sample4.c:11)
==25811== Address 0x4C2F030 is 0 bytes inside a block of size 10
==25811== at 0x4A05130: operator delete(void*)
(vg_replace_malloc.c:244)
==25811== by 0x400654: main (sample4.c:9)
==25811== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 5
==25811== malloc/free: in use at exit: 0 bytes in 0 blocks.
==25811== malloc/free: 1 allocs, 2 frees, 10 bytes allocated.
==25811== For counts of detected errors, rerun with: -v
==25811== All heap blocks were freed -- no leaks are possible.
例5．内存泄漏
int main()
char *x = (char*)malloc(20);
char *y = (char*)malloc(20);
Valgrind提示如下
==19013== Invalid free() / delete / delete[]
==19013== at 0x4A0541E: free (vg_replace_malloc.c:233)
==19013== by 0x4004F5: main (sample5.c:8)
==19013== Address 0x4C2E078 is 0 bytes inside a block of size 20
==19013== at 0x4A0541E: free (vg_replace_malloc.c:233)
==19013== by 0x4004EC: main (sample5.c:7)
==19013== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 5
==19013== malloc/free: in use at exit: 20 bytes in 1 blocks.
==19013== malloc/free: 2 allocs, 2 frees, 40 bytes allocated.
==19013== For counts of detected errors, rerun with: -v
==19013== searching for pointers to 1 not-freed blocks.
==19013== checked 66,584 bytes.
==19013== LEAK SUMMARY:
==19013== definitely lost: 20 bytes in 1 blocks.
==19013== possibly lost: 0 bytes in 0 blocks.
==19013== still reachable: 0 bytes in 0 blocks.
==19013== suppressed: 0 bytes in 0 blocks.
==19013== Use --leak-check=full to see details of leaked
例6．非法写/读
int main()
int i, *x;
x = (int *)malloc(10*sizeof(int));
for (i=0; i&11; i++)
Valgrind提示如下
==21483== Invalid write of size 4
==21483== at 0x4004EA: main (sample6.c:6)
==21483== Address 0x4C2E058 is 0 bytes after a block of size 40
==21483== at 0x4A05809: malloc (vg_replace_malloc.c:149)
==21483== by 0x4004C9: main (sample6.c:4)
==21483== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 5
==21483== malloc/free: in use at exit: 0 bytes in 0 blocks.
==21483== malloc/free: 1 allocs, 1 frees, 40 bytes allocated.
==21483== For counts of detected errors, rerun with: -v
==21483== All heap blocks were freed -- no leaks are possible.
例7．无效指针
int main()
char *x = malloc(10);
x[10] = 'a';
Valgrind提示如下
==15262== Invalid write of size 1
==15262== at 0x4004D6: main (sample7.c:5)
==15262== Address 0x4C2E03A is 0 bytes after a block of size 10
==15262== at 0x4A05809: malloc (vg_replace_malloc.c:149)
==15262== by 0x4004C9: main (sample7.c:4)
==15262== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 5
==15262== malloc/free: in use at exit: 0 bytes in 0 blocks.
==15262== malloc/free: 1 allocs, 1 frees, 10 bytes allocated.
==15262== For counts of detected errors, rerun with: -v
==15262== All heap blocks were freed -- no leaks are possible.
例8．重复释放
int main()
char *x = malloc(10);
Valgrind提示如下
==15005== Invalid free() / delete / delete[]
==15005== at 0x4A0541E: free (vg_replace_malloc.c:233)
==15005== by 0x4004DF: main (sample8.c:6)
==15005== Address 0x4C2E030 is 0 bytes inside a block of size 10
==15005== at 0x4A0541E: free (vg_replace_malloc.c:233)
==15005== by 0x4004D6: main (sample8.c:5)
==15005== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 5
==15005== malloc/free: in use at exit: 0 bytes in 0 blocks.
==15005== malloc/free: 1 allocs, 2 frees, 10 bytes allocated.
==15005== For counts of detected errors, rerun with: -v
==15005== All heap blocks were freed -- no leaks are possible.
Valgrind的局限
l Valgrind不对静态数组(分配在栈上)进行边界检查。如果在程序中声明了一个数组:
int main()
char x[10];
x[11] = 'a';
Valgrind则不会警告你，你可以把数组改为动态在堆上分配的数组，这样就可能进行边界检查了。这个方法好像有点得不偿失的感觉。
Valgrind占用了更多的内存--可达两倍于你程序的正常使用量。如果你用Valgrind来检测使用大量内存的程序就会遇到问题，它可能会用很长的
时间来运行测试。大多数情况下，这都不是问题，即使速度慢也仅是检测时速度慢，如果你用Valgrind来检测一个正常运行时速度就很慢的程序，这下问题
Valgrind不可能检测出你在程序中犯下的所有错误--如果你不检查缓冲区溢出，Valgrind也不会告诉你代码写了它不应该写的内存。
附录A：参数指令
基本选项：
这些选项对所有工具都有效。
显示所有选项的帮助，包括内核和选定的工具两者。
--help-debug
和--help相同，并且还能显示通常只有Valgrind的开发人员使用的调试选项。
显示Valgrind内核的版本号。工具可以有他们自已的版本号。这是一种保证工具只在它们可以运行的内核上工作的一种设置。这样可以减少在工具和内核之间版本兼容性导致奇怪问题的概率。
-q --quiet
安静的运行，只打印错误信息。在进行回归测试或者有其它的自动化测试机制时会非常有用。
-v --verbose
显示详细信息。在各个方面显示你的程序的额外信息，例如：共享对象加载，使用的重置，执行引擎和工具的进程，异常行为的警告信息。重复这个标记可以增加详细的级别。
调试Valgrind自身发出的信息。通常只有Valgrind开发人员对此感兴趣。重复这个标记可以产生更详细的输出。如果你希望发送一个bug报告，通过-v
-v -d -d生成的输出会使你的报告更加有效。
--tool= [default:
运行toolname指定的Valgrind，例如，Memcheck, Addrcheck, Cachegrind,等等。
--trace-children= [default:
当这个选项打开时，Valgrind会跟踪到子进程中。这经常会导致困惑，而且通常不是你所期望的，所以默认这个选项是关闭的。
--track-fds= [default:
当这个选项打开时，Valgrind会在退出时打印一个打开文件描述符的列表。每个文件描述符都会打印出一个文件是在哪里打开的栈回溯，和任何与此文件描述符相关的详细信息比如文件名或socket信息。
--time-stamp= [default:
当这个选项打开时，每条信息之前都有一个从程序开始消逝的时间，用天，小时，分钟，秒和毫秒表示。
--log-fd= [default: 2,
指定Valgrind把它所有的消息都输出到一个指定的文件描述符中去。默认值2,
是标准错误输出(stderr)。注意这可能会干扰到客户端自身对stderr的使用,
Valgrind的输出与客户程序的输出将穿插在一起输出到stderr。
--log-file=
指定Valgrind把它所有的信息输出到指定的文件中。实际上，被创建文件的文件名是由filename、'.'和进程号连接起来的（即.），从而每个进程创建不同的文件。
--log-file-exactly=
类似于--log-file，但是后缀".pid"不会被添加。如果设置了这个选项，使用Valgrind跟踪多个进程，可能会得到一个乱七八糟的文件。
--log-file-qualifier=
当和--log-file一起使用时，日志文件名将通过环境变量$VAR来筛选。这对于MPI程序是有益的。更多的细节，查看手册2.3节
--log-socket=
指 定Valgrind输出所有的消息到指定的IP，指定的端口。当使用1500端口时，端口有可能被忽略。如果不能建立一个到指定端口的连
接，Valgrind将输出写到标准错误(stderr)。这个选项经常和一个Valgrind监听程序一起使用。更多的细节，查看手册2.3节
错误相关选项：
这些选项适用于所有产生错误的工具，比如Memcheck, 但是Cachegrind不行。
--xml= [default: no]
当这个选项打开时，输出将是XML格式。这是为了使用Valgrind的输出做为输入的工具，例如GUI前端更加容易些。目前这个选项只在Memcheck时生效。
--xml-user-comment=
在XML开头 附加用户注释，仅在指定了--xml=yes时生效，否则忽略。
--demangle= [default:
开/关闭C++的名字自动解码。默认打开。当打开时，Valgrind将尝试着把编码过的C++名字自动转回初始状态。这个解码器可以处理g++版本为
2.X,3.X或4.X生成的符号。一个关于名字编码解码重要的事实是，禁止文件中的解码函数名仍然使用他们未解码的形式。Valgrind在搜寻可用的
禁止条目时不对函数名解码，因为这将使禁止文件内容依赖于Valgrind的名字解码机制状态，会使速度变慢，且无意义。
--num-callers= [default:
认情况下，Valgrind显示12层函数调用的函数名有助于确定程序的位置。可以通过这个选项来改变这个数字。这样有助在嵌套调用的层次很深时确定程序
的位置。注意错误信息通常只回溯到最顶上的4个函数。(当前函数，和它的3个调用者的位置)。所以这并不影响报告的错误总数。这个值的最大值是50。注意
高的设置会使Valgrind运行得慢，并且使用更多的内存,但是在嵌套调用层次比较高的程序中非常实用。
--error-limit= [default:
当这个选项打开时，在总量达到10,000,000，或者1,000个不同的错误，Valgrind停止报告错误。这是为了避免错误跟踪机制在错误很多的程序下变成一个巨大的性能负担。
--error-exitcode= [default:
定如果Valgrind在运行过程中报告任何错误时的退出返回值，有两种情况；当设置为默认值(零)时，Valgrind返回的值将是它模拟运行的程序的
返回值。当设置为非零值时，如果Valgrind发现任何错误时则返回这个值。在Valgrind做为一个测试工具套件的部分使用时这将非常有用，因为使
测试工具套件只检查Valgrind返回值就可以知道哪些测试用例Valgrind报告了错误。
--show-below-main= [default:
默认地，错误时的栈回溯不显示main()之下的任何函数(或者类似的函数像glibc的__libc_start_main()，如果main()没有出现在栈回溯中)；这些大部分都是令人厌倦的C库函数。如果打开这个选项，在main()之下的函数也将会显示。
--suppressions= [default:
$PREFIX/lib/valgrind/default.supp]
指定一个额外的文件读取不需要理会的错误；你可以根据需要使用任意多的额外文件。
--gen-suppressions= [default:
当 设置为yes时，Valgrind将会在每个错误显示之后自动暂停并且打印下面这一行：---- Print suppression ?
--- [Return/N/n/Y/y/C/c]
----这个提示的行为和--db-attach选项(见下面)相同。如果选择是，Valgrind会打印出一个错误的禁止条目，你可以把它剪切然后粘帖
到一个文件，如果不希望在将来再看到这个错误信息。当设置为all时，Valgrind会对每一个错误打印一条禁止条目，而不向用户询问。这个选项对
C++程序非常有用，它打印出编译器调整过的名字。注意打印出来的禁止条目是尽可能的特定的。如果需要把类似的条目归纳起来，比如在函数名中添加通配符。
并且，有些时候两个不同的错误也会产生同样的禁止条目，这时Valgrind就会输出禁止条目不止一次，但是在禁止条目的文件中只需要一份拷贝(但是如果
多于一份也不会引起什么问题)。并且，禁止条目的名字像&在这儿输入一个禁止条目的名字&;名字并不是很重要，它只是和-v选项一起使用打印
出所有使用的禁止条目记录。
--db-attach= [default:
当 这个选项打开时，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= [default: gdb
-nw %f %p]
通过--db-attach指定如何使用调试器。默认的调试器是gdb.默认的选项是一个运行时扩展Valgrind的模板。
%f会用可执行文件的文件名替换，%p会被可执行文件的进程ID替换。
这指定了Valgrind将怎样调用调试器。默认选项不会因为在构造时是否检测到了GDB而改变,通常是/usr/bin/gdb.使用这个命令，你可以指定一些调用其它的调试器来替换。
给出的这个命令字串可以包括一个或多个%p
%f扩展。每一个%p实例都被解释成将调试的进程的PID，每一个%f实例都被解释成要调试的进程的可执行文件路径。
--input-fd= [default: 0,
使用--db-attach=yes和--gen-suppressions=yes选项，在发现错误时，Valgrind会停下来去读取键盘输入。默认地，从标准输入读取，所以关闭了标准输入的程序会有问题。这个选项允许你指定一个文件描述符来替代标准输入读取。
--max-stackframe= [default:
的最大值。如果栈指针的偏移超过这个数量，Valgrind则会认为程序是切换到了另外一个栈执行。如果在程序中有大量的栈分配的数组，你可能需要使用这
个选项。valgrind保持对程序栈指针的追踪。如果栈指针的偏移超过了这个数量，Valgrind假定你的程序切换到了另外一个栈，并且
Memcheck行为与栈指
的偏移没有超出这个数量将会不同。通常这种机制运转得很好。然而，如果你的程序在栈上申请了大的结构，这种机制将会表现得愚蠢，并且Memcheck将会
报告大量的非法栈内存访问。这个选项允许把这个阀值设置为其它值。应该只在Valgrind的调试输出中显示需要这么做时才使用这个选项。在这种情况下，
它会告诉你应该指定的新的阀值。普遍地，在栈中分配大块的内存是一个坏的主意。因为这很容易用光你的栈空间，尤其是在内存受限的系统或者支持大量小堆栈的
线程的系统上，因为Memcheck执行的错误检查，对于堆上的数据比对栈上的数据要高效很多。如果你使用这个选项，你可能希望考虑重写代码在堆上分配内
存而不是在栈上分配。
MALLOC()相关的选项:
对于使用自有版本的malloc() (例如Memcheck和massif)，下面的选项可以使用。
--alignment= [default:
默认Valgrind的malloc(),realloc(),
等等，是8字节对齐地址的。这是大部分处理器的标准。然而，一些程序可能假定malloc()等总是返回16字节或更多对齐的内存。提供的数值必须在8和4096区间之内，并且必须是2的幂数。
非通用选项：
这些选项可以用于所有的工具，它们影响Valgrind core的几个特性。大部分人不会用到这些选项。
--run-libc-freeres= [default:
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，轻微的修改模拟行为的非标准或危险方式，可能有助于模拟奇怪的特性。默认没有提示打开。小心使用！目前已知的提示有：
l lax-ioctls:
对ioctl的处理非常不严格，唯一的假定是大小是正确的。不需要在写时缓冲区完全的初始化。没有这个，用大量的奇怪的ioctl命令来使用一些设备驱动将会非常烦人。
l enable-inner:打开某些特殊的效果，当运行的程序是Valgrind自身时。
--kernel-variant=variant1,variant2,...
处理系统调用和ioctls在这个平台的默认核心上产生不同的变量。这有助于运行在改进过的内核或者支持非标准的ioctls上。小心使用。如果你不理解这个选项做的是什么那你几乎不需要它。已经知道的变量有：
支持X86平台上的sys_broc系统调用。这是为了运行在BProc，它是标准Linux的一个变种，有时用来构建集群。
--show-emwarns= [default:
当这个选项打开时，Valgrind在一些特定的情况下将对CPU仿真产生警告。通常这些都是不引人注意的。
--smc-check= [default:
个选项控制Valgrind对自我修改的代码的检测。Valgrind可以不做检测，可以检测栈中自我修改的代码，或者任意地方检测自我修改的代码。注意
默认选项是捕捉绝大多数情况，到目前我们了解的情况为止。使用all选项时会极大的降低速度。(但是用none选项运行极少影响速度，因为对大多数程序，
非常少的代码被添加到栈中)
调试VALGRIND选项：
还有一些选项是用来调试Valgrind自身的。在运行一般的东西时不应该需要的。如果你希望看到选项列表，使用--help-debug选项。
内存检查选项：
--leak-check= [default:
这个选项打开时，当客户程序结束时查找内存泄漏。内存泄漏意味着有用malloc分配内存块，但是没有用free释放，而且没有指针指向这块内存。这样的
内存块永远不能被程序释放，因为没有指针指向它们。如果设置为summary，Valgrind会报告有多少内存泄漏发生了。如果设置为full或
yes，Valgrind给出每一个独立的泄漏的详细信息。
--show-reachable= [default:
这个选项关闭时，内存泄漏检测器只显示没有指针指向的内存块，或者只能找到指向块中间的指针。当这个选项打开时，内存泄漏检测器还报告有指针指向的内存
块。这些块是最有可能出现内存泄漏的地方。你的程序可能，至少在原则上，应该在退出前释放这些内存块。这些有指针指向的内存块和没有指针指向的内存块，或
者只有内部指针指向的块，都可能产生内存泄漏，因为实际上没有一个指向块起始的指针可以拿来释放，即使你想去释放它。
--leak-resolution= [default:
做内存泄漏检查时，确定memcheck将怎么样考虑不同的栈是相同的情况。当设置为low时，只需要前两层栈匹配就认为是相同的情况；当设置为med，
必须要四层栈匹配，当设置为high时，所有层次的栈都必须匹配。对于hardcore内存泄漏检查，你很可能需要使用--leak-
resolution=high和--num-callers=40或者更大的数字。注意这将产生巨量的信息，这就是为什么默认选项是四个调用者匹配和低
分辨率的匹配。注意--leak-resolution=
设置并不影响memcheck查找内存泄漏的能力。它只是改变了结果如何输出。
--freelist-vol= [default:
客户程序使用free(C中)或者delete(C++)释放内存时，这些内存并不是马上就可以用来再分配的。这些内存将被标记为不可访问的，并被放到一
个已释放内存的队列中。这样做的目的是，使释放的内存再次被利用的点尽可能的晚。这有利于memcheck在内存块释放后这段重要的时间检查对块不合法的
访问。这个选项指定了队列所能容纳的内存总容量，以字节为单位。默认的值是5000000字节。增大这个数目会增加memcheck使用的内存，但同时也
增加了对已释放内存的非法使用的检测概率。
--workaround-gcc296-bugs=
[default: no]
当 这个选项打开时，假定读写栈指针以下的一小段距离是gcc 2.96的bug，并且不报告为错误。距离默认为256字节。注意gcc
2.96是一些比较老的Linux发行版(RedHat
7.X)的默认编译器，所以你可能需要使用这个选项。如果不是必要请不要使用这个选项，它可能会使一些真正的错误溜掉。一个更好的解决办法是使用较新的，
修正了这个bug的gcc/g++版本。
--partial-loads-ok= [default:
制memcheck如何处理从地址读取时字长度，字对齐，因此哪些字节是可以寻址的，哪些是不可以寻址的。当设置为yes是，这样的读取并不抛出一个寻址
错误。而是从非法地址读取的V字节显示为未定义，访问合法地址仍然是像平常一样映射到内存。设置为no时，从部分错误的地址读取与从完全错误的地址读取同
样处理：抛出一个非法地址错误，结果的V字节显示为合法数据。注意这种代码行为是违背ISO
C/C++标准，应该被认为是有问题的。如果可能，这种代码应该修正。这个选项应该只是做为一个最后考虑的方法。
--undef-value-errors=
[default: yes]
控制memcheck是否检查未定义值的危险使用。当设为yes时，Memcheck的行为像Addrcheck,
一个轻量级的内存检查工具，是Valgrind的一个部分，它并不检查未定义值的错误。使用这个选项，如果你不希望看到未定义值错误。
CACHEGRIND选项：
手 动指定I1/D1/L2缓冲配置，大小是用字节表示的。这三个必须用逗号隔开，中间没有空格，例如： valgrind
--tool=cachegrind
--I1=你可以指定一个，两个或三个I1/D1/L2缓冲。如果没有手动指定，每个级别使用普通方式(通过CPUID指令得到缓冲
配置，如果失败，使用默认值)得到的配置。
指定第一级指令缓冲的大小，关联度和行大小。
指定第一级数据缓冲的大小，关联度和行大小。
指定第二级缓冲的大小，关联度和行大小。
CALLGRIND选项：
--heap= [default:
当这个选项打开时，详细的追踪堆的使用情况。关闭这个选项时，massif.pid.txt或massif.pid.html将会非常的简短。
--heap-admin= [default:
每个块使用的管理字节数。这只能使用一个平均的估计值，因为它可能变化。glibc使用的分配器每块需要4~15字节，依赖于各方面的因素。管理已经释放的块也需要空间，尽管massif不计算这些。
--stacks= [default:
当打开时，在剖析信息中包含栈信息。多线程的程序可能有多个栈。
--depth= [default: 3]
详细的堆信息中调用过程的深度。增加这个值可以给出更多的信息，但是massif会更使这个程序运行得慢，使用更多的内存，并且产生一个大的massif.pid.txt或者massif.pid.hp文件。
--alloc-fn=
定一个分配内存的函数。这对于使用malloc()的包装函数是有用的，可以用它来填充原来无效的上下文信息。(这些函数会给出无用的上下文信息，并在图
中给出无意义的区域)。指定的函数在上下文中被忽略，例如，像对malloc()一样处理。这个选项可以在命令行中重复多次，指定多个函数。
--format= [default:
产生text或者HTML格式的详细堆信息，文件的后缀名使用.txt或者.html。
HELGRIND选项：
--private-stacks= [default:
假定线程栈是私有的。
--show-last-access= [default:
显示最后一次字访问出错的位置。
LACKEY选项：
--fnname= [default:
_dl_runtime_resolve()]
对函数计数。
--detailed-counts= [default:
对读取，存储和alu操作计数。
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。