Thread: trying to identify a memory leak in my program. please help me here.

Originally Posted by vlrk

so after regular interval i am issuing ps command and i see that vmsize of my task is getting increased is this correct way of justifying the memory leak issue?

Not with certainty, no. All ps will tell you is whether the process memory usage is increasing, decreasing, or remaining static. Even if memory usage decreases between two measurements, there may still be a memory leak .... if some amount of memory released exceeds what is leaked.

If memory usage remains static or increases between two measurements, there may or may not be a leak. Not all cases where memory usage increases (or does not decrease) are attributable to memory leaks.

A continually increasing memory usage MIGHT be a symptom of a memory leak. But it might also mean that the program is behaving as intended, is allocating memory to do some long-duration task but - since it has not completed that task - may not yet have released that memory.

What you really need to do is analyse the design of your program, and the code, to account for memory usage.

If there is any potential for memory to be allocated, but never released, then you may have a leak. If you are able to establish that all memory allocated will be deallocated exactly once (deallocating something more than once is actually a nastier problem than a memory leak) then you can argue convincingly that there is NOT a memory leak.

You might also use debugging tools (like valgrind) to gather data about various memory problems, including potential leaks. This is the most common approach, practically, because most people are not good enough at analysing software design nor at analysing large amounts of source code in order to determine if their program is behaving as intended.

However, tools like valgrind can give false positives (identify problems that don't exist) and false negatives (missing problems that do exist), because they only gather data about code that is executed. If some critical code is not executed, then valgrind will not gather information about what it is doing (whether good or bad).

Using LD, the GNU linker - Options

--wrap symbol
Use a wrapper function for symbol. Any undefined reference to symbol will be resolved to __wrap_symbol. Any undefined reference to __real_symbol will be resolved to symbol. This can be used to provide a wrapper for a system function. The wrapper function should be called __wrap_symbol. If it wishes to call the system function, it should call __real_symbol. Here is a trivial example:

Code:

    void *
    __wrap_malloc (int c)
    {
      numMallocCalls++;
      return __real_malloc (c);
    }

Periodically print the counters to see if your numMallocCalls is getting away from your numFreeCalls

Don't forget to include calloc in this, and also do the right thing in realloc.

Invoke the linker through the compiler, since it will pass all the correct standard library options as well.

gcc -o test testm.o test.o --wrap malloc

Sorry, forgot it was a linker-specific option.

Code:

$ cat foo.c
#include <stdio.h>
#include <stdlib.h>
extern void *__wrap_malloc(size_t);

// for testing
extern int numMallocCalls;

int main()
{
    char *test;

    test = __wrap_malloc(10);

    sprintf(test,"testing");
    printf("%s\n",test);
    free(test);
    printf("Stats=%d\n",numMallocCalls);
    return 0;
}
$ cat bar.c
#include <stdlib.h>
extern void *__real_malloc(size_t);
int numMallocCalls;

void *
__wrap_malloc(int c)
{
     numMallocCalls++;
     return __real_malloc(c);
}
$ gcc foo.c bar.c -Wl,--wrap=malloc
$ ./a.out 
testing
Stats=1

Vmsize does not reflect the actual amount of ram used. Read this:

VIRTUAL ADDRESS SPACE VS. PHYSICAL MEMORY

That's from a man page for a tool I wrote last year, but the logic also applies to the info from top or ps (since all these things get their data from the same place). The tool itself may or may not be useful to you, it has some fields not available in other monitors but it works on a much coarser timescale:

Plog

Top or htop are much much better for monitoring a process in real time than ps is, since ps is not persistent.

htop - an interactive process-viewer for Linux

Keep in mind that address space is not necessarily released immediately when free() is called. You might try throwing this in after your free calls, which can make a noticeable difference (altho in "the big picture" is not so significant):

Code:

#include <malloc.h>

malloc_trim(0);

Nb. that is linux specific.