Using Reversible Computation Techniques in a Parallel Optimistic Simulation of a Multi-Processor Computing System

Naborskyy, Andriy; Fujimoto, Richard M.

doi:10.1109/pads.2007.31

Cited by 6 publications

(4 citation statements)

References 28 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…A completely orthogonal technique for supporting consistency in case of a time-causality violation is reverse computation [5,12], which is based on the concept of reverse event codes, that are able to associate undo operations with the ones which produced changes in the simulation states with no (or little) history requirements. Therefore, whenever a previous simulation state must be restored, inverse events are executed, until the previous local virtual time associated with the target state is reached.…”

Section: Related Workmentioning

confidence: 99%

Cache-Aware Memory Manager for Optimistic Simulations

Vitali¹,

Pellegrini²,

Cerasuolo³

2012

Proceedings of the Fifth International Conference on Simulation Tools and Techniques

View full text Add to dashboard Cite

Parallel Discrete Event Simulation is a well known technique\ud for executing complex general-purpose simulations where\ud models are described as objects the interaction of which is\ud expressed through the generation of impulsive events. In\ud particular, Optimistic Simulation allows full exploitation of\ud the available computational power, avoiding the need to\ud compute safety properties for the events to be executed. Optimistic Simulation platforms internally rely on several data\ud structures, which are meant to support operations aimed\ud at ensuring correctness, inter-kernel communication and/or\ud event scheduling. These housekeeping and management operations access them according to complex patterns, commonly suﬀering from misuse of memory caching architectures. In particular, operations like log/restore access data\ud structures on a periodic basis, producing the replacement\ud of in-cache buﬀers related to the actual working set of the\ud application logic, producing a non-negligible performance\ud drop.\ud In this work we propose generally-applicable design principles for a new memory management subsystem targeted at\ud Optimistic Simulation platforms which can face this issue by\ud wisely allocating memory buﬀers depending on their actual\ud future access patterns, in order to enhance event-execution\ud memory locality. Additionally, an application-transparent\ud implementation within ROOT-Sim, an open-source generalpurpose optimistic simulation platform, is presented along\ud with experimental results testing our proposal

show abstract

Section: Related Workmentioning

confidence: 99%

Cache-Aware Memory Manager for Optimistic Simulations

Vitali¹,

Pellegrini²,

Cerasuolo³

2012

Proceedings of the Fifth International Conference on Simulation Tools and Techniques

View full text Add to dashboard Cite

show abstract

“…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 information before and during the forward execution to allow reconstruction of the state of the LP just prior to executing the event.…”

Section: Context and Related Workmentioning

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

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

“…Some recent advances [5,8,14] have shown the viability and effectiveness of optimistic state management via reverse computation, where a reverse version of application level simulation code is (automatically, or semiautomatically) generated and employed for backward computation just aimed at restoring the state of the simulation object. Anyway, in general simulation contexts (e.g., possibly exhibiting non-reversible execution paths), this approach still needs to be complemented via optimized log/restore techniques like the one we have presented in this work.…”

Section: Related Workmentioning

confidence: 99%

Di-DyMeLoR: Logging only Dirty Chunks for Efficient Management of Dynamic Memory Based Optimistic Simulation Objects

Pellegrini

Vitali

Quaglia

2009

2009 ACM/IEEE/SCS 23rd Workshop on Principles of Advanced and Distributed Simulation

View full text Add to dashboard Cite

A recent work has presented the design and implementation of a software library, named NONAME-LIB (name removed for blind review) supporting transparent log/restore facilities for optimistic simulation objects with generic memory layout. This library offers the possibility to allocate/deallocate memory chunks within the object state via standard API, and performs log/restore of the object state via pack/unpack techniques, exploiting ad-hoc meta-data concisely identifying the object state layout at each point in simulation time. In this paper we complement such a library with a software architecture offering the following additional advantages: (i) run-time identification of chunk updates within the dynamic memory map, (ii) reduced checkpoint latency and increased effectiveness in memory usage thanks to log/restore facilities based on (periodic) snapshots of the whole simulation object state, taken via the incremental copy of the modified (dirty) chunks only. Hence, Di-NONAME-LIB (Dirty-NONAME-LIB). Our approach is based on software instrumentation techniques (suited for LINUX and the ELF format), targeting memory update references performed by the application level software, and on a lightweight run-time monitoring mechanism providing minimal overhead while tracking the exact memory addresses and the size of memory areas dirtied by the execution of each event. Also, Di-NONAME-LIB has been designed for portability across 32-bits and 64-bits Intel compliant architectures, thus covering a wide spectrum of offthe-shelf machines. Some performance results for an evaluation of effectiveness and scalability of our proposal (vs the state size) are provided.

show abstract

Using Reversible Computation Techniques in a Parallel Optimistic Simulation of a Multi-Processor Computing System

Cited by 6 publications

References 28 publications

Cache-Aware Memory Manager for Optimistic Simulations

Cache-Aware Memory Manager for Optimistic Simulations

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

Di-DyMeLoR: Logging only Dirty Chunks for Efficient Management of Dynamic Memory Based Optimistic Simulation Objects

Contact Info

Product

Resources

About