Detecting memory leaks in c program

In problem areas such as these, dynamic memory management enables more efficient use of the available RAM than a predefined number of buffers. When the memory is not being used by one message queue, it can be used by another queue, or by a completely different part of the program. One particular problem often arises when there is more than one pointer to a specific block. If the first entity owns the memory and wants to free it, then it must first consider whether any other pointers point at that location.

If any do, and the first entity frees the memory, those other pointers become dangling pointers—pointers that point to space that is no longer valid. When the dangling pointer is used, you may happen to get the correct data, but eventually the memory will be reused via another call to malloc , leading to unpleasant interactions between the dangling pointer and the new owner of that piece of memory.

A dangling pointer is the opposite of a leak. A leak occurs when you fail to free something; a dangling pointer occurs when you free something that was not yet ready to be freed. Memory leaks are similar to race conditions in a number of ways. The misbehavior they cause may occur far from where the bug was caused. As a result, these problems are difficult to resolve by stepping through the code with a debugger. For both memory leaks and race conditions, code inspections sometimes catch these problems more quickly than any technical solution.

Adding debug code to generate output is often a better alternative than a source code debugger, but in the case of race conditions, it could alter the behavior enough to disguise the problem.

With memory leaks, adding debug code can change the shape of the memory layout, which means that dangling pointer bugs may exhibit different behavior. Another drawback is that if the debugging code consumes memory, you may run out of RAM sooner in the debug version than you would in the production version. Still, a leak is a leak and should remain detectable regardless of these side effects of the debug code. Some programming languages provide intrinsic memory management capabilities that can reduce the possibility of memory leaks.

Java, for example, has automatic memory management in the form of garbage collection. Java programmers do not have to worry about freeing allocated memory. If you ever program in Java, you will appreciate just how much time and effort other languages require to keep track of memory. In Java, you pay a runtime cost in exchange for programming simplicity. This is because manually managing the memory produces a more efficient implementation.

When programs become large, however, manual management breaks down. While good manual management will always minimize total heap size, it might not always be easy to implement. In a large program that involves dozens of programmers, human error will introduce enough leaks to tip the performance scales in favor of an automatic solution. The article seemed to imply that this meant that the supermarkets were ripping us off.

What the article failed to point out was a comparison with the alternative, where the person on the till has to manually type in the price of each item, which, I am guessing, would have had a higher error rate. The other consideration is that shop assistants, like programmers, vary widely in their skill levels.

If the automatic system has a measurable error level, then at least management can allow for it in their plans. If the volume of customers and groceries is high, the supermarket and the customer are better off in the long run with an automatic system. A similar logic applies to automatic garbage collection. An excellent individual programmer will do far better than an automatic collector, but in a large project, with a large number of programmers, it may be impossible to find and plug all of the leaks.

Choosing an automatic system may mean that you compromise performance. You also have to accept that the automatic collector will occasionally mess up. While automatic collection is attractive for very large programs, most embedded developers are not developing systems of that complexity. Of those who are, only the minority have access to a programming environment, such as Perl, Smalltalk, or Java, that includes automatic garbage collection.

A number of tools help in the hunt for memory leaks. The most popular free ones are dmalloc and mpatrol. On a number of projects, I was responsible for tracking down memory leaks and providing some evidence that all such leaks had been removed.

Initially, I assumed that one of the tools mentioned above would solve my problems. However, I found that a complete replacement for malloc and free was not always appropriate for embedded systems. For instance, I could be perfectly happy with my current implementation and simply want to add some monitoring. If I choose a library that replaces malloc and free , I have to port those routines.

Since the free libraries available are Unix-oriented, they use the sbrk call to obtain blocks of memory from the operating system. I might not have that call available in my operating system—in fact, I might not even have an operating system.

When porting, I would also have to address issues such as pointer size and memory alignment issues of the specific processor. These issues have already been addressed by the version of malloc and free provided with my compiler library, which obviously has been ported to the processor that I am using, so I want to avoid repeating that work.

The other challenge of porting one of these debugging versions of malloc is that they assume that they can store their analysis data in a file. Alas, the systems I work on generally do not have any file system available. I may have to restrict how much data is stored on a device with minimal resources. I also considered running a portion of the code on a desktop computer using an off-the-shelf tool.

BoundsChecker from Compuware was available and already being used in-house for other purposes. I was disappointed with the results. Large amounts of data were available, but it was necessary to eliminate numerous red herrings to discern the important information. The biggest obstacle was that BoundsChecker delivers its report after the program has exited. Any data that was not freed up before exit is considered a leak.

While this is a reasonable definition, it was not a good match for my application. Wikipedia offers the following definition: In computer science, a memory leak is a type of resource leak that occurs when a computer program incorrectly manages memory allocations in such a way that memory which is no longer needed is not released.

Download Whitepaper. Written by Arthur Hicken Arthur has been involved in software security and test automation at Parasoft for over 25 years, helping research new methods and techniques including 5 patents while helping clients improve their software practices.

View All Resources. Webinar Jan Note: I would like to do this without any external utilities for practice. Jonathan Leffler k gold badges silver badges bronze badges. Mike G Mike G 4, 10 10 gold badges 43 43 silver badges 74 74 bronze badges. MitchWheat i mentioned that i cant use any external utilities — Mike G.

Well, if this is for learning, you could learn about how valgrind does it Mike G: sure you can write your own. Although excoriated by some, Writing Solid Code has some interesting ideas. For the excoriation, see the the review at ACCU. The book is old and dates from just after the C89 standard was finished and before all compilers supported it; it is a little quaint in places.

But memory allocation tracking is discussed extensively, and the general attitude 'Fortify your subsystems', etc is good. Add a comment. Active Oldest Votes. As suggested, there already exist excellent tools like Valgrind to do this.

Further: I would like to do this without any external utilities for practice This is interesting and I am sure would be fulfilling, You can use macro trick to detect such memory usage and leak errors, in fact write your own neat leak detector. Hope this helps and All the Best :. Alok Save Alok Save k 47 47 gold badges silver badges bronze badges. This is definitely and interesting approach, can i just add size to some counter when malloc is invoked then subtract size when free is invoked?

You could but that's not going to give you the granularity you might want. So you lost bytes. You can test the same code in Windows as well. The output shows the file name and line number which causes the memory leak and now you can free the unallocated memory.

If you have multiple source files, you can add the header file in all the files where you want to detect possible memory leak and compile the program as above. While calling malloc , our xmalloc is called and we keep all information of the allocated memory like the address, size, file name and line number in a linked list. While the code calls the free function, it actually calls our xfree and we manage to do the cleanup task remove the entry of the allocated memory from the list and free up the allocated memory.

You can also use pragma exit directive instead of atexit. Sign in Email. Forgot your password? Search within: Articles Quick Answers Messages. Stats Memory Leak Detection in C. Rabinarayan Biswal Rate me:. Please Sign up or sign in to vote. A simple yet effective solution to memory leak detection in C code. Download source - 5.

But we can write very simple code to detect memory leak in our program. The below method is a very simple one and helps to detect memory leak in your program. Using the Code Let's assume you have allocated some memory in your code using malloc and calloc and haven't deallocated it and your code looks like below.

Copy Code. Rabinarayan Biswal. A self-motivated programmer, blogger, leader — an avid reader and growing older. First Prev Next include header in all files using makefile Member Feb Member 7-Mar Manoj Kumar Choubey Feb Tapeshmittal 7-Mar Ari Poutanen Feb TeslaTaylor Oct Frank Heimes Jan