Michiel Ronsse

RecPlay: a fully integrated practical record/replay system

This article presents a practical solution for the cyclic debugging of nondeterministic parallel programs. The solution consists of a combination of record/replay with automatic on-the-fly data race detection. This combination enables us to limit the record phase to the more efficient recording of the synchronization operations, while deferring the time-consuming data race detection to the replay phase. As the record phase is highly efficient, there is no need to switch it off, hereby eliminating the possibility of Heisenbugs because tracing can be left on all the time. This article describes an implementation of the tools needed to support RecPlay.

Record/replay for nondeterministic program executions

Controlling the nondeterministic features within multithreaded and highly responsive applications enables the continued use of all traditional software development techniques.

JaRec: a portable record/replay environment for multi-threaded Java applications

This paper describes JaRec, a portable record/replay system for Java. It correctly replays multi‐threaded, data‐race free Java applications, by recording the order of synchronization operations, and by executing them in the same order during replay. The record/replay infrastructure is developed in Java, and does not require a modification of the Java Virtual Machine (JVM) if it provides the JVM Profiler Interface (JVMPI). If the JVM does not support JVMPI, which is used for intercepting the loaded classes, only a minor modification to the JVM is required in order to run the system. On ystems with limited memory resources, JaRec can be executed in a distributed fashion. This also makes it suitable to aid debugging of multi‐threaded applications on embedded systems. Copyright

Rolt/sup MP/-replay of Lamport timestamps for message passing systems

Debugging nondeterministic parallel programs is rather difficult, because consecutive runs with the same input data may result in different executions. To overcome these problems for cyclic debugging, replay mechanisms based on trace driven simulation have been developed. As replay is based on a previously monitored program run, the overhead generated by the monitoring functionality is rather critical. It has to be small enough in order to keep the intrusion on the program as low as possible. An example of such a replay mechanism with low intrusion is the ROLT method, which was originally developed for shared memory systems. This method uses Lamport clocks to trace the order of accesses to shared objects. Although processes in message passing systems interact completely different, some ideas of ROLT are useful and can be ported to the distributed memory area. As a result an improved monitoring and replay approach with a lower overhead compared to other existing methods can be implemented.

MPL*: Efficient Record/Play of Nondeterministic Features of Message Passing Libraries

A major source of problems when debugging message passing programs is the nondeterministic behavior of the promiscuous receive and nonblocking test operations. This prohibits the use of cyclic debugging techniques because the intrusion caused by a debugger is often large enough to change the order in which processes interact. This paper describes the solutions we propose to efficiently record and replay the nondeterministic features of message passing libraries (MPL) like MPI or PVM. It turns out that for promiscuous receive operations it is sufficient to keep track of the sender of the message, and for nonblocking test-operations to keep track of the number of failed tests. The proposed solutions have been implemented for an existing MPI-library, and performance measurements reveal that the time overhead of both record and replay executions is very low with respect to the (nondeterministic) original execution while the size of the log files remains very small.

An efficient data race detector backend for DIOTA

Publisher Summary This chapter describes data race backend developed for DIOTA (Dynamic Instrumentation, Optimization and Transformation of Applications). DIOTA is generic instrumentation tool, and this tool uses so-called backend to use the information gathered using the instrumentation. Data race backend uses innovative technologies like multilevel bitmaps, snooped matrix clocks, and segment merging in order to limit the amount of memory used. The tool was implemented for Linux systems running on IA32 processors and is fully operational. In the future, if one wants to improve the speed of the data race backend in several ways, one technique is to remove redundant checks of addresses; once an address has been written to once in a segment, all subsequent read and write operations to the same address are irrelevant as far as data race detection is concerned. Therefore, it is possible to greatly optimize the instrumentation. Simple testing has shown that for e.g., the Mozilla web browser, 60% of the memory accesses use the same address as the previous memory access. Also when looking at loops, it is possible to move a lot of instrumentation code out of the loop body, e.g., the instrumentation of the write operations to loop counters.

Debugging shared memory parallel programs using record/replay

This paper presents a debugging aid for parallel program developers. The tool presented enables programmers to use cyclic debugging techniques for debugging non-deterministic parallel programs running on multiprocessor systems with shared memory. The solution proposed consists of a combination of record/replay with automatic on-the-fly data race detection. This combination enables us to limit the record phase to the more efficient recording of the synchronization operations, and checking for data races (using intrusive methods) during a replayed execution. As the record phase is highly efficient, there is no need to switch it off, hereby eliminating the possibility of Heisenbugs because tracing can be left on all the time.

JiTI : a robust just in time instrumentation technique

In this paper, we describe JiTI, a novel technique for instrumenting program binaries. The technique correctly deals with programs that contain traditionally hard to instrument features such as data in code, code in data, and self-modifying code. The technique does not require reverse engineering, program understanding tools or heuristics about the compiler or linker used. The basic is that a running process is cloned in memory, and that the cloned process is completely instrumented (code + data). By using the code of the instrumented process (clone) on the data of the original process, we can guarantee a correct instrumentation of the full code while keeping the process data untouched. JiTI has been completely implemented for SPARC processors and is used in a data race detector.

Clock snooping and its application in on-the-fly data race detection

In this paper, we describe clock snooping, a novel logical clock update technique that improves the performance of classical logical clocks (scalar clocks, vector clocks, as well as matrix clocks). The basic idea of clock snooping is that logical clocks will not only get updated with information piggybacked on communication messages, but that processes can explicitly request the current value of the clock of another process, and use that information to resynchronize their own clock. The usefulness of this concept is shown in our on-the-fly race detection software.

Detecting data races in sequential programs with DIOTA

In this paper we show that data races, a type of bug that generally only causes havoc in parallel programs, can also occur in sequential programs that use signal handlers. Fortunately, it turns out that adapting existing data race detectors to detect such bugs for sequential programs is straightforward. We present such a tool, and we describe the modifications that were necessary to detect data races in sequential programs. The experimental evaluation revealed a number of data races in some widely used programs.