Causal-Consistent Replay Debugging for Message Passing Programs

Abstract

Debugging of concurrent systems is a tedious and error-prone activity. A main issue is that there is no guarantee that a bug that appears in the original computation is replayed inside the debugger. This problem is usually tackled by so-called replay debugging, which allows the user to record a program execution and replay it inside the debugger. In this paper, we present a novel technique for replay debugging that we call controlled causal-consistent replay. Controlled causal-consistent replay allows the user to record a program execution and, in contrast to traditional replay debuggers, to reproduce a visible misbehavior inside the debugger including all and only its causes. In this way, the user is not distracted by the actions of other, unrelated processes.

Global Reproducibility Through Local Control for Distributed Active Objects

“…We believe we could benefit from their work to obtain more efficient trace representations. Lanese et al recently proposed a notion of causal-consistent replay based on reversible debugging [30], which enables replay to a state by only replaying its causal dependencies. Similar to our work, they also formalize record & replay for an actor language.…”

A Case Study for Reversible Computing: Reversible Debugging of Concurrent Programs

“…-Then, we instrument the standard semantics in different ways. On the one hand, we instrument it to produce a log of the computation; namely, by recording all actions involving the sending and receiving of messages, as well as the spawning of new processes (see [30] for more details). On the other hand, one can instrument the semantics so that the configurations now carry enough information to undo any execution step, i.e., a typical Landauer embedding.…”

“…The first line of research [20][21][22] (Sect. 3) supports backtracking (apart from some non relevant actions) for a concurrent imperative language with shared memory, while the second line of research [28][29][30]36] (Sect. 4) supports causal-consistent reversibility for a core subset of the functional messagepassing language Erlang.…”

Software and Reversible Systems: A Survey of Recent Activities

“…To solve this problem, the research studied techniques for tracing a computation and replay it inside the debugger. This lead to the definition of a new form of replay, called causal-consistent replay [43], which allows one to redo a future event of a traced computation, including all and only its causes. One can notice that causal-consistent reversibility and causalconsistent replay are dual, and together they allow one to explore a wrong computation back and forward, always concentrating on events of interest.…”