SCARPE: A Technique and Tool for Selective Capture and Replay of Program Executions

@article{Joshi2007SCARPEAT,
  title={SCARPE: A Technique and Tool for Selective Capture and Replay of Program Executions},
  author={Shrinivas Joshi and Alessandro Orso},
  journal={2007 IEEE International Conference on Software Maintenance},
  year={2007},
  pages={234-243}
}
  • Shrinivas Joshi, A. Orso
  • Published 22 October 2007
  • Computer Science
  • 2007 IEEE International Conference on Software Maintenance
Because of software's increasing dynamism and the heterogeneity of execution environments, the results of in-house testing and maintenance are often not representative of the way the software behaves in the field. [] Key Method Our technique can be used for various applications, including generation of test cases from user executions and post-mortem dynamic analysis. We present our technique and tool, some possible applications, and a preliminary empirical evaluation that provides initial evidence of the…

Figures from this paper

Value-deterministic search-based replay for android multithreaded applications

TLDR
The technique records thread id and value of the shared variables accessed during program execution while during replay it searches thread space to generate the same value of shared variable which it observed while recording.

Repeatedly-executed-method viewer for efficient visualization of execution paths and states in Java

TLDR
REMViewer (Repeatedly-Executed-Method Viewer), or a tool that visualizes multiple execution paths of a Java method, is proposed, which shows each execution path in a separated view so that developers can firstly select actual execution path of interest and then compare the state of local variables in the paths.

Production Monitoring to Improve Test Suites

TLDR
Pankti, an approach which monitors applications as they execute in production and then automatically generates differential unit tests, as well as derived oracles, from the collected data, focuses on one single programming language, Java.

Chronicler: Lightweight recording to reproduce field failures

TLDR
Chronicler is presented, an approach to remote debugging that captures non-deterministic inputs to applications in a lightweight manner, assuring faithful reproduction of client executions.

VCR: Virtual Capture and Replay for Performance Testing

This paper proposes a novel approach to performance testing, called virtual capture and replay (VCR), that couples capture and replay techniques with the checkpointing capabilities provided by the

Activity-based Event Capture and Replay Technique for Reproducing Crashes in Android Applications

TLDR
This paper adapt the context-based capture and replay technique to Android applications by considering Android activity structure and its GUI characteristics, and uses probe code insertion based on AspectJ for minimizing the original code change and for enhancing the efficiency and reusability of the probe codes.

Toward generating reducible replay logs

TLDR
While traditional logging records only system calls and signals, this technique leverages the compiler to selectively collect additional information on the fly to reduce a replay log while retaining its ability to reproduce a failure.

Replay without Recording of Production Bugs for Service Oriented Applications

TLDR
Parikshan is an application monitoring framework that leverages user-space virtualization and network proxy technologies to provide a sandbox “debug” environment that allows developers to attach debuggers and analysis tools without impacting performance or correctness of the production environment.

SymCrash: selective recording for reproducing crashes

TLDR
A dynamic symbolic execution method called SymCon is proposed, which addresses the limitation of conventional symbolic execution by selecting functions that are hard to be resolved by a constraint solver and using their concrete runtime values to replace the symbols.

Monitoring, analysis, and testing of deployed software

  • A. Orso
  • Computer Science
    FoSER '10
  • 2010
TLDR
It is believed that the collection and analysis of field data can provide disruptive advances in the state of the art in software engineering and the research agenda that can help fulfill such vision is discussed.

References

SHOWING 1-10 OF 33 REFERENCES

Selective capture and replay of program executions

TLDR
A technique for selective capture and replay of program executions by selecting a subsystem of interest, capturing at runtime all the interactions between such subsystem and the rest of the application, and replaying the recorded interactions on the subsystem in isolation.

A Technique for Enabling and Supporting Debugging of Field Failures

  • J. ClauseA. Orso
  • Computer Science
    29th International Conference on Software Engineering (ICSE'07)
  • 2007
TLDR
A technique for recording, reproducing, and minimizing failing executions that enables and supports in- house debugging of field failures and an empirical study that evaluates the technique on a widely used e-mail client is presented.

jRapture: A Capture/Replay tool for observation-based testing

We describe the design of jRapture: a tool for capturing and replaying Java program executions in the field. jRapture works with Java binaries (byte code) and any compliant implementation of the Java

Leveraging field data for impact analysis and regression testing

TLDR
This paper investigates the use of the Gamma approach to support and improve two fundamental tasks performed by software engineers during maintenance: impact analysis and regression testing and presents a new approach that leverages field data to perform these two tasks.

Residual test coverage monitoring

  • C. PavlopoulouM. Young
  • Computer Science
    Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002)
  • 1999
TLDR
Experience with a prototype tool for residual test coverage monitoring of Java programs suggests that, at least for statement coverage, the simple strategy of removing all probes except those corresponding to the residue of coverage testing reduces execution overhead to acceptably low levels.

DejaVu: deterministic Java replay debugger for Jalapeño Java virtual machine

TLDR
This demo presents a debugger for the Jalapeño Java Virtual Machine that utilizes the replay capability provided by DejaVu (Deterministic Java Replay Utility), a deterministically replaying the execution behavior of a non-deterministic execution.

Deterministic replay of distributed Java applications

TLDR
This paper describes the issues and presents the design, implementation and preliminary performance results of distributed Deja Vu that provides deterministic replay of distributed Java applications running on multiple JVMs.

Debugging Concurrent Ada Programs by Deterministic Execution

A language-based approach to deterministic execution debugging of concurrent Ada programs is presented. The approach is to define synchronization (SYN)-sequences of a concurrent Ada program in terms

Replay for concurrent non-deterministic shared-memory applications

TLDR
An algorithm is presented, called the repeatable scheduling algorithm, combining scheduling and instruction counts to provide an invariant for efficient, language independent replay of concurrent shared-memory applications, shown to have trace overheads that are independent of the amount of sharing that takes place.

Profiling deployed software: assessing strategies and testing opportunities

TLDR
Analysis of 1,200 user sessions on a 155 KLOC deployed system substantiates the ability of field data to support test suite improvements, assesses the efficiency of profiling techniques for released software, and the effectiveness of testing efforts that leverage profiled field data.