Nonblocking checkpointing for optimistic parallel simulation: description and an implementation

In an optimistic (time-warp) parallel simulation, local clocks with different logical processes must advance at the same rate in order to reduce the number of rollbacks. In this paper, we propose two algorithms for dynamic load balancing which reduce the number of rollbacks in an optimistic parallel discrete event simulation (PDES) system. The first algorithm is based on the load transfer mechanism between logical processes, while the second algorithm, which is based on the principle of an evolutionary strategy, migrates logical processors between several pairs of physical processors. We have implemented both of these algorithms on a cluster of heterogeneous workstations and studied their performance. The experimental results show that the algorithm based on the load transfer is effective when the grain size is larger than 10 ms, and the algorithm based on the process migration yields good performance for grain sizes of 20 ms or larger. In both of these cases, the average speed-up ranges between 1 and 2 using four processors, when the computation grain-size is within the range 7 to 50 ms. The reduction in rollback messages as a percentage of the total number of messages due to the algorithms is, however, around 4 to 8%.

Efficient computer simulation of complex physical phenomena has long been challenging due to their multiphysics and multiscale nature. In contrast to traditional time-stepped execution methods, the authors describe an approach using optimistic parallel discrete event simulation (PDES) and reverse computation techniques to execute plasma physics codes. They show that reverse computation-based optimistic parallel execution can significantly reduce the execution time of an example plasma simulation without requiring a significant amount of additional memory compared to conservative execution techniques. The authors describe an application-level reverse computation technique that is efficient and suitable for complex scientific simulations.

Parallel and distributed simulation techniques have been investigated in a number of studies as a way to decrease long execution times of personal communication system (PCS) simulations. However, most studies have omitted important issues in radio propagation in the simulations. Including these radio propagation issues makes it significantly more difficult to partition a PCS model efficiently. In this paper we consider parallel simulation of PCS models using time warp and focus on the partitioning issue. We compare base station based partitioning with channel based partitioning for an F/TDMA system. Analytical and experimental results on a shared memory multiprocessor indicate that for realistic parameters the partitioning per channel will significantly outperform the partitioning per base station.

Optimistic synchronization protocols for parallel discrete event simulation employ rollback techniques to ensure causally consistent execution of simulation events. Although event preemptive rollback (i.e. rollback based on timely event execution interruption upon the arrival of a message revealing a causality inconsistency) is recognized as an approach for increasing the performance and tackling run-time anomalies of this type of synchronization, the lack of adequate functionalities at the level of general purpose communication layers typically prevents any effective implementation of event preemptive rollback operations. In this paper we present the design and implementation of a communication layer for Myrinet based clusters, which efficiently supports event preemptive rollback operations. Beyond standard low latency message delivery funcbionalities, this layer also embeds functionalities for allowing the overlying simulation application to efficiently track whether a message will actually produce causality inconsistency of the currently executed simulation event upon its receipt at the application level. Exploiting these functionalities, awareness of the inconsistency precedes the message receipt at the application level, thus allowing timely event execution interruption for activating rollback procedures. We also report experimental results demonstrating the effectiveness of our solution for a Personal Communication System (PCS) simulation application.

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 using 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.

Stable simulation of conservation laws, such as those used to model fluid dynamics and plasma physics applications, requires the satisfaction of the so-called Courant-Friedrichs-Lewy condition. By allowing regions of the mesh to advance with different timesteps that locally satisfy this stability constraint, significant work reduction can be attained when compared to a time integration scheme using a single timestep size. However, parallelizing this algorithm presents considerable difficulty. Since the stability condition depends on the state of the system, dependencies become dynamic and potentially non-local. In this article, we present an adaptive local timestepping algorithm using an optimistic (Timewarp-based) parallel discrete event simulation. We introduce waiting heuristics to limit misspeculation and a semi-static load balancing scheme to eliminate load imbalance as parts of the mesh require finer or coarser timesteps. Last, we outline an interface for separating the physics of the specific conservation law from the temporal integration allowing for productive adoption of our proposed algorithm. We present a misspeculation study for three conservation laws, demonstrating both the productivity of the local timestepping API, for which 74% of the lines of code are reused across different conservation laws, and the robustness of the waiting heuristics—at most 1.5% of element updates are rolled back. Our performance studies demonstrate up to a 2.8× speedup versus a baseline unoptimized local timestepping approach, a 4x improvement in per-node throughput compared to an MPI parallelization of synchronous timestepping, and scalability up to 3,072 cores on NERSC’s Cori Haswell partition.

In this paper, the relationship between the computational models of object-oriented rewriting and parallel discrete-event simulation models is explored. A discrete-event simulation program in which several objects interact with each other by exchanging messages may have a high degree of concurrency (which can be exploited using optimistic or conservative parallel simulation methods). We report on some observations on using rewriting logic in the field of parallel discrete event simulations, and investigate how parallel simulation applications can be expressed using object-oriented rewriting.

In conventional parallel processing, the main objective of scheduling is to reduce the processor's idle time. However, in Time Warp (TW), which is an optimistic parallel discrete event simulation approach, keeping the processors busy does not necessarily lead to good performance, since the processors may be performing erroneous computations that must be eventually rolled back. Hence, the existing knowledge on scheduling is not easily transferable to TW simulations. The main objective of this work is to study the impact of scheduling policies on performance of TW. We compare a dynamic scheduling scheme with a static one. Our experimental results indicate that the dynamic policy reduces rollback costs for small shared memory multiprocessors.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Fine-Grained Parallel and Distributed Spatial Stochastic Simulation of Biological Reactions

There have been P2P systems with simultaneous millions of nodes on Internet. But existing simulators and techniques cannot simulate such a large scale. Even parallelized simulators have not solved the scale problem. They provide large memory and hold a large number of nodes but the speed of simulation degrades significantly than sequential simulation due to much overhead of inter-server synchronization. We propose a simulation technique for large-scale P2P systems based on an optimistic parallel discrete event simulation model. The technique employs low cost synchronization techniques that are effective for P2P simulation.

Edge computing provides a feasible technical solution to solve the problem of resource and energy supply constraints in terminal device deep learning applications. By migrating part of the deep learning application computing from the terminal to the cloud edge server, the computing pressure of the terminal device can be greatly relieved, and the energy consumption of the terminal can also be reduced to a certain extent. However, in the process of computing migration, the context switching loss of deep learning applications results in a long delay. This paper studies the problem of minimizing the completion time of deep learning applications under edge computing. We model the deep learning application as a task graph, and consider the constraints such as task switching delay, energy consumption and task dependency. Without changing the structure of the task graph, we transform it into a task scheduling-based application completion time minimization problem. In this paper, we first design a parallel scheduling algorithm based on greedy search. Considering the loss of context switching and the dependence of task data, we can allocate tasks to multiple processors for parallel processing by calculating the expected completion time of tasks, thus reducing the completion time of applications. Based on the experimental results, the greedy scheduling algorithm and comparison algorithm are analyzed and verified to optimize the completion time of different depth learning applications.

Research in parallel simulation has been around for more than two decades. However, the number of papers reporting on its application to real world problems is limited. At the 2002 PADS conference, researchers discussed the need to go beyond synchronization and performance issues, and, in particular, to demonstrate that parallel simulation could be used in real world applications outside military and network simulations. Since then, we have seen an increase in the number of papers on the parallel simulation applications in areas such as operations management and the physical sciences. This paper advocates the application of parallel simulation in population dynamics which is often used as the basis for policy planning and analysis. In this paper, we show how the simulation model is implemented using the μsik parallel simulation library. We conduct some experiments to measure the simulation performance. The result shows that good event parallelism can be achieved. 1

Parallel simulation has the potential to accelerate the execution of simulation applications. However developing a parallel discrete-event simulation from scratch requires an in-depth knowledge of the mapping process from the physical model to the simulation model, and a substantial effort in optimising performance. This paper presents an overview of the SPaDES (Structured Parallel Discrete-Event Simulation) parallel simulation framework. We focus on the performance analysis of SPaDES/C++, an implementation of SPaDES on a distributed-memory Fujitsu AP3000 parallel computer. SPaDES/C++ hides the underlying complex parallel simulation synchronization and parallel programming details from the simulationist. Our empirical results show that the SPaDES framework can deliver good speedup if the process granularity is properly optimised.

Research on cluster/distributed computing has been fueled by the availability of cost-effective workstations and high performance networks. Many parallel programming languages and related programming models have become widely accepted. However, the high communication overhead is a major problem of running parallel applications in cluster/distributed computing environments. To reduce the communication overhead and thus the completion time of a parallel application, this paper introduces and analyzes an efficient Key Message (KM) approach to supporting parallel computing in cluster environments. The approach includes the application model and communication model. The application model adopts a DAG (directed acyclic graph) task graph to abstract a parallel application. The communication model presents a priority-based M/M/l queue to analyze the communication delay. Then, with these fundamental models and assumptions, an analytical method is presented to verify the performance of the approach. It demonstrates that when the network background load increases or the computation to communication ratio decreases, the analysis results show a significant improvement on communication of a parallel application over the system which does not use the KM approach.

This paper presents the design, implementation and performance evaluation of a software fault manager for distributed applications. Dubbed Star, it uses the natural redundancy existing in networks of workstations to offer a high level of fault tolerance. Fault management is transparent to the supported parallel applications. To improve the response time of fault-tolerant applications, Star implements non-blocking and incremental checkpointing to perform an efficient backup of process state. Moreover, Star is application independent, highly configurable. Star actually runs on top of SunOs and is easily portable to UNIX™-like operating systems. The current implementation is based on independent checkpointing and message logging. Measurements show the efficiency and the limits of this implementation. The challenge is to show that a software approach to fault tolerance can efficiently be implemented in a standard networked environment.