Search

This work is focused on the issue of job scheduling in a high performance computing systems. The goal is based on the analysis of scheduling models of tasks in grid and cloud, design and implementation of the simulator on the base of GPGPU. The simulator is verified by our own proposed model of job scheduling. The simulator consists of a centralized scheduler that is using GPGPU to process large amounts of data by parallel way. In order to ensure the optimization of the scheduling process we have implemented a simulated annealing algorithm. GPGPU model was compared to the CPU when the number of nodes from 32 to 2048. Improving the implementation based on GPGPU had a significant impact on the system with 512 nodes and with an increasing number of nodes further accelerates in comparison with sequential algorithm. In this work are designed new scheduling criteria which are experimentally evaluated.

Urban traffic simulation of extensive areas with complex driver models poses a significant computational challenge. Developing highly scalable parallel simulation algorithms is the only feasible way to provide useful results in this case. In this paper, we present extensions of the SMARTS system, a traffic simulation tool, which provides efficient scalability with a large number of parallel processes. The presented extensions enabled its scalability for HPC-grade systems. The extended version has been thoroughly tested in strong and weak scalability scenarios for up to 2400 computing cores of a supercomputer. The satisfactory scalability has been achieved by introducing several significant improvements, which have been discussed in details.

Detailed models of numerous groups of social beings, which find applications in broad range of applications, require efficient methods of parallel simulation. Detailed features of particular models strongly influence the complexity of the parallelization problem. In this paper we identify and analyze existing classes of models and possible approaches to their simulation parallelization. We propose a new method for efficient scalability of the most challenging class of models: stochastic, with beings mobility and mutual exclusion of actions. The method is based on a concept of two-stage application of plans, which ensures equivalence of parallel and sequential execution. The method is analyzed in terms of distribution transparency and scalability at HPC-grade hardware. Both weak and strong scalability tests show speedup close to linear with more than 3000 parallel workers.

The shift towards parallel computing witnessed since the turn of this century has forced us to rethink traditional software design paradigms to better utilize resources. Yet, the simulation of time-aware systems remains a challenging topic due to the inherent semantics of time and causality whose consistency needs to be controlled, traditionally in form of a global event queue, limiting the potential for parallel exploitation. We propose a rehash of this problem by tackling it from a different modeling perspective, one which is able to express concurrency more naturally, i.e. dataflow (DF) models of computation (MoCs). By abstracting time aspects as an algebra hosted on a pure DF MoC, we are able to apply recent results from MoC theory not only for the purpose of describing deterministic behaviors for distributed timed systems, but also to overcome the existing limitations of timed execution in order to increase a simulation model's performance. We use a well-known example of a deadlock-prone distributed discrete event system as a driver to introduce the modeling concepts and show their potential for parallelism. QC 20220921Part of proceedings:ISBN 978-1-7281-8928-4

We consider a wireless sensor network (WSN) in the form of a chain of sensors with several sinks. Chiasserini–Garetto conditions are imposed on the functioning of the network nodes and the transmission environment. The number of network nodes is assumed in the thousands. A parallel simulation model is constructed to estimate the WSN performance parameters. Computer experiments conducted on a BlueGene/P supercomputer show good scalability of the model.

One approach for tackling the challenge of efficient implementations for parallel PDE simulations on dynamically changing grids is the usage of space-filling curves (SFCs). While SFC algorithms possess advantageous properties such as low memory requirements and close-to-optimal partitioning approaches with linear complexity, they require efficient communication strategies for keeping and utilizing the connectivity information, in particular for dynamically changing grids. Our approach is to use a sparse communication graph to store the connectivity information and to transfer data blockwise. This permits efficient generation of multiple partitions per memory context (denoted by clustering), which---in combination with a run-length encoding (RLE)---directly leads to elegant solutions for shared, distributed, and hybrid parallelization and allows cluster-based optimizations. While previous work focused on specific aspects, we present in this paper an overall compact summary of the stack-RLE clustering appro...

IP video traffic is forecast to be 82% of all IP traffic by 2022. Traditionally, content distribution networks (CDN) were used extensively to meet quality of service levels for IP video services. To handle the dramatic growth in video traffic, CDN operators are migrating their infrastructure to the cloud and fog in order to leverage its greater availability and flexibility. For hyperscale deployments, energy consumption, cache placement, and resource availability can be analyzed using simulation in order to improve resource utilization and performance. Recently, a discrete-time simulator for modelling hierarchical virtual CDNs (vCDNs) was proposed with reduced memory requirements and increased performance using multi-core systems to cater for the scale and complexity of these networks. The first iteration of this discrete-time simulator featured a number of limitations impacting accuracy and applicability: it supports only tree-based topology structures, the results are computed per level, and requests of the same content differ only in time duration. In this paper, we present an improved simulation framework that (a) supports graph-based network topologies, (b) requests have been reconstituted for differentiation of requirements, and (c) statistics are now computed per site and network metrics per link, improving granularity and parallel performance. Moreover, we also propose a two phase optimization scheme that makes use of simulation outputs to guide the search for optimal cache placements. In order to evaluate our proposal, we simulate a vCDN network based on real traces obtained from the BT vCDN infrastructure, and analyze performance and scalability aspects.

Most modeling and simulation (M&S) questions about cyber-physical systems (CPSs) require expert skills belonging to different scientific fields. The challenges are then to integrate each domain’s tools (formalism and simulation software) within the rigorous framework of M&S process. To answer this issue, we give the specifications of the Multi-agent Environment for Complex-SYstem CO-simulation (MECSYCO) middleware which enables to interconnect several pre-existing and heterogeneous M&S tools, so they can simulate a whole CPS together. The middleware performs the co-simulation in a parallel, decentralized, and distributable fashion thanks to its modular multi-agent architecture. In order to rigorously integrate tools that use different formalisms, the co-simulation engine of MECSYCO is based on the discrete event system specification (DEVS). The central idea of MECSYCO is to use a DEVS wrapping strategy to integrate each tool into the middleware. Thus, heterogeneous tools can be homogeneously co-simulated in the form of a DEVS system. By using DEVS, MECSYCO benefits from the numerous scientific works which have demonstrated the integrative power of this formalism and give crucial guidelines to rigorously design wrappers. We demonstrate that our discrete framework can integrate a vast amount of continuous M&S tools by wrapping the Functional Mockup Interface (FMI) standard. To this end, we take advantage of DEVS efforts of the literature (namely, the DEV&DESS hybrid formalism and Quantized State System (QSS) solvers) to design DEVS wrappers for Functional Mockup Unit (FMU) components. As a side-effect, this wrapping is not restricted to MECSYCO but can be applied in any DEVS-based platform. We evaluate MECSYCO with the proof of concept of a smart heating use case, where we co-simulate non-DEVS-centric M&S tools.

To enable the systematic evaluation of complex technical systems by engineers from various disciplines advanced 3D simulation environments that model all relevant aspects are used. In these Virtual Testbeds real-time capabilities are very hard to achieve without applying multi-threading strategies, due to the high complexity of the simulation. We present a novel simulation architecture that facilitates a modular approach to perform parallel simulations of arbitrary environments, where no explicit knowledge of the underlying simulation algorithms or model partitioning is needed by the engineer. Simulation components such as rigid-body dynamics, kinematics, renderer, controllers etc. can be distributed among different threads without concern about the specific technical realization. We achieve this by managing self-contained independent copies of the simulation model, each bound to one thread.

We present a fine-grained load migration protocol intended for parallel discrete event simulation (PDES) of spatially extended models. Typical models have domains that are fine-grained discretizations of some volume, e.g., a cell, using an irregular three-dimensional mesh, where most events span several voxels. Phenomena of interest in, e.g., cellular biology, are often non-homogeneous and migrate over the simulated domain, making load balancing a crucial part of a successful PDES. Our load migration protocol is local in the sense that it involves only those processors that exchange workload, and does not affect the running parallel simulation. We present a detailed description of the protocol and a thorough proof for its correctness. We combine our protocol with a strategy for deciding when and what load to migrate, which optimizes both for load balancing and inter-processor communication using tunable parameters. Our evaluation shows that the overhead of the load migration protocol is negligible, and that it significantly reduces the number of rollbacks caused by load imbalance. On the other hand, the implementation mechanisms that we added to support fine-grained load balancing incur a significant cost.

Agent Based Modelling (ABM), is an approach for modelling dynamic systems and studying complex and emergent behaviour. ABM approach is a very common technique in biological domain due to high demand for a large scale analysis tool to collect and interpret information to solve biological problems. However, simulating large scale cellular level models (i.e. large number of agents/entities) require a high degree of computational power which is achievable through parallel computing methods such as Graphics Processing Units (GPUs). The use of parallel approaches in ABMs is growing rapidly specifically when modelling in continuous space system (particle based). Parallel implementation of particle based simulation within continuum space where agents contain quantities of chemicals/substances is very challenging. Pair-wise interactions are different abstraction to continuous space (particle) models which is commonly used for immune system modelling. This paper describes an approach to parallelising the key component of biological and immune system models (pair-wise interactions) within an ABM model. Our performance results demonstrate the applicability of this method to a broader class of biological systems with the same type of cell interactions and that it can be used as the basis for developing complete immune system models on parallel hardware.

Monte-Carlo rendering algorithms are known for producing highly realistic images, but at a significant computational cost, because they rely on tracing up to trillions of light paths through a scene to simulate physically based light transport. For this reason, a large body of research exists on various techniques for accelerating these costly algorithms. As one of the Monte-Carlo rendering algorithms, PSSMLT (Primary Sample Space Metropolis Light Transport) is widely used nowadays for photorealistic rendering. Unfortunately, the computational cost of PSSMLT is still very high since the space of light paths in high-dimension and up to trillions of paths are typically required in such path space. Recent research on PSSMLT has proposed a variety of optimized methods for single node rendering, however, multi-node rendering for PSSMLT is rarely mentioned due in large part to the complicated mathematical model, complicated physical processes and the irregular memory access patterns, and the imbalanced workload of light-carrying paths.

Agent-based models (ABMs) need to populate a mega number of agents over a scalable simulation space in order to handle practical problems, (e.g., metropolitan traffic simulation and nationwide epidemic prediction). Although parallel and distributed simulation have steadily addressed their computational needs, non-computing scientists still tend to use GUI-rich, easy-to-use ABM interpretive platforms. This paper intends to identify the difficulty in using the current parallel ABM simulators and to propose their future improvements. For this purpose, we surveyed different ABM applications, modeled them as seven benchmark test cases, used them to analyze the agent descriptivity of parallel ABM simulators, and evaluated their execution performance affected by the current implementations.

With the ever-increasing complexity of simulation models, parallel simulation becomes necessary to perform simulation within reasonable time bounds. The built-in parallelism of Parallel DEVS is often insufficient to tackle this problem on its own. Several synchronization protocols have been proposed, each with their distinct advantages and disadvantages. Due to the significantly different implementation of these protocols, most Parallel DEVS simulation tools are limited to only one such protocol. In this paper, we present a Parallel DEVS simulator, grafted on C++11 and based on PythonPDEVS, supporting both conservative and optimistic synchronization protocols. The simulator not only supports both protocols but also has the capability to switch between them at runtime. The simulator can combine each synchronization protocols with either a threaded or sequential implementation of the PDEVS protocol. We evaluate the performance gain obtained by choosing the most appropriate synchronization protocol. A comparison is made to adevs in terms of CPU time and memory usage, to show that our modularity does not hinder performance. We compare the speedup obtained by synchronization with that of the inherent parallelism of PDEVS in isolation and combination, and contrast the results with the theoretical limits. We further allow for an external component to gather simulation statistics, on which runtime switching between the different synchronization protocols can be based. The effects of allocation on our synchronization protocols are also studied.

An AddSIM(Adaptive distributed and parallel Simulation environment for Interoperable and reusable Models) is an integrated engagement simulation environment with high-resolution weapon system models for estimation and analysis of their performance and effectiveness. AddSIM can simultaneously handle the continuous dynamical system models based on continuous time, and command, control(C2) and network system models based on a discrete event. To accommodate legacies based on DEVS(Discrete Event System Specification) modeling, DEVS legacies must first be converted into AddSIM models. This paper describes how to implement DEVS models on AddSIM. In this study a method of mapping from hierarchical DEVS models to AddSIM players was developed: The hierarchical DEVS model should be flattened into a one layered model and four DEVS functions of the model, external transition, internal transition, output and time advance, should be mapped into functions of the AddSIM player.

Many Dynamic Data-Driven Application Systems (DDDAS) use replicated simulations to project possible future system states. In many cases there are substantial similarities among these different replications. In other cases output statistics are independent of certain simulation computations. This paper explores computational methods to exploit these properties to speed up the simulation execution time. We discuss a new algorithm to speed up the execution of replicated vehicle traffic simulations, where the output statistics of interest focus on one or more attributes such as the trajectory of a certain “target” vehicle. By focusing on correctly reproducing the behavior of the target vehicle and its interaction with other modeled entities across the different replications and modifying the event handling mechanism the execution time can be reduced. A speculative execution method using a tagging mechanism allows this speedup to occur without loss of accuracy in the output statistics.

Coping with emergency situations requires effective and prompt decision-making under constantly changing situations. The deployment of various kinds of sensors makes it possible to acquire vast amounts of information. At present, however, most information processing is not automated; therefore, the quality of decision-making depends heavily on the capacities of the decision maker. To solve this problem, we propose a system for predicting future situations through parallel simulations based on observation data. To facilitate the development of such systems, we have been developing an optimistic simulation engine (hereafter referred to as O-SE) that supports parallel simulation of many possible situations and dynamic simulation modification based on observation data acquired by sensors. The design and evaluation results of the O-SE are illustrated in this paper.

Experience and intuition indicate that both synchronization and the mapping of workload to processors has significant impact on overall performance. However, the behavior of parallel simulations is quite complex, and the inter-relationships between workload mapping and the synchronization overheads need mathematical explanation. This paper develops a performance model of a parallel simulation that is synchronized using composite synchronization. We use this model to help explain how mapping decisions and a synchronization tuning parameter impacts synchronization overhead, and hence performance. The observations we make should inform designers of algorithms to map conservatively synchronized parallel simulations to the available computing platform.

Optimizing parallel discrete event simulation (PDES) on multi-core environments can bring great performance improvement and has become a research hotspot so far. Most of the optimization methods accelerate the simulators by reducing the cost of communication and synchronization with the advantages of shared memory for multi cores. However, both optimistic and conservative simulation algorithms can only support processing events of different entities in parallel, the parallelism of events belonging to one entity is ignored. Focusing on this demand, a deep parallel simulation approach based on conservative simulation algorithm is proposed to explore the parallelism of events belonging to one entity. Besides, a greedy aggregation algorithm is also designed to deal with load balancing problem by reorganizing events into blocks with similar sizes. Phold results show that the parallel simulation approach proposed in this paper gains 15% performance increase comparing to the approach without considering the parallelism of one entity.

Contaminant source characterization (CSC) in a water distribution system (WDS) exhibits a computationally intensive problem. Traditional solutions to the CSC problem can't fulfill the CSC's quality-of-service (QoS) requirements. The authors present a parallel solution using the MapReduce paradigm in the cloud that can deliver a high-performance, fault-tolerant, and flexible solution.

Stochastic simulation of biological systems becomes widely used, since it can intuitively account for the fluctuation of species with a few number of molecules. However, for bigger models and/or models with mixed abundance of molecules, stochastic simulation fails to produce the required results in reasonable time. Parallel simulation can offer a solution for this challenge. Nevertheless, currently available parallel software tools either provide a coarse-grained parallelization or a general-purpose fine-grained parallel simulation of the well-known stochastic simulation algorithm (SSA). The former can only take advantage of parallel processing if multiple runs have to be performed, while the latter requires extensive synchronization and communication between the different processing nodes each time a reaction is to fire. In this paper, a fine-grained parallelization approach is presented that takes advantage of the underlying model semantics to improve the simulator performance. The proposed method is applied to the yeast cell cycle regulation, which is an example of biological models that requires extensive investigation.

Parallelizing (compute-intensive) discrete event simulation (DES) applications is a classical approach for speeding up their execution and for making very large/complex simulation models tractable. This has been historically achieved via parallel DES (PDES) techniques, which are based on partitioning the simulation model into distinct simulation objects (somehow resembling objects in classical object-oriented programming), whose states are disjoint, which are executed concurrently and rely on explicit event-exchange (or event-scheduling) primitives as the means to support mutual dependencies and notification of their state updates. With this approach, the application developer is necessarily forced to reason about state separation across the objects, thus being not allowed to rely on shared information, such as global variables, within the application code. This implicitly leads to the shift of the user-exposed programming model to one where sequential-style global variable accesses within the application code are not allowed. In this article we remove this limitation by providing support for managing global variables in the context of DES code developed in ANSI-C, which gets automatically parallelized. Particularly, we focus on speculative (also termed optimistic) PDES systems that run on top of multi-core machines, where simulation objects can concurrently process their events with no guarantee of causal consistency and actual violations of causality rules are recovered through rollback/recovery schemes. In compliance with the nature of speculative processing, in our proposal global variables are transparently mapped to multi-versions, so as to avoid any form of safety predicate verification upon their updates. Consistency is ensured via the introduction of a new rollback/recovery scheme based on detecting global variables' reads on non-correct versions. At the same time, efficiency in the execution is guaranteed by managing multi-version variables' lists via non-blocking algorithms. Furthermore, the whole approach is fully transparent, being it based on automatized instrumentation of the application software (particularly ELF objects). Hence the programmer is exposed to the classical (and easy to code) sequential-style programming scheme while accessing any global variable. An experimental assessment of our proposal, based on a suite of case study applications, run on top of an off-the-shelf Linux machine equipped with 32 CPU-cores and 64 GB of RAM, is also presented.

This paper describes a partitioning algorithm for real-world transportation networks incorporating previously unaccounted parameters like signalized traffic intersection, road segment length, traffic density, number of lanes and inter-partition communication overhead due to the migration of vehicles from one partition to another. We also describe our hypothetical framework for distributed simulation of the partitioned road network on SUMO, where a master controller is currently under development using TraCI APIs and MPI library to coordinate the parallel simulation and synchronization between the sub-networks generated by our proposed algorithm.

A common approach of parallelising an agent-based road traffic simulation is to partition the road network into sub-regions and assign computations for each subregion to a logical process (LP). Inter-process communication for synchronisation between the LPs is one of the major factors that affect the performance of parallel agent-based road traffic simulation in a distributed memory environment. Synchronisation overhead, i.e., the number of messages and the communication data volume exchanged between LPs, is heavily dependent on the employed road network partitioning algorithm. In this paper, we propose Neighbour-Restricting Graph-Growing (NRGG), a partitioning algorithm which tries to reduce the required communication between LPs by minimising the number of neighbouring partitions. Based on a road traffic simulation of the city of Singapore, we show that our method not only outperforms graph partitioning methods such as METIS and Buffoon, for the synchronisation protocol used, but also is more resilient than stripe spatial partitioning when partitions are cut more ?nely.

On-chip power delivery networks have become an important design bottleneck while posing a significant challenge to design automation tools due to their large models. In this paper we propose a method that uses model order reduction methodologies in order to reformulate the simulation as a reduced parallel simulation problem that can take advantage of modern multi-core CPUs. Numerical examples are used to illustrate the accuracy and efficiency of the proposed method.

Nanotechnology has the potential to revolutionize our lives and to provide technological solutions to our problems in energy, the environment and medicine. This paper describes a swarm intelligence-based control mechanism for medical nanorobots that operates as artificial platelets to search for wounds within the human body. We present a coloured perceptive particle swarm (CPPSO) algorithm to control the movement of nanorobots in self-assembly. To predict emergent nanorobot behaviors, we designed a parallel simulator that models how nanorobots interact with each other and the environment. We will show that due to their implicitly parallel structure, swarm intelligence algorithms can benefit from GPU-based implementations. The algorithm is implemented with CUDA. With the GPU-based implementation adopted here, we find that CPPSO is faster than a PPSO implementation.

Several distributed applications running over the Internet use Reputation Management Systems (RMSs) to guarantee reliable interactions among unknown agents. Because of the heterogeneity of the existing RMSs, their assessment in terms of correctness and resistance to security attacks is not a trivial task. This work addresses this issue by presenting a novel parallel simulator aimed to support researchers in evaluating the performances of a RMS since the design phase. Preliminary results obtained by simulating two different attacks confirm the suitability of the proposed framework to evaluate different RMSs.

It is well known that Parallel Discrete Event Simulation systems may suffer, in terms of delivered performance, from imbalance of the computational load. In case of conservative synchronization we may experience CPU under-utilization and/or excessive communication overhead. On the other hand, for the optimistic paradigm we may even have rollback thrashing effects, with a consequent reduction of the percentage of productive (ie not rolled back) work carried out. This paper presents the design of a global memory management architecture supporting application-transparent migration of simulation objects whose state is scattered across dynamically allocated memory chunks. Our approach is based on a non-intrusive background protocol that provides each instance of the simulation kernel with information on the current mapping of the virtual address space of all the other instances. Dynamic memory requests by the application layer are then locally mapped onto virtual-address ranges that maximize the likelihood of being portable onto the address space of a remote kernel instance. In this way, independently of the load-balancing trigger (or policy), we maximize the likelihood that a desirable migration across a specific couple of kernels can actually take place due to compliance of the corresponding source/destination address spaces. We have integrated the global memory manager within the ROme OpTimistic Simulator (ROOT-Sim), namely a run-time environment based on the optimistic synchronization paradigm which automatically and transparently parallelizes the execution of event-handler-based simulation programs conforming to ANSI-C. Further, we provide a contribution in the direction of widening load-balancing schemes for optimistic simulation systems by defining migration triggers and selection policies for the objects to be migrated on the basis of memory usage patterns. An experimental assessment of the architecture and of memory-oriented load balancing is also provided.

A Hierarchical Parallel simulation framework for spatially-explicit Agent-Based Models (HPABM) is developed to enable computationally intensive agent-based models for the investigation of large-scale geospatial problems. HPABM allows for the utilization of high-performance and parallel computing resources to address computational challenges in agent-based models. Within HPABM, an agent-based model is decomposed into a set of sub-models that function as computational units for parallel computing. Each sub-model is comprised of a sub-set of agents and their spatially-explicit environments. Sub-models are aggregated into a group of super-models that represent computing tasks. HPABM based on the design of super- and sub-models leads to the loose coupling of agent-based models and underlying parallel computing architectures. The utility of HPABM in enabling the development of parallel agent-based models was examined in a case study. Results of computational experiments indicate that HPABM is scalable for developing large-scale agent-based models and, thus, demonstrates efficient support for enhancing the capability of agent-based modeling for large-scale geospatial simulation.

The order according to which the different tasks are carried out within a Time Warp platform has a direct impact on performance, given that event processing is speculative, thus being subject to the possibility of being rolled-back. It is typically recognized that not-yet-executed events having lower timestamps should be given higher CPU-schedule priority, since this contributes to keep low the amount of rollbacks. However, common Time Warp platforms usually execute events as atomic actions. Hence control is bounced back to the underlying simulation platform only at the end of the current event processing routine. In other words, CPU-scheduling of events resembles classical batch-multitasking scheduling, which is recognized not to promptly react to variations of the priority of pending tasks (e.g. associated with the injection of new events in the system). In this article we present the design and implementation of a time-sharing Time Warp platform, to be run on multi-core machines, where the platform-level software is allowed to take back control on a periodical basis (with fine grain period), and to possibly preempt any ongoing event processing activity in favor of dispatching (along the same thread) any other event that is revealed to have higher priority. Our proposal is based on an ad-hoc kernel module for Linux, which implements a fine grain timer-interrupt mechanism with lightweight management, which is fully integrated with the modern top/bottom-half timer-interrupt Linux architecture, and which does not induce any bias in terms of relative CPU-usage planning across Time Warp vs non-Time Warp threads running on the machine. Our time-sharing architecture has been integrated within the open source ROOT-Sim optimistic simulation package, and we also report some experimental data for an assessment of our proposal.

Queueing Petri Nets (QPNs) are a powerful formalism to model the performance of software systems. Such models can be solved using analytical or simulation techniques. Analytical techniques suffer from scalability issues, whereas simulation techniques often require very long simulation runs. Existing simulation techniques for QPNs are strictly sequential and cannot exploit the parallelism provided by modern multi-core processors. In this paper, we present an approach to parallel discrete-event simulation of QPNs using a conservative synchronization algorithm. We consider the spatial decomposition of QPNs as well as the lookahead calculation for different scheduling strategies. Additionally, we propose techniques to reduce the synchronization overhead when simulating performance models describing systems with open workloads. The approach is evaluated in three case studies using performance models of real-world software systems. We observe speedups between 1.9 and 2.5 for these case studies. We also assessed the maximum speedup that can be achieved with our approach using synthetic models.

In a supply chain, an order often connects a number of companies whose schedules affect the success of the order. This paper proposes distributed supply chain scheduling in the agent architecture instead of centralised supply chain scheduling. The companies communicate through their agents that share only the information relevant to the supply chain scheduling. This scheduling relies on distributed parallel forward simulation in which simple messages are exchanged between the agents periodically. According to these messages, each agent simulates the production orders of its company and receives and sends messages about the purchase and sale orders. This synchronises the simulation of the agent with the simulations of the other agents. Distributed simulation reduces the competitor's opportunities to manipulate the company's performance through the schedules of its suppliers and customers. Although distributed simulation does not optimise the schedules, it is capable of finding feasible schedules.

The steady increase in size and complexity of communication networks, coupled with growing needs and demands, has motivated the development of active networks. Active networking techniques embed computational capabilities into conventional networks, thereby massively increasing the complexity and customization of the computations that are performed with a network. One of the most effective techniques for studying and analyzing active networks is computer-based simulation, but customized and flexible tools are required to ease effective use of simulations. In an endeavor to address these diverse issues, an Active Networks Simulation Environment (ANSE) has been developed. ANSE provides an environment for modeling, parallel simulation, and Web-based simulation of active networks. This paper presents the issues involved in the design and development of ANSE and the results obtained from the experiments conducted to evaluate the effectiveness of ANSE. Studies indicate that ANSE provides an effective environment for modeling and simulation of large-scale active networks.

Solid earth simulations have recently been developed to address issues such as natural disasters, global environmental destruction and the conservation of natural resources. The simulation of solid earth phenomena involves the analysis of complex structures including strata, faults, and heterogeneous material properties. Simulation of the generation and cycle of earthquakes is particularly important, but such simulations require the analysis of complex fault dynamics. GeoFEM is a parallel finite-element analysis system intended for solid earth field phenomena problems. This paper describes recent development in the GeoFEM project for the simulation of earthquake generation and cycles.

This paper introduces Muclouds, a parallel simulation framework for simulating large-scale cloud computing systems. Muclouds improves the simulation performance for these large systems, such that the simulation time can be minimized. To achieve this goal, in this paper we propose a novel technique named stage and partition (SAP). SAP is based on the following observation: in an event-based simulation framework for cloud computing, the existence of the interaction and/or correlation of the events, which imposes simulation synchronization, is the major factor that prevents efficient parallelization. To achieve improved parallelization performance, SAP divides events into two main categories: non-interacting events and interacting events. Non-interacting events can be simulated simultaneously to achieve high simulation speed, whereas interacting events must be simulated sequentially to preserve accuracy. Using Muclouds, we constructed several scenarios to evaluate parallelization effectiveness and efficiency. We also conduct several experiments for performance comparisons with state-of-the-art schemes. Evaluation results show that Muclouds facilitates considerable performance improvements when compared with existing approaches.

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.

In order to utilize parallel processing for low power and high performance in embedded systems, ESL models must contain explicit and efficient parallelism.

International audience; The growing complexity of systems, together with in- creasing available parallelism provided by multi-core chips, calls for the parallelization of simulation. Simu- lation speed-ups are expected from co-simulation and parallelization based on models splitting into loosely coupled sub-systems in the framework of Functional Mockup Interface (FMI). However, slackened syn- chronization between the sub-models and associated solvers running in parallel introduces integration er- rors, which must be kept inside predefined bounds. In this paper, context-based extrapolation is investigated to improve the trade-off between integration speed- ups, needing large communication steps, and simula- tion precision, needing frequent updates for the mod- els inputs. An internal combustion engine, based on FMI for model exchange, is used to assess the paral- lelization methodology.; La complexité croissante des systèmes cyber-physiques, ainsi que la disponibilité de puces multicoeurs, permet la parallélisation des simulations. L'accélération des co-simulations est permise par un parallélisme utilisant des modèles partitionnés en sous-systèmes faiblement couplés, utilisant le formalisme fourni par l'environnement FMI associé à Modelica. Cependant, l'intégration numérique de modèles faiblement synchronisés introduit des erreurs d'intégration devant être contenues dans des bornes prédéfinies. Dans ce papier, une méthode d'extrapolation basée sur des contextes permet d'améliorer le compromis entre temps de calcul, nécessitant de grands pas de synchronisation, et précision d'intégration nécessitant des mises à jour fréquentes des entrées des sous-systèmes. La méthode est validée sur un modèle industriel de moteur à combustion interne.

Parallelization is crucial for ecient execution of large-scale network simulation. Today's computing clusters commonly used for that purpose are built from a large amount of multiprocessor machines. The traditional approach to utilize all CPU cores in such a system is to partition the network and distribute the partitions to the cores. This, however, does not incorporate the presence of shared memory into the design, such that messages between partitions on the same computing node have to be serialized and synchronization becomes more complex. In this paper, we present an approach that combines the shared-memory parallelization scheme Horizon [9] with the standard approach to distributed simulation to leverage the strengths of today's computing clusters. To further reduce the synchronization overhead, we introduce a novel synchronization algorithm that takes domain knowledge into account to reduce the number of synchronization points. In a case study with a UMTS LTE model, we show that both contributions combined enable much higher scalability achieving almost linear speedup when simulating 1,536 LTE cells on 1,536 CPU cores. QC 20150123

The recent rapid growth in the Internet and the use of this technology for corporate intranets presents new opportunities for parallel discrete event simulation. Previously, this was the province of specialist groups with dedicated computer facilities, whereas it is now feasible to use small PCs that communicate via TCP/IP. This paper describes research in distributed discrete event simulation using the three-phase approach and implemented in Java using standard Internet technologies. Two specific implementations are described, one for client/server work and the other a distributed, parallel simulator using conservative synchronisation protocols. The problem of managing shared states with competing resources is specifically discussed. They demonstrate proof of concept and contain important aspects of detailed implementation, but have not been used for experimentation to estimate aspects such as speed or message loads.