Stabilizers: Safe Lightweight Check- pointing for Concurrent Programs

A checkpoint is a mechanism that allows program execution to be restarted from a previously saved state. Checkpoints can be used in conjunction with exception handling abstractions to recover from exceptional or erroneous events, to support debugging or replay mechanisms, or to facilitate algorithms that rely on speculative evaluation. While relatively straightforward in a sequential setting, for example through the capture and application of continuations, it is less clear how 6 ascribea meaningful semantics for lightweight and safe check~oints in the Dresence of concurrency. For a thread to correctly resume execution fmm a saved checkpoint, it must ensure that all other threads which have witnessed its unwanted effects after the checkpoint was established are also reverted to a meaningful earlier state. If this is not done, data inconsistencies and other undesirable behavior may result. However, automatically determining what constitutes a consistent global state is not straightforward since thread interactions are a dynamic property of the program; requiring applications to specify such states explicitly is not pragmatic if interactions are complex. In this paper, we present a safe and efficient on-the-fly checkpointing mechanism for concurrent programs. We introduce a new abstraction called stabilizers that permits the specification and restoration of globally consistent checkpoints. This state is computed through lightweight monitoring of communication events among threads (e.g., message-passing operations or updates to shared variables). Our implementation results show that the memory and computation overheads for using stabilizers on highlyconcurrent server applications is small, averaging roughly 4 to 6%, leading us to conclude that stabilizers are a viable abstraction for defining restorable checkpoint state in complex concurrent programs.