Capturing High-level Nondeterminism in Concurrent Programs for Practical Concurrency Model Agnostic Record & Replay

@article{Aumayr2021CapturingHN,
  title={Capturing High-level Nondeterminism in Concurrent Programs for Practical Concurrency Model Agnostic Record \& Replay},
  author={Dominik Aumayr and Stefan Marr and Sophie Kaleba and Elisa Gonzalez Boix and Hanspeter M{\"o}ssenb{\"o}ck},
  journal={Art Sci. Eng. Program.},
  year={2021},
  volume={5},
  pages={14}
}
With concurrency being integral to most software systems, developers combine high-level concurrency models in the same application to tackle each problem with appropriate abstractions. While languages and libraries offer a wide range of concurrency models, debugging support for applications that combine them has not yet gained much attention. Record& replay aids debugging by deterministically reproducing recorded bugs, but is typically designed for a single concurrency model only. This paper… 
View PDF on arXiv
1 Citations

One Citation

Shortening Feedback Loops in a Live Game Development Environment
TLDR
A live game development environment providing a more general live programming workflow in game prototyping, and several mechanisms to work with the running game, for example, programmers can automatically replay situations in the game by using an explicit notion of snapshots.

References

SHOWING 1-10 OF 39 REFERENCES
A concurrency-agnostic protocol for multi-paradigm concurrent debugging tools
TLDR
A concurrency-agnostic debugger protocol is proposed that decouples the debugger from the concurrency models employed by the target application, and the underlying language runtime can define custom breakpoints, stepping operations, and execution events for each concurrency model it supports, and a debugger can expose them without having to be specifically adapted.
Efficient and deterministic record & replay for actor languages
TLDR
This work presents a low-overhead record & replay approach for actor languages that allows one to debug concurrency issues deterministically based on a previously recorded trace, and takes a first step towards deterministic replay debugging of actor systems in production.
Multiverse Debugging: Non-Deterministic Debugging for Non-Deterministic Programs (Brave New Idea Paper)
TLDR
Multiverse debugging is proposed, a new approach for debugging non-deterministic programs that allows developers to observe all possible execution paths of a parallel program and debug it interactively, and a proof of non-interference is provided, i.e., it is proved that observing the behavior of a program by the debugger does not affect thebehavior of that program and vice versa.
Why Do Scala Developers Mix the Actor Model with other Concurrency Models?
TLDR
This study is the first to point out the phenomenon of mixing concurrency models by Scala developers and to systematically identify the factors leading to it, and reveal two reasons for mixing that can be influenced by researchers and library-builders: weaknesses in the actor library implementations, and shortcomings of the actor model itself.
Engineering Record and Replay for Deployability
The ability to record and replay program executions with low overhead enables many applications, such as reverse-execution debugging, debugging of hard-toreproduce test failures, and “black box”…
Understanding Real-World Concurrency Bugs in Go
TLDR
This study performs the first systematic study on concurrency bugs in real Go programs and provides a better understanding on Go's concurrency models and can guide future researchers and practitioners in writing better, more reliable Go software and in developing debugging and diagnosis tools for Go.
Efficient and thread-safe objects for dynamically-typed languages
TLDR
A language-agnostic and thread-safe object model is designed that maintains the efficiency of sequential approaches by ensuring that field reads do not require synchronization and field updates only need to synchronize on objects shared between threads.
Debugging Parallel Programs with Instant Replay
TLDR
This paper presents a general solution for reproducing the execution behavior of parallel programs, termed Instant Replay, which provides for replay of an entire program, rather than individual processes in isolation.
iReplayer: in-situ and identical record-and-replay for multithreaded applications
TLDR
The novel in-situ and identical replay of iReplayer makes it more likely to reproduce errors, and allows it to directly employ debugging mechanisms (e.g. watchpoints) to aid failure diagnosis.
An Empirical Study of Messaging Passing Concurrency in Go Projects
  • Nicolas DilleyJ. Lange
  • Computer Science
    2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER)
  • 2019
TLDR
This paper analyzes 865 Go projects from GitHub in order to understand how message passing concurrency is used in publicly available code and finds that message passing primitives are used frequently and intensively.
...
...