15698160
Performance prediction of a parallel simulator
There are at least three major obstacles thwarting widespread adoption of parallel discrete-event simulation: lack of need; lack of tools; and lack of predictability in behavior and performance. The plain truth is that most simulation studies can be adequately done on ordinary serial computers. Parallel simulation tools are products of research efforts, and simply do not stand up to the demands of modern software engineering. The results of 20 years of research in parallel simulation reveal it to be a highly complex endeavour, with performance results very much dependent on implementation details and model characteristics. The Scalable Simulation Framework (SSF) is an effort to address some these concerns. It addresses lack of need in two ways; it provides a modeling API that is attractive both for serial and parallel simulation, with parallel execution requiring no change to the model, and it targets large-scale telecommunication system modeling, an application area that requires the computational capabilities of parallelism. We address the concern over unpredictable behavior. We show how we measured the internal overheads of the Dartmouth implementation of the SSF API (DaSSF), and how those measurements can be used to predict the performance of a given model, using given features of the simulator, without having to run, or even build, the model.
44819319
Parallelizable execution-driven simulation of threaded distributed memory parallel computations
Discrete-event simulation is an important tool used for the performance evaluation of parallel systems. The space of tradeoffs is large however, when attempting to balance model fidelity and simulation execution tame. The paper describes a simulator-TAPS (Threaded Application Parallel System Simulator)-that, in the context of threaded parallel computations, provides a spectrum of possibilities in this tradeoff space. TAPS is specifically designed to be parallelized; we discuss some crucial considerations regarding its parallelization.
5434773
Simulation validation using direct execution of wireless ad-hoc routing protocols
Computer simulation is the most common approach to studying wireless ad-hoc routing algorithms. The results, however, are only as good as the models the simulation uses. One should not underestimate the importance of validation, as inaccurate models can lead to wrong conclusions. In this paper, we use direct-execution simulation to validate radio models used by ad-hoc routing protocols, against real-world experiments. This paper documents a common testbed that supports direct execution of a set of ad-hoc routing protocol implementations in a wireless network simulator. The testbed reads traces generated from real experiments, and uses them to drive direct-execution implementations of the routing protocols. Doing so we reproduce the same network conditions as in real experiments. By comparing routing behavior measured in real experiments with behavior computed by the simulation, we are able to validate the models of radio behavior upon which protocol behavior depends. We conclude that it is possible to have fairly accurate results using a simple radio model, but the routing behavior is quite sensitive to one of this model's parameters. The implication is that one should: i) use a more complex radio model that explicitly models point-to-point path loss; or ii) use measurements from an environment typical of the one of interest; or iii) study behavior over a range of environments to identify sensitivities.
15096079
Lock-free scheduling of logical processes in parallel simulation
With fixed lookahead information in a simulation model, the overhead of asynchronous conservative parallel simulation lies in the mechanism used for propagating time updates in order for logical processes to safely advance their local simulation clocks. Studies have shown that a good scheduling algorithm should preferentially schedule processes containing events on the critical path. This paper introduces a lock-free algorithm for scheduling logical processes in conservative parallel discrete-event simulation on shared-memory multiprocessor machines. The algorithm uses fetch and add operations that help avoid inefficiencies associated with using locks. The lock-free algorithm is robust. Experiments show that, compared with the scheduling algorithm using locks, the lock-free algorithm exhibits better performance when the number of logical processes assigned to each processor is small or when the workload becomes significant. In models with large number of logical processes, our algorithm shows only modest increase in execution time due to the overhead in the algorithm for extra bookkeeping.
2599117
Composite Synchronization in Parallel Discrete-Event Simulation
This paper considers a technique for composing global (barrier-style) and local (channel scanning) synchronization protocols within a single parallel discrete-event simulation. Composition is attractive because it allows one to tailor the synchronization mechanism to the model being simulated. We first motivate the problem by showing the large performance gap that can be introduced by a mismatch of model and synchronization method. Our solution calls for each channel between submodels to be classified as synchronous or asynchronous. We mathematically formulate the problem of optimally classifying channels and show that, in principle, the optimal classification can be obtained in time proportional to max{C/spl times/log C, V/spl times/N}, where C is the number of channels, V the number of unique minimal delays on those channels, and N is the number of submodels. We then demonstrate an implementation which finds an optimal solution at runtime and consider its performance on network topologies, including one of the global Internet at the autonomous system level. We find that the automated method effectively determines channel assignments that maximize performance.
343488
An implementation of the SSF scalable simulation framework on the Cray MTA
Large-scale parallel discrete event simulations of massive networks, such as the Internet, are "Grand Challenge" problems: packet level simulation of even a small fraction of the Internet would consume the resources of the most powerful computers available. We reimplement the SSF scalable simulation framework so we can run large-scale network simulations originally written for DaSSF. Our implementation, CraySSF, is designed for the Cray-MTA, a multithreaded supercomputer architecture developed specifically to address large-scale computations of the kind that are not easily distributed. We describe the architecture, implementation issues, and preliminary performance results on a variety of (stock) serial and parallel architectures.
28349358
Data Parallel Program Design
We have shown how graphical languages such as CODE/ROPE and PPSE can be used to design SIMD or data parallel programs. The advantages of this approach are machine independence, design clarity, automated program analysis, and accelerated software development. The disadvantages are that many problems remain in this approach such as how to reduce design clutter, how to automate optimal processor mapping, and how to perform messagepassing optimization. More work is needed before this approach can be used in the design of large-scale applications, but we believe the approach is promising. The main contribution is to show how the simple ideas of stencils, stream generators, and replicators can be used effectively to extend the classical dataflow design paradigm into the data parallel design paradigm. While more work is needed, these three ideas lead to greater expressiveness of design. The PPSE toolset currently does much of the mapping, scheduling, and automatic code generation described in this paper. However, PPSE does not currently handle data parallel programming. Work is progressing toward a full implementation of these ideas. Even so, PPSE has been invaluable for performing a variety of what-if analyses on parallel programs. Insights have been gained with this approach that would not be possible with a purely textual representation of the parallel program.
3503340
Organizing synthetic agent behaviors based on a motif architecture
Drawing on our previous work [4], this paper presents an interthreaded motif-based behavioral organiza$on architecture and demonstrates its application in organizing the behaviors of a synthetic agent. The developed architecture enables agent behaviors to be developed as a result of the concurrent self-organization in individual motifs as well as their crisscrossing interactions. The self-organizing motifs contribute to the global organization of agent behaviors through data exchange and control intervention mechanisms along different dimensions of branching threads.
2799209
On adaptive agentlets for distributed divide-and-conquer: a dynamical systems approach
This paper is concerned with the dynamics of autonomous agents in performing distributed problem-solving tasks. The goal of this work is to show: 1) how certain tasks may be handled by breeds of distributed agents self-reproduced by other agents in response to their local environment and 2) how the behavioral repository of the agents may be constructed based on some well-defined dynamical systems models. The breeds of agents progressively generated in the course of distributed problem-solving are referred to as agentlets. The specific task for demonstrating this dynamical systems-based agentlet-oriented approach is the one in which the agents are required to search and mark certain feature locations in a two-dimensional (2-D) search space by way of divide-and-conquer. In so doing, individual agents may have different dynamical motion, depending on when and where they are bred. This paper provides a detailed description of the agents of different dynamics and shows how the agentlets proceed with this task by moving according to their well-defined dynamics, breeding their offspring agents in the environment., and fine-tuning their dynamical systems parameters. In addition, it is proven that in the given example task, the designed agentlets will guarantee to reach all the feature locations in the search space.
15097212
Self-organized autonomous web proxies
With the increasing size of the Internet, proxy servers have emerged as a feasible way to reduce the overall network load and latency. More recently researchers focused on new ways to combine multiple cooperative proxies into one transparent proxy system to further increase the overall performance gain, but no work so far was really able to propose an ideal trade-off between content dissemination and clustering in a changing environment caching environment. This paper introduces a self-organizing approach to combine multiple autonomous proxies into one transparent proxy system. One of the emerging attributes of a system of self-organizing autonomous proxies is a balance between content clustering and data dissemination. Our experimental results show that such a system outperforms conventional cooperative proxy infrastructures.
640793
A component-based approach to modeling and simulating mixed-signal and hybrid systems
Systems with both continuous and discrete behaviors can be modeled using a mixed-signal style or a hybrid systems style. This article presents a component-based modeling and simulation framework that supports both modeling styles. The component framework, based on an actor metamodel, takes a hierarchical approach to manage heterogeneity in modeling complex systems. We describe how ordinary differential equations, discrete event systems, and finite-state machines can be built under this metamodel. A mixed-signal system is a hierarchical composition of continuous-time and discrete event models, and a hybrid system is a hierarchical composition of continuous-time and finite-state-machine models. Hierarchical composition and information hiding help build clean models and efficient execution engines. Simulation technologies, in particular, the interaction between a continuous-time ODE solving engine and various discrete simulation engines are discussed. A signal type system is introduced to schedule hybrid components inside a continuous-time environment. Breakpoints are used to control the numerical integration step sizes so that discrete events are handled properly. A "refiring" mechanism and a "rollback" mechanism are designed to manage continuous components inside a discrete event environment. The technologies are implemented in the Ptolemy II software environment. Examples are given to show the applications of this framework in mixed-signal and hybrid systems.