Linux reversible debugger now runs code 10 times faster.
Feb 27th, 14:08 UTC
Undo Software has released a new version of UndoDB: the first and only debugger that can step Linux applications backwards, as well as forwards. The new version is able to run code 10 times faster than before, and also supports attaching to a running program.
Undo Software has released a new version of UndoDB: the first and only debugger
that can step Linux applications backwards, as well as forwards.
The tool allows developers to step their programs backwards, either line-by-line
or to any time in its history.
Traditional debuggers have been in widespread use for decades, allowing the
developer to stop his program and peer inside. The program can then be started
again, and may be inched forwards an instruction or more at a time. These tools
have their uses, but they are unable to tell the developer what their program
has done previously. UndoDB is a new breed of debugger -- a reversible
debugger -- allowing the developer to pause a running program and inspect
its state not just at that moment, but at any point in the past. The program can
be stepped back a single instruction, or a larger amount of time, giving the
developer much more information to help diagnose the cause of the bug.
A software developer hunting down an elusive bug must think like a detective at
a murder scene. His program has done something unexpected, and he must piece
together scraps of evidence to deduce what really happened, and why.
UndoDB is a tool as powerful for the developer as detailed video footage of the
crime would be for the detective. For the first time, the developer can wind
his program back and forth, like a detective whizzing the video back and forth,
and then stepping forwards and backwards frame-by-frame to discover what really
happened. The result is that bugs which took weeks to fix can now take just
minutes. Literally.
Jacob Rideout works on the KDE project for Linux. He says of UndoDB:
"I found the idea of [the]
product amazing and a boon to my productivity ... I already have been able to
fix a deadlock that was driving me crazy for a week in only 10 minutes".
Debugging is so difficult because once the bug occurs the program often
continues to run for some time before it visibly goes wrong. The developer is
left staring at his crashed program, trying to guess at exactly what point
it started to go wrong. Since computers execute billions of instructions
every second, this is like finding the proverbial needle in a haystack. It's a
process of repeated trial-and-error, making tiny changes and re-running the
program to try to nail down the root-cause of the problem. If the developer is
lucky his program follows the same path each time he re-runs it. If not things
are even more difficult, and some bugs become almost impossible to fix. The
move to multicore processors compounds these issues still further. This is why
even companies with the resources of Microsoft can find their projects slipping
embarrassingly late, and it's why software is so often full of bugs when it is
finally released. NIST estimates that bugs represent 80% of the cost of software
development, at a cost to the US economy of $60bn per year [1].
UndoDB effectively lets the developer wind back time. Now when confronted
by his crashed program, he can just "rewind the tape" to find out exactly what
happened. He can whizz backwards and forwards, homing in on the exact moment
it all went wrong. No more guess-work, no more trial-and-error, and no more
endless re-running of the program with fingers crossed.
With the latest version of UndoDB (version 2.2), the tool is now even more
powerful. It can run programs 10 times faster than before, saving developers
even more time. Previous versions of UndoDB provided the power of reversible
debugging at a price. When a program was run under the debugger, it would run
forwards rather slowly -- up to 70 times slower than normal. With UndoDB
version 2.2 that slow-down has been reduced more than tenfold to around 6 or 7
times. In addition, version 2.2 allows the debugger to be attached to an
already-running program. Together, these two features mean that UndoDB is now
much more practical for use on long-running programs.
Reversible debugging is so powerful because it gives the user control over
time. To debug a program is to reason backwards from the point of
failure to determine the cause of that failure. On the first page of their
book, The Practice of Programming, Brian Kernighan and Rob Pike (two of
the pioneers of modern computer programming) give the following advice to
programmers when debugging:
Reason back from the state of the crashed program to
determine what could have caused this. Debugging involves backwards reasoning,
like solving murder mysteries. Something impossible occurred, and the only solid
information is that it really did occur. So we must think backwards from the
result to discover the reasons.
With this analogy, a programmer using a reversible debugger is like the
detective finding detailed video footage of a murder and everything leading up
to it.
UndoDB uniquely enables reversible debugging of arbitrary Linux
binary programs, including those written in C or C++. UndoDB requires no
recompilation or other modifications to the program being debugged, nor does it
require any specialized hardware, kernel patches, or kernel modules.
Although UndoDB is not open source, developers who don't get paid for
their work can use UndoDB for free. For professional use, UndoDB
costs between $195 and $495 per seat. There is also a free 30-day evaluation
version. UndoDB 2.2 is available now, from http://undo-software.com/.
###
References
[1] NIST --
Software Errors Cost U.S. Economy $59.5 Billion Annually
http://www.nist.gov/public_affairs/releases/n02-10.htm.
(Submitted by Greg Law of support@undo-software.com)
| 
