Alternative to valgrind (memcheck) for finding leaks on linux? [closed]

Closed. This question is seeking recommendations for books, tools, software libraries, and more. It does not meet Stack Overflow guidelines. It is not currently accepting answers.

---

We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.

Closed 2 years ago.

Improve this question

I have a linux x86 application that makes use of various third-party shared-object libraries. I suspect these libraries are leaking memory (since it can't possibly be my code ;-)

I tried the trusty valgrind, but it died a horrible death because one of the third-party libraries is using an obscure x86 instruction that valgrind doesn't implement.

I found a recommendation for DUMA and gave it a try (using the LD_PRELOAD technique to bring DUMA in at 开发者_运维百科run-time), but it aborted complaining about a free operation on memory that wasn't allocated via DUMA (almost certainly by some constructor of a static object in one of the previously mentioned third-party libraries).

Are there other run-time-linkable (or otherwise not requiring a recompilation/relink) tools around that will work on linux?

---

Give Dr. Memory a try. It is based on DynamoRIO and shares many of the features with Valgrind.

---

The TotalView debugger (or, more precisely, its Memscope) has a feature set similar to the one of Valgrind.

You can also try Electric Fence (original author's link) (the origin of DUMA) for buffer overflows or touch-after-free cases (but not for memleaks, though).

---

In 2020, to find memory leaks on Linux, you may try:

Address Sanitizers

For both GCC(above 4.8) and Clang (above 3.1), the address sanitizer can be used, it's great the tool has been proved useful in large projects such as Chromium and Firefox. It's much faster than other old alternatives like Valgrind.

ASan will provide very detailed memory region information, which is very helpful for analysis of the leak.

The drawback for ASan: You need to build your program with the option -fsanitize=address; The extra memory cost is much bigger.

TCmalloc

TCmalloc can be both used with LD_PRELOAD or directly link to your program. The result can be visualized with the pprof program, it has both beautiful web UI and consoles text mode, I suggest using it if address sanitizer is not applicable in your environment(If you have a very old compiler or your PC have very limited memory to run ASan).

TCmalloc is also used in large-scale production and proved to be robust.

Linux Perf tools and BCC

Linux perf tools can also be used to find memory leaks, it's a tool based on sampling. So it can not be precise, but it's still a great tool to help us analyze the usage of memory.

There is also a script from bcc's tools.

./memleak -p $(pidof allocs)
        Trace allocations and display a summary of "leaked" (outstanding)
        allocations every 5 seconds
./memleak -p $(pidof allocs) -t
        Trace allocations and display each individual allocator function call
./memleak -ap $(pidof allocs) 10
        Trace allocations and display allocated addresses, sizes, and stacks
        every 10 seconds for outstanding allocations
./memleak -c "./allocs"
        Run the specified command and trace its allocations
./memleak
        Trace allocations in kernel mode and display a summary of outstanding
        allocations every 5 seconds
./memleak -o 60000
        Trace allocations in kernel mode and display a summary of outstanding
        allocations that are at least one minute (60 seconds) old
./memleak -s 5
        Trace roughly every 5th allocation, to reduce overhead

The pros of such tools: We don't need to rebuild our program, so it's handy for analyzing some online services.

---

Heapusage is a simple run-time tool for finding memory leaks on Linux and macOS. The output logging format for leaks is quite similar to Valgrind, but it only logs definite leaks (i.e. allocations not free'd at termination).

Full disclosure: I wrote Heapusage for usage in situations when Valgrind is inadequate (high performance applications, and also for CPU architectures not supported by Valgrind).