Analyzing Data Dependencies for Increased Parallelism in Discrete Event Simulation

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

Loops are the main source of parallelism in scientific programs. Hence, several techniques were developed to detect parallelism in these loops and transform them into parallel forms. In this dissertation, compile time transformations and efficient parallel execution of loops with various type of dependencies are investigated. First, Doacross loops with uniform dependencies are considered for execution on distributed memory parallel machines (multicomputers). Most known Doacross loop execution techniques can be applied efficiently only to shared memory parallel machines. In this thesis, code reordering technique, improvements to partitioning strategies, and finding a balance between communication and parallelism are presented to reduce the execution time of Doacross loops on multicomputers. As with most parallelizing transformation techniques, only single loopnests are considered in the first part of this dissertation. However, parallelizing each loopnest in a program separately, even if an optimal execution can be obtained for each loopnest, may not result in an efficient execution of all the code in the program because of communication overhead across the loops in a multicomputer environment. Hence, across loop data dependence representation and analysis are introduced in this work to improve the parallel execution of the whole code. Our contribution consists of finding and representing data dependencies whose sources and destinations are subspaces of the iteration space mainly common across the loops. This type of dependence information is used in this thesis to improve global iteration space partitioning, automatic generation of communication statements across loops, and index alignment. The final part of this dissertation presents new parallelizing techniques for loops with irregular and complex dependencies. Various data dependence analysis algorithms can be found in the literature even for loops with complex array indexing. However, the improvement in data dependence testing has not been followed by similar amelioration in restructuring transformations for loops with complex dependencies. Such loops are mostly executed in serial mode. Our parallelizing techniques for these loops consists of identifying regions of the iteration space where all iterations can be executed in parallel. The advantages of all the transformations presented in this dissertation are: (1) they significantly reduce the execution time of loops with various types of dependencies as shown in this work using the MasPar machine (2) they can be implemented at compile, time which makes the task of parallel programming easier.

The Discrete Event Simulation (DES) process interaction world view describes models that focus on simulated entities that progress through a series of temporally related activities. DES formalisms and vendor approaches for representing DES models serve as a basis for developing an open neutral representation of models that can be encoded into ontologies. This paper reviews world views, formal foundations, and ontologies as background. The process for creating ontologies for the process interaction DES domain is discussed. Next an approach to ontology based simulation model representation is presented and last conclusions and recommendations for future work are provided.

To increase and maintain web application security, developers could use some different methods, one of them is static code analysis. This method could find security vulnerabilities inside a source code without the need of running the program. It could also be automated by using tools, which considered more efficient than manual reviews. One specific method which is commonly used in static code analysis is taint analysis. Taint analysis usually utilizes source code modeling to prepare the code for analysis process to detect any untrusted data flows into security sensitives computations. While this kind of analysis could be very helpful, static code analysis tool for Laravel-based web application is still quite rare, despite its popularity. Therefore, in this research, we want to know how static code (taint) analysis could be utilized to detect security vulnerabilities and how the projects (Laravel-based) should be modeled in order to facilitate this analysis. We then developed a static analysis tool, which models the application’s source code using AST and dictionary to be used as the base of the taint analysis. The tool first parsed the route file of Laravel project to get a list of controller files. Each file in that list would be parsed in order to build the source code representation, before actually being analyzed using taint analysis method. The experiments was done using this tool shows that the tools (with taint analysis) could detect 13 security vulnerabilities from 6 Laravel-based projects with one False Negative. An ineffective sanitizer was the suspected cause of this False Negative. This also shows that proposed modeling technique could be helpful in facilitating taint analysis in Laravel-based projects. For future development and studies, this tool should be tested with more Laravel and even other framework based web application with a wider range of security vulnerabilities.

The large number of industrial control systems based on PLCs (Programmable Logic Controllers) available at CERN implies a huge number of programs and lines of code. The software quality assurance becomes a key point to ensure the reliability of the control systems. Static code analysis is a relatively easy-to-use, simple way to find potential faults or error-prone parts in the source code. While static code analysis is widely used for general purpose programming languages (e.g. Java, C), this is not the case for PLC program languages. We have analyzed the possibilities and the gains to be expected from applying static analysis to the PLC code used at CERN, based on the UNICOS framework. This paper reports on our experience with the method and the available tools and sketches an outline for future work to make this analysis method practically applicable.

Java is a very promising language for use in the simulation of physical models due to its object-oriented nature, portability, robustness and support for multithreading. This paper presents JWarp, a Java library for discrete-event parallel simulations. It is based on an optimistic model for synchronization of the simulation entities: the Time Warp mechanism. We introduce the main features of the library and discuss some of the implementation details. © 1998 John Wiley & Sons, Ltd.

Discrete Event Simulation (DES) is a widely used technique in which the state of the simulator is updated by events happening at discrete points in time (hence the name). DES is used to model and analyze many kinds of systems, including computer architectures, communication networks, street traffic, and others. Parallel and Distributed Simulation (PADS) aims at improving the efficiency of DES by partitioning the simulation model across multiple processing elements, in order to enabling larger and/or more detailed studies to be carried out. The interest on PADS is increasing since the widespread availability of multicore processors and affordable high performance computing clusters. However, designing parallel simulation models requires considerable expertise, the result being that PADS techniques are not as widespread as they could be. In this paper we describe ErlangTW, a parallel simulation middleware based on the Time Warp synchronization protocol. ErlangTW is entirely written in Erlang, a concurrent, functional programming language specifically targeted at building distributed systems. We argue that writing parallel simulation models in Erlang is considerably easier than using conventional programming languages. Moreover, ErlangTW allows simulation models to be executed either on single-core, multicore and distributed computing architectures. We describe the design and prototype implementation of ErlangTW, and report some preliminary performance results on multicore and distributed architectures using the well known PHOLD benchmark.

The ever increasing need to ensure that code is reliably, efficiently and safely constructed has fueled the evolution of popular static binary code analysis tools. In identifying potential coding flaws in binaries, tools such as IDA Pro are used to disassemble the binaries into an opcode/assembly language format in support of manual static code analysis. Because of the highly manual and resource intensive nature involved with analyzing large binaries, the probability of overlooking potential coding irregularities and inefficiencies is quite high. In this paper, a light-weight, unsupervised data flow methodology is described which uses highly-correlated data flow graph (CDFGs) to identify coding irregularities such that analysis time and required computing resources are minimized. Such analysis accuracy and efficiency gains are achieved by using a combination of graph analysis and unsupervised machine learning techniques which allows an analyst to focus on the most statistically significant flow patterns while performing binary static code analysis.

The event horizon is a very important concept that applies to both parallel and sequential discrete-event simulations. By exploiting the event horizon, parallel simulations can processes events optimistically in a risk-free manner (i.e., without requiring antimessages) using adaptable breathing time cycles with variable time widths. Additionally, exploiting the event horizon can significantly reduce the overhead of event list management that is common to virtually all discrete-event simulations. This paper is a continuation of work previously reported at PADS94. In that report, a complete mathematical formulation of the event horizon was derived under equilibrium conditions using the hold model. Various forms of the beta density function were consequently used to verify the predicted results of the analytic model. This second report describes how the concept of the event horizon can also be applied to event list management. By exploiting the event horizon, the performance of several priority queue data structures are improved including: linked lists, various binary trees, and heaps. A somewhat detailed description of these modified data structures along with other relevant background information is provided for completeness. Performance results for each of these priority queue data structure is provided.

Preface. Contributors. PART ONE: PRINCIPLES OF MODELING AND SIMULATION: A MULTIDISCIPLINARY APPROACH. Chapter 1: What is Modeling and Simulation? Introduction. Models: Approximations of Real World Events. A Brief History of Modeling and Simulation. Application Areas. Using Modeling and Simulation: Advantages and Disadvantages. Conclusion. Key Terms. Further Reading. References. Chapter 2: The Role of Modeling and Simulation. Introduction. Using Simulations to Solve Problems. Uncertainty and Its Effects. Gaining Insight. A Simulation's Lifetime. Conclusion. Key Terms. Further Reading. PART TWO: THEORETICAL UNDERPINNINGS. Chapter 3: Simulation: Models That Vary Over Time. Introduction. Discrete Event Simulation. Continuous Simulation. Conclusion. Key Terms. References. Chapter 4: Queue Modeling and Simulation. Introduction. Analytical Solution. Queuing Models. Sequential Simulation. SimPack Queuing Implementation. Parallel Simulation. Conclusion. Key Terms. Further Reading. References. Chapter 5: Human Interaction with Simulations. Introduction. Simulation and Data Dependency. Visual Representation. Conclusion. Key Terms. References. Chapter 6: Verification and Validation. Introduction. Performing Verification and Validation. Verification and Validation Examples. Conclusion. Key Terms. References. PART THREE: PRACTICAL DOMAINS. Chapter 7: Uses of Simulation. Introduction. The Many Facets of Simulation. Experimentation Aspect of Simulation. Experience Aspect of Simulation. Examples of Uses of Simulation. Ethics in the Use of Simulation. Some Excuses to Avoid Simulation. Conclusion. Key Terms. Further Exploration. References. Appendix A-Simulation Associations/Groups/Research Centers. CHAPTER 8: MODELING AND SIMULATION: REAL-WORLD EXAMPLES. Introduction. Transportation. Business M&S. Medical M&S. Social Science M&S. Conclusion. Key Terms. Further Reading. References. Chapter 9: The Future of Simulation. Introduction. A Brief ... and Selective ... History of Simulation. Convergent Simulations. Serious Games. Human-Simulator Interfaces. Computing Technology. The Role of Education in Simulation. The Future of Simulation. Index.

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.

Data dependence analysis is the foundation to many reordering related compiler optimizations and loop parallelization. Traditional data dependence analysis algorithms are developed primarily for Fortran-like subscripted array variables. They are not very effective for pointer-based references in C or C++. With more advanced hardware support for speculative execution, such as the advanced load instructions in Intel’s IA64 architecture, some data dependences with low probability can be speculatively ignored. However, such speculative optimizations must be carefully applied to avoid excessive cost associated with potential mis-speculations. Data dependence profiling is one way to provide probabilistic information on data dependences to guide such speculative optimizations and speculative thread generation. Software-based data dependence profiling requires detailed tracing of memory accesses, therefore, could be very time consuming. In this paper, we examine issues related to data dependence profiling, and propose various techniques to improve the efficiency of data dependence profiling. We use the Open Research Compiler (ORC) [15,16] to test the efficiency of our data profiling techniques. We also study the effectiveness of data dependence profiling on data speculative optimizations on Itanium systems. Our results show that efficient data dependence profiling could improve the performance for data speculative optimizations.

Algorithms are often parallelized based on data dependence analysis manually or by means of parallel compilers. Some vector/matrix computations such as the matrix‐vector products with simple data dependence structures (data parallelism) can be easily parallelized. For problems with more complicated data dependence structures, parallelization is less straightforward. The data dependence graph is a powerful means for designing and analyzing parallel algorithms. However, for sparse matrix computations, parallelization based on solely exploiting the existing parallelism in an algorithm does not always give satisfactory results. For example, the conventional Gaussian elimination algorithm for the solution of a tri‐diagonal system is inherently sequential, so algorithms specially for parallel computation has to be designed. After briefly reviewing different parallelization approaches, a powerful graph formalism for designing parallel algorithms is introduced. This formalism will be discussed using a tri‐diagonal system as an example. Its application to general matrix computations is also discussed. Its power in designing parallel algorithms beyond the ability of data dependence analysis is shown by means of a new algorithm called ACER (Alternating Cyclic Elimination and Reduction algorithm).

Event-driven Process Chain (EPC) is a known business process modeling language which is primarily renowned for efficient modeling of business requirements. It is a semi-formal modeling language which is commonly verified though various formal mechanism for simple atomic events. However, the complexity of business requirements cannot be modeled through EPC atomic events alone especially in case of real time systems. Therefore, the complex events patterns like Event Time, Event location, Event Cardinality, Event Sequence, Event Exclusion, Event Trend and Data dependency are introduced in EPC from the novel area of complex event processing. However, to the best of our knowledge, there is no mechanism available in EPC to model and verify such complex events. Therefore, in this paper, we investigate the verification possibilities of both (atomic and complex) events in the context of Timed-Automata (TA) and Time Petri Nets (TPN). Particularly, we try to map the semantics of simple and complex events with the corresponding concepts of TA and TPN. It is analyzed that the simple EPC events can be formalized through TA and TPN but limited support is available for complex events. The restaurant process case study has been used for further investigation of complex events. It has been concluded that TA formalism is more suitable than TPN for the verification of complex events in EPC.

Static code analysis is a very important stage in the development and implementation of software, and it needs to be used to obtain a better code. The most complicated in static analysis is the analysis of source code, and further analysis. Analysis of the source code can be done multiple times and expand the set of necessary grammar. The main goal was and remains to provide a solution to reduce the time needed for a global reassessment of static analysis at code level after a change.The main problem when using static code analysis is to build an abstract semantic graph, because each software solution is provided with a separate data warehouse. The proposed solution proposes to use as a database repository using graphs. Thus, the storage mechanisms of the created abstract semantic graph have been simplified, which in turn, in addition to increasing the clarity of the information we store, provides convenient ways to further work with the stored information.The developed solution can transform a rather large source repository into a graphic representation and maintain it later. It is found that the approach is suitable for carrying out code compliance checks and for performing static analysis tests on a graphic representation. This approach also uses advanced file-level detailing, accelerating static analysis. Based on my measurements, the frameworks are fast enough to help their users quickly change the repository of codes.This article confirms the thesis about the possibility of storing an abstract semantic graph in a graph database, and after refinement, if it contains sufficient transformations and requests for language processing, can become a complete transport for communication between various static analysis tools that usually perform one of two the functions of verification either for quality or for vulnerability, thereby making a unified creation of an abstract semantic graph.As an improvement it is necessary to consider the possibility of incremental analysis – the analysis of changes in the code, in order to minimize resource costs for a rather resource intensive operation of the structure of the abstract semantic graph.Manuscript received 09.06.2020