Search

Different communication-aware mapping techniques were proposed in recent years for improving the performance of distributed systems based on both, off-chip and on-chip networks. Some of these proposals were based on heuristic search for finding pseudo-optimal assignments of tasks and processing elements. However, the technology integration improvements have allowed a significant increase in the number of network nodes, requiring the acceleration of the heuristic search. In this paper, we propose a comparative study of the local search method used in a communication-aware mapping technique, when implemented on different parallel architectures. We compare the performance provided by a version of the local search method when executed on a single Graphics Processing Unit (GPU) with the one provided by the MPI version executed on a supercomputer with the same theoretical performance of the GPU platform, in order to study a fair scenario. We have considered a GPU based on the Fermi architecture, evaluating the improvements achieved by some new architectural features of this platform. The results show that a mixed parallel implementation on a single GPU outperforms the MPI implementation of the local search method. These results validate the GPU implementation as a very cost-effective accelerator for the local search method. [ABSTRACT FROM AUTHOR]

Because of their widely generalized use in many industries, composites are the subject of many research campaigns. More particularly, the development of both accurate and flexible numerical models able to capture their intrinsically multiscale modes of failure is still a challenge. The standard finite element method typically requires intensive remeshing to adequately capture the geometry of the cracks and high accuracy is thus often sacrificed in favor of scalability, and vice versa. In an effort to preserve both properties, we present here an extended finite element method (XFEM) for large scale composite fracture simulations. In this formulation, the standard FEM formulation is partially enriched by use of shifted Heaviside functions with special attention paid to the scalability of the scheme. This enrichment technique offers several benefits since the interpolation property of the standard shape function still holds at the nodes. Those benefits include (i) no extra boundary condition for the enrichment degree of freedom, and (ii) no need for transition/blending regions; both of which contribute to maintaining the scalability of the code. Two different cohesive zone models (CZM) are then adopted to capture the physics of the crack propagation mechanisms. At the intralaminar level, an extrinsic CZM embedded in the XFEM formulation is used. At the interlaminar level, an intrinsic CZM is adopted for predicting the failure. The overall framework is implemented in ALYA, a mechanics code specifically developed for large scale, massively parallel simulations of coupled multi-physics problems. The implementation of both intrinsic and extrinsic CZM models within the code is such that it conserves the extremely efficient scalability of ALYA while providing accurate physical simulations of computationally expensive phenomena. The strong scalability provided by the proposed implementation is demonstrated. The model is ultimately validated against a full experimental campaign of loading tests and X-ray tomography analyzes. [ABSTRACT FROM AUTHOR]

The computing capabilities of current multi-core and many-core architectures have been used in crowd simulations for both enhancing crowd rendering and simulating continuum crowds. However, improving the scalability of crowd simulation systems by exploiting the inherent parallelism of these architectures is still an open issue. In this paper, we propose different parallelization strategies for the collision check procedure that takes place in agent-based simulations. These strategies are designed for exploiting the parallelism in both multi-core and many-core architectures like graphic processing units (GPUs). As for the many-core implementations, we analyse the bottlenecks of a previous GPU version of the collision check algorithm, proposing a new GPU version that removes the bottlenecks detected. In order to fairly compare the GPU with the multi-core implementations, we propose a parallel CPU version that uses read--copy update (RCU), a new synchronization method which significantly improves performance. We perform a comparison study of these different implementations. On the one hand, the comparison study shows the first performance evaluation of RCU in a real user-space application with complex data structures. On the other hand, the comparison shows that the GPU greatly accelerates the collision test with respect to any other implementation optimized for multi-core CPUs. In addition, we analyse the efficiency of the different implementations taking into account the theoretical performance and power consumption of each platform. The evaluation results show that the GPU-based implementation consumes less energy and provides a minimum speedup of 45× with respect to any of the CPU-based implementations. Since interactivity is a hard constraint in crowd simulations, this acceleration of the collision check process represents a significant improvement in the overall system throughput and response time. Therefore, the simulations are significantly accelerated, and the system throughput and scalability are improved. [ABSTRACT FROM AUTHOR]

SUMMARY In this paper, we look at the acceleration of weakly coupled electromechanics using the graphics processing unit (GPU). Specifically, we port to the GPU a number of components of [ABSTRACT FROM AUTHOR]

Abstract: Interactive applications like crowd simulations need to properly render the virtual world while simulating the interaction of thousands of agents at the same time. The computational workload generated by these two tasks highly increases with the number of the simulated agents, requiring a scalable design of the multiagent system. In this paper, we present, in an unified manner, a distributed multiagent system architecture that can manage large crowds of autonomous agents at interactive rates while rendering multiple views of the virtual world being simulated. This architecture consists of a distributed multiagent system and a complementary distributed visualization subsystem. We also present a new scalability study of the distributed multiagent system architecture, as well as an application example. The scalability study shows that, since no system bottlenecks are present in the proposed multiagent system architecture, it can efficiently simulate population sizes of different orders of magnitude by simply adding more hardware, provided that the ratio of clients per server is appropriate for the computer platforms acting as servers. On the other hand, the application example shows that these improvements are achieved without affecting the interactivity of the simulation. Therefore, the scalability of the proposed multiagent system architecture is validated for interactive large-scale applications. [Copyright &y& Elsevier]

The Read-Copy Update ( RCU) synchronization method was designed to cope with multiprocessor scalability some years ago, and it was included in the Linux kernel October of 2002. Recently, libraries providing user-space access to this method have been released, although they still have not been used in complex applications. In this paper, we propose the evaluation of the RCU synchronization method for two different cases of use in a distributed system architecture for crowd simulations. We have compared the RCU implementation with a parallel implementation based on Mutex, a traditional locking synchronization method for solving race conditions among threads in parallel applications. The performance evaluation results show that the use of RCU significantly decreases the system response time and increases the system throughput, supporting a higher number of agents while providing the same latency levels. The reason for this behavior is that the RCU method allows read accesses in parallel with write accesses to dynamic data structures, avoiding the sequential access that a Mutex represents for these data structures. In this way, it can better exploit the existing number of processor cores. These results show the potential of this synchronization method for improving parallel and distributed applications. [ABSTRACT FROM AUTHOR]

The visualization system of large-scale crowd simulations should scale up with both the number of visuals (views of the virtual world) and the number of agents displayed in each visual. Otherwise, we could have large scale crowd simulations where only a small percentage of the population is displayed. Several approaches have been proposed in order to efficiently render crowds of animated characters. However, these approaches either render crowds animated with simple behaviors or they can only support a few hundreds of user-driven entities. In this paper, we propose a distributed visualization system for large crowds of autonomous agents that allows the visualization of crowds animated with complex behaviors without adding significant overhead to the simulation servers. The proposed implementation can be hosted on dedicated computers different from the servers, and it takes advantage of the Graphics Processor Unit (GPU) capabilities. As a result, the performance evaluation shows that thousands of agents can be rendered without affecting the system performance. Also, the results show that the design of the visual client allows to add multiple visuals for displaying large crowds. [ABSTRACT FROM AUTHOR]

The simulation of large crowds of autonomous agents with a realistic behavior is still a challenge for several computer research communities. Distributed architectures can provide scalability to crowd simulations, but they require the use of efficient partitioning methods. Although convex hulls have been shown as very efficient structures for crowd partitioning, providing efficient workload balancing to large scale simulations is still an open issue. In this paper, we propose the integration of a workload balancing technique for crowd simulations within a partitioning method based on convex hulls. The region-based balancing technique reassigns agents to servers using a criterion of distance. The performance evaluation results show that this technique ensures the saturation avoidance of the servers in an homogeneous distributed system. This feature can increase the scalability of crowd simulations. [ABSTRACT FROM AUTHOR]