Compute Unified Device Architecture Kernel Research Articles

Optimizing the GPU based method calculating energy deposition of beams coupling with discrete materials in dynamical and thermal simulations for higher computing efficiency

In order to obtain more accurate energy deposition simulation results of beams coupling with discrete materials especially the granular materials in dynamical and thermal simulations, a discrete energy deposition calculation method was proposed previously to replace the equivalent homogenization method and accelerated with GPUs (Tian et al., 2021 [10]). However, it was found that the computing efficiency drops so severely with the increasing of the energy space size and the time required for simulations increases greatly unacceptably. In this work, for higher computing performance, based on the bottleneck analyses of CUDA (Compute Unified Device Architecture) kernels of the previous method, two improvements were made to the space cell marking phase and the energy deposition phase. In the space cell marking phase, a new proposed Lagrange-Euler Mapping Method searching the fixed space cells through flowing grains replaced the previous Euler Searching Method searching the flowing grains from fixed space cells. In the energy deposition phase, a warp aggregation method was used, assigning fewer threads to perform atomic operations. In the simulation of a granular-flow target bombarded by a 1 GeV proton beam setting a large energy computing space with a number of cells up to ∼108, the improved algorithm can effectively reduce the number of memory access instructions of CUDA warps. As a result, the computing performance was improved by 85% on A100 GPUs and 206% on K80 GPUs, making the dynamical and thermal simulations of granular-flow targets more efficient. Our method also could be beneficial for simulating the interactions between arbitrary source (or field) with a fixed spatial distribution and discrete materials.

Implementation of a parallel high-order WENO-type Euler equation solver using a CUDA PTX paradigm

ABSTRACT This study proposes the optimization of a low-level assembly code to reconstruct the flux for a splitting flux Harten–Lax–van Leer (SHLL) scheme on high-end graphic processing units. The proposed solver is implemented using the weighted essentially non-oscillatory reconstruction method to simulate compressible gas flows that are derived using an unsteady Euler equation. Instructions in the low-level assembly code, i.e. parallel thread execution and instruction set architecture in compute unified device architecture (CUDA), are used to optimize the CUDA kernel for the flux reconstruction method. The flux reconstruction method is a fifth-order one that is used to process the high-resolution intercell flux for achieving a highly localized scheme, such as the high-order implementation of SHLL scheme. Many benchmarking test cases including shock-tube and four-shock problems are demonstrated and compared. The results show that the reconstruction method is computationally very intensive and can achieve excellent performance up to 5183 GFLOP/s, ∼66% of peak performance of NVIDIA V100, using the low-level CUDA assembly code. The computational efficiency is twice the value as compared with the previous studies. The CUDA assembly code reduces 26.7% calculation and increases 37.5% bandwidth. The results show that the optimal kernel reaches up to 990 GB/s for the bandwidth. The overall efficiency of bandwidth and computation performance achieves 127% of the predicted performance based on the HBM2-memory roofline model estimated by Empirical Roofline Tool.

Component-based 2-/3-dimensional nearest neighbor search based on Elias method to GPU parallel 2D/3D Euclidean Minimum Spanning Tree Problem

We present improved data parallel approaches working on graphics processing unit (GPU) compute unified device architecture (CUDA) platform to build hierarchical Euclidean minimum spanning forest or tree (EMSF/EMST) for applications whose input only contains N points with arbitrary data distribution in 2D/3D Euclidean space. Characteristic of the proposed parallel algorithms follows “data parallelism, decentralized control and O(1) local memory occupied by each GPU thread”. This research has to solve GPU parallelism of component-based nearest neighbor search (component-based NNS), tree traversal, and other graph operations like union-find. For exact NNS, instead of using classical K-d tree search or brute-force computing method, we propose a K-d search method working based on dividing the Euclidean K-dimensional space into congruent and non-overlapping square/cubic cells where size of points in each cell is bounded. For component-based NNS, with the uniqueness property based on 2D/3D square/cubic space partition, we propose dynamic and static pruning techniques to prune unnecessary neighbor cells’ search. For tree traversal, instead of using breadth-first-search, this paper proposes CUDA kernels working with a distributed dynamic link list for selecting a local spanning tree’s shortest outgoing edge since size of local EMSTs in EMSF cannot be predicted. Source code is provided online and experimental comparisons are conducted on both 2D and 3D benchmarks with up to 107 points to build final EMST. Results show that applying K-d search with static pruning technique and the proposed operators totally working in parallel on GPU, our current implementation runs faster than our previous work and current optimal sequential dual-tree mlpack EMST library.

Wind farm simulations based on a DFIG machine using parallel programming

New computational techniques for simulating a large array of wind turbines are highly needed to model modern electrical grid networks. In this paper, an implementation of a doubly fed induction generator wind turbine model solver is proposed. This solver will run on an NVIDIA graphic processing unit, and it will be coded using the compute unified device architecture (CUDA). The implementation will integrate a linear time-invariant system represented by state-space matrices. It has been implemented a CUDA kernel capable of simulating many wind turbines in parallel with different wind profiles and using different configurations. Strategies such as optimizing memory access and overlapping data transfers with the kernel were used to obtain the results. The CUDA implementation reaches an occupancy of 95%, while simulating 500 wind turbines where each unit is subject to a different wind profile or using different configuration parameters.

Phaseless Auxiliary-Field Quantum Monte Carlo on Graphical Processing Units.

We present an implementation of phaseless Auxiliary-Field Quantum Monte Carlo (ph-AFQMC) utilizing graphical processing units (GPUs). The AFQMC method is recast in terms of matrix operations which are spread across thousands of processing cores and are executed in batches using custom Compute Unified Device Architecture kernels and the GPU-optimized cuBLAS matrix library. Algorithmic advances include a batched Sherman-Morrison-Woodbury algorithm to quickly update matrix determinants and inverses, density-fitting of the two-electron integrals, an energy algorithm involving a high-dimensional precomputed tensor, and the use of single-precision floating point arithmetic. These strategies accelerate ph-AFQMC calculations with both single- and multideterminant trial wave functions, though particularly dramatic wall-time reductions are achieved for the latter. For typical calculations we find speed-ups of roughly 2 orders of magnitude using just a single GPU card compared to a single modern CPU core. Furthermore, we achieve near-unity parallel efficiency using 8 GPU cards on a single node and can reach moderate system sizes via a local memory-slicing approach. We illustrate the robustness of our implementation on hydrogen chains of increasing length and through the calculation of all-electron ionization potentials of the first-row transition metal atoms. We compare long imaginary-time calculations utilizing a population control algorithm with our previously published correlated sampling approach and show that the latter improves not only the efficiency but also the accuracy of the computed ionization potentials. Taken together, the GPU implementation combined with correlated sampling provides a compelling computational method that will broaden the application of ph-AFQMC to the description of realistic correlated electronic systems.

GPU-Accelerated Self-Calibrating GRAPPA Operator Gridding for Rapid Reconstruction of Non-Cartesian MRI Data

Self-calibrating GRAPPA operator gridding (SC-GROG) is a method by which non-Cartesian (NC) data in magnetic resonance imaging (MRI) are shifted to the Cartesian k-space grid locations using the parallel imaging concept of GRAPPA operator. However, gridding with SC-GROG becomes computationally expensive and leads to longer reconstruction time when mapping a large number of NC samples in MRI data to the nearest Cartesian grid locations. This work aims to accelerate the SC-GROG for radial acquisitions in MRI, using massively parallel architecture of graphics processing units (GPUs). For this purpose, a novel implementation of GPU-accelerated SC-GROG is presented, which exploits the inherent parallelism in gridding operations. The proposed method employs the look-up-table (LUT)-based optimized kernels of compute unified device architecture (CUDA), to pre-calculate all the possible combinations of 2D-gridding weight sets and uses appropriate weight sets to shift the NC signals from multi-channel receiver coils at the nearest Cartesian grid locations. In the proposed method, LUTs are implemented to avoid the race condition among the CUDA kernel threads while shifting various NC points to the same Cartesian grid location. Several experiments using 24-channel simulated phantom and (12 and 30 channel) in vivo data sets are performed to evaluate the efficacy of the proposed method in terms of computation time and reconstruction accuracy. The results show that the GPU-based implementation of SC-GROG can significantly improve the image reconstruction efficiency, typically achieving 6× to 30× speed-up (including transfer time between CPU and GPU memory) without compromising the quality of image reconstruction.

Finite element method completely implemented for graphic processor units using parallel algorithm libraries

A finite element code is developed in which all of the computationally expensive steps are performed on a graphics processing unit via the THRUST and the PARALUTION libraries. The code focuses on the simulation of transient problems where the repeated computations per time-step create the computational cost. It is used to solve partial and ordinary differential equations as they arise in thermal-runaway simulations of automotive batteries. The speed-up obtained by utilizing the graphics processing unit for every critical step is compared against the single core and the multi-threading solutions which are also supported by the chosen libraries. This way a high total speed-up on the graphics processing unit is achieved without the need for programming a single classical Compute Unified Device Architecture kernel.

An artifact detection scheme with CUDA-based image operations

Many image filtering techniques can be accelerated with compute unified device architecture (CUDA)-based massively parallel implementations. In this paper, we show the major issues on our acceleration techniques, and also its implementation details. We implemented various image filtering operations in our own CUDA kernel programs, and they are combined to build an artifact-detection scheme in PCB board soldering process. We designed our own computational logics on the artifact detection, and finally, the whole system figure out the potential artifact regions. Comparing with the central processing unit-based reference implementation, we show its correctness and feasibility, with much execution speed-ups.

A graphics processing unit-accelerated meshless method for two-dimensional compressible flows

ABSTRACTA graphics processing unit (GPU) -accelerated meshless method is presented for solving two-dimensional compressible flows over aerodynamic bodies. The Compute Unified Device Architecture (CUDA) Fortran programming model is employed to port the meshless method from central processing unit to GPU as a way of achieving efficiency, which involves implementation of CUDA kernels and management of data storage structure and thread hierarchy. The CUDA kernel subroutines are designed to meet with the point-based computing of the meshless method. The corresponding point-based data structure and thread hierarchy are constructed or manipulated in the paper by presenting two specific GPU implementations of the meshless method, which are developed for solving Navier–Stokes equations. The Jameson–Schmidt–Turkel scheme is used to estimate the flux terms of the Navier–Stokes equations and an explicit four-stage Runge–Kutta scheme is applied to update the solution at time level. After tuning the performances of the resulting two GPU-accelerated meshless solvers by changing the number of threads in a block, a set of typical flows over aerodynamic bodies are simulated for validation. Numerical results are shown in a comparison with available experimental data or computational values that appear in extant literature with an analysis of code performance. This reveals that the cost of computing time of the presented test cases is significantly reduced for both solvers without losing accuracy, while impressive speedups up to 64 times are achieved due to careful management of memory access.

GPU-accelerated 3D reconstruction of porous media using multiple-point statistics

It is very important for the study of predicting fluid transport properties or mechanisms of fluid flow in porous media that the characteristics of porous media can be extracted in relatively smaller scales and then are copied in a larger or even arbitrary region to reconstruct virtual 3D porous media that have similar structures with the real porous media. One of multiple-point statistics (MPS) method, the single normal equation simulation algorithm (SNESIM), has been widely used in reconstructing 3D porous media recently. However, owing to its large CPU cost and rigid memory demand, the application of SNESIM has been limited in some cases. To overcome this disadvantage, parallelization of SNESIM is performed on the compute unified device architecture (CUDA) kernels in the graphic processing unit (GPU) to reconstruct each node on simulation grids, combined with choosing the optimal size of data templates based on the entropy calculation towards the training image (TI) to acquire high-quality reconstruction with a low CPU cost; meanwhile, the integration of hard data and soft data is also included in the processing of CUDA kernels to improve the accuracy. Representative elementary volumes (REVs) for porosity, variogram, and entropy are analyzed to guarantee that the scale of observation is large enough and parameters of concern are constant. This parallel GPU-version 3D porous media reconstruction only requires relatively small size memory and benefits from the tremendous calculating power given by CUDA kernels to shorten the CPU time, showing its high efficiency for the reconstruction of porous media.

Exploration of automatic optimisation for CUDA programming

Writing optimised compute unified device architecture (CUDA) program for graphic processing units (GPUs) is complex even for experts. We present a design methodology for a restructuring tool that converts C-loops into optimised CUDA kernels based on a three-step algorithm which are loop tiling, coalesced memory access and resource optimisation. A method for finding possible loop tiling solutions with coalesced memory access is developed and a simplified algorithm for restructuring C-loops into an efficient CUDA kernel is presented. In the evaluation, we implement matrix multiply (MM), matrix transpose (M-transpose), matrix scaling (M-scaling) and matrix vector multiply (MV) using the proposed algorithm. We present the analysis of the execution time and GPU throughput for the above applications, which favourably compare to other proposals. Evaluation is carried out while scaling the problem size and running under a variety of kernel configurations. The obtained speedup is about 28–35% for M-transpose compared to NVIDIA Software Development Kit, 33% speedup for MV compared to general purpose computation on graphics processing unit compiler, and more than 80% speedup for MM and M-scaling compared to CUDA-lite.

A CUDA implementation of the Continuous Space Language Model

The training phase of the Continuous Space Language Model (CSLM) was implemented in the NVIDIA hardware/software architecture Compute Unified Device Architecture (CUDA). A detailed explanation of the CSLM algorithm is provided. Implementation was accomplished using a combination of CUBLAS library routines, NVIDIA NPP functions, and CUDA kernel calls on three different CUDA enabled devices of varying compute capability and a time savings over the traditional CPU approach demonstrated. The efficiency of the CUDA version of the open source implementation is analyzed and compared to that using the Intel Math Kernel Libraries (MKL) on a variety of CUDA enabled and multi-core CPU platforms. It is demonstrated that substantial performance benefit can be obtained using CUDA, even with nonoptimal code. Techniques for optimizing performance are then provided. Furthermore, an analysis is performed to determine the conditions in which the performance of CUDA exceeds that of the multi-core MKL realization.

CU++: an object oriented framework for computational fluid dynamics applications using graphics processing units

The application of graphics processing units (GPU) to solve partial differential equations is gaining popularity with the advent of improved computer hardware. Various lower level interfaces exist that allow the user to access GPU specific functions. One such interface is NVIDIA's Compute Unified Device Architecture (CUDA) library. However, porting existing codes to run on the GPU requires the user to write kernels that execute on multiple cores, in the form of Single Instruction Multiple Data (SIMD). In the present work, a higher level framework, termed CU++, has been developed that uses object oriented programming techniques available in C++ such as polymorphism, operator overloading, and template meta programming. Using this approach, CUDA kernels can be generated automatically during compile time. Briefly, CU++ allows a code developer with just C/C++ knowledge to write computer programs that will execute on the GPU without any knowledge of specific programming techniques in CUDA. This approach is tremendously beneficial for Computational Fluid Dynamics (CFD) code development because it mitigates the necessity of creating hundreds of GPU kernels for various purposes. In its current form, CU++ provides a framework for parallel array arithmetic, simplified data structures to interface with the GPU, and smart array indexing. An implementation of heterogeneous parallelism, i.e., utilizing multiple GPUs to simultaneously process a partitioned grid system with communication at the interfaces using Message Passing Interface (MPI) has been developed and tested.

Auto‐tuning of level 1 and level 2 BLAS for GPUs

SUMMARYThe use of high‐performance libraries for dense linear algebra operations is of great importance in many numerical scientific applications. The most common operations form the backbone of the Basic Linear Algebra Subroutines (BLAS) library. In this paper, we consider the performance and auto‐tuning of level 1 and level 2 BLAS routines on graphical processing units. As examples, we develop single‐precision Compute Unified Device Architecture kernels for three of the most popular operations, the Euclidian norm (SNRM2), the matrix–vector multiplication (SGEMV), and the triangular solution (STRSV). The target hardware is the most recent Nvidia (Santa Clara, CA, USA) Tesla 20‐series (Fermi architecture), which is designed from the ground up for high‐performance computing. We show that it is essentially a matter of fully utilizing the fine‐grained parallelism of the many‐core graphical processing unit to achieve high performance for level 1 and level 2 BLAS operations. We show that auto‐tuning can be successfully employed to kernels for these operations so that they perform well for all input sizes. Copyright © 2012 John Wiley & Sons, Ltd.

Accelerating incompressible flow computations with a Pthreads-CUDA implementation on small-footprint multi-GPU platforms

Graphics processor units (GPU) that are originally designed for graphics rendering have emerged as massively-parallel "co-processors" to the central processing unit (CPU). Small-footprint multi-GPU workstations with hundreds of processing elements can accelerate compute-intensive simulation science applications substantially. In this study, we describe the implementation of an incompressible flow Navier---Stokes solver for multi-GPU workstation platforms. A shared-memory parallel code with identical numerical methods is also developed for multi-core CPUs to provide a fair comparison between CPUs and GPUs. Specifically, we adopt NVIDIA's Compute Unified Device Architecture (CUDA) programming model to implement the discretized form of the governing equations on a single GPU. Pthreads are then used to enable communication across multiple GPUs on a workstation. We use separate CUDA kernels to implement the projection algorithm to solve the incompressible fluid flow equations. Kernels are implemented on different memory spaces on the GPU depending on their arithmetic intensity. The memory hierarchy specific implementation produces significantly faster performance. We present a systematic analysis of speedup and scaling using two generations of NVIDIA GPU architectures and provide a comparison of single and double precision computational performance on the GPU. Using a quad-GPU platform for single precision computations, we observe two orders of magnitude speedup relative to a serial CPU implementation. Our results demonstrate that multi-GPU workstations can serve as a cost-effective small-footprint parallel computing platform to accelerate computational fluid dynamics (CFD) simulations substantially.