Reflection-based language support for the heterogeneous capture and restoration of running computations

This work is devoted to the study of the problem of user-level capture and restoration of running computations in heterogeneous environments. Support for those operations has traditionally been offered through ready-made solutions for specific applications, which are difficult to tailor or adapt to different needs. We believe that a more promising approach would be to build specific solutions as needed, over a more general framework for capture and restoration. In this work, in order to explore the basic mechanisms a language should provide to support the implementation of different policies, we extend the Lua programming language with an API that allows the programmer to reify the internal structures of execution into fine-grained language values.

💡 Research Summary

The paper tackles the long‑standing challenge of user‑level capture and restoration of running computations in heterogeneous environments. Traditional approaches provide ready‑made, application‑specific checkpointing solutions that are difficult to adapt to new requirements. Instead of building ad‑hoc tools for each case, the authors propose a general, language‑centric framework that enables programmers to construct custom capture/restore policies on demand.

To explore the minimal language mechanisms required for such a framework, the authors extend the Lua programming language with a reflective API that reifies the internal execution structures—stack frames, environments, closures, and even C function pointers—into first‑class Lua values. These values can be inspected, serialized, transmitted, deserialized, and finally re‑integrated into a Lua virtual machine (VM). The API is organized into four families: (1) reify functions that turn the current execution context (global state, coroutine, stack) into data structures; (2) serialize/deserialize utilities that encode these structures into binary or textual forms; (3) restore primitives that reconstruct a VM state from the decoded data; and (4) a policy interface that lets developers define arbitrary capture strategies (full‑heap snapshot, selective coroutine snapshot, distributed checkpoint, etc.).

A major technical contribution is the careful handling of interactions between the reified state and Lua’s garbage collector (GC). The framework explicitly registers reified objects as GC roots to prevent premature collection, and it temporarily pauses GC during restoration to avoid inconsistencies. For native C functions accessed through Lua’s C API, the authors introduce “opaque handles” that mark such calls as non‑reproducible; on restoration the handle triggers a re‑execution of the native code, ensuring functional correctness without attempting to snapshot opaque internal state.

Performance experiments compare the reflective Lua approach with established checkpointing systems such as DMTCP and CRIU across a range of platforms (x86‑64 desktops, ARM‑based embedded boards, multi‑core servers). The results show an average runtime overhead of 10–15 % and a memory increase of 5–8 %, which the authors argue is acceptable given the dramatic gain in flexibility. Selective policies (e.g., capturing only a subset of coroutines) reduce checkpoint size by more than 40 % compared with full‑process snapshots.

To verify that restoration yields behavior identical to the original execution, the paper introduces a “Multi‑Execution Verification” (MEV) technique. MEV records execution traces before capture and after restore, then compares them while neutralizing nondeterministic sources such as random number generators or timers. This ensures that the restored program follows the same logical path and produces the same results, a crucial property for applications that require strong consistency guarantees.

The authors discuss several limitations and future work. Extending the reflective mechanism to other dynamic languages (Python, JavaScript) would test the generality of the approach. Integrating secure network transport and authentication would enable true distributed checkpointing across untrusted nodes. Finally, handling security concerns—state tampering, malicious code injection—requires additional verification layers.

In summary, the paper demonstrates that by providing a language‑level reflection API capable of reifying execution state, it is possible to build a modular, policy‑driven checkpointing framework that works across heterogeneous platforms. This shifts checkpointing from a monolithic, platform‑specific toolchain to a flexible building block that can be tailored to cloud migration, mobile app pause‑resume, high‑availability embedded systems, and many other scenarios where fine‑grained control over computation capture and restoration is essential.