UndoDB is unique in that it is able to record with low overheads and without restriction on CPU make/model, execution environment (e.g. AWS), and comes with a host of features, including support for shared memory, deferred recording, live reversible debugging, attaching to a running process, and many more.
No. UndoDB can be used from various frontends e.g. Emacs, Eclipse, DDD or from the command line. This means UndoDB can be integrated into your developers’ existing workflow, making it quick and easy to get up and running.
UndoDB works on any Linux distro with kernel 2.6 or later, on ARM or x86. UndoDB also supports Android (Native) on ARM.
The number of lines of source is not directly relevant to UndoDB. Instead, it’s the size of the resulting program and its data that matters. We have customers that use UndoDB on programs that consume more than 100GB of memory.
No – UndoDB is for user-mode code only.
During record mode, the effects of all non-deterministic operations, including all system calls, thread-switches, signals and shared memory accesses, are stored in an event log. During replay, non-deterministic events are not performed directly, but their effects are synthesized based on the contents of the event log.
Yes. However, when debugging using traditional tools, it’s often necessary to restart the program multiple times. UndoDB saves time because you can go backward and forward as often as you need without having to restart. For a further speedup it’s possible to defer the start of recording until later in the program’s execution.
No, replaying process is self-contained and does not re-execute system calls. From outside (except via the debugger), the process appears to have frozen at the moment the recording stopped.
No, you can’t go back in time to change history. The reason is that in replay mode your application is disconnected from the outside world. Consider a webserver sending a page on a socket. If you go back to mid-way through the page’s transmission, change something and attempt to begin a new recording from that point, the webserver would send the second half of the page twice, very likely confusing the other end of the socket.
Yes, although your debug experience will be the same as using regular debuggers on optimised code.
Yes, you can ship or deploy a Live Recorder enabled application without debug information. Load the recording and point at a version of the binary with the debug information to get full source-level debugging.
Live Recorder typically causes programs to experience a 2-3x slowdown. This can be more or less, depending on the individual situation.
Spatial requirements vary hugely depending on the program, but typically a few megabytes per second of recording.
Yes. Live Recorder uses a circular event log so old history is discarded. Due to the performance overheads however, most of our customers do not run their programs with Live Recorder always on, but have a way to enable or disable recording as required.
Yes. As long as both the record and replay machines are running Linux and use the same CPU architecture, it's fine. However, you can't replay ARM recordings on x86. Live Recorder is not a simulator, so your replay machine CPU must support all of the instructions used on the recording machine. E.g. if your program uses AVX instructions when the recording is made then you must replay on a machine with a CPU that has AVX support.
Live Recorder is enabled simply by calling the undodb_recording_start() function.
Yes. Just by calling the undodb_recording_stop() function.
The recording is saved to a file on the local filesystem. The recording is generated when you call the undodb_save() function, or, if so-configured, when the program terminates.
The recording contains the program starting state, all non-determinstic inputs, any debug information files and all libraries used by the program are all contained in the recording. It is completely self-contained.