Graphics Processing Unit Implementation Research Articles

A sample implementation for parallelizing Divide-and-Conquer algorithms on the GPU

The strategy of Divide-and-Conquer (D&C) is one of the frequently used programming patterns to design efficient algorithms in computer science, which has been parallelized on shared memory systems and distributed memory systems. Tzeng and Owens specifically developed a generic paradigm for parallelizing D&C algorithms on modern Graphics Processing Units (GPUs). In this paper, by following the generic paradigm proposed by Tzeng and Owens, we provide a new and publicly available GPU implementation of the famous D&C algorithm, QuickHull, to give a sample and guide for parallelizing D&C algorithms on the GPU. The experimental results demonstrate the practicality of our sample GPU implementation. Our research objective in this paper is to present a sample GPU implementation of a classical D&C algorithm to help interested readers to develop their own efficient GPU implementations with fewer efforts.

Fast Batched Solution for Real-Time Optimal Power Flow With Penetration of Renewable Energy

Renewable energy systems have become an integral part of modern power grid operation, where the forecasting error is inevitable even though advanced prediction techniques are utilized. To improve the solution efficiency and accuracy of real-time optimal power flow (RTOPF), a three-stage framework for parallel processing is employed in this paper. In Stage 1, uncertainties from renewable generators and demand loads are characterized with scenarios. Large numbers of RTOPFs corresponding to each scenario are formulated and addressed in Stage 2, where the linear systems are regulated into the same sparsity pattern and then tackled in a batched style with the graphics processing unit (GPU). Results from Stage 2 are utilized in Stage 3 to perform a hot-start RTOPF, where the forecasting error can be minimized. Case studies are implemented on the IEEE 14-bus, 57-bus, 118-bus, and 300-bus systems with 1024 scenarios. The superiority of the batched GPU solution has been validated by comparisons with regular GPU, parallel CPU, and sequential CPU implementations. Discussions on the batch size and hot-start strategy are also presented.

Accelerated Thermal Simulation for Three-Dimensional Interactive Optimization of Computer Numeric Control Sheet Metal Laser Cutting

In the context of computer numeric control (CNC)-based sheet metal laser cutting, the problem of heat transfer simulation is relevant for the optimization of CNC programs. Current physically based simulation tools use numeric or analytic algorithms which provide accurate but slow solutions due to the underlying mathematical description of the model. This paper presents: (1) an analytic solution to the laser heating problem of rectangular sheet metal for curved laser trajectories and convective cooling, (2) a graphics processing unit (GPU) implementation of the analytic solution for fast simulation of the problem, and (3) an integration within an interactive environment for the simulation of sheet metal CNC laser cutting. This analytic approach sacrifices the material removal effect of the laser cut in the favor of an approximated real-time temperature map on the sheet metal. The articulation of thermal, geometric, and graphic feedback in virtual manufacturing environments enables interactive redefinition of the CNC programs for better product quality, lower safety risks, material waste, and energy usage among others. The error with respect to finite element analysis (FEA) in temperature prediction descends as low as 3.5%.

Optimization and validation of accelerated golden-angle radial sparse MRI reconstruction with self-calibrating GRAPPA operator gridding.

Golden-angle radial sparse parallel (GRASP) MRI reconstruction requires gridding and regridding to transform data between radial and Cartesian k-space. These operations are repeatedly performed in each iteration, which makes the reconstruction computationally demanding. This work aimed to accelerate GRASP reconstruction using self-calibrating GRAPPA operator gridding (GROG) and to validate its performance in clinical imaging. GROG is an alternative gridding approach based on parallel imaging, in which k-space data acquired on a non-Cartesian grid are shifted onto a Cartesian k-space grid using information from multicoil arrays. For iterative non-Cartesian image reconstruction, GROG is performed only once as a preprocessing step. Therefore, the subsequent iterative reconstruction can be performed directly in Cartesian space, which significantly reduces computational burden. Here, a framework combining GROG with GRASP (GROG-GRASP) is first optimized and then compared with standard GRASP reconstruction in 22 prostate patients. GROG-GRASP achieved approximately 4.2-fold reduction in reconstruction time compared with GRASP (∼333 min versus ∼78 min) while maintaining image quality (structural similarity index ≈ 0.97 and root mean square error ≈ 0.007). Visual image quality assessment by two experienced radiologists did not show significant differences between the two reconstruction schemes. With a graphics processing unit implementation, image reconstruction time can be further reduced to approximately 14 min. The GRASP reconstruction can be substantially accelerated using GROG. This framework is promising toward broader clinical application of GRASP and other iterative non-Cartesian reconstruction methods. Magn Reson Med 80:286-293, 2018. © 2017 International Society for Magnetic Resonance in Medicine.

On the Evaluation of Different High-Performance Computing Platforms for Hyperspectral Imaging: An OpenCL-Based Approach

Hyperspectral imaging systems are a powerful tool for obtaining surface information in many different spectral channels that can be used in many different applications. Nevertheless, the huge amount of information provided by hyperspectral images also has a downside, since it has to be processed and analyzed. For such purpose, parallel hardware devices, such as field-programmable gate arrays (FPGAs) and graphic processing units (GPUs), are typically used, especially for hyperspectral imaging applications under real-time constraints. However, developing hardware applications typically requires expertise in the specific targeted device, as well as in the tools and methodologies that can be used to perform the implementation of the desired algorithms in that device. In this scenario, the Open Computing Language (OpenCL) emerges as a very interesting solution in which a single high-level language can be used to efficiently develop applications in multiple and different hardware devices. In this work, the parallel Fast Algorithm for Linearly Unmixing Hyperspectral Images (pFUN) has been implemented in two different NVIDIA GPUs, the GeForce GTX 980 and the Tesla K40c, using OpenCL. The obtained results are compared with the results provided by the previously developed NVIDIA CUDA implementation of the pFUN algorithm for the same GPU devices for comparing the efficiency of OpenCL against a more specific synthesis design language for the targeted hardware devices, such as CUDA is for NVIDIA GPUs. Moreover, the FUN algorithm has also been implemented into a Bitware Stratix V Altera FPGA, using OpenCL, for comparing the results that can be obtained using OpenCL when targeting different devices and architectures. The obtained results demonstrate the suitability of the followed methodology in the sense that it allows the achievement of efficient FPGA and GPU implementations able to cope with the stringent requirements imposed by hyperspectral imaging systems.

Block matching super-resolution parallel GPU implementation for computational imaging

This work presents the computational acceleration of a proprietary Super-Resolution (SR) algorithm (patented) for image and video enhancement. The considered algorithm is based on fusion SR techniques. The version proposed in this paper consists on the comparison of frames divided into Macro Blocks (MB) of fixed dimensions and on acquisition from a single camera. Due to its intensive computation, that limits its practical application in specific contexts where fast processing (even with real-time constraints) is necessary, the algorithm has been implemented in two platforms: OpenMP and GPU. Several tests have been conducted on seven popular image sequences and the results show a considerable improvement of the proposed solutions, in particular the Graphic Processing Units implementations. Consequently, it can be stated that GPUs represent an efficient solution to accelerate this type of algorithms to improve the perception of the image quality.

Complex coupled mode theory electromagnetic mode solver

We present a method for computing waveguide eigenmodes based on complex coupled mode theory (CCMT). This approach generalizes Fourier transform methods by allowing an arbitrary but convenient basis set to be used for the expansion. In the presented approach, one is free to choose an arbitrary basis representation; for example, we show the use of electromagnetic modes of a cylindrical metal waveguide. CCMT-computed modes are compared with modes computed using analytic expressions and results obtained using a finite difference solver. In cases where the basis set is small, the method can efficiently re-compute modes after structural refinements are made, and can efficiently compute dispersion. The parallel nature of the algorithm makes it well suited to a graphics processing unit implementation, as demonstrated here.

Review of GPU implementation to process of RNA sequence on cancer

Abstract Nowadays, in the field of research the Graphics Processing Units (GPUs) is possibly the maximum powerful computational hardware. Beside of powerful graphics engine, the modern GPU is also an advanced programmable processor attributes enlarges arithmetic and bandwidth memory which considerably rises with equivalent of Central Processing Unit (CPU). The capacity of GPU is considerably reduce the running time required and expanded invitation for the consideration of mainstream researchers. The used of GPU is to structure a vital area with an advantage of having a minimal effort and prepare for massive parallel power. About this study the researchers and developers become eager to utilize power for general-purpose of computing as identified together of GPGPU (“General-Purpose computing on the GPU”). On other hand, computing on the Graphics Processing Units (GPUs) is exploits parallel that RNA Sequence has effectively been connected to cancer study. RNA Sequence is a strategy created to transcriptome profiling that utilizes profound sequencing technologies. RNA Sequence is used for high-throughput sequencing techniques to convey understanding into the transcriptome of a cell. It has conquered a few disadvantages of already utilized advancements. RNA Sequence preferences are a single test, possibly new genes and splice isoforms, RNA alter, combination transcripts, and allele-particular appearance. This review presents GPU implementation methods, tools and RNA Sequence advantages on cancer.

Solution of 2-D Inverse Heat Conduction Problem with Graphic Accelerator

Abstract The parallelized particle swarm optimization (PSO) method has been developed to solve inverse heat transfer problems. Temporal- and spatial-dependent heat transfer coefficient functions obtained on the surfaces of axis-symmetrical work pieces are estimated by applying the novel technique. The goal function to be minimized by the PSO approach is defined by the deviation of the measurements and the calculated temperatures. The PSO algorithm has been parallelized and implemented on a graphic processing unit (GPU) architecture. Numerical results demonstrate that the determination of heat transfer coefficient functions can be performed by using the parallelized PSO method as well as the GPU implementation and that they provide a less time-consuming and more accurate estimation.

General purpose graphics-processing-unit implementation of cosmological domain wall network evolution.

Topological defects unavoidably form at symmetry breaking phase transitions in the early universe. To probe the parameter space of theoretical models and set tighter experimental constraints (exploiting the recent advances in astrophysical observations), one requires more and more demanding simulations, and therefore more hardware resources and computation time. Improving the speed and efficiency of existing codes is essential. Here we present a general purpose graphics-processing-unit implementation of the canonical Press-Ryden-Spergel algorithm for the evolution of cosmological domain wall networks. This is ported to the Open Computing Language standard, and as a consequence significant speedups are achieved both in two-dimensional (2D) and 3D simulations.

Optimization of SIFT algorithm for fast-image feature extraction in line-scanning ophthalmoscope

The Scale Invariant Feature Transform (SIFT) algorithm is utilized broadly in image registration to improve image qualities. However, the algorithm’s complexity reduces its efficiency in biology study and usually requires real-time. In this article, we present an improved SIFT technique in software architecture for matching sequences of images taken from a line-scanning ophthalmoscope (LSO). The method generates the Gaussian Scale-space pyramid in frequency domain to complete the SIFT feature detector more quickly. A novel SIFT descriptor invariable with rotation and illumination is then created to reduce calculation time, implementing the original SIFT method, our improved SIFT method, and the graphic processing unit (GPU) version of our improved SIFT method. The experiments have shown that the improved SIFT is almost 2–3 times faster than the original while maintaining more robust performance, and the GPU implementation of the improved SIFT is 20 times faster than central processing unit (CPU) implementation and achieves acceleration at real-time as expected. Although tested on an LSO system, the improved SIFT method does not rely on the acquisition setup. As a result, this method can be applied to other imaging instruments, e.g., adaptive optics to increase their resolution in agreement.

GPU Implementation of DPSO-RE Algorithm for Parameters Identification of Surface PMSM Considering VSI Nonlinearity

In this paper, an accurate parameter estimation model of surface permanent magnet synchronous machines (SPMSMs) is established by taking into account voltage-source-inverter (VSI) nonlinearity. A fast dynamic particle swarm optimization (DPSO) algorithm combined with a receptor editing (RE) strategy is proposed to explore the optimal values of parameter estimations. This combination provides an accelerated implementation on graphics processing unit (GPU), and the proposed method is, therefore, referred to as G-DPSO-RE. In G-DPSO-RE, a dynamic labor division strategy is incorporated into the swarms according to the designed evolutionary factor during the evolution process. Two novel modifications of the movement equation are designed to update the velocity of particles. Moreover, a chaotic-logistic-based immune RE operator is developed to facilitate the global best individual ( gBest particle) to explore a potentially better region. Furthermore, a GPU parallel acceleration technique is utilized to speed up parameter estimation procedure. It has been demonstrated that the proposed method is effective for simultaneous estimation of the PMSM parameters and the disturbance voltage ( $V_{\mathrm { {dead}}})$ due to VSI nonlinearity from experimental data for currents and rotor speed measured with inexpensive equipment. The influence of the VSI nonlinearity on the accuracy of parameter estimation is analyzed.

Optimized BiCGStab Based GPU Accelerated Computation of Incompressible Viscous Flows by the $$\psi $$ ψ –v Formulation

In this work, we present an optimization strategy for implementing the BiCGStab iterative solver on graphic processing units (GPU) for computing incompressible viscous flows governed by the unsteady Navier–Stokes (N–S) equations on a CUDA platform. A recently developed $$\psi $$ –v formulation is used to discretize the biharmonic form of the N–S equation. Special emphasis was given on optimizing the matrix-vector multiplication and the dot product kernels in GPU as the bulk of the computational efforts was seen to be occupied by these two kernels. The parallel code was implemented on the benchmark problem of lid-driven square cavity flow and remarkable speed-up up to 20 times was achieved on finer grids. The GPU implementation enabled us to compute the flow on extremely fine grids and very small scales were resolved with remarkable accuracy.

Adaptive loss‐less data compression method optimized for GPU decompression

SummaryThere is no doubt that data compression is very important in computer engineering. However, most lossless data compression and decompression algorithms are very hard to parallelize, because they use dictionaries updated sequentially. The main contribution of this paper is to present a new lossless data compression method that we call adaptive loss‐less (ALL) data compression. It is designed so that the data compression ratio is moderate, but decompression can be performed very efficiently on the graphics processing unit (GPU). This makes sense for applications such as training of deep learning, in which compressed archived data are decompressed many times. To show the potentiality of ALL data compression method, we have evaluated the running time using five images and five text data and compared ALL with previously published lossless data compression methods implemented in the GPU, Gompresso, CULZSS, and LZW. The data compression ratio of ALL data compression is better than the others for eight data out of these 10 data. Also, our GPU implementation on GeForce GTX 1080 GPU for ALL decompression runs 84.0 to 231 times faster than the CPU implementation on Core i7‐4790 CPU. Further, it runs 1.22 to 23.5 times faster than Gompresso, CULZSS, and LZW running on the same GPU.

General purpose graphic processing unit implementation of adaptive pulse compression algorithms

This study introduces a practical approach to implement real-time signal processing algorithms for general surveillance radar based on NVIDIA graphical processing units (GPUs). The pulse compression algorithms are implemented using compute unified device architecture (CUDA) libraries such as CUDA basic linear algebra subroutines and CUDA fast Fourier transform library, which are adopted from open source libraries and optimized for the NVIDIA GPUs. For more advanced, adaptive processing algorithms such as adaptive pulse compression, customized kernel optimization is needed and investigated. A statistical optimization approach is developed for this purpose without needing much knowledge of the physical configurations of the kernels. It was found that the kernel optimization approach can significantly improve the performance. Benchmark performance is compared with the CPU performance in terms of processing accelerations. The proposed implementation framework can be used in various radar systems including ground-based phased array radar, airborne sense and avoid radar, and aerospace surveillance radar.

EccCL: parallelized GPU implementation of Ensemble Classifier Chains

BackgroundMulti-label classification has recently gained great attention in diverse fields of research, e.g., in biomedical application such as protein function prediction or drug resistance testing in HIV. In this context, the concept of Classifier Chains has been shown to improve prediction accuracy, especially when applied as Ensemble Classifier Chains. However, these techniques lack computational efficiency when applied on large amounts of data, e.g., derived from next-generation sequencing experiments. By adapting algorithms for the use of graphics processing units, computational efficiency can be greatly improved due to parallelization of computations.ResultsHere, we provide a parallelized and optimized graphics processing unit implementation (eccCL) of Classifier Chains and Ensemble Classifier Chains. Additionally to the OpenCL implementation, we provide an R-Package with an easy to use R-interface for parallelized graphics processing unit usage.ConclusioneccCL is a handy implementation of Classifier Chains on GPUs, which is able to process up to over 25,000 instances per second, and thus can be used efficiently in high-throughput experiments. The software is available at http://www.heiderlab.de.

Efficient optimization approach for fast GPU computation of Zernike moments

Our study focuses on accelerating the computation of Zernike moments on graphics processing units (GPUs). There are two ideas to achieve the goal. First is to implement a novel re-layout that involves reordering the image pixels and addressing the diagonal pixels in advance, so that computations of all pixels are allocated to an octant effectively. Second is to the leverage the constant memory to store precomputed values used across GPU threads. An in-depth study has been carried out to evaluate the performance in each case and to compare against GPU implementation of other algorithms and to discuss the bottleneck. The result shows that our approach is effective and achieves significant performance improvement compared to other GPU state-of-the-art implementations. Furthermore, our approach is suited for allocating the data flow into multiple GPUs.

A high-performance and energy-efficient exhaustive key search approach via GPU on DES-like cryptosystems

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.

A GPU-based symmetric non-rigid image registration method in human lung.

Quantitative computed tomography (QCT) of the lungs plays an increasing role in identifying sub-phenotypes of pathologies previously lumped into broad categories such as chronic obstructive pulmonary disease and asthma. Methods for image matching and linking multiple lung volumes have proven useful in linking structure to function and in the identification of regional longitudinal changes. Here, we seek to improve the accuracy of image matching via the use of a symmetric multi-level non-rigid registration employing an inverse consistent (IC) transformation whereby images are registered both in the forward and reverse directions. To develop the symmetric method, two similarity measures, the sum of squared intensity difference (SSD) and the sum of squared tissue volume difference (SSTVD), were used. The method is based on a novel generic mathematical framework to include forward and backward transformations, simultaneously, eliminating the need to compute the inverse transformation. Two implementations were used to assess the proposed method: a two-dimensional (2-D) implementation using synthetic examples with SSD, and a multi-core CPU and graphics processing unit (GPU) implementation with SSTVD for three-dimensional (3-D) human lung datasets (six normal adults studied at total lung capacity (TLC) and functional residual capacity (FRC)). Success was evaluated in terms of the IC transformation consistency serving to link TLC to FRC. 2-D registration on synthetic images, using both symmetric and non-symmetric SSD methods, and comparison of displacement fields showed that the symmetric method gave a symmetrical grid shape and reduced IC errors, with the mean values of IC errors decreased by 37%. Results for both symmetric and non-symmetric transformations of human datasets showed that the symmetric method gave better results for IC errors in all cases, with mean values of IC errors for the symmetric method lower than the non-symmetric methods using both SSD and SSTVD. The GPU version demonstrated an average of 43 times speedup and ~5.2 times speedup over the single-threaded and 12-threaded CPU versions, respectively. Run times with the GPU were as fast as 2min. The symmetric method improved the inverse consistency, aiding the use of image registration in the QCT-based evaluation of the lung.

GPU Implementation of Bitplane Coding with Parallel Coefficient Processing for High Performance Image Compression

The fast compression of images is a requisite in many applications like TV production, teleconferencing, or digital cinema. Many of the algorithms employed in current image compression standards are inherently sequential. High performance implementations of such algorithms often require specialized hardware like field integrated gate arrays. Graphics Processing Units (GPUs) do not commonly achieve high performance on these algorithms because they do not exhibit fine-grain parallelism. Our previous work introduced a new core algorithm for wavelet-based image coding systems. It is tailored for massive parallel architectures. It is called bitplane coding with parallel coefficient processing (BPC-PaCo). This paper introduces the first high performance, GPU-based implementation of BPC-PaCo. A detailed analysis of the algorithm aids its implementation in the GPU. The main insights behind the proposed codec are an efficient thread-to-data mapping, a smart memory management, and the use of efficient cooperation mechanisms to enable inter-thread communication. Experimental results indicate that the proposed implementation matches the requirements for high resolution (4 K) digital cinema in real time, yielding speedups of 30 $\times$ with respect to the fastest implementations of current compression standards. Also, a power consumption evaluation shows that our implementation consumes 40 $\times$ less energy for equivalent performance than state-of-the-art methods.