Question #4: Other Tools?

Have you used other tools that do similar things to some Valgrind skins? If so, how does Valgrind compare?

Another very messy question, unfortunately.

First, the easy answers:

no:                                                            18
no answer:                                                      5
no, because other tools wouldn't work due to env. limitations:  1

Now, a tool-by-tool breakdown. I list various things, except for tools with only one or two mentions, which I just give straight:
- Valgrind advantages
- other tool's advantages
- areas in which Valgrind and the other tool are equally good
- general non-comparative statements

Lots of people gave multiple comparisons. I show advantages rather than disadvantages; to do this, I inverted some descriptions (eg. "Purify is expensive" becomes "Valgrind not expensive").

Also, Purify is tricky because versions on different platforms differ substantially. So I've divided them up. If no platform was mentioned, I use a "(?)".

Purify first.

I think most of the (?) responses apply to the Solaris version, which seems to be clearly the best. A couple of people even said things like "I'm ignoring the Linux version, which is rubbish".

---------------------- Purify (Solaris) -----------------------------
Valgrind pros                      Purify pros
easier to run                5     lets DDD attach                        2
is faster                    2     errors easier to understand            1
not expensive                2     allows interactive leak checks         1
on x86                       2     easier to use                          1
is open-source               1     supports pool allocators better        1
on Linux (and doesn't suck)  1     docs better                            1
no horrible licence server   1     GUI good:                              2
text UI better than P's GUI  1     - can suppress errors interactively    1
                                   - can drill down through stack trace   1
                                   - can show code in window              1
                                   tracks fd's                            1
                                   tracks thread stack collisions 
                                   (badly, but better than nothing)       1
                                   handles ugly situations better 
                                   (maybe due to SPARC)                   1
                                   lets you set breakpoints               1
                                   detects a wider range of errors        1
                                   can summarise large numbers of errors  1
                                   can compare errors between runs        1

Equally good                       Non-comparative statements
find similar errors:         1     P very good:                           3
both good:                   1

---------------------- Purify (?) ---------------------------------
Valgrind pros                      Purify pros
easier to run               13     GUI is nicer                           8
is better                    7     faster                                 3
no horrible licence server   4     allows interactive leak checks         2
rocks! (implied comparison)  2     can say when uninit memory is copied   1
supports Linux               2     errors easier to understand            1
text UI better than P's GUI  2     more user-friendly                     1
purify "failed"              1     works on more platforms                1
more effective               1     gives spurious errors                  1
functionally better          1     checks stack variables                 1
is faster                    1     uses less memory                       1
uses less memory             1     can run code under P within GDB
easier to upgrade            1     (don't need to attach on each error)   1
finds bugs purify doesn't    1     handles non-Posix signals perfectly    1
not expensive                1     code coverage tool works at same time  1
has better tech support      1
is usable on really big apps 1
is not a pain (purify is)    1
finds free/mismatch errors   1

Equally good                       Non-comparative statements
both fall over sometimes     1     V's lack of GUI is not a problem       1
equivalent function          1     P's GUI is fancy                       1
similar errors               1
V is a good substitute       1
V compares well to P         1
do very comparable jobs      1

---------------------- Purify (Windows) ---------------------------
Valgrind pros                      Non-comparative statements
is better                    2     P doesn't work with Vis Studio, 
easier to run                2       C++ 2003.net                         1
no horrible licence server   1

---------------------- Purify (Linux) -----------------------------
Valgrind pros
is better                      3
doesn't suck (P on linux does) 2

Purify is clearly the most equivalent tool, and lots of people have used it, most on Solaris, I think. Valgrind compares pretty well.

Particular Valgrind strengths:

no recompilation
free
people hate the Purify license server; it is very restrictive and sometimes they can't use it on certain machines/networks

Particular Purify strengths:

GUI: some people don't mind V's text-based UI, but quite a few prefer a GUI.
Also, it gives some extra functions, eg. interactive suppression adding, interactive leak checking, displaying code.

No clear winner:

Speed: some say Valgrind is faster, some say Purify is faster.
Bug-finding: seem to find similar bugs.

Now for insure/insure++.

---------------------- insure ++ (?) -----------------------------
Valgrind pros               insure pros   
easier to run          3    "recompile" mode: more thorough        2
is better              2    "no recompile" mode: eager mode makes 
less bloaty            1      diagnosing uninit. errors easier     1
reports more reliable  1    has static checking                    1
                            identifies exact leaking instructions  1
equally good
V just as good         1

---------------------- insure ++ (linux) -------------------------
Valgrind pros                insure pros   
is better             1      is better                           1
easier to use         1      GUI nice for "normal" developers    2

---------------------- insure ++ (AIX) ---------------------------
Valgrind pros
easier to use         1

As for insure/insure++, Valgrind seems to run a bit better, but some people think insure's errors are better. Hard to say, not too conclusive.

Profilers: comparison against KCachegrind / Cachegrind

---------------------- Quantify (solaris) -------------------------
K/Cachegrind pros         Quantify pros        Non-comp. statements
K/C easier to use   1     Q faster     1       Q very good        2
K/C faster          1                          (no comment)       1

gprof:               K/C much better                          1
vtune:               faster than K/C, but crappy              1
pixie/ssrun(Irix):   K has better GUI, more flexible output   1
oprofile:            K quite different                        2
                     K has smaller learning curve             1
                     K is a good complement                   1
AQTime (profiling): (no comparison given)                     1

Generally, KCachegrind is well-liked.

---------------------- Electric Fence -----------------------------
Valgrind pros
better                    6
faster                    2
easier to use             2
gives more info           2
uses less memory          1
finds leaks               1
handles multi-threading   1

---------------------------- mpatrol -------------------------------
Valgrind pros
better                    1
faster                    1
gives more info           1
handles multi-threading   1

--------------------------- 3rd degree -----------------------------
Valgrind pros                       3rd degree pros
easier to use             1         3d faster                    1
                                    3d is 64-bit                 1

--------------------------- dmalloc --------------------------------
Valgrind pros
gives better info for finding bugs  2
easier to use                       2

---------------------- boundschecker (Windows) ---------------------
Valgrind pros
much better               2
on linux                  1

---------------- bcheck (a Solaris leak checker) -------------------
Valgrind pros                        bcheck pros
much better               1          V slower                      1

-------------------------- "Windows ones" --------------------------
Valgrind pros
better                               1
easier to use                        1
actually finds bugs don't find bugs  1
faster                               1

----------------------- custom leak checkers -----------------------
Valgrind pros                        clc pros 
requires no maintenance   1          faster                          1
                                     sometimes easier to use         1
Equally good
Each sometimes better, sometimes worse  1

--------------------- unknown (tool not named) ----------------------
Valgrind pros
V rocks! (implied comparison)  1
V not crap                     1
V not commercial               1

Not much to say here. Valgrind thrashes all of them, except Third Degree.

Single mentions

memprof:             V works (memprof didn't)           1
assure:              V faster                           1
HeapAgent (windows): V better, esp suppressions         1
"leak detectors":    V much better                      1
CodeGuard (windows): V would replace it, if on Windows  1
AIX debugger:        V much easier to run               1
glibc MALLOC_CHECK_  V catches 10x more bugs            1

Nothing much to say here.