C/C++内存检测工具valgrind--memcheck

Valgrind简介

Valgrind是运行在Linux上的一套基于仿真技术的程序调试和分析工具，作者是获得过Google-O’Reilly开源大奖的Julian Seward，它包含一个内核 —— 一个软件合成的CPU，和一系列的小工具，每个工具都可以完成一项任务──调试，分析，或测试等，内存检测，我们可以使用它的工具：Memcheck。

Valgrind安装

方法 1. valgrind官网：http://valgrind.org下载

方法 2. Ubuntu： sudo apt-get install valgrind

Memcheck的检测范围

它可以用来检测c/c++程序中出现的内存问题，所有对内存的读写都会被检测到，一切对malloc()/free()/new/delete的调用都会被捕获。所以，它能检测以下问题：
1）. 对未初始化内存的使用；

2）. 读/写释放后的内存块；

3）. 读/写超出malloc等分配的动态内存范围；

4）. 读/写不适当的栈中内存块；

5）. 内存泄漏，指向一块内存的指针永远丢失；

6）. 不正确的malloc/free或new/delete匹配；

7）. memcpy()相关函数中的dst和src指针重叠问题。

Memcheck检测使用步骤及注意事项

1、在编译程序的时候打开调试模式（gcc编译器的-g选项），以便显示行号，编译时去掉-O1 -O2等优化选项;检查的是C++程序的时候，考虑加上选项： -fno- inline ,这样它函数调用链会很清晰。

2、执行：valgrind --tool=memcheck --leak-check=full --log-file=./log.txt ./YourProgram

3、程序运行结束，查看 log.txt 中的结果。

结果分析：

Valgrind(memcheck)包含这7类错误，黑体为一般的错误提示：

1、illegal read/illegal write errors 非法读取/非法写入错误

2、use of uninitialised values 使用未初始化的区域

3、use of uninitialised or unaddressable values in system calls 系统调用时使用了未初始化或不可寻址的地址

4、illegal frees 非法的释放

5、when a heap block is freed with an inappropriate deallocation function 分配和释放函数不匹配

6、overlapping source and destination blocks 源和目的内存块重叠

7、memory leak detection 内存泄漏检测

7.1 Still reachable 内存指针还在还有机会使用或者释放，指针指向的动态内存还没有被释放就退出了

7.2 Definitely lost 确定的内存泄露，已经不能够访问这块内存

7.3 Indirectly lost 指向该内存的指针都位于内存泄露处

7.4 Possibly lost 可能的内存泄露，仍然存在某个指针能够访问某块内存，但该指针指向的已经不是该内存首位置

7.5 Suppressed 某些库产生的错误不予以提示，这些错误会被统计到suppressed项目

测试案例：

最近刚刚用最小堆实现了一个定时容器，写完之后就使用Valgrind的memcheck工具检测了一些内存，log日志如下：

==38716== Memcheck, a memory error detector
==38716== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==38716== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==38716== Command: ./test_heap_timer_new
==38716== Parent PID: 17817
==38716==
==38716== Invalid write of size 4
==38716==    at 0x10BFF8: HeapTimer<Event>::setPos(int) (heap_timer.hpp:59)
==38716==    by 0x10BF30: HeapTimerContainer<Event>::percolateDown(int) (heap_timer.hpp:334)
==38716==    by 0x10BAD3: HeapTimerContainer<Event>::popTimer() (heap_timer.hpp:300)
==38716==    by 0x10B79C: HeapTimerContainer<Event>::tick() (heap_timer.hpp:196)
==38716==    by 0x10B34C: main (test_heap_timer_new.cpp:307)
==38716==  Address 0x4db2478 is 24 bytes inside a block of size 32 free'd
==38716==    at 0x483D1CF: operator delete(void*, unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==38716==    by 0x10BA8B: HeapTimerContainer<Event>::popTimer() (heap_timer.hpp:296)
==38716==    by 0x10B79C: HeapTimerContainer<Event>::tick() (heap_timer.hpp:196)
==38716==    by 0x10B34C: main (test_heap_timer_new.cpp:307)
==38716==  Block was alloc'd at
==38716==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==38716==    by 0x10B808: HeapTimerContainer<Event>::addTimer(long) (heap_timer.hpp:212)
==38716==    by 0x10AC77: acceptConn(Event*, ITimerContainer<Event>*) (test_heap_timer_new.cpp:175)
==38716==    by 0x10B2B5: main (test_heap_timer_new.cpp:293)
==38716==
==38716==
==38716== HEAP SUMMARY:
==38716==     in use at exit: 0 bytes in 0 blocks
==38716==   total heap usage: 10 allocs, 10 frees, 78,304 bytes allocated
==38716==
==38716== All heap blocks were freed -- no leaks are possible
==38716==
==38716== For lists of detected and suppressed errors, rerun with: -s
==38716== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

可以看到有一个4字节的无效内存写入，是在HeapTimer::setPos(int) (heap_timer.hpp:59)里面，我找了半天，最终发现了原因。

原代码链接：高性能定时器1——最小堆实现_Peerless__的博客-CSDN博客

代码如下：

template <typename _UData>
void HeapTimerContainer<_UData>::tick()
{std::cout << "----------tick----------" << std::endl;HeapTimer<_UData> *tmp = _array[0];time_t cur = getMSec();// 循环处理到期的定时器while(!isEmpty()){if(!tmp){break;}// 如果定时器没到期，则退出循环if(tmp->getExpire() > cur){break;}tmp->handleTimeOut();// 将堆顶元素删除，同时生成新的堆顶定时器popTimer();tmp = _array[0];}
}template <typename _UData>
void HeapTimerContainer<_UData>::popTimer()
{if(isEmpty()){return;}if(_array[0]){delete _array[0];// 将原来的堆顶元素替换为堆数组中最后一个元素_array[0] = _array[--_size];// 对新的堆顶元素执行下滤操作percolateDown(0);}
}// 最小堆的下滤操作，它确保数组中以第hole个节点作为根的子树拥有最小堆性质
template <typename _UData>
void HeapTimerContainer<_UData>::percolateDown(int hole)
{/*    if(_size == 0){return;}*/HeapTimer<_UData> *temp = _array[hole];int child = 0;for(; ((hole * 2 + 1) <= _size - 1); hole = child){child = hole * 2 + 1;if((child < (_size - 1)) && (_array[child + 1]->getExpire() < _array[child]->getExpire())){child++;}if(_array[child]->getExpire() < temp->getExpire()){_array[hole] = _array[child];_array[hole]->setPos(hole);             // 调整定时器的位置时，重新设置timer中pos保存的其在数组中的位置}else {break;}}_array[hole] = temp;_array[hole]->setPos(hole);
}

上面代码的逻辑是，tick函数被调用就会从最小堆中取出最近要超时的定时器（也就是堆顶元素），检查是否超时，如果超时就执行回调函数，然后调用popTimer弹出堆顶元素。在popTimer中delete掉了刚超时的定时器，并将堆数组中最后一个元素放到堆顶，然后调用percolateDown来调整最小堆。Valgrind生成的日志中提示在HeapTimer::setPos(int) (heap_timer.hpp:59)出错了。后来发现，如果堆中只有一个元素，这段代码_array[0] = _array[–_size];也就变成了_array[0] = _array[0];然后就是在percolateDown函数中对已经delete掉的对象调用了setPos函数。也就是使用了已经delete掉的对象，但是程序运行的时候竟然没有崩溃，这是个挺大的隐患的，没有崩溃更为恐怖，因为可能下一次就要崩溃。解决方案就是在percolateDown函数中加一个数组是否为空的判断，如果为空直接返回就好了。