Design and Implementation of Particle Systems for Meshfree Methods with High Performance

Abstract

Particle systems, commonly associated with computer graphics, animation, and video games, are an essential component in the implementation of numerical methods ranging from the meshfree methods for computational fluid dynamics and related applications (e.g., smoothed particle hydrodynamics, SPH) to minimization methods for arbitrary problems (e.g., particle swarm optimization, PSO). These methods are frequently embarrassingly parallel in nature, making them a natural fit for implementation on massively parallel computational hardware such as modern graphics processing units (GPUs). However, naive implementations fail to fully exploit the capabilities of this hardware. We present practical solutions to the challenges faced in the efficient parallel implementation of these particle systems, with a focus on performance, robustness, and flexibility. The techniques are illustrated through GPUSPH, the first implementation of SPH to run completely on GPU, and currently supporting multi-GPU clusters, uniform precision independent of domain size, and multiple SPH formulations.

Efficient Simulation of Fluids

“…Moreover, the particles' data must be split into multiple arrays for efficiency (one array for position, one for density, one for pressure, etc.) as in [10].…”

“…Previous SPH implementations use the SORT pattern to build the neighbors' grid [7,9,10]. The first step consists in calculating the grid index of each particle, using a MAP.…”

“…The main problem is that the sorting algorithm takes a large part of the computation time, near 30% according to [10]. In this chapter, we avoid the full sorting by combining simple parallel patterns and atomic operations.…”

Fast, feature-rich weakly-compressible SPH on GPU: coding strategies and compiler choices

“…In most cases, the ideal storage system for the particle properties themselves (position, velocity, mass, density, apparent viscosity etc) is that of a structure of arrays, where an individual array is used for each property, optionally merging some scalar and vector properties that are frequently used together: for example, in GPUSPH we use a single 4-component vector data type to store 3D position and mass, and another 4-component vector to store velocity and density. This is especially convenient for hardware such as GPUs, but is actually convenient on most modern CPU systems as well [8], as it tends to naturally map array elements to the hardware vector types.…”

“…The adoption of the meta-programming techniques discussed so far has been the key to one of the most significant performance boost from version 4 to version 5 of GPUSPH: the split neighbors list processing, which has brought an overall performance improvement between 15% and 30%, depending on the combination of framework options and hardware capabilities [8,9].…”