Compute Unified Device Architecture Implementation Research Articles

CUDA and OpenMp Implementation of Boolean Matrix Product with Applications in Visual SLAM

In this paper, the concept of ultrametric structure is intertwined with the SLAM procedure. A set of pre-existing transformations has been used to create a new simultaneous localization and mapping (SLAM) algorithm. We have developed two new parallel algorithms that implement the time-consuming Boolean transformations of the space dissimilarity matrix. The resulting matrix is an important input to the vector quantization (VQ) step in SLAM processes. These algorithms, written in Compute Unified Device Architecture (CUDA) and Open Multi-Processing (OpenMP) pseudo-codes, make the Boolean transformation computationally feasible on a real-world-size dataset. We expect our newly introduced SLAM algorithm, ultrametric Fast Appearance Based Mapping (FABMAP), to outperform regular FABMAP2 since ultrametric spaces are more clusterable than regular Euclidean spaces. Another scope of the presented research is the development of a novel measure of ultrametricity, along with creation of Ultrametric-PAM clustering algorithm. Since current measures have computational time complexity order, O(n3) a new measure with lower time complexity, O(n2), has a potential significance.

Brownian dynamics simulations of mesoscale chromatin fibers

The relationship between chromatin architecture and function defines a central problem in biology and medicine. Many computational chromatin models with atomic, coarse-grained, mesoscale, and polymer resolution have been used to shed light onto the mechanisms that dictate genome folding and regulation of gene expression. The associated simulation techniques range from Monte Carlo to molecular, Brownian, and Langevin dynamics. Here, we present an efficient Compute Unified Device Architecture (CUDA) implementation of Brownian dynamics (BD) to simulate chromatin fibers at the nucleosome resolution with our chromatin mesoscale model. With the CUDA implementation for computer architectures with graphic processing units (GPUs), we significantly accelerate compute-intensive hydrodynamic tensor calculations in the BD simulations by massive parallelization, boosting the performance a hundred-fold compared with central processing unit calculations. We validate our BD simulation approach by reproducing experimental trends on fiber diffusion and structure as a function of salt, linker histone binding, and histone-tail composition, as well as Monte Carlo equilibrium sampling results. Our approach proves to be physically accurate with performance that makes feasible the study of chromatin fibers in the range of kb or hundreds of nucleosomes (small gene). Such simulations are essential to advance the study of biological processes such as gene regulation and aberrant genome-structure related diseases.

Parallel Algorithms of Well-Balanced and Weighted Average Flux for Shallow Water Model Using CUDA

Compute Unified Device Architecture (CUDA) implementations are presented of a well-balanced finite volume method for solving a shallow water model. The CUDA platform allows programs to run parallel on GPU. Four versions of the CUDA algorithm are presented in addition to a CPU implementation. Each version is improved from the previous one. We present the following techniques for optimizing a CUDA program: limiting register usage, changing the global memory access pattern, and using loop unroll. The accuracy of all programs is investigated in 3 test cases: a circular dam break on a dry bed, a circular dam break on a wet bed, and a dam break flow over three humps. The last parallel version shows 3.84x speedup over the first CUDA implementation. We use our program to simulate a real-world problem based on an assumed partial breakage of the Srinakarin Dam located in Kanchanaburi province, Thailand. The simulation shows that the strong interaction between massive water flows and bottom elevations under wet and dry conditions is well captured by the well-balanced scheme, while the optimized parallel program produces a 57.32x speedup over the serial version.

Performance evaluation of GPU- and cluster-computing for parallelization of compute-intensive tasks

PurposeThis paper aims to evaluate different approaches for the parallelization of compute-intensive tasks. The study compares a Java multi-threaded algorithm, distributed computing solutions with MapReduce (Apache Hadoop) and resilient distributed data set (RDD) (Apache Spark) paradigms and a graphics processing unit (GPU) approach with Numba for compute unified device architecture (CUDA).Design/methodology/approachThe paper uses a simple but computationally intensive puzzle as a case study for experiments. To find all solutions using brute force search, 15! permutations had to be computed and tested against the solution rules. The experimental application comprises a Java multi-threaded algorithm, distributed computing solutions with MapReduce (Apache Hadoop) and RDD (Apache Spark) paradigms and a GPU approach with Numba for CUDA. The implementations were benchmarked on Amazon-EC2 instances for performance and scalability measurements.FindingsThe comparison of the solutions with Apache Hadoop and Apache Spark under Amazon EMR showed that the processing time measured in CPU minutes with Spark was up to 30% lower, while the performance of Spark especially benefits from an increasing number of tasks. With the CUDA implementation, more than 16 times faster execution is achievable for the same price compared to the Spark solution. Apart from the multi-threaded implementation, the processing times of all solutions scale approximately linearly. Finally, several application suggestions for the different parallelization approaches are derived from the insights of this study.Originality/valueThere are numerous studies that have examined the performance of parallelization approaches. Most of these studies deal with processing large amounts of data or mathematical problems. This work, in contrast, compares these technologies on their ability to implement computationally intensive distributed algorithms.

Parallelizing Multiple Flow Accumulation Algorithm using CUDA and OpenACC

Watershed analysis, as a fundamental component of digital terrain analysis, is based on the Digital Elevation Model (DEM), which is a grid (raster) model of the Earth surface and topography. Watershed analysis consists of computationally and data intensive computing algorithms that need to be implemented by leveraging parallel and high-performance computing methods and techniques. In this paper, the Multiple Flow Direction (MFD) algorithm for watershed analysis is implemented and evaluated on multi-core Central Processing Units (CPU) and many-core Graphics Processing Units (GPU), which provides significant improvements in performance and energy usage. The implementation is based on NVIDIA CUDA (Compute Unified Device Architecture) implementation for GPU, as well as on OpenACC (Open ACCelerators), a parallel programming model, and a standard for parallel computing. Both phases of the MFD algorithm (i) iterative DEM preprocessing and (ii) iterative MFD algorithm, are parallelized and run over multi-core CPU and GPU. The evaluation of the proposed solutions is performed with respect to the execution time, energy consumption, and programming effort for algorithm parallelization for different sizes of input data. An experimental evaluation has shown not only the advantage of using OpenACC programming over CUDA programming in implementing the watershed analysis on a GPU in terms of performance, energy consumption, and programming effort, but also significant benefits in implementing it on the multi-core CPU.

Real-time optical properties and oxygenation imaging using custom parallel processing in the spatial frequency domain.

The development of real-time, wide-field and quantitative diffuse optical imaging methods is becoming increasingly popular for biological and medical applications. Recent developments introduced a novel approach for real-time multispectral acquisition in the spatial frequency domain using spatio-temporal modulation of light. Using this method, optical properties maps (absorption and reduced scattering) could be obtained for two wavelengths (665 nm and 860 nm). These maps, in turn, are used to deduce oxygen saturation levels in tissues. However, while the acquisition was performed in real-time, processing was performed post-acquisition and was not in real-time. In the present article, we present CPU and GPU processing implementations for this method with special emphasis on processing time. The obtained results show that the proposed custom direct method using a General Purpose Graphic Processing Unit (GPGPU) and C CUDA (Compute Unified Device Architecture) implementation enables 1.6 milliseconds processing time for a 1 Mega-pixel image with a maximum average error of 0.1% in extracting optical properties.

GPU-Based Lossless Compression of Aurora Spectral Data using Online DPCM

It is well known that aurorae have very high research value, but the data volume of aurora spectral data is very large, which brings great challenges to storage and transmission. To alleviate this problem, compression of aurora spectral data is indispensable. This paper presents a parallel Compute Unified Device Architecture (CUDA) implementation of the prediction-based online Differential Pulse Code Modulation (DPCM) method for the lossless compression of the aurora spectral data. Two improvements are proposed to improve the compression performance of the online DPCM method. One is on the computing of the prediction coefficients, and the other is on the encoding of the residual. In the CUDA implementation, we proposed a decomposition method for the matrix multiplication to avoid redundant data accesses and calculations. In addition, the CUDA implementation is optimized with a multi-stream technique and multi-graphics processing unit (GPU) technique, respectively. Finally, the average compression time of an aurora spectral image reaches about 0.06 s, which is much less than the 15 s aurora spectral data acquisition time interval and can save a lot of time for transmission and other subsequent tasks.

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.

Nonlinear scattering and mode conversion of Lamb waves at breathing cracks: An efficient numerical approach

This article presents an efficient numerical approach to the investigation of nonlinear scattering and mode conversion phenomena of Lamb waves as they interact with breathing cracks. A Local Interaction Simulation Approach (LISA) is adopted, which possesses the versatility to capture arbitrary damage profiles. The stick-slip contact dynamics is implemented in the LISA model via the penalty method, which captures the nonlinear interactions between Lamb waves and breathing cracks. The LISA framework achieves remarkable computational efficiency with its parallel implementation using Compute Unified Device Architecture (CUDA) executed on powerful GPUs. A small-size LISA model with absorbing boundaries is tailored for the purpose of extracting the Lamb wave scattering and mode conversion features. Due to the explicit parallel CUDA implementation and the small-size model setup, the computation is highly efficient. Numerical case studies on nonlinear scattering of Lamb waves from breathing cracks are given. Distinctive higher harmonic generation and selective mode conversion phenomena are presented using the complex-valued Wave Damage Interaction Coefficients (WDICs) containing both amplitude and phase information of the scattered wave field. The effect of oblique incident angle on nonlinear scattering phenomenon is investigated. The rough crack surface feature with initial openings and closures is also considered to better approximate fatigue cracks in practical engineering scenarios. In addition, the wave amplitude effect on the nonlinear scattering and mode conversion is studied. This research may provide guidelines for the effective design of sensor arrays utilizing nonlinear Lamb waves for fatigue crack detection.

Power-Constrained Image Enhancement Using Multiband Processing for TFT LCD Devices With an Edge LED Backlight Unit

This paper presents a subband-decomposed image-enhancement algorithm that can preserve the luminance and contrast levels in power-controllable thin-film-transistor liquid-crystal display devices. The proposed algorithm consists of three steps. First, an input image is decomposed to multiscale subbands via subband decomposition. Second, luminance compensation and contrast preservation are achieved simultaneously by adjusting the gain of each subband properly. Third, additional power consumption caused by excessive boosting, while coping with the local dimming through specific clipping, is prevented. The experimental results show that the proposed algorithm provides more natural details and contrast, while preserving more similarities with the original, than the existing methods. Even in terms of the peak signal-to-noise-ratio and the structural similarity index, the proposed algorithm has 27.8% and 3.8% higher values compared to a state-of-the-art method. The real-time operation of the proposed algorithm was verified through intensive optimization and the Compute Unified Device Architecture implementation. In addition, the power-reduction effect of the proposed algorithm on commercial monitors was investigated experimentally.

The new SCIARA-fv3 numerical model and acceleration by GPGPU strategies

This paper presents the parallel implementation, using the Compute Unified Device Architecture (CUDA) architecture, of the SCIARA-fv3 Complex Cellular Automata model for simulating lava flows. The computational model is based on a Bingham-like rheology and both flow velocity and the physical time corresponding to a computational step have been made explicit. The parallelization design has involved, among other issues, the application of strategies that can avoid incorrect computation results due to race conditions and achieving the best performance and occupancy of the underlying available hardware. Two hardware types were adopted for testing different versions of the CUDA implementations of the SCIARA-fv3 model, namely the GTX 580 and GTX 680 graphic processors. Despite its computational complexity, carried out experiments of the model parallelization have shown significant performance improvements, confirming that graphic hardware can represent a valid solution for the implementation of Cellular Automata models.

Parallel Computation of Aerial Target Reflection of Background Infrared Radiation: Performance Comparison of OpenMP, OpenACC, and CUDA Implementations

The infrared (IR) signature of an aerial target due to the reflection of radiation from the Sun, the Earth’s surface and atmosphere plays an important role in aerial target detection and tracking. As the background radiation from the Earth’s surface, and atmosphere is distributed in the entire space and in a wide spectrum, it is time-consuming to obtain an aerial target’s reflected radiation. This problem is suitable for parallel implementation to run on multicore CPU or many-core GPU because the reflection of background radiation incident from different directions in each spectral wavelength can be calculated in parallel. We consider three different parallel approaches: 1) CPU implementation using OpenMP (open multiprocessing); 2) GPU implementation using OpenACC (open accelerators); and 3) GPU implementation using CUDA (compute unified device architecture). An NVIDIA K20c GPU (with 2496 cores) and two Intel Xeon E5-2690 CPU (with 8 cores each) are used in our experiment. Compared to their single-threaded CPU counterpart, speedups obtained by OpenMP, OpenACC, and CUDA implementations are 15x, 140x, 426x, respectively. The result shows that GPU implementations are promising in our problem.

Parallel Statistical Multiresolution Estimation for Image Reconstruction

We show that a careful parallelization of statistical multiresolution estimation (SMRE) improves the phase reconstruction in X-ray near-field holography. The central step in, and the computationally most expensive part of, SMRE methods is Dykstra's algorithm. It projects a given vector onto the intersection of convex sets. We discuss its implementation on NVIDIA's compute unified device architecture (CUDA). Compared to a CPU implementation parallelized with OpenMP, our CUDA implementation is up to one order of magnitude faster. Our results show that a careful parallelization of Dykstra's algorithm enables its use in large-scale statistical multiresolution analyses.

Fast computation of bare soil surface roughness on a Fermi GPU

Surface roughness is an important factor in bare soil microwave radiation for the observation of the Earth. Correlation length and standard deviation of surface height are the two statistical parameters that describe surface roughness. However, when the number of data points is large, the calculation of surface roughness parameters becomes time-consuming. Therefore, it is desired to have a high-performance computing facility to execute this task. A Graphics Processing Unit (GPU) provides hundreds of computing cores along with a high memory bandwidth. To carry out a parallel implementation of the algorithms, Compute Unified Device Architecture (CUDA) provides researchers with an easy way to execute multiple threads in parallel on GPUs. In this paper, we propose a GPU-based parallel computing method for 2D surface roughness estimation. We use an NVIDIA GeForce GTX 590 graphics card to run the CUDA implementation. The experimental input data is collected by our in-house surface roughness tester which is designed based on the laser triangulation principle, giving sample data points of up to 52,040. According to the experimental results, the serial CPU version of the implementation takes 5422s whereas our GPU implementation takes only 47s, resulting a significant 115× speedup.

Fast alternating direction implicit method for efficient transient thermal simulation of integrated circuits

SummaryThis paper presents fast alternating direction implicit (FADI) method for efficient transient thermal simulation of integrated circuits. The FADI method is formulated from Peaceman–Rachford's ADI and Douglas–Gunn's ADI methods. The update procedure of the proposed method has basic implicit form that features derivative‐free right‐hand side and hence, better efficiency and conciseness. Subsequently, through the basic implicit form of FADI method, the relationship between classical Peaceman–Rachford's and Douglas–Gunn's ADI methods can be clarified and elucidated in detail. A unified boundary condition that can cater to common kinds of boundary conditions in thermal simulation is also introduced. To further accelerate FADI method, the graphics processing unit is also utilized through Compute Unified Device Architecture implementation. It is shown that high efficiency gain can be achieved using the proposed FADI method through large time step size and data parallelism, while maintaining stability and good accuracy. As numerical illustration, an integrated circuit structure with microchannel cooling is demonstrated. Numerical results further ascertain the cooling effect of the microchannels. Copyright © 2015 John Wiley & Sons, Ltd.

GPU Accelerated Belief Propagation Decoding of Non-Binary LDPC Codes with Parallel and Sequential Scheduling

Low-Density Parity-Check (LDPC) codes are very powerful channel coding schemes with a broad range of applications. The existence of low complexity (i.e., linear time) iterative message passing decoders with close to optimum error correction performance is one of the main strengths of LDPC codes. It has been shown that the performance of these decoders can be further enhanced if the LDPC codes are extended to higher order Galois fields, yielding so called non-binary LDPC codes. However, this performance gain comes at the cost of rapidly increasing decoding complexity. To deal with this increased complexity, we present an efficient implementation of a signed-log domain FFT decoder for non-binary irregular LDPC codes which exploits the inherent massive parallelization capabilities of message passing decoders. We employ Nvidia's Compute Unified Device Architecture (CUDA) to incorporate the available processing power of state-of-the-art Graphics Processing Units (GPUs). Furthermore, we present a CUDA implementation of the signed-log domain FFT decoder using the so-called layered update rule, in which check nodes are updated one after another. This sequential updating of nodes has been shown to converge about twice as fast as the traditional flooding scheme. To achieve a high speedup of the layered CUDA implementation, we employ quasi-cyclic non-binary LDPC codes since they allow to update multiple neighboring check nodes in parallel without any performance loss.

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.

A Comparison of Sequential and GPU Implementations of Iterative Methods to Compute Reachability Probabilities

We consider the problem of computing reachability probabilities: given a Markov chain, an initial state of the Markov chain, and a set of goal states of the Markov chain, what is the probability of reaching any of the goal states from the initial state? This problem can be reduced to solving a linear equation Ax = b for x, where A is a matrix and b is a vector. We consider two iterative methods to solve the linear equation: the Jacobi method and the biconjugate gradient stabilized (BiCGStab) method. For both methods, a sequential and a parallel version have been implemented. The parallel versions have been implemented on the compute unified device architecture (CUDA) so that they can be run on a NVIDIA graphics processing unit (GPU). From our experiments we conclude that as the size of the matrix increases, the CUDA implementations outperform the sequential implementations. Furthermore, the BiCGStab method performs better than the Jacobi method for dense matrices, whereas the Jacobi method does better for sparse ones. Since the reachability probabilities problem plays a key role in probabilistic model checking, we also compared the implementations for matrices obtained from a probabilistic model checker. Our experiments support the conjecture by Bosnacki et al. that the Jacobi method is superior to Krylov subspace methods, a class to which the BiCGStab method belongs, for probabilistic model checking.

Fast geocoding of spaceborne synthetic-aperture radar images using graphics processing units

Geocoding is crucial for using remotely sensed data in almost all applications, especially when a combination of multiple data sources is required. However, geocoding a synthetic-aperture radar image with the standard range-Doppler method is a time-consuming process due to unavoidable iterations. Using a replacement sensor model, for example the rational polynomial camera (RPC) model, can significantly reduce the calculation time cost. Another way to improve the calculation efficiency is to use massively parallel processing techniques. Modern graphics processing units (GPU) can be used as parallel processing units for computationally intensive applications. Using NVIDIA's Compute Unified Device Architecture (CUDA) the implementation of the range-Doppler and RPC methods on GPUs is easy, because the existing C/C++ code can be reused. With further optimizations for GPU processing, tremendous improvements can be achieved. The CUDA implementations run about 10 to 30 times faster compared with similar implementations on the central processing unit (CPU), and almost 200 times faster if particularly optimized for GPU computing.

GPGPU implementation of growing neural gas: Application to 3D scene reconstruction

Self-organising neural models have the ability to provide a good representation of the input space. In particular the Growing Neural Gas (GNG) is a suitable model because of its flexibility, rapid adaptation and excellent quality of representation. However, this type of learning is time-consuming, especially for high-dimensional input data. Since real applications often work under time constraints, it is necessary to adapt the learning process in order to complete it in a predefined time. This paper proposes a Graphics Processing Unit (GPU) parallel implementation of the GNG with Compute Unified Device Architecture (CUDA). In contrast to existing algorithms, the proposed GPU implementation allows the acceleration of the learning process keeping a good quality of representation. Comparative experiments using iterative, parallel and hybrid implementations are carried out to demonstrate the effectiveness of CUDA implementation. The results show that GNG learning with the proposed implementation achieves a speed-up of 6× compared with the single-threaded CPU implementation. GPU implementation has also been applied to a real application with time constraints: acceleration of 3D scene reconstruction for egomotion, in order to validate the proposal.