Recording shared memory dependencies using strata

Abstract

Significant time is spent by companies trying to reproduce and fix bugs. BugNet and FDR are recent architecture proposals that provide architecture support for deterministic replay debugging. They focus on continuously recording information about the program's execution, which can be communicated back to the developer. Using that information, the developer can deterministically replay the program's execution to reproduce and fix the bugs.In this paper, we propose using Strata to efficiently capture the shared memory dependencies. A stratum creates a time layer across all the logs for the running threads, which separates all the memory operations executed before and after the stratum. A strata log allows us to determine all the shared memory dependencies during replay and thereby supports deterministic replay debugging for multi-threaded programs.

Rerun: Exploiting Episodes for Lightweight Memory Race Recording

“…Fortunately, recent work has proposed hardware support for multithreaded deterministic replay, in general, and, memory race recording, in particular [25,26,39,40]. These systems log the outcome of memory races as they occur.…”

“…Hardware vendors would like to see this state reduced, in part, because it is cost paid even when recording is disabled. Strata [25] reduces this state, performs well for four-core systems, but, suffers a substantial increase in per-core log sizes as the number of cores per system grows (Section 5).…”

A practice-driven systematic review of dependency analysis solutions

“…Debugging is looking for the anomalies in the code, which are syntactic patterns that evidence a programming error or irrespective use of the language specification, e.g., using a variable before it has been defined. Dependency analysis supports debugging for looking for various kinds of anomalies in program statements (Podgurski and Clarke 1990), bug introduction in C/C++ programs (Bohnet et al 2009), replay debugging for multi-threaded programs (Narayanasamy 2006), and even debugging of aspect-oriented software (Ishio et al 2004). …”

“…Then, the solutions analyze the repositories using data-mining algorithm, statistical analysis, (Agarwal et al 2004;Brown et al 2001;Gupta et al 2003;Li et al 2005b). Other solutions use hardware-based monitoring mechanisms to capture shared memory dependencies for supporting debugging activities (Narayanasamy 2006).…”

Quantifying the Potential of Program Analysis Peripherals

“…Furthermore, there is demand for even more complex tools that detect concurrency bugs such as data races [27] and atomicity violations [13], [11], [26], or record shared memory dependencies for later playback as in Strata [18]. HARD [40] proposes tightly integrated hardware acceleration of the lockset based race detection algorithm with 16 bit tags for cache lines and additional logic to update the tags.…”