CODEWITHSUNDEEP
c++clinuxvalgrind
glagolig
glagolig

Reputation: 1120

Lightweight memory leak debugging on linux

I looked for existing answers first and saw that Valgrind is everyone’s favorite tool for memory leak debugging on linux. Unfortunately Valgrind does not seem to work for my purposes. I will try to explain why.

Constraints:

What I need is an equivalent of Microsoft’s UMDH: turn on stack tracing for each heap allocation, then at certain point of time dump all allocations grouped by stacks and ordered by allocation count in descending order. Our app ships on both Windows and Linux platforms, so I know that performance on Windows under UMDH is still tolerable.

Here are the tools/methods I considered

Did I miss anything? Are there any lightweight Valgrind options or existing LD_PRELOAD tool?

Upvotes: 24

Views: 32812

Answers (8)

Gerald Chu
Gerald Chu

Reputation: 53

You might also consider using Google's gperftools, which has a heap profiler that can be loaded via LD_PRELOAD. You can also link in its tcmalloc and leak checker into your binary, and enable them only when needed.

For details, see https://github.com/gperftools/gperftools

Upvotes: 0

Tim Boddy
Tim Boddy

Reputation: 1069

There is a free, open source tool called chap that will do most of what you want. It specifically will not give you stack traces, but it is an extremely light weight tool because it doesn't require any instrumentation at all. All you need is to be able to grab a live core of the process in question, at a point at which you believe the process has already exhibited the bug (so you believe that it has leaked or is too large or whatever).

For details, see https://github.com/vmware/chap

Upvotes: 0

wub
wub

Reputation: 485

memleax should work for you.

It debugs memory leak of a running process by attaching it, without recompiling program or restarting target process. It's very convenient and suitable for production environment.

It TRAPs only for malloc/free() calls, so it should bring less performace impact than Vagrild.

It works on GNU/Linux-x86_64 and FreeBSD-amd64.

NOTE: I'm the author, any suggestion is welcomed

Upvotes: 5

milianw
milianw

Reputation: 5326

I would like to advertise my just announced heaptrack utility, which should be just what you where looking for back then. You can find more information here: http://milianw.de/blog/heaptrack-a-heap-memory-profiler-for-linux

Compared to your heapwatch tool, the performance should be far better, as I use libunwind and later libbacktrace to delay the annotation of the backtrace with DWARF debug information.

I'd love to get more feedback on it, so try it out!

Upvotes: 5

glagolig
glagolig

Reputation: 1120

Surprisingly, I was unable to find anything like Microsoft's UMDH in open-source domain or available for immediate download. (I also looked at Google Heap Leak Checker but it is more like Valgrind rather than to UMDH). So I ended up writing the tool myself using malloc instrumentation project as a reference point:

https://github.com/glagolig/heapwatch

The tool has number of limitations, but it worked just fine for my purposes.

Upvotes: 1

Chris Gottbrath
Chris Gottbrath

Reputation: 216

@glagolig,

Yes, MemoryScape can group allocations by stack location.

Were you able to get the evaluation version? Assuming you used an email address that doesn't look like a bot you should have heard back from us pretty quickly. If not, or if you are having technical trouble with it give me a shout or reach out to our tech support team.

Chris Gottbrath

Principal Product Manager for TotalView at Rogue Wave Software

email: Firstname . Lastname (at) roguewave . com

Upvotes: 1

DanielKO
DanielKO

Reputation: 4516

GNU libc has built-in malloc debugging:

http://www.gnu.org/software/libc/manual/html_node/Allocation-Debugging.html

Use LD_PRELOAD to call mtrace() from your own .so:

#include <mcheck.h>
static void prepare(void) __attribute__((constructor));
static void prepare(void)
{
    mtrace();
}

Compile it with:

gcc -shared -fPIC dbg.c -o dbg.so

Run it with:

export MALLOC_TRACE=out.txt
LD_PRELOAD=./dbg.so ./my-leaky-program

Later inspect the output file:

mtrace ./my-leaky-program out.txt

And you will get something like:

Memory not freed:
-----------------
           Address     Size     Caller
0x0000000001bda460     0x96  at /tmp/test/src/test.c:7

Of course, feel free to write your own malloc hooks that dump the entire stack (calling backtrace() if you think that's going to help).

Lines numbers and/or function names will be obtainable if you kept debug info for the binary somewhere (e.g. the binary has some debug info built in, or you did objcopy --only-keep-debug my-leaky-program my-leaky-program.debug).

Also, you could try Boehm's GC, it works as a leak detector too:

http://www.hpl.hp.com/personal/Hans_Boehm/gc/leak.html

Upvotes: 18

SebGR
SebGR

Reputation: 293

MemoryScape would meet your needs. This is the dynamic memory debugging tool that comes with the TotalView debugger.

http://www.roguewave.com/products/memoryscape.aspx

Upvotes: 2

Related Questions