Assembly instruction level reverse execution for debugging

Akgul, Tankut; Mooney, Vincent J.

doi:10.1145/1018210.1018211

Cited by 14 publications

(20 citation statements)

References 23 publications

(32 reference statements)

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…A more sophisticated incremental inversion approach, due to Akgul and Mooney (2004), applies incremental inversion at the instruction level as an aid to debugging. In their approach, if a value x is destroyed in forward execution, the reaching definition of x can be reexecuted in the reverse code to restore it.…”

Section: Incremental Vs Region-based Inversion Methodsmentioning

confidence: 99%

See 1 more Smart Citation

The Backstroke framework for source level reverse computation applied to parallel discrete event simulation

Vulov

Hou

Quinlan

et al. 2011

Proceedings of the 2011 Winter Simulation Conference (WSC)

View full text Add to dashboard Cite

We introduce Backstroke, a new open source framework for the automatic generation of reverse code for functions written in C++. Backstroke enables reverse computation for optimistic parallel discrete event simulations. It is built over the ROSE open-source compiler infrastructure, and handles complex C++ features including pointers and pointer types, arrays, function and method calls, class types, inheritance, polymorphism, virtual functions, abstract classes, templated classes and containers. Backstroke also introduces new program inversion techniques based on advanced compiler analysis tools built into ROSE. We explore and illustrate some of the complex language and semantic issues that arise in generating correct reverse code for C++ functions. INTRODUCTIONBackstroke is a new open source framework for the automatic generation of reverse code for functions written in C++. It is built on ROSE, a widely used source-to-source compiler infrastructure that has been under development at Lawrence Livermore National Laboratory for a decade (Quinlan 2011). The primary purpose of Backstroke is to enable reverse computation for fast, efficient rollback in optimistic parallel discrete event simulations. Reverse computation is a well established technique now, but major practical barriers still prevent its widespread adoption. It is difficult to create correct and efficient reverse methods by hand, and unrealistic to require programmers to do so. Further, since the number of times an event is rolled back is unpredictable, simple bugs in reverse code frequently act as nondeterministic "Heisenbugs", making debugging very difficult. These considerations suggest automatic generation of reverse code (Perumalla 1999, Carothers, Perumalla, and. Backstroke takes this approach, but advances it considerably beyond prior systems. In particular, it can reverse more complex language constructs than prior work, since it applies to C++ rather than just C, and it serves as a general framework allowing experimentation with many different inversion techniques. We will describe some of the general approaches to automatic generation of reverse code, and explore language and semantic issues that arise in generating correct reverse code for C++ functions. CONTEXT AND RELATED WORKA parallel discrete event simulation (PDES) program consists of logical processes (LPs) that execute concurrently and exchange timestamped event messages. A synchronization algorithm is required to ensure each LP processes events in non-decreasing timestamp order. Optimistic synchronization uses rollback to undo the computation of events that are performed out of timestamp order (Jefferson 1985). Parallel discrete event simulation and optimistic execution are described in detail in (Fujimoto 2000). Reverse computation is a technique to efficiently implement event rollback (Carothers, Perumalla and Fujimoto, 1999;Tang Perumalla, and Fujimoto 2006, Naborskyy andFujimoto 2007). Each event routine is instrumented to save a minimal amount of control and data informat...

show abstract

Section: Incremental Vs Region-based Inversion Methodsmentioning

confidence: 99%

“…Here we borrow the terminology first proposed by Akgul and Mooney (2004). A restorative inversion method stores overwritten values, and later simply restores, without taking advantage of any mathematical relationships among them.…”

Section: Restorative Vs Regenerative Inversion Methodsmentioning

confidence: 99%

The Backstroke framework for source level reverse computation applied to parallel discrete event simulation

Vulov

Hou

Quinlan

et al. 2011

Proceedings of the 2011 Winter Simulation Conference (WSC)

View full text Add to dashboard Cite

show abstract

“…Akgul et al [3] provide an assembly language level reverse execution approach for the purposes of application debugging. Biswas and Mall [7] provide an reverse execution approach for purposes of debugging.…”

Section: Related Workmentioning

confidence: 99%

Lorain

LaPre

Gonsiorowski

Carothers

2014

Proceedings of the 2nd ACM SIGSIM Conference on Principles of Advanced Discrete Simulation

View full text Add to dashboard Cite

Automatic parallelization of models has been the"Holy Grail" of the PDES community for the last 20 years. In this paper we present LORAIN -Low Overhead Runtime Assisted Instruction Negation -a tool capable of automatic emission of a reverse event handler by the compiler. Upon detection of certain instructions, LORAIN is able to account for, and in many cases reverse, the computation without resorting to state-saving techniques. For our PDES framework, we use Rensselaer's Optimistic Simulation System (ROSS) coupled with the LLVM [18] compiler to generate the reverse event handler.One of the primary contributions of this work is that LO-RAIN operates on the LLVM-generated Intermediate Representation (IR) as opposed to the model, high-level source code. Through information gleaned from the IR, LORAIN is able to analyze, instrument, and invert various operations and emit efficient reverse event handlers at the binary code level.This preliminary work demonstrates the potential of this tool. We are able to reverse both the PHOLD model (a synthetic benchmark) as well as Fujimoto's airport model. Our results demonstrate that LORAIN-generated models are able to execute at a rate that is over 97% of hand-written, parallel model code performance.

show abstract

“…If the program counter is not within that predefined range, we stop the execution. The owner of the program under test inspects the instruction trace or reverse executes the program [3,4,5] to locate the offending instruction.…”

Section: Invalid Program Countermentioning

confidence: 99%

Hard-to-detect errors due to the assembly-language environment

Johnson

Pheanis

2007

2007 37th Annual Frontiers in Education Conference - Global Engineering: Knowledge Without Borders, Opportunities Without Passp

View full text Add to dashboard Cite

Most programming errors are reasonably simple to understand and detect. One of the benefits of a high-level language is its encapsulation of error-prone concepts such as memory access and stack manipulation. Assembly-language programmers do not have this luxury. In our quest to create automated error-prevention and error-detection tools for assembly language, we need to create a comprehensive list of possible errors. We are not considering syntax errors or algorithmic errors. Assemblers, simple testing, and automated testing can detect those errors. We want to deal with design errors that are direct byproducts of the assembly-language environment or result from a programmer's lack of understanding of the assembly-language environment. Over many years of assembly-language instruction, we have come across a plethora of errors. Understanding the different types of errors and how to prevent and detect them is essential to our goal of creating automated errorprevention and error-detection tools. In this paper we list and explain the types of errors we have cataloged.

show abstract

Assembly instruction level reverse execution for debugging

Cited by 14 publications

References 23 publications

The Backstroke framework for source level reverse computation applied to parallel discrete event simulation

The Backstroke framework for source level reverse computation applied to parallel discrete event simulation

Lorain

Hard-to-detect errors due to the assembly-language environment

Contact Info

Product

Resources

About