linux下使用valgrind排查内存泄漏

最新推荐文章于 2024-05-11 16:07:30 发布
最新推荐文章于 2024-05-11 16:07:30 发布
阅读量2k 收藏 11
点赞数 2
分类专栏： 软件调试 文章标签： linux valgrind
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/www_dong/article/details/131775218
版权

安装

yum install valgrind -y

说明

1）概念

Valgrind是一套Linux下，开放源代码（GPL V2）的仿真调试工具的集合。Valgrind由内核（core）以及基于内核的其他调试工具组成。内核类似于一个框架（framework），它模拟了一个CPU环境，并提供服务给其他工具；而其他工具则类似于插件 (plug-in)，利用内核提供的服务完成各种特定的内存调试任务。

Valgrind包括memcheck、Callgrind、Cachegrind、Helgrind、Massif等工具。

memcheck用来检测程序中出现的内存问题，所有对内存的读写都会被检测到，一切对malloc()/free()/new/delete 的调用都会被捕获。

2）命令行

valgrind --tool=memcheck --leak-check=full --show-leak-kinds=all --undef-value-errors=no --log-file=log ./可执行程序名
  • –tool=memcheck：使用 memcheck 工具检测内存错误，包括使用未初始化的变量、读写越界等；
  • –leak-check=full：全面检测内存泄漏，不仅仅检测未释放的内存，还会检测处理时出现的一些问题；
  • –show-leak-kinds=all：显示所有的内存泄漏信息；
  • –undef-value-errors=no：不检查未定义的值错误；
  • –log-file=log：将日志信息输出到 log 文件中；

几种内存问题

申请内存多次释放

示例

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

void MyTest()
{
	char* p = (char*)malloc(sizeof(char)*10);
	
	delete[] p;

	cout << "MyTest finished" << endl;

	delete[] p;
}

int main()
{
	MyTest();

	return 0;
}

测试

执行valgrind --leak-check=yes ./testValgrind查看结果。

[root@localhost debug]# valgrind --leak-check=yes ./testValgrind
==5532== Memcheck, a memory error detector
==5532== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==5532== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==5532== Command: ./testValgrind
==5532== 
==5532== Mismatched free() / delete / delete []
==5532==    at 0x4C2BB8F: operator delete[](void*) (vg_replace_malloc.c:651)
==5532==    by 0x400A1A: MyTest() (testValgrind.cpp:10)
==5532==    by 0x400A64: main (testValgrind.cpp:19)
==5532==  Address 0x6b529d0 is 0 bytes inside a block of size 10 alloc'd
==5532==    at 0x4C29F73: malloc (vg_replace_malloc.c:309)
==5532==    by 0x400A03: MyTest() (testValgrind.cpp:8)
==5532==    by 0x400A64: main (testValgrind.cpp:19)
==5532== 
MyTest finished
==5532== Invalid free() / delete / delete[] / realloc()
==5532==    at 0x4C2BB8F: operator delete[](void*) (vg_replace_malloc.c:651)
==5532==    by 0x400A58: MyTest() (testValgrind.cpp:14)
==5532==    by 0x400A64: main (testValgrind.cpp:19)
==5532==  Address 0x6b529d0 is 0 bytes inside a block of size 10 free'd
==5532==    at 0x4C2BB8F: operator delete[](void*) (vg_replace_malloc.c:651)
==5532==    by 0x400A1A: MyTest() (testValgrind.cpp:10)
==5532==    by 0x400A64: main (testValgrind.cpp:19)
==5532==  Block was alloc'd at
==5532==    at 0x4C29F73: malloc (vg_replace_malloc.c:309)
==5532==    by 0x400A03: MyTest() (testValgrind.cpp:8)
==5532==    by 0x400A64: main (testValgrind.cpp:19)
==5532== 
==5532== 
==5532== HEAP SUMMARY:
==5532==     in use at exit: 32 bytes in 1 blocks
==5532==   total heap usage: 22 allocs, 22 frees, 136,124 bytes allocated
==5532== 
==5532== LEAK SUMMARY:
==5532==    definitely lost: 0 bytes in 0 blocks
==5532==    indirectly lost: 0 bytes in 0 blocks
==5532==      possibly lost: 0 bytes in 0 blocks
==5532==    still reachable: 32 bytes in 1 blocks
==5532==         suppressed: 0 bytes in 0 blocks
==5532== Reachable blocks (those to which a pointer was found) are not shown.
==5532== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==5532== 
==5532== For lists of detected and suppressed errors, rerun with: -s
==5532== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
[root@localhost debug]#

结果分析：

# 不匹配的free,(testValgrind.cpp:10)进行了
==5532== Mismatched free() / delete / delete []
==5532==    at 0x4C2BB8F: operator delete[](void*) (vg_replace_malloc.c:651)
==5532==    by 0x400A1A: MyTest() (testValgrind.cpp:10)
==5532==    by 0x400A64: main (testValgrind.cpp:19)
==5532==  Address 0x6b529d0 is 0 bytes inside a block of size 10 alloc'd
==5532==    at 0x4C29F73: malloc (vg_replace_malloc.c:309)
==5532==    by 0x400A03: MyTest() (testValgrind.cpp:8)
==5532==    by 0x400A64: main (testValgrind.cpp:19)
==5532==

内存泄漏

示例

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

void MyTest()
{
	char* p = (char*)malloc(sizeof(char)*10);

	cout << &p << endl;
}

int main()
{
	MyTest();

	return 0;
}

测试

执行valgrind --leak-check=yes ./testValgrind查看结果。

[root@localhost debug]# valgrind --leak-check=yes ./testValgrind
==12941== Memcheck, a memory error detector
==12941== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==12941== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==12941== Command: ./testValgrind
==12941== 
0x1ffefff8a8
==12941== 
==12941== HEAP SUMMARY:
==12941==     in use at exit: 42 bytes in 2 blocks
==12941==   total heap usage: 22 allocs, 20 frees, 136,124 bytes allocated
==12941== 
==12941== 10 bytes in 1 blocks are definitely lost in loss record 1 of 2
==12941==    at 0x4C29F73: malloc (vg_replace_malloc.c:309)
==12941==    by 0x400993: MyTest() (testValgrind.cpp:8)
==12941==    by 0x4009CE: main (testValgrind.cpp:15)
==12941== 
==12941== LEAK SUMMARY:
==12941==    definitely lost: 10 bytes in 1 blocks
==12941==    indirectly lost: 0 bytes in 0 blocks
==12941==      possibly lost: 0 bytes in 0 blocks
==12941==    still reachable: 32 bytes in 1 blocks
==12941==         suppressed: 0 bytes in 0 blocks
==12941== Reachable blocks (those to which a pointer was found) are not shown.
==12941== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==12941== 
==12941== For lists of detected and suppressed errors, rerun with: -s
==12941== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
[root@localhost debug]#

结果分析：

# 10个字节确定丢失,发生了内存泄漏
==12941== 10 bytes in 1 blocks are definitely lost in loss record 1 of 2
==12941==    at 0x4C29F73: malloc (vg_replace_malloc.c:309)
==12941==    by 0x400993: MyTest() (testValgrind.cpp:8)
==12941==    by 0x4009CE: main (testValgrind.cpp:15)
==12941== 

# 总结摘要部分也可确认该问题
==12941== LEAK SUMMARY:
==12941==    definitely lost: 10 bytes in 1 blocks   --- 确定发生了10个字节的内存泄漏
==12941==    indirectly lost: 0 bytes in 0 blocks
==12941==      possibly lost: 0 bytes in 0 blocks
==12941==    still reachable: 32 bytes in 1 blocks
==12941==         suppressed: 0 bytes in 0 blocks
==12941== Reachable blocks (those to which a pointer was found) are not shown.
==12941== To see them, rerun with: --leak-check=full --show-leak-kinds=all

释放空指针

示例

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

int main()
{
	char* p = nullptr;
	bool bFind = false;

	// ... 

    // 此时bFind仍为false
	if(bFind)
	{
		p = new char[64];
	}

	delete[] p;

	return 0;
}

测试

执行valgrind --leak-check=yes ./testValgrind查看结果。

[root@localhost debug]# valgrind --leak-check=yes ./testValgrind
==23591== Memcheck, a memory error detector
==23591== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==23591== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==23591== Command: ./testValgrind
==23591== 
==23591== 
==23591== HEAP SUMMARY:
==23591==     in use at exit: 32 bytes in 1 blocks
==23591==   total heap usage: 21 allocs, 20 frees, 136,114 bytes allocated
==23591== 
==23591== LEAK SUMMARY:
==23591==    definitely lost: 0 bytes in 0 blocks
==23591==    indirectly lost: 0 bytes in 0 blocks
==23591==      possibly lost: 0 bytes in 0 blocks
==23591==    still reachable: 32 bytes in 1 blocks
==23591==         suppressed: 0 bytes in 0 blocks
==23591== Reachable blocks (those to which a pointer was found) are not shown.
==23591== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==23591== 
==23591== For lists of detected and suppressed errors, rerun with: -s
==23591== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
[root@localhost debug]#

申请与释放的内存不匹配

示例

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

int main()
{
	char* p = new char[20];

	for(int i = 0; i < 20; i++)
	{
		cout << *(p++) << endl;
	}

	delete[] p;

	return 0;
}

测试

执行valgrind --leak-check=yes ./testValgrind查看结果。

[root@localhost debug]# valgrind --leak-check=yes ./testValgrind
==26240== Memcheck, a memory error detector
==26240== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==26240== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==26240== Command: ./testValgrind
==26240== 
==26240== Conditional jump or move depends on uninitialised value(s)
==26240==    at 0x65C8F6E: _IO_file_overflow@@GLIBC_2.2.5 (in /usr/lib64/libc-2.17.so)
==26240==    by 0x65CA030: _IO_default_xsputn (in /usr/lib64/libc-2.17.so)
==26240==    by 0x65C7A91: _IO_file_xsputn@@GLIBC_2.2.5 (in /usr/lib64/libc-2.17.so)
==26240==    by 0x65BC7E1: fwrite (in /usr/lib64/libc-2.17.so)
==26240==    by 0x4ECDBB4: std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long) (in /usr/lib64/libstdc++.so.6.0.19)
==26240==    by 0x4ECDDE7: std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char) (in /usr/lib64/libstdc++.so.6.0.19)
==26240==    by 0x400A37: main (testValgrind.cpp:12)
==26240== 
==26240== Syscall param write(buf) points to uninitialised byte(s)
==26240==    at 0x663CBA0: __write_nocancel (in /usr/lib64/libc-2.17.so)
==26240==    by 0x65C72F2: _IO_file_write@@GLIBC_2.2.5 (in /usr/lib64/libc-2.17.so)
==26240==    by 0x65C8B0D: _IO_do_write@@GLIBC_2.2.5 (in /usr/lib64/libc-2.17.so)
==26240==    by 0x65C9002: _IO_file_overflow@@GLIBC_2.2.5 (in /usr/lib64/libc-2.17.so)
==26240==    by 0x65C4BD8: putc (in /usr/lib64/libc-2.17.so)
==26240==    by 0x4ECD5C5: std::ostream::put(char) (in /usr/lib64/libstdc++.so.6.0.19)
==26240==    by 0x4ECD811: std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&) (in /usr/lib64/libstdc++.so.6.0.19)
==26240==    by 0x400A4C: main (testValgrind.cpp:12)
==26240==  Address 0x4023000 is in a rw- anonymous segment
==26240== 

==26240== Conditional jump or move depends on uninitialised value(s)
==26240==    at 0x65C7AE5: _IO_file_xsputn@@GLIBC_2.2.5 (in /usr/lib64/libc-2.17.so)
==26240==    by 0x65BC7E1: fwrite (in /usr/lib64/libc-2.17.so)
==26240==    by 0x4ECDBB4: std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long) (in /usr/lib64/libstdc++.so.6.0.19)
==26240==    by 0x4ECDDE7: std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char) (in /usr/lib64/libstdc++.so.6.0.19)
==26240==    by 0x400A37: main (testValgrind.cpp:12)
==26240== 

==26240== Invalid free() / delete / delete[] / realloc()
==26240==    at 0x4C2BB8F: operator delete[](void*) (vg_replace_malloc.c:651)
==26240==    by 0x400A65: main (testValgrind.cpp:15)
==26240==  Address 0x6b529e4 is 0 bytes after a block of size 20 alloc'd
==26240==    at 0x4C2AC38: operator new[](unsigned long) (vg_replace_malloc.c:433)
==26240==    by 0x400A03: main (testValgrind.cpp:8)
==26240== 
==26240== 
==26240== HEAP SUMMARY:
==26240==     in use at exit: 52 bytes in 2 blocks
==26240==   total heap usage: 22 allocs, 21 frees, 136,134 bytes allocated
==26240== 
==26240== 20 bytes in 1 blocks are definitely lost in loss record 1 of 2
==26240==    at 0x4C2AC38: operator new[](unsigned long) (vg_replace_malloc.c:433)
==26240==    by 0x400A03: main (testValgrind.cpp:8)
==26240== 
==26240== LEAK SUMMARY:
==26240==    definitely lost: 20 bytes in 1 blocks
==26240==    indirectly lost: 0 bytes in 0 blocks
==26240==      possibly lost: 0 bytes in 0 blocks
==26240==    still reachable: 32 bytes in 1 blocks
==26240==         suppressed: 0 bytes in 0 blocks
==26240== Reachable blocks (those to which a pointer was found) are not shown.
==26240== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==26240== 
==26240== Use --track-origins=yes to see where uninitialised values come from
==26240== For lists of detected and suppressed errors, rerun with: -s
==26240== ERROR SUMMARY: 42 errors from 5 contexts (suppressed: 0 from 0)
[root@localhost debug]#

结果分析：

# 关于“Conditional jump or move depends on uninitialised value(s)”
某些变量未初始化，检查一下数组/class/struct有没有赋初值，或者说看看初始化的大小是否为正确的大小，下面信息会提示在哪个函数里面。

# 关于“Syscall param write(buf) points to uninitialised byte”
系统调用传递不可访问或未初始化内存。
# 需确认以下几点：
## 1. 参数是否有初始化
## 2. 如果是系统调用读取程序提供的buffer，会产检整个buffer是否可访问和已经初始化
## 3. 如果是系统调用要往用户的buffer写入数据，会检查buffer是否可访问

# 在(testValgrind.cpp:15)处存在非法释放
==26240== Invalid free() / delete / delete[] / realloc()
==26240==    at 0x4C2BB8F: operator delete[](void*) (vg_replace_malloc.c:651)
==26240==    by 0x400A65: main (testValgrind.cpp:15)
==26240==  Address 0x6b529e4 is 0 bytes after a block of size 20 alloc'd
==26240==    at 0x4C2AC38: operator new[](unsigned long) (vg_replace_malloc.c:433)
==26240==    by 0x400A03: main (testValgrind.cpp:8)
==26240== 

# 存在内存泄漏
==26240== LEAK SUMMARY:
==26240==    definitely lost: 20 bytes in 1 blocks  --- 存在20字节内存泄漏
==26240==    indirectly lost: 0 bytes in 0 blocks
==26240==      possibly lost: 0 bytes in 0 blocks
==26240==    still reachable: 32 bytes in 1 blocks
==26240==         suppressed: 0 bytes in 0 blocks

引用已释放的内存块

示例

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

int main()
{
	char* p = new char[20];

	// ...	

	delete[] p;

	// ... 

	p[0] = 'a';

	return 0;
}

测试

执行valgrind --leak-check=yes ./testValgrind查看结果。

[root@localhost debug]# valgrind --leak-check=yes ./testValgrind
==38628== Memcheck, a memory error detector
==38628== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==38628== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==38628== Command: ./testValgrind
==38628== 
==38628== Invalid write of size 1
==38628==    at 0x4008AF: main (testValgrind.cpp:16)
==38628==  Address 0x6b529d0 is 0 bytes inside a block of size 20 free'd
==38628==    at 0x4C2BB8F: operator delete[](void*) (vg_replace_malloc.c:651)
==38628==    by 0x4008AA: main (testValgrind.cpp:12)
==38628==  Block was alloc'd at
==38628==    at 0x4C2AC38: operator new[](unsigned long) (vg_replace_malloc.c:433)
==38628==    by 0x400893: main (testValgrind.cpp:8)
==38628== 
==38628== 
==38628== HEAP SUMMARY:
==38628==     in use at exit: 32 bytes in 1 blocks
==38628==   total heap usage: 22 allocs, 21 frees, 136,134 bytes allocated
==38628== 
==38628== LEAK SUMMARY:
==38628==    definitely lost: 0 bytes in 0 blocks
==38628==    indirectly lost: 0 bytes in 0 blocks
==38628==      possibly lost: 0 bytes in 0 blocks
==38628==    still reachable: 32 bytes in 1 blocks
==38628==         suppressed: 0 bytes in 0 blocks
==38628== Reachable blocks (those to which a pointer was found) are not shown.
==38628== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==38628== 
==38628== For lists of detected and suppressed errors, rerun with: -s
==38628== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
[root@localhost debug]#

结果分析：

动态内存越界

# ==38628==在(testValgrind.cpp:16)处发生动态内存越界
==38628== Invalid write of size 1
==38628==    at 0x4008AF: main (testValgrind.cpp:16)
==38628==  Address 0x6b529d0 is 0 bytes inside a block of size 20 free'd
==38628==    at 0x4C2BB8F: operator delete[](void*) (vg_replace_malloc.c:651)
==38628==    by 0x4008AA: main (testValgrind.cpp:12)
==38628==  Block was alloc'd at
==38628==    at 0x4C2AC38: operator new[](unsigned long) (vg_replace_malloc.c:433)
==38628==    by 0x400893: main (testValgrind.cpp:8)
==38628==

越界访问

示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;

void MyTest()
{
	char* p = new char[10];
	memset(p, 0, sizeof(char)*10);

	p[10] = 'c';	

	delete[] p;
}

int main()
{
	MyTest();

	return 0;
}

测试

[root@localhost debug]# valgrind --leak-check=yes ./testValgrind
==44390== Memcheck, a memory error detector
==44390== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==44390== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==44390== Command: ./testValgrind
==44390== 
==44390== Invalid write of size 1
==44390==    at 0x400906: MyTest() (testValgrind.cpp:12)
==44390==    by 0x400927: main (testValgrind.cpp:19)
==44390==  Address 0x6b529da is 0 bytes after a block of size 10 alloc'd
==44390==    at 0x4C2AC38: operator new[](unsigned long) (vg_replace_malloc.c:433)
==44390==    by 0x4008E3: MyTest() (testValgrind.cpp:9)
==44390==    by 0x400927: main (testValgrind.cpp:19)
==44390== 
==44390== 
==44390== HEAP SUMMARY:
==44390==     in use at exit: 32 bytes in 1 blocks
==44390==   total heap usage: 22 allocs, 21 frees, 136,124 bytes allocated
==44390== 
==44390== LEAK SUMMARY:
==44390==    definitely lost: 0 bytes in 0 blocks
==44390==    indirectly lost: 0 bytes in 0 blocks
==44390==      possibly lost: 0 bytes in 0 blocks
==44390==    still reachable: 32 bytes in 1 blocks
==44390==         suppressed: 0 bytes in 0 blocks
==44390== Reachable blocks (those to which a pointer was found) are not shown.
==44390== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==44390== 
==44390== For lists of detected and suppressed errors, rerun with: -s
==44390== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
[root@localhost debug]#

结果分析：

# 在(testValgrind.cpp:12)处程序访问非法地址的内存,无效写入,即堆溢出。
==44390== Invalid write of size 1
==44390==    at 0x400906: MyTest() (testValgrind.cpp:12)
==44390==    by 0x400927: main (testValgrind.cpp:19)
==44390==  Address 0x6b529da is 0 bytes after a block of size 10 alloc'd
==44390==    at 0x4C2AC38: operator new[](unsigned long) (vg_replace_malloc.c:433)
==44390==    by 0x4008E3: MyTest() (testValgrind.cpp:9)
==44390==    by 0x400927: main (testValgrind.cpp:19)
==44390==
却道天凉_好个秋
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C/C++ 集成内存调试、内存泄漏检测和性能分析的工具 Valgrind 】Linux 下 Valgrind 工具的全面使用指南
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-11 1663
Valgrind 是一个非常强大的工具，主要用于内存管理错误检测，以及 CPU 和内存分析。
Linux下用Valgrind做检查(防止内存泄露)
09-04
总而言之，Valgrind是Linux开发者必备的工具之一，它能够有效地帮助排查内存问题和优化程序性能，节省大量的调试时间，提高代码质量。通过熟练掌握Valgrind的使用，开发者可以更有效地管理和维护他们的程序，避免...
使用 Valgrind 检测内存泄漏
最新发布
阿乐的博客
05-11 1049
Valgrind 是一个编程工具，用于内存调试、内存泄漏检测以及性能分析。Valgrind 工具集中的 Memcheck 是用于检测内存管理和线程错误的主要工具。
[转] Valgrind使用
weixin_30516243的博客
04-01 1152
调不尽的内存泄漏，用不完的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设置环境（需...
Linux下 valgrind 工具定位内存泄露的方法
wojiaxiaohuang2014的博客
11-16 949
Linux下 valgrind 工具定位内存泄露的方法
【调试】Valgrind内存泄漏内存越界|运行时间|调用|cache命中率|多线程竞态|堆栈分析
bandaoyu的note
06-10 5963
目录 即可即用 简介 Valgrind工具详解 安装 使用 检测内存泄漏 其他内存问题 memcheck 工具的常用选型 其他选项 附录 其他类似工具 即可即用 1、没有安装的先在程序运行的主机上安装，安装教程见：1.4安装。 2、使用： 命令： valgrind--leak-check=full --log-file=leak.log/...
linux代码检测工具valgrind之内存检测memcheck
hanxiaoyong_的博客
04-19 1055
valgrind检测工具的安装与内存泄漏memchek检测使用介绍。 “definitely lost”必须需要修复。间接丢失“indirectly lost“，如果修复了绝对丢失，则间接丢失应该消失。
防止内存泄露 Linux下用Valgrind做检查
09-11
【防止内存泄露：Linux下用Valgrind进行检查】 在C语言编程中，内存管理是一项至关重要的任务。然而，由于其复杂性，内存泄漏和内存访问越界等问题时常发生，导致程序性能下降甚至崩溃。为了解决这些问题，开发人员...
tcmalloc排查内存泄漏的方法
01-03
在本文中，我们将介绍如何使用tcmalloc来排查内存泄漏的方法。 安装gperftools 首先，我们需要安装gperftools这个工具包，可以使用以下命令来安装： wget ...
Linux内存泄漏检测shell脚本
09-15
然而，实际的内存泄漏排查可能需要结合多种工具和技巧，包括理解内存管理机制、使用调试工具，以及对代码进行审查。对于开发者来说，了解和掌握这些知识对于优化程序性能和确保系统的稳定性至关重要。
linux下的调试工具valgrind.pdf
10-27
例如，使用Memcheck检查内存泄漏，命令为`valgrind --tool=memcheck --leak-check=yes program_name`。Valgrind在运行时会接管程序，读取调试信息并在其虚拟CPU环境中执行，同时插入检查代码。由于这个过程，程序...
使用valgrind工具检查内存泄漏
小爱玄策
12-24 1216
讲解Linux下使用valgrind工具对c/c++程序进行内存泄漏检测的方法。
Valgrind查找内存泄露
u010451780的专栏
11-23 1136
Valgrind查找内存泄露利器 Valgrind是一个GPL的软件，用于Linux（For x86, amd64 and ppc32）程序的内存调试和代码剖析。你可以在它的环境中运行你的程序来监视内存的使用情况，比如C 语言中的malloc和free或者 C++中的new和 delete。使用Valgrind的工具包，你可以自动的检测许多内存管理和线程的bug，避免花费太多的时间在bug寻找上，使得你的程序更加稳固。 Valgrind的主要功能 Valgrind工具包包含多个工具，如Memcheck
valgrind基本功能介绍、基础使用方法说明
嵌入式与Linux那些事的博客
11-13 6128
Valgrind是一套Linux下，开放源代码（GPL V2）的仿真调试工具的集合。Valgrind由内核（core）以及基于内核的其他调试工具组成。内核类似于一个框架（framework），它模拟了一个CPU环境，并提供服务给其他工具；而其他工具则类似于插件 (plug-in)，利用内核提供的服务完成各种特定的内存调试任务。这是valgrind应用最广泛的工具，一个重量级的内存检查器，能够发现开发中绝大多数内存错误使用情况，比如：使用未初始化的内存，使用已经释放了的内存，内存访问越界等。
介绍一下内存泄漏工具valgrind的使用
ZHONGkunjia的专栏
09-15 379
valgrind 是一款开源内存检测的工具，里面包含了很多的工具，一般使用Memcheck这个工具偏多； Memcheck：这是valgrind应用最广泛的工具，一个重量级的内存检查器，能够发现开发中绝大多数内存错误使用情况，比如：使用未初始化的内存，使用已经释放了的内存，内存访问越界等。 注：代码编译时我们要带上参数-g,有了符号表才可以显示行号这些东西； valgrind工具命令参考： valgrind --tool=memcheck --leak-check=full --show-..
C++ 内存泄漏检测工具valgrind简单使用
m0_46684679的博客
10-24 2424
valgrind内存泄漏工具简单使用和说明
valgrind：内存泄漏 memory leak 调试教程
reason的博客
07-11 741
valgrind：内存泄漏 memory leak 调试教程
linux内存泄漏通用排查方法
热门推荐
jersonborn521的专栏
02-23 1万+
一．概述 Linux下经常遇到内存泄漏的问题，尤其对C/C++开发人员来说是一个亘古不变的话题，现在介绍解决Linux内存泄漏问题的方法层出不穷，让人眼花缭乱，但是作为开发人员应该从本质上了解为何会发生内存泄漏，在面对内存泄漏的问题时应当知道相关的技术细节，在解决问题时应当有个固定的排查思路，要善用Linux系统本身提供的工具来定位和解决，而不是一味的通过各种各样不常用的、不熟悉的工具来排查问题，这样不仅耗时，最终不一定能够解决问题。 本文力求通过一种通用的方法来讲解如何在Linux下定位和解决内...
linux排查内存泄漏
07-27
Linux 内存泄漏是指在程序运行过程中，由于程序设计或者代码实现问题，导致程序申请的内存无法被释放，最终导致系统内存不足，甚至系统崩溃。内存泄漏是一种常见的程序错误，需要及时发现和解决。在 Linux 系统中，可以使用一些工具来检测和定位内存泄漏问题，如 Valgrind、GDB 等。同时，程序员也需要在编写代码时注意内存管理，避免出现内存泄漏问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值