Parallel discrete event simulation

Reviewer: Paul Adrian Luker

The devotion of this issue of Communications of the ACM to simulation attests to the increasing importance of simulation as a tool to help understand and manage our increasingly complex world. This special issue is also evidence of a recognition that simulation poses interesting problems for the computer scientist. For example, many simulationists are concerned with the integration of artificial intelligence techniques and traditional simulations, while others, in a quest for speed, are developing simulations for distribution over multiprocessor systems, or LANs. For papers like those in this issue, the reader would normally have to consult specialist publications, such as those of the Society for Computer Simulation, or the proceedings of simulation conferences. This collection has been produced from reworkings of papers presented at the 1989 Winter Simulation Conference, an annual conference that primarily addresses discrete event simulation. The collection was compiled, edited, and introduced by the program chair of the conference, Philip Heidelberger. The introduction is quite short and is little more than a (good) summary of each paper. My only major concern with the special issue is that it lacks the glue to hold the components together. Each paper is excellent in its own way, but the reader who is not familiar with discrete event simulation may not find it easy to put each contribution into its proper context. I would have liked to see a longer introduction that provided a general overview of discrete event simulation and led into each paper at the appropriate point. Further, the ordering of the papers shows no clear logic. L'Ecuyer's paper, for example, is germane to all discrete event simulations, while Fujimoto's paper addresses distributed simulation which, though very interesting, is at present relevant to fewer would-be simulationists. Richard Fujimoto's paper is by far the longest contribution to the special issue. A well-known and respected author in the area of distributed simulation, Fujimoto has here produced an excellent introduction to parallel discrete event simulation, beginning with a review of the nature of discrete event simulation (which may justify the paper's position in the vanguard). Typically, discrete event systems are asynchronous. The simulation is decomposed into a set of concurrent processes that may be mapped onto different processor configurations, loosely or tightly coupled, to achieve a speedup in performance. The parallelization is data-dependent and is certainly not amenable to techniques such as vector processing. Consequently, parallel discrete event simulation is seen as a model for distributed computation in general. For all discrete event simulations, the key problem is to process events in increasing simulation time (or timestamp) order. If this order is violated, then causality errors can arise, in which an event could affect a past event—clearly no more acceptable in the simulation than in the system being simulated. In parallel discrete event simulation, each real-world process is represented in the simulation by a logical process, which communicates with other processes by sending messages that represent future events. However the simulation is implemented, each logical process has to process events in increasing order of event time. Herein lies the challenge. Fujimoto discusses at some length the two basic mechanisms, conservative and optimistic, to meet this challenge. He follows the description of each method with an assessment of its performance and a critique. Conservative mechanisms, as the name implies, avoid causality errors by only processing an event when it is safe to do so. This requires blocking processes, which in turn can lead to deadlock. Fujimoto describes schemes for overcoming deadlock and discusses a number of approaches to performance optimization. Optimistic mechanisms detect causality errors after the fact and then recover from them, which involves “undoing” any damage. The author describes Time Warp, the best known optimistic method, along with variations and alternative and hybrid approaches. In sum, Fujimoto's paper will interest anybody who wants to speed up a discrete event simulation and anybody curious about parallel and distributed computation in general. The second paper, by Jain, Barber, and Osterfeld, describes a specific application of discrete event simulation: plant floor scheduling in computer integrated manufacturing. Although specific in focus, this contribution has a general interest in that it describes the integration of an expert system with simulation software. The expert system is used to capture the human scheduling expertise, while the simulation is used to produce schedules and identify decision points. The authors discuss the expert system component first. They assess the limitations of existing packages and make the case for using the expert system. When constructing the expert system, the authors had access to a good human expert, who, from the description given, seems to have been a knowledge engineer's dream. Their simulation component employs backward simulation, analogous to backward reasoning, which starts with the same goal state and moves backwards in time to the initial state. Such a method makes it easier to accommodate just-in-time scheduling. Compatibility between the two components was achieved through the use of object orientation. Specifically, KEE was used for the expert system and LISP for the simulation. Having explained the architecture of their system, the authors explain and illustrate its role on the factory floor. They conclude by discussing some of the advantages of their system, which will interest those who wish to combine expert systems and simulations. One of the problems cited is the difficulty of interfacing AI hardware with general-purpose hardware: in particular, the communication overhead can be prohibitive. Among the advantages listed are the ability to perform rapid prototyping with the expert system shell and the flexibility of the frame-based knowledge representation scheme used. The next paper describes another specific application, NEST. Once again, though, the architecture of the system is of general appeal. NEST is a graphical environment, embedded within UNIX, for the simulation and rapid prototyping of distributed, networked systems. It can be used to investigate such things as performance, fault tolerance, and protocols. The structure of the problem is described graphically, while algorithms (for routing or other protocols) are written in C. The results of the simulations are displayed graphically. The authors contrast the basic approach of NEST to what they call the “traditional approaches,” which are either language-based or model-based. In the former approach, the simulation is specified in its entirety using a simulation language. While this allows maximum generality, it separates modeling and simulation from the processes of design and development. It is also tedious and error-prone. The model-based approach, using special-purpose packages such as RESQ, is less flexible, only allowing a limited scope, but it can lead to excellent run-time efficiency. Language- and model-based systems both require expertise of the user. These disadvantages led the authors (and many other workers) to adopt an environment-based approach, which provides the user with a high level of support without requiring a lot of expertise. NEST's architecture is interesting—NEST is configured as a simulation server with client monitors. The client monitors, which utilize windows and menus, are used to create, edit, and configure simulations and display the results of their executions. It is possible to reconfigure a simulation during a run, which makes the system highly suitable for analyzing the effect of system failures. These monitors will, typically, reside on separate workstations. The communication overhead between client and server is low, so the server can support clients over a wide area network. Each node is represented in the simulation server by a lightweight process (or thread) within a single UNIX process. This leads to a maximization of concurrency and, thereby, efficient execution. The authors describe the synchronization of events and discuss the relationship between simulation time and real time (which harks back to some of Fujimoto's discussion). They give an example of a simulation of the Routing Information Protocol, developed at Xerox PARC and UC Berkeley. The paper ends with a summary of other applications and further discussion of the implementation of NEST. I enjoyed this paper, which contains some good, widely applicable ideas. The fourth paper, by Peter Glynn, is the most specific of the six, and will only be useful if you are interested in optimizing stochastic systems. Glynn describes a technique for Monte Carlo gradient estimation, which he claims is very efficient. He begins by describing and elaborating two scenarios that motivate the development of efficient gradient estimation techniques. He then describes the underlying nature of the technique, specializes it for discrete-time stochastic processes, and derives a treatment of continuous-time (but discrete-event) systems. The derivations of all formulae are shown, and examples demonstrate the wide applicability of the technique. Although Glynn's method assumes that the simulations terminate, the final section discusses the extension of likelihood ratio gradient estimation to steady-state performance measurement. Regenerative stochastic systems are well suited to the technique, but non-regenerative systems remain a subject of research. As L'Ecuyer himself states in the fifth paper, many people believe that the problem of generating uniform “random” numbers has long been solved—and in some respects it has. Good theoretical treatments have been published, and random number generators that have excellent statistical properties are available. Nevertheless, some generators that have terrible properties are in use. With dependence on simulation increasing, it is especially important that there be robust, reliable, efficient, and portable random number generators. This paper offers a useful overview of techniques that are relevant to today's requirements on machines ranging from laptops to supercomputers. L'Ecuyer gives a base definition of a pseudorandom number generator and discusses the assessment of such generators. He then presents a detailed treatment of (matrix) linear congruential generators, into which category the majority of available generators fit. The discussion is comprehensive, well structured, and clear. Among the important issues addressed is the generation of (well separated) subsequences, including vectorization techniques for simultaneous subsequence generation on parallel computers. The author then considers the programming of linear congruential generators and goes on to discuss their statistical properties. A brief section on nonlinear generators leads into a discussion of hybrid generators, which attempt to obtain the best of both the linear and nonlinear worlds—a long period without regular patterns. Everybody undertaking discrete event simulations should read this excellent treatment of current concerns and techniques in random generation. The bibliography is outstanding. The final paper describes a simulation of a semiconductor fabrication line. In such a production line, turnaround time is of vital importance because it affects contamination, yield, and costs. The process is too complex to yield entirely to analytical techniques, so simulation is the only methodology that can be applied to studying the dynamics of semiconductor manufacture. Miller explains the main variables of the production process and then provides details of the model and simulation. The chosen implementation language, SIMAN, quite rightly enforces a separation of the model specification from the specification of the experiment to be performed. The paper describes the structure of both components of the simulation as well as the verification and validation procedures. Although the model is for a specific plant, it has been applied to other semiconductor fabrication lines. As has been found for models of many types of production line, the simulation described here led to improved production characteristics without the need for retooling or additional resources.

Reviewer: Yi-Bing Lin

Recently there has been a great deal of interest in parallel discrete event simulation, and several survey articles on the execution of simulation models on parallel processors have appeared [1-4]. Fujimoto's survey covers most of the material in the previous papers and discusses current research directions in parallel simulation. The author shows that discrete event simulation is difficult to parallelize because of sequencing constraints. He then describes two basic approaches to parallel simulation, conservative and optimistic. The conservative mechanisms are the Chandy-Misra deadlock avoidance protocol, the Chandy-Misra deadlock detection and recovery protocol, synchronization operation, and the conservative time window. Fujimoto proposes three methods to improve the performance of the conservative mechanisms: exploiting lookahead, exploiting conditional knowledge, and exploiting network topology. The optimistic mechanisms are the Time Warp protocol and its variations—lazy cancellation, lazy reevaluation, optimistic time window, wolf calls, direct cancellation, and space-time. The paper examines the performance of both mechanisms and provides a critique and assessment. Fujimoto points out that an important application area that has not yet been adequately addressed by the parallel mechanisms is real-time applications. This paper provides insight into the problem of executing discrete event simulation programs on a parallel computer and indicates several directions for future research.