Programmable Graphics Processing Units Research Articles

Advances in CUDA for computational physics

Advances in the graphics processing unit (GPU) development led to the opportunity for software developers to increase the execution speed for their programs by massive parallelization of the algorithms using GPU programming. NVIDIA company developed an arhitecture for parallel computing named Compute Unified Device Architecture (CUDA) which includes a set of CUDA instructions and the hardware for parallel computing. Computational Physics is an interdisciplinary field which is in continuous progress and which studies, develops and optimizes numerical algorithms and computational techniques for their application in solving various physics problems. Computational Physics has applicability in all sub-branches of physics and related fields such as: biophysics, astrophysics, plasma physics, biomechanics, fluid physics, etc. Moreover, with the evolution of technology in the last few decades, this relatively new field has helped to quickly obtain results in these fields, facilitating the connection between theoretical and experimental physics. In this paper, some of the latest researches and results obtained in computational physics by using GPU computing with CUDA architecture are reviewed.

Accurate Global Point Cloud Registration Using GPU-Based Parallel Angular Radon Spectrum.

Accurate robot localization and mapping can be improved through the adoption of globally optimal registration methods, like the Angular Radon Spectrum (ARS). In this paper, we present Cud-ARS, an efficient variant of the ARS algorithm for 2D registration designed for parallel execution of the most computationally expensive steps on Nvidia™ Graphics Processing Units (GPUs). Cud-ARS is able to compute the ARS in parallel blocks, with each associated to a subset of input points. We also propose a global branch-and-bound method for translation estimation. This novel parallel algorithm has been tested on multiple datasets. The proposed method is able to speed up the execution time by two orders of magnitude while obtaining more accurate results in rotation estimation than state-of-the-art correspondence-based algorithms. Our experiments also assess the potential of this novel approach in mapping applications, showing the contribution of GPU programming to efficient solutions of robotic tasks.

Benchmarking Optimization Algorithms for Auto-Tuning GPU Kernels

Recent years have witnessed phenomenal growth in the application, and capabilities of Graphical Processing Units (GPUs) due to their high parallel computation power at relatively low cost. However, writing a computationally efficient GPU program (kernel) is challenging, and generally only certain specific kernel configurations lead to significant increases in performance. Auto-tuning is the process of automatically optimizing software for highly-efficient execution on a target hardware platform. Auto-tuning is particularly useful for GPU programming, as a single kernel requires re-tuning after code changes, for different input data, and for different architectures. However, the discrete, and non-convex nature of the search space creates a challenging optimization problem. In this work, we investigate which algorithm produces the fastest kernels if the time-budget for the tuning task is varied. We conduct a survey by performing experiments on 26 different kernel spaces, from 9 different GPUs, for 16 different evolutionary black-box optimization algorithms. We then analyze these results and introduce a novel metric based on the PageRank centrality concept as a tool for gaining insight into the difficulty of the optimization problem. We demonstrate that our metric correlates strongly with observed tuning performance.

Efficient GPU Cloud architectures for outsourcing high-performance processing to the Cloud

The world is becoming increasingly dependant in computing intensive applications. The appearance of new paradigms, such as Internet of Things (IoT), and advances in technologies such as Computer Vision (CV) and Artificial Intelligence (AI) are creating a demand for high-performance applications. In this regard, Graphics Processing Units (GPUs) have the ability to provide better performance by allowing a high degree of data parallelism. These devices are also beneficial in specialized fields of manufacturing industry such as CAD/CAM. For all these applications, there is a recent tendency to offload these computations to the Cloud, using a computing offloading Cloud architecture. However, the use of GPUs in the Cloud presents some inefficiencies, where GPU virtualization is still not fully resolved, as our research on what main Cloud providers currently offer in terms of GPU Cloud instances shows. To address these problems, this paper first makes a review of current GPU technologies and programming techniques that increase concurrency, to then propose a Cloud computing outsourcing architecture to make more efficient use of these devices in the Cloud.

PCIe-based FPGA-GPU heterogeneous computation for real-time multi-emitter fitting in super-resolution localization microscopy.

Real-time multi-emitter fitting is a key technology for advancing super-resolution localization microscopy (SRLM), especially when it is necessary to achieve dynamic imaging quality control and/or optimization of experimental conditions. However, with the increase of activation densities, the requirements in the computing resources would increase rapidly due to the complexity of the fitting algorithms, making it difficult to realize real-time multi-emitter fitting for emitter density more than 0.6 mol/µm2 in large field of view (FOV), even after acceleration with the popular Graphics Processing Unit (GPU) computation. Here we adopt the task parallelism strategy in computer science to construct a Peripheral Component Interconnect Express (PCIe) based all-in-one heterogeneous computing platform (AIO-HCP), where the data between two major parallel computing hardware, Field Programmable Gate Array (FPGA) and GPU, are interacted directly and executed simultaneously. Using simulated and experimental data, we verify that AIO-HCP could achieve a data throughput of up to ∼ 1.561 GB/s between FPGA and GPU. With this new platform, we develop a multi-emitter fitting method, called AIO-STORM, under big data stream parallel scheduling. We show that AIO-STORM is capable of providing real-time image processing on raw images with 100 µm × 100 µm FOV, 10 ms exposure time and 5.5 mol/µm2 structure density, without scarifying image quality. This study overcomes the data throughput limitation of heterogeneous devices, demonstrates the power of the PCIe-based heterogeneous computation platform, and offers opportunities for multi-scale stitching of super-resolution images.

Productively accelerating positron emission tomography image reconstruction on graphics processing units with Julia

Research in medical imaging is hampered by a lack of programming languages that support productive, flexible programming as well as high performance. In search for higher quality imaging, researchers can ideally experiment with novel algorithms using rapid-prototyping languages such as Python. However, to speed up image reconstruction, computational resources such as those of graphics processing units (GPUs) need to be used efficiently. Doing so requires re-programming the algorithms in lower-level programming languages such as CUDA C/C++ or rephrasing them in terms of existing implementations of established algorithms in libraries. The former has a detrimental impact on research productivity and requires system-level programming expertise, and the latter puts severe constraints on the flexibility to research novel algorithms. Here, we investigate the use of the Julia scientific programming language in the domain of PET image reconstruction as a means to obtain both high performance (portability) on GPUs and high programmer productivity and flexibility, all at once, without requiring expert GPU programming knowledge. Using rapid-prototyping features of Julia, we developed basic and performance-optimized GPU implementations of baseline maximum likelihood expectation maximization (MLEM) positron emission tomography (PET) image reconstruction algorithms, as well as multiple existing algorithmic extensions. Thus, we mimic the effort that researchers would have to invest to evaluate the quality and performance potential of algorithms. We evaluate the obtained performance and compare it to state-of-the-art existing implementations. We also analyse and compare the required programming effort. With the Julia implementations, performance in line with existing GPU implementations written in the low-level, unproductive programming language CUDA C is achieved, while requiring much less programming effort, even less than what is needed for much less performant CPU implementations in C++. Switching to Julia as the programming language of choice can therefore boost the productivity of research into medical imaging and deliver excellent performance at a low cost in terms of programming effort.

Accelerating the finite element method for calculating the full 2-body problem with CUDA

Binary asteroids in solar systems usually have irregularly shaped components; and their internal structures, though lacking direct measurements, are suspected to be uneven given the theoretical considerations of their formation history. This poses a huge challenge to precise dynamic modelling. The finite element method (FEM) is capable of modelling asteroids with irregular shapes and heterogeneous internal structures with good convergence. However, the implementation of the FEM in the full 2-body problem is usually time-consuming for single-core CPU processing. We note that the computing process is comprised of serialized independent calculations that can be parallelized with inexpensive and ubiquitous graphics processing unit (GPU) hardware. We propose a parallel algorithm to accelerate the FEM to calculate the full 2-body problem with CUDA (Compute Unified Device Architecture). Benchmarking tests are performed to verify this method, which is later applied to the study of the motion of the binary asteroid system (66391) 1999KW4. Simulations with more than 10 thousand nodes on a single graphics card exhibit a speedup of up to two orders of magnitude over using a single-core CPU. Both the achieved speedup(s) and the numerical simulation result accuracy suggest that CUDA-based GPU programming can be used in the FEM for computational full 2-body problem methods with efficiency and reliability. As an application, we studied the motion of the binary asteroid system (65803) Didymos, the target object of the DART mission. With the simulation results, we show the influences of the irregular shape/uneven internal structure of the primary on the postimpact motion of the secondary. The code is available at https://github.com/yyu86/femF2BP.git .

3D tools for building and infrastructures inspection from thermal UAS data: first steps

Thermal imaging has been widely used for the inspection of human-made and natural scenarios, from electrical installations and advanced machinery to buildings. Regarding buildings, it can be used to assess problems concerning heat, airflows, and water. Hence, thermography has been increasingly applied to the energy efficiency of new and old buildings. Some examples of applications are the detection of heating and cooling losses, moisture sources, missing insulation, floor heating failures, and the evaluation of building restorations. However, the main drawback of thermal imagery is its reduced resolution, e.g., 640 × 512, which is significantly lower than RGB imagery. In the case of buildings, cameras or thermal sensors mounted on UAS (Unmanned Aerial System) offer a wider range of possibilities by acquiring areas not accessible by other surveying methods. This paper presents a tool that allows building dense 3D thermal point clouds applied to conserving buildings and infrastructures inspection. Also, the aim of this work is to provide a visualization solution of the generated point clouds, thus allowing a human operator to analyze building defects. Accordingly, the rendering is improved by taking advantage of modern Graphical Processing Unit (GPU) capabilities, while also considering the occlusion for the accurate assignment of thermal information to the point cloud. Due to the high response time of the procedure, the complete pipeline is accelerated using GPU programming. Finally, our method is proven to generate point clouds with a higher number of points and density than notable commercial solutions, while also lowering the response time.

Evolution of the Graphics Processing Unit (GPU)

Graphics processing units (GPUs) power today’s fastest supercomputers, are the dominant platform for deep learning, and provide the intelligence for devices ranging from self-driving cars to robots and smart cameras. They also generate compelling photorealistic images at real-time frame rates. GPUs have evolved by adding features to support new use cases. NVIDIA’s GeForce 256, the first GPU, was a dedicated processor for real-time graphics, an application that demands large amounts of floating-point arithmetic for vertex and fragment shading computations and high memory bandwidth. As real-time graphics advanced, GPUs became programmable. The combination of programmability and floating-point performance made GPUs attractive for running scientific applications. Scientists found ways to use early programmable GPUs by casting their calculations as vertex and fragment shaders. GPUs evolved to meet the needs of scientific users by adding hardware for simpler programming, double-precision floating-point arithmetic, and resilience.

Continuous Gravitational-Wave Data Analysis with General Purpose Computing on Graphic Processing Units

We present a new approach to searching for Continuous gravitational Waves (CWs) emitted by isolated rotating neutron stars, using the high parallel computing efficiency and computational power of modern Graphic Processing Units (GPUs). Specifically, in this paper the porting of one of the algorithms used to search for CW signals, the so-called FrequencyHough transform, on the TensorFlow framework, is described. The new code has been fully tested and its performance on GPUs has been compared to those in a CPU multicore system of the same class, showing a factor of 10 speed-up. This demonstrates that GPU programming with general purpose libraries (the those of the TensorFlow framework) of a high-level programming language can provide a significant improvement of the performance of data analysis, opening new perspectives on wide-parameter searches for CWs.

A survey of software implementations used by application codes in the Exascale Computing Project

The US Department of Energy Office of Science and the National Nuclear Security Administration initiated the Exascale Computing Project (ECP) in 2016 to prepare mission-relevant applications and scientific software for the delivery of the exascale computers starting in 2023. The ECP currently supports 24 efforts directed at specific applications and six supporting co-design projects. These 24 application projects contain 62 application codes that are implemented in three high-level languages—C, C++, and Fortran—and use 22 combinations of graphical processing unit programming models. The most common implementation language is C++, which is used in 53 different application codes. The most common programming models across ECP applications are CUDA and Kokkos, which are employed in 15 and 14 applications, respectively. This article provides a survey of the programming languages and models used in the ECP applications codebase that will be used to achieve performance on the future exascale hardware platforms.

Modelling Casuarina junghuhniana dispersal in Tengger sea of sands of Bromo Tengger Semeru National Park using cellular automata

The growing of population of a pioneer species may show a unique behavior. Casuarina junghuhniana is reported as a pioneer species, this is because of its tolerance to adverse environment and transform it to become inhabitable for other organism. A comprehensive method involving field observation, the use of mathematical model and computation to understand plants behavior still needs to be developed. This paper is attempting to show a method to build a model for showing unique dispersal behavior of Casuarina junghuhniana. A relatively straightforward use of Fisher’s reaction diffusion equation, cellular automata based modeling and programming can show behavior easier to understand on a grid space. Some assumption must be used to represent the C. junghuhniana dispersal. As it is known that C. junghuhniana can reproduce both vegetatively and generatively, and both were assumed to have different dispersal behavior. Vegetative reproduction using shoots emerging from roots has pattern to spread close to each other. While generative reproduction by seeds which is lightweight has possibility spread further with the help of wind. The total model area of 1km 2 was divided into 300 × 300 cells which represents 1 km 2 area. Cellular automata apply the same rule to each cell and the result was observed from the pattern of cells interaction. A simple program was developed using Python with Jupyter Notebook an interactive computing environment. The number of iteration was limited before observed simulation reached one of area boundaries. The simulation running time was greatly reduced using Graphical Processing Unit (GPU) parallel processing. NUMBA was used as an interface between python and Compute Unified Device Architecture (CUDA), the GPU programming API. The simulation showed behavior of the trees spread downward along the slope. The wind direction simulation with additional data from wind rose available from internet was also demonstrated in the simulation. Modeling dispersal with influence from wind showed more sporadic pattern at further distance from originating parents cluster. The trees in the simulation showed clusters in dispersal pattern when rely more on generative reproduction. When the trees rely on vegetative reproduction by roots shoots, the population showed more like continuous cover. When concerning real 3 dimensional aspect, this simulation still can not distinguish vertical (z axis) aspect. It means two points would be seen as close to each other although they actually have far vertical distance. At this stage, the simulation has not yet been optimized to easily convert input from the wind rose. The wind information still needs to be written as code into the program.

GPU Programming Productivity in Different Abstraction Paradigms

Coprocessor architectures in High Performance Computing are prevalent in today’s scientific computing clusters and require specialized knowledge for proper utilization. Various alternative paradigms for parallel and offload computation exist, but little is known about the human factors impacts of using the different paradigms. With computer science student participants from the University of Nevada, Las Vegas with no previous exposure to Graphics Processing Unit programming, our study compared NVIDIA CUDA C/C++ as a control group and the Thrust library. The designers of Thrust claim their higher level of abstraction enhances programmer productivity. The trial was conducted on 91 participants and was administered through our computerized testing platform. Although the study was narrowly focused on the basic steps of an offloaded computation problem and was not intended to be a comprehensive evaluation of the superiority of one approach or the other, we found evidence that although Thrust was designed for ease of use, the abstractions tended to be confusing to students and in several cases diminished productivity. Specifically, abstractions in Thrust for (i) memory allocation through a C++ Standard Template Library-style vector library call, (ii) memory transfers between the host and Graphics Processing Unit coprocessor through an overloaded assignment operator, and (iii) execution of an offloaded routine through a generic transform library call instead of a CUDA kernel routine all performed either equal to or worse than CUDA.

GpuRIR: A python library for room impulse response simulation with GPU acceleration

The Image Source Method (ISM) is one of the most employed techniques to calculate acoustic Room Impulse Responses (RIRs), however, its computational complexity grows fast with the reverberation time of the room and its computation time can be prohibitive for some applications where a huge number of RIRs are needed. In this paper, we present a new implementation that dramatically improves the computation speed of the ISM by using Graphic Processing Units (GPUs) to parallelize both the simulation of multiple RIRs and the computation of the images inside each RIR. Additional speedups were achieved by exploiting the mixed precision capabilities of the newer GPUs and by using lookup tables. We provide a Python library under GNU license that can be easily used without any knowledge about GPU programming and we show that it is about 100 times faster than other state of the art CPU libraries. It may become a powerful tool for many applications that need to perform a large number of acoustic simulations, such as training machine learning systems for audio signal processing, or for real-time room acoustics simulations for immersive multimedia systems, such as augmented or virtual reality.

Hybrid MPI and CUDA Parallelization for CFD Applications on Multi-GPU HPC Clusters

Graphics processing units (GPUs) have a strong floating-point capability and a high memory bandwidth in data parallelism and have been widely used in high-performance computing (HPC). Compute unified device architecture (CUDA) is used as a parallel computing platform and programming model for the GPU to reduce the complexity of programming. The programmable GPUs are becoming popular in computational fluid dynamics (CFD) applications. In this work, we propose a hybrid parallel algorithm of the message passing interface and CUDA for CFD applications on multi-GPU HPC clusters. The AUSM + UP upwind scheme and the three-step Runge–Kutta method are used for spatial discretization and time discretization, respectively. The turbulent solution is solved by the K−ω SST two-equation model. The CPU only manages the execution of the GPU and communication, and the GPU is responsible for data processing. Parallel execution and memory access optimizations are used to optimize the GPU-based CFD codes. We propose a nonblocking communication method to fully overlap GPU computing, CPU_CPU communication, and CPU_GPU data transfer by creating two CUDA streams. Furthermore, the one-dimensional domain decomposition method is used to balance the workload among GPUs. Finally, we evaluate the hybrid parallel algorithm with the compressible turbulent flow over a flat plate. The performance of a single GPU implementation and the scalability of multi-GPU clusters are discussed. Performance measurements show that multi-GPU parallelization can achieve a speedup of more than 36 times with respect to CPU-based parallel computing, and the parallel algorithm has good scalability.

Computing integrals for electron molecule scattering on heterogeneous accelerator systems

SummaryUsing heterogeneous accelerators to obtain high performance for mathematical kernels remains an active research frontier in computational science. The accelerators have compute architectures that are different from the CPUs and in addition have memory spaces independent of the CPU systems to which they are connected. It follows that accelerators require a different approach to writing optimal code than that needed on a multi‐CPU system. Taken together these issues have represented a significant barrier to widespread adoption of accelerators for execution with large legacy code bases. OpenCL has emerged as a common programming language with which to implement code that runs across a range of parallel architectures, including multi‐core CPUs. This article is a case study on how the instruction‐level parallelism offered by field programmable gate arrays (FPGAs) and GPUs through OpenCL can be exploited in molecular physics. The algorithm which we study is the evaluation of tail integrals between Gaussian type basis functions for the R‐matrix method, a task that arises in the study of scattering of low energy electrons by molecular targets. The results of our productivity study, which is the first application of OpenCL in this problem domain, show that significant performance can be obtained from both FPGA and graphics processing unit (GPU) accelerators for this application. We discuss suitable transformations unique to each accelerator architecture for the integrals studied and present performance results comparing the FPGA and GPU with execution on Intel multi‐core systems.

Characterizing and Exploiting Soft Error Vulnerability Phase Behavior in GPU Applications

System reliability has become a first-class design constraint. As the use of Graphics Processing Units (GPU) continues to increase in compute applications, including High Performance Computing (HPC) and safety-critical applications, so do the number of transient faults in GPUs. However, our understanding of the potential impact of transient fault propagation in GPU applications remains limited. This study shows that the resilience characteristics of GPU programs change significantly during program execution and these characteristics show repetitive, time-varying behavior. Interestingly, these repetitive, time-varying, resilience characteristics of GPU programs do not align or correlate well with the performance phases of GPU programs. Furthermore, this work discovers and validates that temporal changes in the vulnerability behavior during a kernel execution tends to coincide with changes in basic block execution paths. Finally, we demonstrate how these observations can be exploited to accelerate the fault injection campaigns for reliability assessment of GPU programs by an order of magnitude and open opportunities for designing other effective resilience mitigation strategies.

GPU acceleration of a 2D compressible Euler solver on CUDA-based block-structured Cartesian meshes

A novel block-structured Cartesian mesh method is developed that is well designed for the graphics processing unit (GPU) acceleration of flow simulations. The size of the mesh block is set based on the thread hierarchy in Compute Unified Device Architecture which is an easy-to-use GPU programming model. The mesh method is implemented in a finite-volume compressible flow solver, where the two-dimension steady Euler equations are solved by using the AUSM + scheme in spatial discretization and third-order total-variation-diminishing Runge–Kutta method in time discretization. For the GPU implementation, the redundant computation, data structure reorganization and Structure-of-Arrays (SoA) mesh layout are utilized to reduce the frequency and data size for information transfer between host and device. Two test cases, the supersonic flow over a circular cylinder and a NACA0012 airfoil, are presented to validate numerical approaches and valuate computational performance. Additionally, numerical experiments are carried out on a test case at different mesh sizes and execution configurations to investigate properties of the proposed method.

A Fast Spatial Clustering Method for Sparse LiDAR Point Clouds Using GPU Programming.

Fast and accurate obstacle detection is essential for accurate perception of mobile vehicles’ environment. Because point clouds sensed by light detection and ranging (LiDAR) sensors are sparse and unstructured, traditional obstacle clustering on raw point clouds are inaccurate and time consuming. Thus, to achieve fast obstacle clustering in an unknown terrain, this paper proposes an elevation-reference connected component labeling (ER-CCL) algorithm using graphic processing unit (GPU) programing. LiDAR points are first projected onto a rasterized x–z plane so that sparse points are mapped into a series of regularly arranged small cells. Based on the height distribution of the LiDAR point, the ground cells are filtered out and a flag map is generated. Next, the ER-CCL algorithm is implemented on the label map generated from the flag map to mark individual clusters with unique labels. Finally, obstacle labeling results are inverse transformed from the x–z plane to 3D points to provide clustering results. For real-time 3D point cloud clustering, ER-CCL is accelerated by running it in parallel with the aid of GPU programming technology.

Computer vision algorithms acceleration using graphic processors NVIDIA CUDA

Using graphic processing units (GPUs) in parallel with central processing unit in order to accelerate algorithms and applications demanding extensive computational resources has been a new trend used for the last few years. In this paper, we propose a GPU-accelerated method to parallelize different Computer vision tasks. We will report on parallelism and acceleration in computer vision applications, we provide an overview about the CUDA NVIDIA GPU programming language used. After that we will dive on GPU Architecture and acceleration used for time consuming optimization. We introduce a high-speed computer vision algorithm using graphic processing unit by using the NVIDIA’s programming framework compute unified device architecture (CUDA). We realize high and significant accelerations for our computer vision algorithms and we demonstrate that using CUDA as a GPU programming language can improve Efficiency and speedups. Especially we demonstrate the efficiency of our implementations of our computer vision algorithms by speedups obtained for all our implementations especially for some tasks and for some image sizes that come up to 8061 and 5991 and 722 acceleration times.