Valgrind 2.2.0: Memory Debugging and Profiling

For tracking down memory leaks and other performance issues, the ease and flexibility of Valgrind may make up for slow runtimes.

Memory and performance problems plague most of us, but tools are available that can help. One of the best, most powerful and easiest to use is Valgrind. One thing stands out when you use Valgrind--you do not need to recompile, relink or modify your source code. Valgrind is an open-source project available under the GPL 2 license.

Valgrind works on all x86 systems and is being adapted to run on the PowerPC architecture. It works with all major Linux distributions. Valgrind's benefits include:

  • Dynamic binary translation so you don't need to modify, recompile or relink your applications.

  • Able to debug and profile large and complex programs.

  • Usable on almost any kind of software written in any language.

  • Works with the entire program, including libraries.

  • Usable with other tools, such as GDB.

  • Works as a platform for writing and testing new debugging tools.

Also, Valgrind is maintained actively.

Feature Set

The Valgrind distribution includes five major tools that are tightly integrated into the Valgrind core: Memcheck, Addrcheck, Cachegrind, Massif and Helgrind. Memcheck detects the following problems:

  • Use of uninitialized memory.

  • Reading/writing memory after it has been freed or deleted.

  • Reading/writing off the end of malloced or new blocks.

  • Reading/writing inappropriate areas on the stack.

  • Memory leaks--where pointers to memory blocks are lost forever.

  • Passing uninitialized and/or unaddressable memory to system calls.

  • Mismatched use of malloc/new/new[] vs free/delete/delete[].

  • Overlapping src and dst pointers in memcpy() and related functions.

  • Some misuses of the POSIX pthreads API.

When Memcheck is run:

  • All memory reads and writes are checked.

  • All calls to malloc/new/free/delete are instrumented.

  • Immediate error reporting happens, giving source line number, if possible.

  • Function stack tracing shows how the error line was reached.

  • Tracks are addressable at the byte-level and initialization of values at the bit-level. So Valgrind detects the use of single uninitialized bits and does not report spurious errors on bitfield operations.

  • It runs programs about 10--30x slower than normal.

Addrcheck is a lightweight version of Memcheck. It does not check for uninitialized data. The tradeoff is that Addrcheck detects fewer errors than Memcheck but runs about twice as fast (about 5--20x slower than normal). Also, a lot less memory is used. This means programs can be run for longer and cover more test scenarios. And Valgrind still finds a lot of important bugs in this mode. The authors suggest that you use Addrcheck most of the time for finding memory bugs, and occasionally use Memcheck for more thorough checking.

Cachegrind is a cache profiler. It simulates the I1, D1 and L2 caches in your CPU and pinpoints the sources of cache misses in your code. It identifies the number of cache misses, memory references and instructions executed for each line of source code, with per-function, per-module and whole-program summaries. It is useful with programs written in any language. Cachegrind runs programs about 20--100x slower than normal.

Massif is a heap profiler. It performs detailed heap profiling by taking regular snapshots of a program's heap. It produces a graph showing heap usage over time, including information about which parts of the program are responsible for the most memory allocations. The graph is supplemented by a text or HTML file that includes more information for determining where the most memory is being allocated. Massif runs programs about 20x slower than normal. Massif was introduced in version 2.1.1 of Valgrind.

Helgrind is a thread debugger that finds data races in multithreaded programs. It looks for memory locations accessed by more than one (POSIX p-)thread but for which no consistently used (pthread_mutex_)lock can be found. Such locations are indicative of missing synchronization between threads and could cause hard-to-find timing-dependent problems. It is useful for any program that uses pthreads. It is experimental, so the authors really welcome your feedback here.

Additional Tools

To make Valgrind even easier to use or to extend its functionality, a number of other tools are available, including Kcachegrind, an extension to Cachegrind that provides more data about call graphs. Its visualization tool also gives a much better overview of the data it collects. There also are patches for vgprof, a Valgrind tool, that profiles in the same manner as gprof but doesn't require recompilation. It works with threaded programs and can profile shared libraries. Several experimental tools also are available, including a memory access tracer, a pointer misuse-checker and a signal-handler checker. Another patch for Valgrind adds watch points on memory locations.



Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Valgrind is cool

Andre Adrian's picture

Valgrind is cool. It is very easy to use and very powerful. The programs run quite slow and sometimes I do simplify the computing intensive algorithms to be able to run my real-time applications under valgrind, but again: Valgrind is cool.

Andre Adrian
Senior Engineer

Valgrind is cool

Anonymous's picture

I could not have said it better myself (as a matter of fact, I didn't :-)).

Reg. Charney