在AIX版本5.3上使用MALLOCDEBUG隔离和解决内存泄漏

最新推荐文章于 2024-03-12 09:06:25 发布
最新推荐文章于 2024-03-12 09:06:25 发布
阅读量385 收藏
点赞数
文章标签： python linux java 编程语言 操作系统
原文链接：https://www.ibm.com/developerworks/aix/library/au-mallocdebug.html
版权

在对应用程序进行编程时，动态内存分配是一个福音。 它有助于在程序运行时分配所需的内存，而不是在进程开始时分配。 但是，有效管理此内存非常重要。 在大型，复杂的应用程序中，内存泄漏是一个非常普遍的问题。 当不再需要或不可访问但仍未释放先前分配的内存时，就会发生内存泄漏，从而导致该进程缺少总可用内存。 虽然良好的编程习惯可以确保将泄漏降到最低，但我们的经验是，当相同的内存块被众多功能处理时，内存泄漏往往会发生。 遇到错误路径时尤其如此。

本文概述了解决内存泄漏时可以使用的方法，并讨论了如何利用AIX®随附的MALLOCDEBUG工具。

为什么内存泄漏是很难解决的问题

您可以根据应用程序遇到的条件在其生命周期的不同时间释放一块内存。 必须对应用程序进行设计，以便它知道何时准备释放一块内存，并尽早执行该操作，而不是稍后执行。 根据控制流，可以在代码中的不同点释放内存。 覆盖所有此类控制流，而不仅仅是命中率最高的代码流路径，这一点非常重要。

同时，在准备释放内存之前释放内存可能是致命的。 因此，对应用程序内的控制流有很好的了解对于理解准备释放块的位置非常有用。

检测内存泄漏

在以下情况下，某些症状表明可能存在泄漏：

  • Malloc返回errno设置为ENOMEM 。
  • 发生核心转储，并且堆栈中的功能之一来自malloc子系统。
  • 与正常运行时相比，核心时的进程大小很大。
  • 进程大小（可以通过ps命令看到）Swift增长。

如果有迹象表明您有内存泄漏，则最好使用内存监视工具。 有一些第三方工具，例如Zerofault和IBMRational®Purify®，但是本文讨论了AIX随附的MALLOCDEBUG工具。

使用MALLOCDEBUG报告内存泄漏

MALLOCDEBUG是易于使用的malloc子系统监视工具。 您可以使用两个环境变量MALLOCDEBUG和MALLOCTYPE轻松地为特定应用程序的malloc子系统启用调试功能。 您需要将这些变量导出到将启动应用程序的外壳程序中。 错误报告将写入AIX版本5.3中的stderr。

合金型

MALLOCTYPE变量确定应使用哪个malloc子系统，以及是否启用调试。 下表1显示了可以设置MALLOCTYPE的各种值。 请参阅相关信息的链接，在“开发和移植的C和C ++在AIX上的应用程序。” IBM红皮书。

表1. MALLOCTYPE变量
MALLOCTYPE = 内存分配器 IBM红皮书“在AIX上开发和移植C和C ++应用程序”中的详细解释
3.1 3.1内存分配器 部分4.2.1，3.1内存分配器
空值 默认内存分配器 部分4.2.2，默认的内存分配器
水桶 具有malloc存储桶扩展名的默认内存分配器 部分4.2.3，带有malloc buckets扩展名的默认内存分配器
调试 调试内存分配器 部分4.2.4，调试内存分配器
用户：archive_name 用户定义的内存分配器 部分4.2.5，用户定义的malloc替换

您应该知道，MALLOCDEBUG假定使用默认分配器。

MALLOCDEBUG

MALLOCDEBUG变量可以从下表2中的列表中获取多个逗号分隔的值。

表2. MALLOCDEBUG变量
MALLOCDEBUG = 简要说明
对齐：n n是内存对齐的字节数。 请参阅相关主题以获取更多信息。
postfree_checking postfree_checking使MALLOCDEBUG报告尝试访问释放的内存，然后中止程序的尝试。
validate_ptrs 如果将以前未由malloc分配的指针传递给free()调用，则会引发错误消息，并且程序将中止。
overlay_signal_handling 当MALLOCDEBUG检测到内存错误时，它将使用SIGSEGV或SIGABRT强制程序进入内核。 设置override_signal_handling可以确保程序终止并运行，即使这些信号已由应用程序处理。
allow_overreading allow_overreading会忽略过度读取。
report_allocations report_allocations报告所有在应用程序退出时未释放的内存分配。
record_allocations record_allocations报告所有内存分配。
继续 继续会报告错误，但不会终止程序。 这是AIX 5.3版中可用的有用功能。
stack_depth：n stack_depth：n将错误堆栈的深度报告为n ，而不是默认值6。

在这些选项中， report_allocations选项与使用最相关，因为它为您提供了在应用程序中检测到的泄漏的列表。

例

在本节中，您将研究一个示例和一些示例代码清单，以说明如何使用MALLOCDEBUG。 此示例的源代码可在“ 下载”部分中找到。

清单1. MALLOCDEBUG和MALLOCTYPE设置导出到外壳 
/home/user> export MALLOCTYPE=debug /home/user> export
                MALLOCDEBUG=report_allocations
清单2.程序的输出 
/home/user> ./stud
                2>mal_dbg_stud Student Name: Manish Subjects # Maths English Student Name: Vaarun
                Subjects # Chemistry Physics Student Name: Sandeep Subjects # Biology Maths ......
                ...... ...... ...... Student Name: Govind Subjects # Physics Biology Student Name:
                Manish Subjects # Maths English Current allocation report: Allocation #0: 0x2000EFE8
                Allocation size: 0x14 Allocation traceback: 0xD0371F64 malloc 0xD0322194 init_malloc
                0xD0323224 malloc 0x10000BE4 initialize_leaky Allocation #1: 0x20010FF0 Allocation
                size: 0xA Allocation traceback: 0xD0371F64 malloc 0x10000C08 initialize_leaky
                0x10000DD4 main 0x100001B4 __start Allocation #2: 0x20012FF0 Allocation size: 0xA
                Allocation traceback: 0xD0371F64 malloc 0x10000C08 initialize_leaky 0x10000DD4 main
                0x100001B4 __start ...... ...... ...... ...... Allocation #17: 0x20030FF0 Allocation
                size: 0x10 Allocation traceback: 0xD0371F64 malloc 0x100008F4 getnode 0x10000B08
                insert 0x10000DDC main Allocation #18: 0x20032FF8 Allocation size: 0x8 Allocation
                traceback: 0xD0371F64 malloc 0x10000894 allocate_for_dbl_ptr 0x10000910 getnode
                0x10000B08 insert Allocation #19: 0x20034FE8 Allocation size: 0x14 Allocation
                traceback: 0xD0371F64 malloc 0x10000A5C allocate_name 0x10000B18 insert 0x10000DDC
                main Allocation #22: 0x2003AFF0 Allocation size: 0x10 Allocation traceback:
                0xD0371F64 malloc 0x100008F4 getnode 0x10000B3C insert 0x10000DDC main ...... ......
                ...... ......

MALLOCDEBUG的输出格式不是非常用户友好。 它仅打印每个未释放的已分配块的调用malloc的函数堆栈。 它还返回该块的大小以及malloc返回的指针的值。

为了使上面的输出更易于理解，我们编写了一个示例脚本。 （请参见下载部分。请注意，这是一个示例脚本，旨在与示例程序类似地用于输出。）下面的清单3显示了在上述堆栈上运行脚本后的输出。

清单3.通过脚本解析MALLOCDEBUG的输出 
/home/user>
                ./format_mallocdebug_op.ksh Usage : ./stack.ksh stackfile /home/katiyar/DW>
                ./format_mallocdebug_op.ksh ./mal_dbg_stud | tee ./mal_dbg_stud_formatted Parsing
                output from debug malloc ... Analyzed 50 stacks ... main insert allocate_subjects
                malloc ################################ 220 bytes leaked in 22 Blocks
                ################################ main insert allocate_name malloc
                ################################ 220 bytes leaked in 11 Blocks
                ################################ __start main initialize_leaky malloc
                ################################ 190 bytes leaked in 16 Blocks
                ################################ main insert getnode malloc
                ################################ 176 bytes leaked in 11 Blocks
                ################################ insert getnode allocate_for_dbl_ptr malloc
                ################################ 88 bytes leaked in 11 Blocks
                ################################ initialize_leaky malloc init_malloc malloc
                ################################ 20 bytes leaked in 1 Blocks
                ################################

调查应从最大的泄漏开始。 上面的第一个堆栈显示了main调用insert ，后者调用了allocate_subjects 。 allocate_subjects通过调用malloc分配一个内存块，并且永远不会释放该块。 脚本输出提到22个单独的分配已累计泄漏了220个字节。 这意味着您应该查看代码中我们在allocate_subjects函数中分配了10个字节数据的位置，并检查其所有实例是否都已释放。 对程序进行仔细的分析后，您会找到应该释放有关内存块的位置。

对报告中的每个堆栈都进行了类似的分析，并对其进行了修复。 在程序中，如果在运行程序之前将FREE_BLOCKS=1环境变量导出到外壳程序，则该修复程序将生效。

清单4.释放分配的块后的输出 
/home/katiyar/DW> ./stud
                Student Name: Manish Subjects # Maths English Student Name: Vaarun Subjects #
                Chemistry Physics Student Name: Sandeep Subjects # Biology Maths ...... ......
                ...... ...... Student Name: Govind Subjects # Physics Biology Student Name: Manish
                Subjects # Maths English Current allocation report: Total allocations: 0.

结论

在客户计算机上维修软件时，已经注意到MALLOCDEBUG是少数可用的malloc子系统监视工具之一。 为了避免在机器上获取服务时要求客户提供MALLOCDEBUG日志时出现大量malloc错误，在将应用程序交付给客户之前使用MALLOCDEBUG测试应用程序可能非常有益。 我们希望本文为必须处理客户计算机上的内存泄漏的开发人员和服务工程师提供了有用的介绍。

翻译自: https://www.ibm.com/developerworks/aix/library/au-mallocdebug.html

cusi77914
关注
Android malloc debug定位native内存问题(主要是内存泄漏)
xlnaan的博客
11-21 1万+
android sources全局指导坐镇 https://source.android.com/devices/tech/debug/native-memory 一直没有实践native进程的内存泄漏问题的debug，网上也一直没找到有用的。直到遇到heapsnap，发现真是有用，至此一块心病也是解决了。再加上之前用asan来分析userspace的内存问题，可以说稳定性这块关于内存的算是有...
aix5.3 ssh安装包
08-31
综上所述，这个"aix5.3 ssh安装包"是针对AIX 5.3系统的一个安全远程访问解决方案，包含OpenSSH和OpenSSL组件。用户需要在Windows环境下解压RAR文件，然后将内容转移并安装在AIX服务器上，以实现安全的远程管理。
AIX下内存泄漏的监控
cti27515的博客
04-10 283
内存泄露主要就是监控进程的内存消耗，AIX下可以通过ps vg得到内存的消耗量，从而比较另外，有个很有用的脚本：post_vg.sh 用来比较内存的增加 下面是一个以前监控内存泄漏问题时的一个自动脚本-------------...
分析AIX上的native内存泄露
技术风向标
07-01 168
Running native profiling on AIX Read the information provided <!-- -->Introduction AIX provides a debug extension to the malloc subsystem for debugging memory allocation errors a...
在 AIX V5.3 中使用 MALLOCDEBUG 隔离并解决内存泄漏
IBM技术期刊
05-11 962
 AIX® Version 5.3 中附带的 malloc 子系统监视工具 MALLOCDEBUG，可以帮助您隔离内存泄漏。内存泄漏是非常棘手的问题，并且处理起来需要很大的代价，所以使用好的工具以确定并了解出现泄漏的原因是非常重要的。本文中提供的示例代码将向您展示处理内存泄漏的一种方法。 引言 在编写应用程序时进行动态内存分配是非常必要的。它可以在程序运行的过程中帮助分配所需的内存，而不是在进程启
UNIX（如AIX）下内存泄露问题分析方法
yefengwuhen2012的专栏
11-11 4262
内存泄露简单的说就是申请了一块内存空间，使用完毕后没有释放掉。它的一般表现方式是程序运行时间越长，占用内存越多，最终用尽全部内存，整个系统崩溃。 封装 new 和 delete 对内存泄漏进行分析 通过对 new 和 delete 的封装，将 new 和 delete 的过程通过日志文件的保存记录下来。然后对日志文件进行分析，是否 new 和 delete 是匹配的，有哪些内存申请，但是没
Oracle10gRAC在IBM-AIX5.3上的安装手册.docx
05-19
### Oracle10gRAC在IBM-AIX5.3上的安装关键知识点 #### 安装概述与背景 Oracle10g Real Application Clusters (RAC) 是一款支持高可用性和可扩展性的数据库集群解决方案。本手册针对Oracle10gRAC在IBM-AIX5.3操作...
AIX原文官方文档（aix5.3）
06-20
在AIX 5.3版本中，它提供了丰富的功能和强大的稳定性，适用于企业级应用和服务。这份"AIX原文官方文档（aix5.3）"是一个重要的参考资料，特别是对于系统管理员和运维人员来说，它详细介绍了AIX 5.3中的各种命令和...
db2在aix5.3和6.1的参数配置.docx
最新发布
07-02
在两个版本中均保持一致，推荐值为128，表明在AIX 5.3和6.1中，对于大多数应用场景，预读量设置为128即可达到较好的性能表现。 2. **ioo j2_maxRandomWrite** - AIX 5.3默认设置: 128 - AIX 6.1默认设置: 0 - ...
AIX_5.3_power64-latest.tar
04-16
AIX 5.3是一个较旧的版本，发布于2005年，因此这个压缩包可能是为了帮助仍在使用该系统的用户进行升级、修复安全漏洞或增加新功能。使用最新版本的软件对于任何系统来说都是重要的，特别是对于关键业务系统，因为这...
如何检查内存泄露 on AIX
07-26
介绍如何使用aix的工具来发现内存泄露，内容不多，但却是很实用
format_mallocdebug_op.ksh
04-18
format_mallocdebug_op.ksh mallocdebug后格式化输出堆栈日志
Debugging Malloc Lab: Detecting Memory-Related Errors
10-31
Introduction The usual implementation of malloc and free are unforgiving to errors in their callers' code, including cases where the programmer overflows an array, forgets to free memory, or frees a memory block twice. This often does not affect the program immediately, waiting until the corrupted memory is used later (in the case of overwrites) or gradually accumulating allocated but unused blocks. Thus, debugging can be extremely difficult. In this assignment, you will write a wrapper for the malloc package that will catch errors in the code that calls malloc and free. The skills you will have learned upon the completion of this exercise are pointer arithmetic and a greater understanding of the consequences of subtle memory mistakes. Logistics Unzip debugging_malloc.zip into an empty directory. The files contained are as follows: File(s): Function: debugmalloc.c Contains the implementation of the three functions you will be writing. This is the one file you will be editing and handing in. debugmalloc.h Contains the declaration of the functions, as well as the macros that will call them. driver.c Contains main procedure and the code that will be calling the functions in the malloc package dmhelper.c, dmhelper.h Contain the helper functions and macros that you will be calling from your code grader.pl Perl script that runs your code for the various test cases and gives you feedback based on your current code debugmalloc.dsp Exercise 3 project file debugmalloc.dsw Exercise 3 workspace file tailor.h, getopt.c, getopt.h Tools that are used only by the driver program for I/O purposes. You will not need to know what the code in these files do. Others Required by Visual C++. You do not need to understand their purpose Specification Programs that use this package will call the macros MALLOC and FREE. MALLOC and FREE are used exactly the same way as the malloc() and free() functions in the standard C malloc package. That is, the line void *ptr = MALLOC ( n ) ;will allocate a payload of at least n bytes, and ptr will point to the front of this block. The line FREE(ptr);will cause the payload pointed to by ptr to be deallocated and become available for later use. The macros are defined as follows: #define MALLOC(s) MyMalloc(s, __FILE__, __LINE__) #define FREE(p) MyFree(p, __FILE__, __LINE__) The __FILE__ macro resolves to the filename and __LINE__ resolves to the current line number. The debugmalloc.c file contains three functions that you are required to implement, as shown: void *MyMalloc(size_t size, char *filename, int linenumber); void MyFree(void *ptr, char *filename, int linenumber); int AllocatedSize(); Using the macros above allow MyMalloc and MyFree to be called with the filename and line number of the actual MALLOC and FREE calls, while retaining the same form as the usual malloc package. By default, MyMalloc and MyFree() simply call malloc() and free(), respectively, and return immediately. AllocatedSize() should return the number of bytes currently allocated by the user: the sum of the requested bytes through MALLOC minus the bytes freed using FREE. By default, it simply returns 0 and thus is unimplemented. The definitions are shown below: void *MyMalloc(size_t size, char *filename, int linenumber) { return (malloc(size)); } void MyFree(void *ptr, char *filename, int linenumber) { free(ptr); } int AllocatedSize() { return 0; } Your job is to modify these functions so that they will catch a number of errors that will be described in the next section. There are also two optional functions in the debugmalloc.c file that you can implement: void PrintAllocatedBlocks(); int HeapCheck(); PrintAllocatedBlocks should print out information about all currently allocated blocks. HeapCheck should check all the blocks for possible memory overwrites. Implementation Details To catch the errors, you will allocate a slightly larger amount of space and insert a header and a footer around the "requested payload". MyMalloc() will insert information into this area, and MyFree() will check to see if the information has not changed. The organization of the complete memory block is as shown below: Header Checksum ... Fence Payload Footer Fence Note:MyMalloc() returns a pointer to the payload, not the beginning of the whole block. Also, the ptr parameter passed into MyFree(void *ptr) will point to the payload, not the beginning of the block. Information that you might want to store in this extra (header, footer) area include: a "fence" immediately around the requested payload with a known value like 0xCCDEADCC, so that you can check if it has been changed when the block is freed. the size of the block a checksum for the header to ensure that it has not been corrupted (A checksum of a sequence of bits is calculated by counting the number of "1" bits in the stream. For example, the checksum for "1000100010001000" is 4. It is a simple error detection mechanism.) the filename and line number of the MALLOC() call The errors that can occur are: Error #1: Writing past the beginning of the user's block (through the fence) Error #2: Writing past the end of the user's block (through the fence) Error #3: Corrupting the header information Error #4: Attempting to free an unallocated or already-freed block Error #5: Memory leak detection (user can use ALLOCATEDSIZE to check for leaks at the end of the program) To report the first four errors, call one of these two functions: void error(int errorcode, char *filename, int linenumber); errorcode is the number assigned to the error as stated above. filename and linenumber contain the filename and line number of the line (the free call) in which the error is invoked. For example, call error(2, filename, linenumber) if you come across a situation where the footer fence has been changed. void errorfl(int errorcode, char *filename_malloc, int linenumber_malloc, char *filename_free, int linenumber_free); This is the same as the error(), except there are two sets of filenames and line numbers, one for the statement in which the block was malloc'd, and the other for the statement in which the block was free'd (and the error was invoked). The fact that MyMalloc() and MyFree() are given the filename and line number of the MALLOC() and FREE() call can prove to be very useful when you are reporting errors. The more information you print out, the easier it will be for the programmer to locate the error. Use errorfl() instead of error() whenever possible. errorfl() obviously cannot be used on situations where FREE() is called on an unallocated block, since it was not ever MALLOC'd. Note: You will only be reporting errors from MyFree(). None of the errors can be caught in MyMalloc() In the case of memory leaks, the driver program will call AllocatedSize(), and the grader will look at its return value and possible output. AllocatedSize() should return the number of bytes currently allocated from MALLOC and FREE calls. For example, the code segment: void *ptr1 = MALLOC(10), *ptr2 = MALLOC(8); FREE(ptr2); printf("%d\n", AllocatedSize()); should print out "10". Once you have gotten to the point where you can catch all of the errors, you can go an optional step further and create a global list of allocated blocks. This will allow you to perform analysis of memory leaks and currently allocated memory. You can implement the void PrintAllocatedBlocks() function, which prints out the filename and line number where all currently allocated blocks were MALLOC()'d. A macro is provided for you to use to print out information about a single block in a readable and gradeable format: PRINTBLOCK(int size, char *filename, int linenumber) Also, you can implement the int HeapCheck() function. This should check all of the currently allocated blocks and return -1 if there is an error and 0 if all blocks are valid. In addition, it should print out the information about all of the corrupted blocks, using the macro #define PRINTERROR(int errorcode, char *filename, int linenumber), with errorcode equal to the error number (according to the list described earlier) the block has gone through. You may find that this global list can also allow you to be more specific in your error messages, as it is otherwise difficult to determine the difference between an overwrite of a non-payload area and an attempted FREE() of an unallocated block. Evaluation You are given 7 test cases to work with, plus 1 extra for testing a global list. You can type "debugmalloc -t n" to run the n-th test. You can see the code that is being run in driver.c. If you have Perl installed on your machine, use grader.pl to run all the tests and print out a table of results. There are a total of 100 possible points. Here is a rundown of the test cases and desired output (do not worry about the path of the filename): Test case #1 Code char *str = (char *) MALLOC(12); strcpy(str, "123456789"); FREE(str); printf("Size: %d\n", AllocatedSize()); PrintAllocatedBlocks(); Error # None Correct Output Size: 0 Points worth 10 Details 10 points for not reporting an error and returning 0 in AllocatedSize() Test case #2 Code char *str = (char *) MALLOC(8); strcpy(str, "12345678"); FREE(str); Error # 2 Correct Output Error: Ending edge of the payload has been overwritten. in block allocated at driver.c, line 21 and freed at driver.c, line 23 Points worth 15 Details 6 pts for catching error 3 pts for printing the filename/line numbers 6 pts for correct error message Test case #3 Code char *str = (char *) MALLOC(2); strcpy(str, "12"); FREE(str); Error # 2 Correct Output Error: Ending edge of the payload has been overwritten. in block allocated at driver.c, line 28 and freed at driver.c, line 30 Points worth 15 Details 6 pts for catching error 3 pts for printing the filename/line numbers 6 pts for correct error message Test case #4 Code void *ptr = MALLOC(4); *ptr2 = MALLOC(6); FREE(ptr); printf("Size: %d\n", AllocatedSize()); PrintAllocatedBlocks(); Error # None Correct Output Size: 6 Currently allocated blocks: 6 bytes, created at driver.c, line 34 Points worth 15 Details 15 pts for not reporting an error and returning 6 from AllocatedSize Extra for printing out the extra block Test case #5 Code void *ptr = MALLOC(4); FREE(ptr); FREE(ptr); Error # 4 Correct Output Error: Attempting to free an unallocated block. in block freed at driver.c, line 43 Points worth 15 Details 15 pts for catching error Extra for correct error message Test case #6 Code char *ptr = (char *) MALLOC(4); *((int *) (ptr - 8)) = 8 + (1 << 31); FREE(ptr); Error # 1 or 3 Correct Output Error: Header has been corrupted.or Error: Starting edge of the payload has been overwritten. in block allocated at driver.c, line 47 and freed at driver.c, line 49 Points worth 15 Details 9 pts for catching error 6 pts for a correct error message Test case #7 Code char ptr[5]; FREE(ptr); Error # 4 Correct Output Error: Attempting to free an unallocated block. in block freed at driver.c, line 54 Points worth 15 Details 15 pts for recognizing error Extra for printing correct error message Test case #8 (Optional) Code int i; int *intptr = (int *) MALLOC(6); char *str = (char *) MALLOC(12); for(i = 0; i < 6; i++) { intptr[i] = i; } if (HeapCheck() == -1) { printf("\nCaught Errors\n"); } Error # None Correct Output Error: Ending edge of the payload has been overwritten. Invalid block created at driver.c, line 59 Caught Errors Points worth Extra Details "Caught Errors" indicates that the HeapCheck() function worked correctly. Extra points possible. Your instructor may give you extra credit for implementing a global list and the PrintAllocatedBlocks() and HeapCheck() functions.
dmalloc：调试Malloc内存分配调试C库
02-14
调试Malloc库 版本5.6.5-2020年12月28日 调试内存分配库或“ dmalloc”库被设计为替代系统的malloc ， realloc ， calloc ， free和其他内存管理例程，同时提供了可在运行时配置的强大调试功能。 这些功能包括诸如内存泄漏跟踪，fence-post写检测，文件/行号报告以及常规统计记录之类的功能。 该库具有相当好的可移植性，并且已至少在以下操作系统上成功运行：AIX，DGUX，Free / Net / OpenBSD，GNU / Hurd，HPUX，Irix，Linux，OSX，NeXT，OSF / DUX，SCO，Solaris，Sunos ，Ultrix，Unixware，MS Windows和Cray T3E上的Unicos。 它还为调试线程程序提供支持。 该软件包包括库，配置脚本，调试实用程序，测试程序和文档。 提供了联机文档以及完
Android内存优化（二）之Native内存泄露检测工具malloc debug基础篇
longlong2015的博客
04-08 4723
google 有个debug工具malloc debug，可以用于检测native内存泄露，我们都知道，分配内存的方式有许多，为什么要选malloc_debug?而不是calloc_debug等呢~ 原因 在native世界，我们经常用到的语言就是C语言和C++语言，首先看下C语言的内存分配： C语言的内存分配方式 在C语言中,分配内存方式主要有三种: &lt;1&gt;从静态存...
Android系统malloc_debug的使用
Danny_llp的博客
10-25 4125
一.malloc_debug简介 android 的libc中有malloc_debug的hook调用，具体android源码/bionic/libc/malloc_debug下，我们可以使用malloc_debug中的hook函数对内存分配进行跟踪加测。 malloc_debug主要包含的功能如下： 1.内存分配和释放跟踪,支持的函数如下: When malloc debug is enabled, it works by adding a shim layer that replaces the nor
AIX上的MALLOCTYPE
aolitianya的博客
03-12 349
AIX上使用MALLOCTYPE
Android 内存检测
July_JC的专栏
04-25 1869
本文转载自：http://www.2cto.com/kf/201310/249230.html，还没有试验，留着以后用 1.   Introduction Android对内存的使用包括内存泄漏和内存越界，内存泄漏会导致系统内存减少，最终分配不到内存，这样大的程序就不能运行，甚至系统没有内存而崩溃。Android中kernel和应用程序都可能会有内存泄漏和越界。对于Java
malloc debug抓日志
cengdong的博客
06-13 984
malloc debug正常抓日志： 1.adb root 2.setenforce 0 3.cd /data/local/ 4.chmod 777 tmp 5.setprop libc.debug.malloc 1 6.setprop libc.debug.malloc.program 进程名 7.setprop libc.debug.malloc.options "backtrace leak_track" 8.kill -9 进程号,重启进程 9.复现问题 10.kill -47 进程号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值