Performance Analysis and Optimization of Graphics Processing Unit

List mode based image reconstruction is continuously gaining ground in PET imaging. The centerpiece of this reconstruction is the ray projector which unfortunately also represents the most time consuming part of the reconstruction process. Graphics processing units (GPU) represent today a cheap alternative to getting high computation power in medical imaging. However, only few GPU adapted methods have been proposed within the PET image reconstruction context, especially concerning the ray projector. In this work we propose and evaluate a new projector called DDA-ELL, which has the advantage of being applicable to both CPU and GPU architectures. The proposed projector was incorporated and evaluated within the 3D-OPLEM reconstruction algorithm implemented on both CPU and GPU architectures. Quantitative and qualitative performance evaluation was performed using simulated phantom and clinical datasets. We have shown that the proposed ray projector reconstructed images lead to improved noise and contrast characteristics compared to the widely used iterative Siddon approach. The speedup reached by the CPU version of our method compared to the iterative Siddon method was 11, while the GPU version was nearly 140 times faster.

Most Computational Fluid Dynamics (CFD) applications solve the Naiver-Stokes equations using various discretization methods like Finite Difference Method (FDM), Finite Element Method (FEM), Finite Volume Method (FVM), etc. The most compute-intensive process in CFD algorithms is the pressure Poisson solver. Solving the pressure Poisson equation requires the solution of a set of linear simultaneous equations. As the problem size/complexity increases, so does the effort and time invested in solving the equations. This study presents fast and robust iterative solvers and the acceleration of the same using the Graphics Processing Unit (GPU) architecture. Serial versions of the codes are implemented in the C language and the parallelization on GPU is achieved using Compute Unified Device Architecture (CUDA). For this study, a two-dimensional heat conduction problem is considered. FDM is used for discretization. Iterative solvers Conjugate Gradient and Multi Grid methods have been implemented in serial and parallel. The performance enhancement with single GPU and CPU system over a single CPU in terms of computing time is reported. It is seen that multigrid algorithms are superior in convergence and nearly 13 times speed-up has been obtained through GPU acceleration using CUDA, for a grid size of 2048 X 2048. The tests have been done on a cluster with Intel(R) Xeon(R) CPU E5-2670 CPU and NVIDIA K10 GPU.

A direct simulation Monte Carlo (DSMC) method is implemented on graphical processing unit (GPU) architecture to simulate the deposition phenomena that occur on a glass panel during modern organic light emitting diodes (OLED) manufacturing processes with a huge number of simulated particles because a fully three-dimensional (3D) particle simulation is required to accurately predict deposition thickness and uniformity on the substrate in a low-pressure environment. To examine the accuracy and efficiency of the newly developed DSMC code running on GPU architecture, verification and validation tests were performed by solving several benchmarking problems. Under three conditions which have been applied in previous OLED deposition process test experiments, the new DSMC model successfully simulates the transport of organic material evaporated from the heated nozzle array and its deposition onto a glass panel inside a low-pressure chamber. The uniformity and normalized thickness between the DSMC and experimental results for the three test cases are then compared. The normalized thickness of the organic material deposited to the large glass panel calculated from the DSMC is found to have an error of less than 4%, and the uniformity values calculated from the absolute deposition thickness show good agreement with those obtained from experimental data in all test cases.

High-fidelity simulations of turbulent flames are computationally expensive when using detailed chemical kinetics. For practical fuels and flow configurations, chemical kinetics can account for the vast majority of the computational time due to the highly non-linear nature of multi-step chemistry mechanisms and the inherent stiffness of combustion chemistry. While reducing this cost has been a key focus area in combustion modeling, the recent growth in graphics processing units (GPUs) that offer very fast arithmetic processing, combined with the development of highly optimized libraries for artificial neural networks used in machine learning, provides a unique pathway for acceleration. The goal of this paper is to recast Arrhenius kinetics as a neural network using matrix-based formulations. Unlike ANNs that rely on data, this formulation does not require training and exactly represents the chemistry mechanism. More specifically, connections between the exact matrix equations for kinetics and traditional artificial neural network layers are used to enable the usage of GPU-optimized linear algebra libraries without the need for modeling. Regarding GPU performance, speedup and saturation behaviors are assessed for several chemical mechanisms of varying complexity. The performance analysis is based on trends for absolute compute times and throughput for the various arithmetic operations encountered during the source term computation. The goals are ultimately to provide insights into how the source term calculations scale with the reaction mechanism complexity, which types of reactions benefit the GPU formulations most, and how to exploit the matrix-based formulations to provide optimal speedup for large mechanisms by using sparsity properties. Overall, the GPU performance for the species source term evaluations reveals many informative trends with regards to the effect of cell number on device saturation and speedup. Most importantly, it is shown that the matrix-based method enables highly efficient GPU performance across the board, achieving near-peak performance in saturated regimes.

The graphics processing unit (GPU) became an undoubtedly important computing engine for high-performance computing. With massive parallelism and easy programmability, GPU has been quickly adopted by various emerging computing domains including gaming, artificial intelligence, security, virtual reality, and so on. With its huge success in the market, GPU execution and its architecture became one of the essential topics in parallel computing today. The goal of this chapter is to provide readers with a basic understanding of GPU architecture and its programming model. This chapter explores the historical background of current GPU architecture, basics of various programming interfaces, core architecture components such as shader pipeline, schedulers and memories that support SIMT execution, various types of GPU device memories and their performance characteristics, and some examples of optimal data mapping to memories. Several recent studies are also discussed that helped advance the GPU architecture from the perspectives of performance, energy efficiency, and reliability.

Recently, graphical processing units (GPUs) have found a prominent role in general-purpose applications. Specifically, in parallel processing applications where a considerable number of tasks should be processed while meeting specific design constraints. One of the most interesting subjects in this area is cipher breaking via brute-force attacks, which attracts the attention of many researchers to the field. In this paper, we introduce a novel exhaustive key search approach for block cipher cryptosystems. The key point is how to utilize the single instruction multiple thread architecture to improve the speed of the DES-like hardware-based cryptosystems. At first, the standard DES core is implemented while all operations like bit permutation, swapping, and general hardware data stream follow the original algorithm. Then, in order to maximize the usage of the memory bandwidth and to eliminate the bit access penalty in GPU architecture, we exploit the register permutation and swapping (instead of the conventional bit swapping) in our implementation. In this approach, each thread examines a set of 32 keys per each iteration and hence a considerable throughput is achieved. The experimental results demonstrate 24K $$\times $$ , 800 $$\times $$ , and 400 $$\times $$ speed up over the traditional DES implementation on single-core CPU, the best previous work on multi-core CPU, and the conventional implementation on GPU, respectively. Furthermore, we measure the power and energy consumption of the best GPU and CPU approaches, where the GPU implementation proves to be more power efficient.

This document discusses the evaluation of a consolidated linear performance model of Texas State University's HPC LEAP Cluster, and the development of a non-linear model to represent the performance of the NVIDIA V100 Graphics Processing Unit (GPU). The consolidated model constructed for the LEAP Cluster was evaluated by using it to compute execution times for different sizes of processes and comparing those times to the actual processes run on LEAP. The model itself is found to effectively represent the performance trends of LEAP but fail to match the actual value. The GPU's performance analysis was done by first collecting performance data then using non-linear methods to model it. The number of floating-point operations required to perform a square matrix multiplication is readily known, so the performance data was gathered by running a simple square matrix multiplication program and measuring its execution time. The size of the matrices was then used to determine the number of floating-point operations and divided by the execution time to calculate FLOPS. The final model for the GPU was generated by using a set of logarithmic functions that mapped the GPU performance to a semi-logarithmic scale of the number of floating-point operations.

The Ansys Fluent GPU solver is a native GPU-powered solver, which uses the high performance of graphics processing units (GPUs) to facilitate the computation of complex simulations. More than CPUs, GPUs are optimized for parallel processing and have high bandwidth memory, resulting in remarkable increase in performance of flow calculations with respect to the traditional multi-core CPU-based computations. The recent advancements in GPU hardware make the native GPU solver unique and attractive for applications with computationally intensive flow solutions like aeroengines where dense meshes, complex multiphysics and turbulent interacting phenomena coexist. The current work examines a general-purpose finite rate chemistry solver development in the native GPU solver. Specifically, we explore the capability of the finite rate chemistry solver in simulations of experimentally well-characterized fully premixed and partially premixed turbulent flames, ranging from hydrogen flames to blended fuels. We showcase good agreement between the computed resolved mean statistics and experimental measurements. Each case is used to validate the accuracy of the GPU solution against experimental measurements. The objective of this work is to understand and optimize computational efficiency for detailed chemistry solutions in GPU framework. Following the establishment of the baseline results, scaling and benchmarking studies are conducted over three different mesh densities.

Monte Carlo simulation (MCS) plays a key role in medical applications, especially for emission tomography and radiotherapy. However MCS is also associated with long calculation times that prevent its use in routine clinical practice. Recently, graphics processing units (GPU) became in many domains a low cost alternative for the acquisition of high computational power. The objective of this work was to develop an efficient framework for the implementation of MCS on GPU architectures. Geant4 was chosen as the MCS engine given the large variety of physics processes available for targeting different medical imaging and radiotherapy applications. In addition, Geant4 is the MCS engine behind GATE which is actually the most popular medical applications' simulation platform. We propose the definition of a global strategy and associated structures for such a GPU based simulation implementation. Different photon and electron physics effects are resolved on the fly directly on GPU without any approximations with respect to Geant4. Validations have shown equivalence in the underlying photon and electron physics processes between the Geant4 and the GPU codes with a speedup factor of 80–90. More clinically realistic simulations in emission and transmission imaging led to acceleration factors of 400–800 respectively compared to corresponding GATE simulations.

We propose a generalized method for adapting and optimizing algorithms for efficient execution on modern graphics processing units (GPU). The method consists of several steps. First, build a control flow graph (CFG) of the algorithm. Next, transform the CFG into a tree of loops and merge non-parallelizable loops into parallelizable ones. Finally, map the resulting loops tree to the tree of GPU computational units, unrolling the algorithm’s loops as necessary for the match. The mapping should be performed bottom-up, from the lowest GPU architecture levels to the highest ones, to minimize off-chip memory access and maximize register file usage. The method provides programmer with a convenient and robust mental framework and strategy for GPU code optimization. We demonstrate the method by adapting to a GPU the DPLL backtracking search algorithm for solving the Boolean satisfiability problem (SAT). The resulting GPU version of DPLL outperforms the CPU version in raw tree search performance sixfold for regular Boolean satisfiability problems and twofold for irregular ones.

We present a spectral crystal plasticity (CP) solver for graphics processing unit (GPU) architectures that achieves a tenfold increase in efficiency over prior GPU solvers. The approach makes use of a database containing a spectral decomposition of CP simulations performed using a conventional iterative solver over a parameter space of crystal orientations and applied velocity gradients. The key improvements in efficiency come from reducing global memory transactions, exposing more instruction-level parallelism, reducing integer instructions and performing fast range reductions on trigonometric arguments. The scheme also makes more efficient use of memory than prior work, allowing for larger problems to be solved on a single GPU. We illustrate these improvements with a simulation of 390 million crystal grains on a consumer-grade GPU, which executes at a rate of 2.72 s per strain step.

The architecture of the latest Graphic Processing Unit (GPU) has surpassed the previous application-specific stream architecture. This has led to an architecture consisting of a number of uniform programmable units integrated on the same chip which facilitate the general-purpose computing beyond the graphic processing. With the multiple programmable units executing in parallel, the latest GPU shows superior performance. Furthermore, programmers can have a direct control on the GPU pipeline using easy-to-use parallel programming environments, whereas they had to rely on specific graphics API's in the past. These advances in hardware and software make General-Purpose GPU (GPGPU) computing widespread. In this paper, using the latest GPU and its software environment, we parallelize a computationally demanding financial application and optimize its performance. We also analyze the performance results compared with those obtained using CPU only. Experimental results show that GPU can achieve a superior performance, greater than 190x, compared with the CPU-only case.

The power consumption models of mobile application processors have emerged as key objects of interest following the tremendous growth in mobile device production given that such consumption is an important factor in the graphics performance of mobile technologies. Conventionally, the performance of the graphics processing units (GPUs) depends critically on texture mapping units, which is why the number of such GPU components and texture fill rates value prominently whenever the GPU performance is evaluated. Our previous work has established a model to predict maximum performance based on unified shaders. By extending the work, this paper developed a practically applicable GPU performance prediction model on the basis of texture mapping performance. The effects of increased texture mapping units on unified shader performance and GPU efficiency were examined, and a performance prediction model based on the number of frames per second (FPS) was constructed. For these purposes, a benchmark related to texture mapping units was formulated and the experiments were conducted to determine utilization factors that are relevant to GPU performance and efficiency. The final stage in model construction involved establishing a relationship between the previously investigated utilization factors and relevant resources that are consumed during graphics processing. The experimental results showed that the proposed prediction model produced an average error rate of 5.77%.

The Single Instruction Multiple Data (SIMD) architecture of Graphic Processing Units (GPUs) makes them perfect for parallel processing of big data. In this paper, we present the design, implementation and evaluation of G-Storm , a GPU-enabled parallel system based on Storm, which harnesses the massively parallel computing power of GPUs for high-throughput online stream data processing. G-Storm has the following desirable features: 1) G-Storm is designed to be a general data processing platform as Storm, which can handle various applications and data types. 2) G-Storm exposes GPUs to Storm applications while preserving its easy-to-use programming model. 3) G-Storm achieves high-throughput and low-overhead data processing with GPUs. 4) G-Storm accelerates data processing further by enabling Direct Data Transfer (DDT), between two executors that process data at a common GPU. We implemented G-Storm based on Storm 0.9.2 and tested it using three different applications, including continuous query, matrix multiplication and image resizing. Extensive experimental results show that 1) Compared to Storm, G-Storm achieves over 7× improvement on throughput for continuous query, while maintaining reasonable average tuple processing time. It also leads to 2.3× and 1.3× throughput improvements on the other two applications, respectively. 2) DDT significantly reduces data processing time.

Complex networks are a technique for the modeling and analysis of large data sets in many scientific and engineering disciplines. Due to their excessive size conventional algorithms and single core processors struggle with the efficient processing of such networks. Employing multi-core graphic processing units (GPUs) could provide sufficient processing power for the analysis of such networks. However, commonly designed algorithms cannot exploit these massively parallel processing power for the analysis of such networks. In this paper, we present the Multi Layer Network Decomposition (MLND) approach which provides a general approach for parallel network analysis using multi-core processors via efficient partitioning and mapping of networks onto GPU architectures. Evaluation using a 336 core GPU graphic card demonstrated a 16x speed-up in complex network analysis relative to a CPU based approach.