#include <iostream>
int main() {
int x; // 未初始化
if (x == 0) {
std::cout << "X is zero" << std::endl;
return 0;
$ g++ -std=c++11 -g -O0 -Wall main.cpp -o main
使用 Valgrind 检测内存使用情况:
$ valgrind --tool=memcheck --leak-check=full ./main
输出信息:
==8360== Memcheck, a memory error detector
==8360== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==8360== Command: ./main
==8360==
==8360== Conditional jump or move depends on uninitialised value(s)
==8360== at 0x40117E: main (main.cpp:4)
==8360==
X is zero
==8360==
==8360== HEAP SUMMARY:
==8360== in use at exit: 0 bytes in 0 blocks
==8360== total heap usage: 2 allocs, 2 frees, 73,728 bytes allocated
==8360==
==8360== All heap blocks were freed -- no leaks are possible
==8360==
==8360== For counts of detected and suppressed errors, rerun with: -v
==8360== Use --track-origins=yes to see where uninitialised values come from
==8360== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
使用--track-origins=yes
选项查看具体未初始化变量的位置
$ valgrind --tool=memcheck --leak-check=full --track-origins=yes ./main
==8498== Conditional jump or move depends on uninitialised value(s)
==8498== at 0x40117E: main (main.cpp:4)
==8498== Uninitialised value was created by a stack allocation
==8498== at 0x401172: main (main.cpp:2)
输出结果会显示:Conditional jump or move depends on uninitialized value(s)
即程序的跳转依赖于一个未初始化的变量。
内存读写越界(非法读写)
当访问了不该访问或者没有权限访问的内存地址空间,对动态内存访问时超出了申请的内存大小范围。
输出结果会显示: Invalid write of size 4; Invalid read of size 4
注意:valgrind无法发现静态数组越界的问题。
动态数组访问越界
#include <iostream>
int main() {
// int a[10]; 静态数组越界valgrind无法检查出来
int *iptr = new int[10]; //动态内存
std::cout << iptr[10] << std::endl; // 动态数组访问越界
delete[] iptr;
return 0;
编译程序时,需要加上加上-g
,O0
,Wall
选项:
$ g++ -std=c++11 -g -O0 -Wall main.cpp -o main
使用 Valgrind 分析这段程序,Valgrind 会提示越界访问:
$ valgrind --tool=memcheck --leak-check=full ./main
$ valgrind --tool=memcheck --leak-check=full ./main
==7233== Memcheck, a memory error detector
==7233== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==7233== Command: ./main
==7233==
==7233== Invalid read of size 4
==7233== at 0x4011B0: main (main.cpp:5)
==7233== Address 0x4d8dca8 is 0 bytes after a block of size 40 alloc'd
==7233== at 0x483650F: operator new[](unsigned long) (vg_replace_malloc.c:423)
==7233== by 0x4011A3: main (main.cpp:4)
==7233==
==7233==
==7233== HEAP SUMMARY:
==7233== in use at exit: 0 bytes in 0 blocks
==7233== total heap usage: 3 allocs, 3 frees, 73,768 bytes allocated
==7233==
==7233== All heap blocks were freed -- no leaks are possible
==7233==
==7233== For counts of detected and suppressed errors, rerun with: -v
==7233== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
vector访问越界
#include <iostream>
#include <vector>
int main() {
std::vector<int> v(10, 0); //动态内存
std::cout << v[10] << std::endl;
//静态数组越界无法检查出来
return 0;
编译程序时,需要加上加上-g
,O0
,Wall
选项:
$ g++ -std=c++11 -g -O0 -Wall main.cpp -o main
使用 Valgrind 分析这段程序,Valgrind 会提示越界访问:
$ valgrind --tool=memcheck --leak-check=full ./main
$ valgrind --tool=memcheck --leak-check=full ./main
==5797== Memcheck, a memory error detector
==5797== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==5797== Command: ./main
==5797==
==5797== Invalid read of size 4
==5797== at 0x401214: main (main.cpp:5)
==5797== Address 0x4d8dca8 is 0 bytes after a block of size 40 alloc'd
==5797== at 0x4835DEF: operator new(unsigned long) (vg_replace_malloc.c:334)
==5797== by 0x4017F9: __gnu_cxx::new_allocator<int>::allocate(unsigned long, void const*) (new_allocator.h:111)
==5797== by 0x401766: std::allocator_traits<std::allocator<int> >::allocate(std::allocator<int>&, unsigned long) (alloc_traits.h:436)
==5797== by 0x4016B7: std::_Vector_base<int, std::allocator<int> >::_M_allocate(unsigned long) (stl_vector.h:296)
==5797== by 0x4015A4: std::_Vector_base<int, std::allocator<int> >::_M_create_storage(unsigned long) (stl_vector.h:311)
==5797== by 0x401446: std::_Vector_base<int, std::allocator<int> >::_Vector_base(unsigned long, std::allocator<int> const&) (stl_vector.h:260)
==5797== by 0x401339: std::vector<int, std::allocator<int> >::vector(unsigned long, int const&, std::allocator<int> const&) (stl_vector.h:429)
==5797== by 0x4011F6: main (main.cpp:4)
==5797==
==5797==
==5797== HEAP SUMMARY:
==5797== in use at exit: 0 bytes in 0 blocks
==5797== total heap usage: 3 allocs, 3 frees, 73,768 bytes allocated
==5797==
==5797== All heap blocks were freed -- no leaks are possible
==5797==
==5797== For counts of detected and suppressed errors, rerun with: -v
==5797== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
Invalid read of size 4
表示越界读取 4 个字节,这个操作出现在main.cpp
文件的第 5 行。另外可以看到,vector
分配了一块 40 字节的内存,程序越界访问紧接着这块内存之后的 4 个字节。
valgrind无法发现静态数组越界
Valgrind不对静态数组(分配在栈上)进行边界检查。无法发现静态数组越界的问题。
如果在程序中声明了一个静态数组,存在访问越界问题,程序不会挂掉,valgrind无法检查出来:
#include <iostream>
int main() {
int a[10];
a[22] = 22; // 静态数组越界,程序不会挂掉,valgrind无法检查出来
std::cout << a[22] << std::endl; // 静态数组越界
return 0;
valgrind没有发现静态数组越界的问题:
$ valgrind --tool=memcheck --leak-check=full ./main==22741== Memcheck, a memory error detector
==22741== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==22741== Command: ./main
==22741==
==22741==
==22741== HEAP SUMMARY:
==22741== in use at exit: 0 bytes in 0 blocks
==22741== total heap usage: 2 allocs, 2 frees, 73,728 bytes allocated
==22741==
==22741== All heap blocks were freed -- no leaks are possible
==22741==
==22741== For counts of detected and suppressed errors, rerun with: -v
==22741== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Valgrind则不会警告你静态数组(分配在栈上)越界。你可以把数组改为动态在堆上分配的数组,这样就可能进行边界检查了。这个方法好像有点得不偿失的感觉。
内存泄漏(未释放内存)
常见的内存分配方式分三种:静态存储,栈上分配,堆上分配。全局变量属于静态存储,它们是在编译时就被分配了存储空间,函数内的局部变量属于栈上分配,而最灵活的内存使用方式当属堆上分配,也叫做内存动态分配了。常用的内存动态分配函数包括:malloc, alloc, realloc, new等,动态释放函数包括free, delete。
在程序中动态申请的内存在使用完后既没有释放也也法被程序的其他部分访问。
显示输出结果如下:12 bytes in 1 blocks are definitely lost in loss record 1 of 1
动态数组内存泄漏
Valgrind 可以用来检测程序在哪个位置发生内存泄漏
#include <vector>
int main() {
int *iptr = new int[3]; //未释放
// auto vptr = new std::vector<int>(3); //未释放
return 0;
编译程序时,需要加上加上-g
,O0
,Wall
选项:
$ g++ -std=c++11 -g -O0 -Wall main.cpp -o main
使用 Valgrind 检测内存使用情况:
$ valgrind --tool=memcheck --leak-check=full ./main
$ valgrind --tool=memcheck --leak-check=full ./main
==11483== Memcheck, a memory error detector
==11483== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==11483== Command: ./main
==11483==
==11483==
==11483== HEAP SUMMARY:
==11483== in use at exit: 12 bytes in 1 blocks
==11483== total heap usage: 2 allocs, 1 frees, 72,716 bytes allocated
==11483==
==11483== 12 bytes in 1 blocks are definitely lost in loss record 1 of 1
==11483== at 0x483650F: operator new[](unsigned long) (vg_replace_malloc.c:423)
==11483== by 0x401133: main (main.cpp:3)
==11483==
==11483== LEAK SUMMARY:
==11483== definitely lost: 12 bytes in 1 blocks
==11483== indirectly lost: 0 bytes in 0 blocks
==11483== possibly lost: 0 bytes in 0 blocks
==11483== still reachable: 0 bytes in 0 blocks
==11483== suppressed: 0 bytes in 0 blocks
==11483==
==11483== For counts of detected and suppressed errors, rerun with: -v
==11483== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
HEAP SUMMARY
,它表示程序在堆上内存分配的情况,其中的2 allocs
表示程序分配了 2 次内存,1 frees
表示程序释放了 1 次内存,12 bytes allocated
表示分配了 12 个字节的内存。
另外,Valgrind 也会报告程序是在哪个位置发生内存泄漏。by 0x401133: main (main.c:3)
从上面的信息可以看到,程序发生了一次内存泄漏,位置是main.c
文件的第 3 行。
LEAK SUMMARY
,它表示程序内存泄露的情况。definitely lost: 12 bytes in 1 blocks
程序一定存在内存泄露。
vector会分配额外空间
new vector<int>(3)
相比数组new int[3]
占用的空间更大,来处理理vector。
#include <vector>
int main() {
// int *iptr = new int[3]; //未释放
auto vptr = new std::vector<int>(3); //未释放
return 0;
$ valgrind --tool=memcheck --leak-check=full ./main
==11754== Memcheck, a memory error detector
==11754== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==11754== Command: ./main
==11754==
==11754==
==11754== HEAP SUMMARY:
==11754== in use at exit: 36 bytes in 2 blocks
==11754== total heap usage: 3 allocs, 1 frees, 72,740 bytes allocated
==11754==
==11754== 36 (24 direct, 12 indirect) bytes in 1 blocks are definitely lost in loss record 2 of 2
==11754== at 0x4835DEF: operator new(unsigned long) (vg_replace_malloc.c:334)
==11754== by 0x401186: main (main.cpp:4)
==11754==
==11754== LEAK SUMMARY:
==11754== definitely lost: 24 bytes in 1 blocks
==11754== indirectly lost: 12 bytes in 1 blocks
==11754== possibly lost: 0 bytes in 0 blocks
==11754== still reachable: 0 bytes in 0 blocks
==11754== suppressed: 0 bytes in 0 blocks
==11754==
==11754== For counts of detected and suppressed errors, rerun with: -v
==11754== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
new vector<*int*>(3)
占36字节
==11754== HEAP SUMMARY:
==11754== in use at exit: 36 bytes in 2 blocks
==11754== total heap usage: 3 allocs, 1 frees, 72,740 bytes allocated
==11754==
==11754== 36 (24 direct, 12 indirect) bytes in 1 blocks are definitely lost in loss record 2 of 2
==11754== at 0x4835DEF: operator new(unsigned long) (vg_replace_malloc.c:334)
new int[3]
占12字节
==11483== HEAP SUMMARY:
==11483== in use at exit: 12 bytes in 1 blocks
==11483== total heap usage: 2 allocs, 1 frees, 72,716 bytes allocated
==11483==
==11483== 12 bytes in 1 blocks are definitely lost in loss record 1 of 1
==11483== at 0x483650F: operator new[](unsigned long) (vg_replace_malloc.c:423)
重复释放内存
申请了多少内存,在使用完成后就要释放多少。如果没有释放,或者少释放了就是内存泄露;多释放了也会产生问题。当申请与释放大小不一致时,即申请了多少内存却没有释放完或者多释放了,
显示输出结果如下:Invalid free() /delete/delete[]
上述程序中,指针sm_ptr和ptr指向的是同一块内存,却被先后释放两次。
#include <iostream>
int main() {
int *ptr = new int; //动态内存
delete ptr;
int *sm_ptr = ptr;
delete sm_ptr; //sm_ptr和ptr指向的是同一块内存,重复释放
return 0;
编译程序时,需要加上加上-g
,O0
,Wall
选项:
$ g++ -std=c++11 -g -O0 -Wall main.cpp -o main
使用 Valgrind 分析这段程序:
$ valgrind --tool=memcheck --leak-check=full ./main
==8895== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==8895== Command: ./main
==8895==
==8895== Invalid free() / delete / delete[] / realloc()
==8895== at 0x4836EAB: operator delete(void*) (vg_replace_malloc.c:576)
==8895== by 0x401197: main (main.cpp:6)
==8895== Address 0x4d8dc80 is 0 bytes inside a block of size 4 free'd
==8895== at 0x4836EAB: operator delete(void*) (vg_replace_malloc.c:576)
==8895== by 0x401183: main (main.cpp:4)
==8895== Block was alloc'd at
==8895== at 0x4835DEF: operator new(unsigned long) (vg_replace_malloc.c:334)
==8895== by 0x401173: main (main.cpp:3)
==8895==
==8895==
==8895== HEAP SUMMARY:
==8895== in use at exit: 0 bytes in 0 blocks
==8895== total heap usage: 2 allocs, 3 frees, 72,708 bytes allocated
==8895==
==8895== All heap blocks were freed -- no leaks are possible
==8895==
==8895== For counts of detected and suppressed errors, rerun with: -v
==8895== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
对释放的内存读/写
本质上说,系统会在堆上维护一个动态内存链表,如果被释放,就意味着该块内存可以继续被分配给其他部分,如果内存被释放后再访问,就可能覆盖其他部分的信息,这是一种严重的错误。
错误显示输出结果如下:Invalid write of size 4
#include <iostream>
int main() {
int *iptr = new int; //动态内存
delete iptr;
*iptr = 9; // 释放后仍然读写
return 0;
编译程序时,需要加上加上-g
,O0
,Wall
选项:
$ g++ -std=c++11 -g -O0 -Wall main.cpp -o main
使用 Valgrind 分析这段程序:
$ valgrind --tool=memcheck --leak-check=full ./main
$ valgrind --tool=memcheck --leak-check=full ./main
==8246== Memcheck, a memory error detector
==8246== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==8246== Command: ./main
==8246==
==8246== Invalid write of size 4
==8246== at 0x401188: main (main.cpp:5)
==8246== Address 0x4d8dc80 is 0 bytes inside a block of size 4 free'd
==8246== at 0x4836EAB: operator delete(void*) (vg_replace_malloc.c:576)
==8246== by 0x401183: main (main.cpp:4)
==8246== Block was alloc'd at
==8246== at 0x4835DEF: operator new(unsigned long) (vg_replace_malloc.c:334)
==8246== by 0x401173: main (main.cpp:3)
==8246==
==8246==
==8246== HEAP SUMMARY:
==8246== in use at exit: 0 bytes in 0 blocks
==8246== total heap usage: 2 allocs, 2 frees, 72,708 bytes allocated
==8246==
==8246== All heap blocks were freed -- no leaks are possible
==8246==
==8246== For counts of detected and suppressed errors, rerun with: -v
==8246== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
new和delete不匹配
由于 C++ 兼容 C,而 C 与 C++ 的内存申请和释放函数是不同的,因此在 C++ 程序中,就有两套动态内存管理函数。一条不变的规则就是采用 C 方式申请的内存就用 C 方式释放;用 C++ 方式申请的内存,用 C++ 方式释放。也就是用 malloc/alloc/realloc 方式申请的内存,用 free 释放;用 new 方式申请的内存用 delete 释放。
在上述程序中,用 malloc 方式申请了内存却用 delete 来释放,new申请动态数组,delete无法释放数组,虚delete[]释放动态数组。申请与释放不匹配时,显示输出结果如下:Mismatched free() /delete/delete[]
#include <iostream>
int main() {
int *ptr = (int *)malloc(1 * sizeof(int)); //动态内存
*ptr = -1;
delete ptr; // malloc与delete不匹配
int *arr_ptr = new int[10];
delete arr_ptr; // delete无法释放数组,不匹配
return 0;
编译程序时,需要加上加上-g
,O0
,Wall
选项:
$ g++ -std=c++11 -g -O0 -Wall main.cpp -o main
使用 Valgrind 分析这段程序:
$ valgrind --tool=memcheck --leak-check=full ./main
$ valgrind --tool=memcheck --leak-check=full ./main
==11344== Memcheck, a memory error detector
==11344== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==11344== Command: ./main
==11344==
==11344== Mismatched free() / delete / delete []
==11344== at 0x4836EAB: operator delete(void*) (vg_replace_malloc.c:576)
==11344== by 0x40119D: main (main.cpp:5)
==11344== Address 0x4d8dc80 is 0 bytes inside a block of size 4 alloc'd
==11344== at 0x483577F: malloc (vg_replace_malloc.c:299)
==11344== by 0x401183: main (main.cpp:3)
==11344==
==11344== Mismatched free() / delete / delete []
==11344== at 0x4836EAB: operator delete(void*) (vg_replace_malloc.c:576)
==11344== by 0x4011B7: main (main.cpp:8)
==11344== Address 0x4d8dcd0 is 0 bytes inside a block of size 40 alloc'd
==11344== at 0x483650F: operator new[](unsigned long) (vg_replace_malloc.c:423)
==11344== by 0x4011A7: main (main.cpp:7)
==11344==
==11344==
==11344== HEAP SUMMARY:
==11344== in use at exit: 0 bytes in 0 blocks
==11344== total heap usage: 3 allocs, 3 frees, 72,748 bytes allocated
==11344==
==11344== All heap blocks were freed -- no leaks are possible
==11344==
==11344== For counts of detected and suppressed errors, rerun with: -v
==11344== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
src和dst内存覆盖
C语言的强大和可怕之处在于其可以直接操作内存,C标准库中提供了大量这样的函数,比如使用C标准库中的strcpy,strncpy,memcpy,strcat时,需要设置源地址(src)和目标地址(dst),src和dst所指向的地址不能发生重叠,否则结果将不可预期。
输出结果会显示:Source and destination overlap in strncpy
(dst地址,src地址,地址相差长度)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[]) {
char str[128];
memset(str, '-1', sizeof(str)); // 字符'\0'在内存中assic码就是数值0
strncpy(str + 20, str, 20); // Good
strncpy(str + 20, str, 21); // Overlap,发生覆盖
memset(str, '-1', sizeof(str));
strncpy(str, str + 20, 20); // Good
strncpy(str, str + 20, 21); // Overlap,发生覆盖
memset(str, '-1', sizeof(str));
str[39] = '\0'; // 29-39(长度20) 复制到-> 0-19(长度20)
strcpy(str, str + 20); // Good
memset(str, '-1', sizeof(str));
str[40] = '\0'; // 29-40(长度21) 复制到-> 0-19(长度20),发生覆盖
strcpy(str, str + 20); // Overlap
return 0;
编译程序时,需要加上加上-g
,O0
,Wall
选项:
$ g++ -std=c++11 -g -O0 -Wall main.cpp -o main
使用 Valgrind 分析这段程序:
$ valgrind --tool=memcheck --leak-check=full ./main
$ valgrind --tool=memcheck --leak-check=full ./main
==21189== Memcheck, a memory error detector
==21189== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==21189== Command: ./main
==21189==
==21189== Source and destination overlap in strncpy(0x1ffeffe829, 0x1ffeffe815, 21)
==21189== at 0x48393E0: __strncpy_sse2_unaligned (vg_replace_strmem.c:554)
==21189== by 0x4011A7: main (main.cpp:8)
==21189==
==21189== Source and destination overlap in strncpy(0x1ffeffe815, 0x1ffeffe829, 21)
==21189== at 0x48393E0: __strncpy_sse2_unaligned (vg_replace_strmem.c:554)
==21189== by 0x4011F5: main (main.cpp:12)
==21189==
==21189== Source and destination overlap in strcpy(0x1ffeffe800, 0x1ffeffe814)
==21189== at 0x4838E68: strcpy (vg_replace_strmem.c:512)
==21189== by 0x401257: main (main.cpp:20)
==21189==
==21189==
==21189== HEAP SUMMARY:
==21189== in use at exit: 0 bytes in 0 blocks
==21189== total heap usage: 1 allocs, 1 frees, 72,704 bytes allocated
==21189==
==21189== All heap blocks were freed -- no leaks are possible
==21189==
==21189== For counts of detected and suppressed errors, rerun with: -v
==21189== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
输出说明程序的8,12,20行,源地址和目标地址设置出现了重叠,Valgrind均准确地发现了问题。
注:参数选项为摘抄,没有验证
基本选项:
这些选项对所有工具都有效。
-h --help
显示所有选项的帮助,包括内核和选定的工具两者。
--help-debug
和--help相同,并且还能显示通常只有Valgrind的开发人员使用的调试选项。
--version
显示Valgrind内核的版本号。工具可以有他们自已的版本号。这是一种保证工具只在它们可以运行的内核上工作的一种设置。这样可以减少在工具和内核之间版本兼容性导致奇怪问题的概率。
-q --quiet
安静的运行,只打印错误信息。在进行回归测试或者有其它的自动化测试机制时会非常有用。
-v --verbose
显示详细信息。在各个方面显示你的程序的额外信息,例如:共享对象加载,使用的重置,执行引擎和工具的进程,异常行为的警告信息。重复这个标记可以增加详细的级别。
调试Valgrind自身发出的信息。通常只有Valgrind开发人员对此感兴趣。重复这个标记可以产生更详细的输出。如果你希望发送一个bug报告,通过-v -v -d -d生成的输出会使你的报告更加有效。
--tool= [default: memcheck]
运行toolname指定的Valgrind,例如,Memcheck, Addrcheck, Cachegrind,等等。
--trace-children= [default: no]
当这个选项打开时,Valgrind会跟踪到子进程中。这经常会导致困惑,而且通常不是你所期望的,所以默认这个选项是关闭的。
--track-fds= [default: no]
当这个选项打开时,Valgrind会在退出时打印一个打开文件描述符的列表。每个文件描述符都会打印出一个文件是在哪里打开的栈回溯,和任何与此文件描述符相关的详细信息比如文件名或socket信息。
--time-stamp= [default: no]
当这个选项打开时,每条信息之前都有一个从程序开始消逝的时间,用天,小时,分钟,秒和毫秒表示。
--log-fd= [default: 2, stderr]
指定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: yes]
打开/关闭C++的名字自动解码。默认打开。当打开时,Valgrind将尝试着把编码过的C++名字自动转回初始状态。这个解码器可以处理g++版本为2.X,3.X或4.X生成的符号。一个关于名字编码解码重要的事实是,禁止文件中的解码函数名仍然使用他们未解码的形式。Valgrind在搜寻可用的禁止条目时不对函数名解码,因为这将使禁止文件内容依赖于Valgrind的名字解码机制状态,会使速度变慢,且无意义。
--num-callers= [default: 12]
默认情况下,Valgrind显示12层函数调用的函数名有助于确定程序的位置。可以通过这个选项来改变这个数字。这样有助在嵌套调用的层次很深时确定程序的位置。注意错误信息通常只回溯到最顶上的4个函数。(当前函数,和它的3个调用者的位置)。所以这并不影响报告的错误总数。这个值的最大值是50。注意高的设置会使Valgrind运行得慢,并且使用更多的内存,但是在嵌套调用层次比较高的程序中非常实用。
--error-limit= [default: yes]
当这个选项打开时,在总量达到10,000,000,或者1,000个不同的错误,Valgrind停止报告错误。这是为了避免错误跟踪机制在错误很多的程序下变成一个巨大的性能负担。
--error-exitcode= [default: 0]
指定如果Valgrind在运行过程中报告任何错误时的退出返回值,有两种情况;当设置为默认值(零)时,Valgrind返回的值将是它模拟运行的程序的返回值。当设置为非零值时,如果Valgrind发现任何错误时则返回这个值。在Valgrind做为一个测试工具套件的部分使用时这将非常有用,因为使测试工具套件只检查Valgrind返回值就可以知道哪些测试用例Valgrind报告了错误。
--show-below-main= [default: no]
默认地,错误时的栈回溯不显示main()之下的任何函数(或者类似的函数像glibc的__libc_start_main(),如果main()没有出现在栈回溯中);这些大部分都是令人厌倦的C库函数。如果打开这个选项,在main()之下的函数也将会显示。
--suppressions= [default: $PREFIX/lib/valgrind/default.supp]
指定一个额外的文件读取不需要理会的错误;你可以根据需要使用任意多的额外文件。
--gen-suppressions= [default: no]
当设置为yes时,Valgrind将会在每个错误显示之后自动暂停并且打印下面这一行:---- Print suppression ? --- [Return/N/n/Y/y/C/c] ----这个提示的行为和--db-attach选项(见下面)相同。如果选择是,Valgrind会打印出一个错误的禁止条目,你可以把它剪切然后粘帖到一个文件,如果不希望在将来再看到这个错误信息。当设置为all时,Valgrind会对每一个错误打印一条禁止条目,而不向用户询问。这个选项对C++程序非常有用,它打印出编译器调整过的名字。注意打印出来的禁止条目是尽可能的特定的。如果需要把类似的条目归纳起来,比如在函数名中添加通配符。并且,有些时候两个不同的错误也会产生同样的禁止条目,这时Valgrind就会输出禁止条目不止一次,但是在禁止条目的文件中只需要一份拷贝(但是如果多于一份也不会引起什么问题)。并且,禁止条目的名字像<在这儿输入一个禁止条目的名字>;名字并不是很重要,它只是和-v选项一起使用打印出所有使用的禁止条目记录。
--db-attach= [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在这种情况下不能启动。
--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, stdin]
使用--db-attach=yes和--gen-suppressions=yes选项,在发现错误时,Valgrind会停下来去读取键盘输入。默认地,从标准输入读取,所以关闭了标准输入的程序会有问题。这个选项允许你指定一个文件描述符来替代标准输入读取。
--max-stackframe= [default: 2000000]
栈的最大值。如果栈指针的偏移超过这个数量,Valgrind则会认为程序是切换到了另外一个栈执行。如果在程序中有大量的栈分配的数组,你可能需要使用这个选项。valgrind保持对程序栈指针的追踪。如果栈指针的偏移超过了这个数量,Valgrind假定你的程序切换到了另外一个栈,并且Memcheck行为与栈指
针的偏移没有超出这个数量将会不同。通常这种机制运转得很好。然而,如果你的程序在栈上申请了大的结构,这种机制将会表现得愚蠢,并且Memcheck将会报告大量的非法栈内存访问。这个选项允许把这个阀值设置为其它值。应该只在Valgrind的调试输出中显示需要这么做时才使用这个选项。在这种情况下,它会告诉你应该指定的新的阀值。普遍地,在栈中分配大块的内存是一个坏的主意。因为这很容易用光你的栈空间,尤其是在内存受限的系统或者支持大量小堆栈的线程的系统上,因为Memcheck执行的错误检查,对于堆上的数据比对栈上的数据要高效很多。如果你使用这个选项,你可能希望考虑重写代码在堆上分配内存而不是在栈上分配。
MALLOC()相关的选项:
对于使用自有版本的malloc() (例如Memcheck和massif),下面的选项可以使用。
--alignment= [default: 8]
默认Valgrind的malloc(),realloc(), 等等,是8字节对齐地址的。这是大部分处理器的标准。然而,一些程序可能假定malloc()等总是返回16字节或更多对齐的内存。提供的数值必须在8和4096区间之内,并且必须是2的幂数。
非通用选项:
这些选项可以用于所有的工具,它们影响Valgrind core的几个特性。大部分人不会用到这些选项。
--run-libc-freeres= [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,轻微的修改模拟行为的非标准或危险方式,可能有助于模拟奇怪的特性。默认没有提示打开。小心使用!目前已知的提示有:
l lax-ioctls: 对ioctl的处理非常不严格,唯一的假定是大小是正确的。不需要在写时缓冲区完全的初始化。没有这个,用大量的奇怪的ioctl命令来使用一些设备驱动将会非常烦人。
l enable-inner:打开某些特殊的效果,当运行的程序是Valgrind自身时。
--kernel-variant=variant1,variant2,...
处理系统调用和ioctls在这个平台的默认核心上产生不同的变量。这有助于运行在改进过的内核或者支持非标准的ioctls上。小心使用。如果你不理解这个选项做的是什么那你几乎不需要它。已经知道的变量有:
l bproc: 支持X86平台上的sys_broc系统调用。这是为了运行在BProc,它是标准Linux的一个变种,有时用来构建集群。
--show-emwarns= [default: no]
当这个选项打开时,Valgrind在一些特定的情况下将对CPU仿真产生警告。通常这些都是不引人注意的。
--smc-check= [default: stack]
这个选项控制Valgrind对自我修改的代码的检测。Valgrind可以不做检测,可以检测栈中自我修改的代码,或者任意地方检测自我修改的代码。注意默认选项是捕捉绝大多数情况,到目前我们了解的情况为止。使用all选项时会极大的降低速度。(但是用none选项运行极少影响速度,因为对大多数程序,非常少的代码被添加到栈中)
调试VALGRIND选项:
还有一些选项是用来调试Valgrind自身的。在运行一般的东西时不应该需要的。如果你希望看到选项列表,使用--help-debug选项。
内存检查选项:
--leak-check= [default: summary]
当这个选项打开时,当客户程序结束时查找内存泄漏。内存泄漏意味着有用malloc分配内存块,但是没有用free释放,而且没有指针指向这块内存。这样的内存块永远不能被程序释放,因为没有指针指向它们。如果设置为summary,Valgrind会报告有多少内存泄漏发生了。如果设置为full或yes,Valgrind给出每一个独立的泄漏的详细信息。
--show-reachable= [default: no]
当这个选项关闭时,内存泄漏检测器只显示没有指针指向的内存块,或者只能找到指向块中间的指针。当这个选项打开时,内存泄漏检测器还报告有指针指向的内存块。这些块是最有可能出现内存泄漏的地方。你的程序可能,至少在原则上,应该在退出前释放这些内存块。这些有指针指向的内存块和没有指针指向的内存块,或者只有内部指针指向的块,都可能产生内存泄漏,因为实际上没有一个指向块起始的指针可以拿来释放,即使你想去释放它。
--leak-resolution= [default: low]
在做内存泄漏检查时,确定memcheck将怎么样考虑不同的栈是相同的情况。当设置为low时,只需要前两层栈匹配就认为是相同的情况;当设置为med,必须要四层栈匹配,当设置为high时,所有层次的栈都必须匹配。对于hardcore内存泄漏检查,你很可能需要使用--leak-resolution=high和--num-callers=40或者更大的数字。注意这将产生巨量的信息,这就是为什么默认选项是四个调用者匹配和低分辨率的匹配。注意--leak-resolution= 设置并不影响memcheck查找内存泄漏的能力。它只是改变了结果如何输出。
--freelist-vol= [default: 5000000]
当客户程序使用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: no]
控制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=65535,2,64你可以指定一个,两个或三个I1/D1/L2缓冲。如果没有手动指定,每个级别使用普通方式(通过CPUID指令得到缓冲配置,如果失败,使用默认值)得到的配置。
--I1=,,
指定第一级指令缓冲的大小,关联度和行大小。
--D1=,,
指定第一级数据缓冲的大小,关联度和行大小。
--L2=,,
指定第二级缓冲的大小,关联度和行大小。
CALLGRIND选项:
--heap= [default: yes]
当这个选项打开时,详细的追踪堆的使用情况。关闭这个选项时,massif.pid.txt或massif.pid.html将会非常的简短。
--heap-admin= [default: 8]
每个块使用的管理字节数。这只能使用一个平均的估计值,因为它可能变化。glibc使用的分配器每块需要4~15字节,依赖于各方面的因素。管理已经释放的块也需要空间,尽管massif不计算这些。
--stacks= [default: yes]
当打开时,在剖析信息中包含栈信息。多线程的程序可能有多个栈。
--depth= [default: 3]
详细的堆信息中调用过程的深度。增加这个值可以给出更多的信息,但是massif会更使这个程序运行得慢,使用更多的内存,并且产生一个大的massif.pid.txt或者massif.pid.hp文件。
--alloc-fn=
指定一个分配内存的函数。这对于使用malloc()的包装函数是有用的,可以用它来填充原来无效的上下文信息。(这些函数会给出无用的上下文信息,并在图中给出无意义的区域)。指定的函数在上下文中被忽略,例如,像对malloc()一样处理。这个选项可以在命令行中重复多次,指定多个函数。
--format= [default: text]
产生text或者HTML格式的详细堆信息,文件的后缀名使用.txt或者.html。
HELGRIND选项:
--private-stacks= [default: no]
假定线程栈是私有的。
--show-last-access= [default: no]
显示最后一次字访问出错的位置。
LACKEY选项:
--fnname= [default: _dl_runtime_resolve()]
对函数计数。
--detailed-counts= [default: no]
对读取,存储和alu操作计数。
reference
Valgrind Documentation
valgrind 详细说明
使用 Valgrind 检测 C++ 内存泄漏
内存泄漏检查工具valgrind使用方法
valgrind详解-参数说明
C++之控制内存分配