CUDA-enabled Graphics Processing Units Research Articles

MATILDA.FT: A mesoscale simulation package for inhomogeneous soft matter.

In this paper, we announce the public release of a massively parallel, graphics processing unit (GPU)-accelerated software, which is the first to combine both coarse-grained particle simulations and field-theoretic simulations in one simulation package. MATILDA.FT (Mesoscale, Accelerated, Theoretically Informed, Langevin, Dissipative particle dynamics, and Field Theory) was designed from the ground-up to run on CUDA-enabled GPUs with Thrust library acceleration, enabling it to harness the possibility of massive parallelism to efficiently simulate systems on a mesoscopic scale. It has been used to model a variety of systems, from polymer solutions and nanoparticle-polymer interfaces to coarse-grained peptide models and liquid crystals. MATILDA.FT is written in CUDA/C++ and is object oriented, making its source-code easy to understand and extend. Here, we present an overview of the currently available features, and the logic of parallel algorithms and methods. We provide the necessary theoretical background and present examples of systems simulated using MATILDA.FT as the simulation engine. The source code, along with the documentation, additional tools, and examples, can be found on the GitHub MATILDA.FT repository.

GPU implementation of evolving spiking neural P systems

Methods for optimizing and evolving spiking neural P systems (in short, SN P systems) have been previously developed with the use of a genetic algorithm framework. So far, these computations, both evolving and simulating, were done only sequentially. Due to the non-deterministic and parallel nature of SN P systems, it is natural to harness parallel processors in implementing its evolution and simulation. In this work, a parallel framework for the evolution of SN P Systems is presented. This is the result of extending our previous work by implementing it on a CUDA-enabled graphics processing unit and adapting CuSNP design in simulations. Using binary addition and binary subtraction with 3 different categories each as initial SN P systems, the GPU-based evolution runs up to 9x faster with respect to its CPU-based evolution counterparts. Overall, when considering the whole process, the GPU framework is up to 3 times faster than the CPU version.

Parallel SVD Algorithm for a Three-Diagonal Matrix on a Video Card Using the Nvidia CUDA Architecture

SVD (Singular Value Decomposition) algorithm is used in recommendation systems, machine learning, image processing, and in various algorithms for working with matrices which can be very large and Big Data, so, given the peculiarities of this algorithm, it can be performed on a large number of computing threads that have only video cards.CUDA is a parallel computing platform and application programming interface model created by Nvidia. It allows software developers and software engineers to use a CUDA-enabled graphics processing unit for general purpose processing – an approach termed GPGPU (general-purpose computing on graphics processing units). The GPU provides much higher instruction throughput and memory bandwidth than the CPU within a similar price and power envelope. Many applications leverage these higher capabilities to run faster on the GPU than on the CPU. Other computing devices, like FPGAs, are also very energy efficient, but they offer much less programming flexibility than GPUs.The developed modification uses the CUDA architecture, which is intended for a large number of simultaneous calculations, which allows to quickly process matrices of very large sizes. The algorithm of parallel SVD for a three-diagonal matrix based on the Givents rotation provides a high accuracy of calculations. Also the algorithm has a number of optimizations to work with memory and multiplication algorithms that can significantly reduce the computation time discarding empty iterations.This article proposes an approach that will reduce the computation time and, consequently, resources and costs. The developed algorithm can be used with the help of a simple and convenient API in C ++ and Java, as well as will be improved by using dynamic parallelism or parallelization of multiplication operations. Also the obtained results can be used by other developers for comparison, as all conditions of the research are described in detail, and the code is in free access.

Parallel time integration using Batched BLAS (Basic Linear Algebra Subprograms) routines

We present an approach for integrating the time evolution of quantum systems. We leverage the computation power of graphics processing units (GPUs) to perform the integration of all time steps in parallel. The performance boost is especially prominent for small to medium-sized quantum systems. The devised algorithm can largely be implemented using the recently-specified batched versions of the BLAS routines, and can therefore be easily ported to a variety of platforms. Our PARAllelized Matrix Exponentiation for Numerical Time evolution (PARAMENT) implementation runs on CUDA-enabled graphics processing units. Program summaryProgram Title: PARAMENTCPC Library link to program files:https://doi.org/10.17632/zy5v4xs89d.1Developer's repository link:https://github.com/parament-integrator/paramentLicensing provisions: Apache 2.0Programming language: C / CUDA / PythonNature of problem: Time-integration of the Schrödinger equation with a time-dependent Hamiltonian for quantum systems with a small Hilbert space but many time-steps.Solution method: A 4th order Magnus integrator, highly parallelized on a GPU, implemented using a small subset of BLAS functions for improved portability.

Design and Implementation of GPS RTK Positioning Using Carrier Phase Measurement on an Embedded Board

The Global Positioning System (GPS) is currently used in many geodetic applications to obtain precise positions within a centimeter, or even within a millimeter. Generally, such a level of accuracy can be obtained by performing complex processing on expensive receivers and antennas. Such high-cost devices can be replaced by low-cost, single-frequency GPS receivers to obtain precise positions. To do so, in this paper, Carrier Phase (CP)-based relative algorithms are successfully implemented on a CUDA-enabled embedded board (the Jetson TK1) with two low-cost GNNS receivers. A CUDA-enabled graphics processing unit (GPU) is a highly parallel structure that makes efficient and faster CP-based algorithms and that can process large blocks of data in parallel. Our results from field measurements clearly show that the positioning performance of a Rover with respect to the Base receiver reached the centimeter level. Therefore, this work shows the possibility of accurately estimating the position of a receiver using low-cost hardware-based RTK algorithms.

Matrix multiplication on batches of small matrices in half and half-complex precisions

Machine learning and artificial intelligence (AI) applications often rely on performing many small matrix operations—in particular general matrix–matrix multiplication (GEMM). These operations are usually performed in a reduced precision, such as the 16-bit floating-point format (i.e., half precision or FP16). The GEMM operation is also very important for dense linear algebra algorithms, and half-precision GEMM operations can be used in mixed-precision linear solvers. Therefore, high-performance batched GEMM operations in reduced precision are significantly important, not only for deep learning frameworks, but also for scientific applications that rely on batched linear algebra, such as tensor contractions and sparse direct solvers.This paper presents optimized batched GEMM kernels for graphics processing units (GPUs) in FP16 arithmetic. The paper addresses both real and complex half-precision computations on the GPU. The proposed design takes advantage of the Tensor Core technology that was recently introduced in CUDA-enabled GPUs. With eight tuning parameters introduced in the design, the developed kernels have a high degree of flexibility that overcomes the limitations imposed by the hardware and software (in the form of discrete configurations for the Tensor Core APIs). For real FP16 arithmetic, performance speedups are observed against cuBLAS for sizes up to 128, and range between 1.5× and 2.5×. For the complex FP16 GEMM kernel, the speedups are between 1.7× and 7× thanks to a design that uses the standard interleaved matrix layout, in contrast with the planar layout required by the vendor’s solution. The paper also discusses special optimizations for extremely small matrices, where even higher performance gains are achievable.

A new deep convolutional neural network model for classifying breast cancer histopathological images and the hyperparameter optimisation of the proposed model

Deep learning algorithms have yielded remarkable results in medical diagnosis and image analysis, besides their contribution to improvements in a number of fields such as drug discovery, time-series modelling and optimisation methods. With regard to the analysis of histopathologic breast cancer images, the similarity of those images and the presence of healthy and tumourous tissues in different areas complicate the detection and classification of tumours on whole slide images. An accurate diagnosis in a short time is a need for full treatment in breast cancer. A successful classification on breast cancer histopathological images will overcome the burden on the pathologist and reduce the subjectivity of diagnosis. In this study, we propose a deep convolutional neural network model. The model uses various algorithms (i.e., stochastic gradient descent, Nesterov accelerated gradient, adaptive gradient, RMSprop, AdaDelta and Adam) to compute the initial weight of the network and update the model parameters for faster backpropagation learning. In order to train the model with less hardware in a short time, we used the parallel computing architecture with Cuda-enabled graphics processing unit. The results indicate that the deep convolutional neural network model is an effective classification model with a high performance up to 99.05% accuracy value.

COMER2: GPU-accelerated sensitive and specific homology searches

SummarySearching for homology in the vast amount of sequence data has a particular emphasis on its speed. We present a completely rewritten version of the sensitive homology search method COMER based on alignment of protein sequence profiles, which is capable of searching big databases even on a lightweight laptop. By harnessing the power of CUDA-enabled graphics processing units, it is up to 20 times faster than HHsearch, a state-of-the-art method using vectorized instructions on modern CPUs.Availability and implementationCOMER2 is cross-platform open-source software available at https://sourceforge.net/projects/comer2 and https://github.com/minmarg/comer2. It can be easily installed from source code or using stand-alone installers.Contact mindaugas.margelevicius@bti.vu.lt Supplementary information Supplementary data are available at Bioinformatics online.

GPU acceleration and performance of the particle-beam-dynamics code Elegant

Elegant is an accelerator physics and particle-beam dynamics code widely used for modeling and design of a variety of high-energy particle accelerators and accelerator-based systems. In this paper we discuss a recently developed version of the code that can take advantage of CUDA-enabled graphics processing units (GPUs) to achieve significantly improved performance for a large class of simulations that are important in practice. The GPU version is largely defined by a framework that simplifies implementations of the fundamental kernel types that are used by Elegant: particle operations, reductions, particle loss, histograms, array convolutions and random number generation. Accelerated performance on the Titan Cray XK-7 supercomputer is approximately 6–10 times better with the GPU than all the CPU cores associated with the same node count. In addition to performance, the maintainability of the GPU-accelerated version of the code was considered a key design objective. Accuracy with respect to the CPU implementation is also a core consideration. Four different methods are used to ensure that the accelerated code faithfully reproduces the CPU results. Program summaryProgram Title: Kernels from the GPU-accelerated ElegantProgram Files doi:http://dx.doi.org/10.17632/jc465zy7p5.1Licensing provisions: MITProgramming language: C/C++/CUDANature of problem: The original design of the Elegant accelerator physics code was implemented on central processing units with message-passing interface parallelization. This implementation is not able to use next-generation multicore systems.Solution method: In this package we develop routines based on the CUDA language extensions to C++ that enable porting the Elegant code to be run on graphics processing units (GPUs). Special consideration is given to algorithms that require collective communication on the GPU.Additional comments including restrictions and unusual features: The full Elegant source code is freely available from Argonne National Laboratory and these distributions include the GPU code in the later releases.

Designing Efficient Index-Digit Algorithms for CUDA GPU Architectures

Modern graphics processing units (GPUs) offer very high computing power at relatively low cost. Nevertheless, designing efficient algorithms for the GPUs normally requires additional time and effort, even for experienced programmers. In this work we present a tuning methodology that allows the design for CUDA-enabled GPU architectures of index-digit algorithms, that is, algorithms where the data movement can be described as the permutations of the digits comprising the indices of the data elements. This methodology, based on two-stages identified as GPU resource analysis and operators string manipulation, is applied to FFT and tridiagonal systems solver algorithms, analyzing the performance features and the most adequate solutions. The resulting implementation is compact and outperforms other well-known and commonly used state-of-the-art libraries, with an improvement of up to 19.2 percent over NVIDIA's complex CUFFT , and more than 3000 percent over the NVIDIA'sCUDPP for real data tridiagonal systems.

Correlation acceleration in GNSS software receivers using a CUDA-enabled GPU

The correlation process in a GNSS receiver tracking module can be computationally prohibitive if it is executed on a central processing unit (CPU) using single-instruction single-data algorithms. An efficient replacement for a CPU is a graphics processing unit (GPU). A GPU is composed of massive parallel processors with high floating point performance and memory bandwidth. It can be used to accelerate the burdensome correlation process in GNSS software receivers. We propose a novel GPU-based correlator architecture for GNSS software receivers, which is independent of the GPU device, the number of the processing channels, the signal type, and the correlation time. The proposed architecture is implemented and optimized using CUDA, a parallel computing platform and programming model for GPUs. We focus on the following aspects: the design and the time complexity analysis of the proposed GPU-based correlator algorithm, the tests that verify the correctness and the optimization of the implementation, and the performance evaluation of the optimized GPU-based correlator. Moreover, we introduce some new CUDA features that can be applied in a GPU-based correlator.

High Performance GPU-Based Fourier Volume Rendering

Fourier volume rendering (FVR) is a significant visualization technique that has been used widely in digital radiography. As a result of its 𝒪(N 2log⁡N) time complexity, it provides a faster alternative to spatial domain volume rendering algorithms that are 𝒪(N 3) computationally complex. Relying on the Fourier projection-slice theorem, this technique operates on the spectral representation of a 3D volume instead of processing its spatial representation to generate attenuation-only projections that look like X-ray radiographs. Due to the rapid evolution of its underlying architecture, the graphics processing unit (GPU) became an attractive competent platform that can deliver giant computational raw power compared to the central processing unit (CPU) on a per-dollar-basis. The introduction of the compute unified device architecture (CUDA) technology enables embarrassingly-parallel algorithms to run efficiently on CUDA-capable GPU architectures. In this work, a high performance GPU-accelerated implementation of the FVR pipeline on CUDA-enabled GPUs is presented. This proposed implementation can achieve a speed-up of 117x compared to a single-threaded hybrid implementation that uses the CPU and GPU together by taking advantage of executing the rendering pipeline entirely on recent GPU architectures.

Routine Microsecond Molecular Dynamics Simulations with AMBER on GPUs. 2. Explicit Solvent Particle Mesh Ewald.

We present an implementation of explicit solvent all atom classical molecular dynamics (MD) within the AMBER program package that runs entirely on CUDA-enabled GPUs. First released publicly in April 2010 as part of version 11 of the AMBER MD package and further improved and optimized over the last two years, this implementation supports the three most widely used statistical mechanical ensembles (NVE, NVT, and NPT), uses particle mesh Ewald (PME) for the long-range electrostatics, and runs entirely on CUDA-enabled NVIDIA graphics processing units (GPUs), providing results that are statistically indistinguishable from the traditional CPU version of the software and with performance that exceeds that achievable by the CPU version of AMBER software running on all conventional CPU-based clusters and supercomputers. We briefly discuss three different precision models developed specifically for this work (SPDP, SPFP, and DPDP) and highlight the technical details of the approach as it extends beyond previously reported work [Götz et al., J. Chem. Theory Comput. 2012, DOI: 10.1021/ct200909j; Le Grand et al., Comp. Phys. Comm. 2013, DOI: 10.1016/j.cpc.2012.09.022].We highlight the substantial improvements in performance that are seen over traditional CPU-only machines and provide validation of our implementation and precision models. We also provide evidence supporting our decision to deprecate the previously described fully single precision (SPSP) model from the latest release of the AMBER software package.

Shape reconstruction of irregular bodies with multiple complementary data sources

We discuss inversion methods for shape reconstruction with complementary data sources. The current main sources are photometry, adaptive optics or other images, occultation timings, and interferometry, and the procedure can readily be extended to include range-Doppler radar and thermal infrared data as well. We introduce the octantoid, a generally applicable shape support that can be automatically used for surface types encountered in planetary research, including strongly nonconvex or non-starlike shapes. We present models of Kleopatra and Hermione from multimodal data as examples of this approach. An important concept in this approach is the optimal weighting of the various data modes. We define the maximum compatibility estimate, a multimodal generalization of the maximum likelihood estimate, for this purpose. We also present a specific version of the procedure for asteroid flyby missions, with which one can reconstruct the complete shape of the target by using the flyby-based map of a part of the surface together with other available data. Finally, we show that the relative volume error of a shape solution is usually approximately equal to the relative shape error rather than its multiple. Our algorithms are trivially parallelizable, so running the code on a CUDA-enabled graphics processing unit is some two orders of magnitude faster than the usual single-processor mode.

Stock trading strategy creation using GP on GPU

This paper investigates the speed improvements available when using a graphics processing unit (GPU) for evaluation of individuals in a genetic programming (GP) environment. An existing GP system is modified to enable parallel evaluation of individuals on a GPU device. Several issues related to implementing GP on GPU are discussed, including how to perform tree-based GP on a device without recursion support, as well as the effect that proper memory layout can have on speed increases when using CUDA-enabled nVidia GPU devices. The specific GP implementation is designed to evolve stock trading strategies using technical analysis indicators. The second goal of this research is to investigate the possible improvement in performance when training individuals on a larger number of stocks and training days. This increased training size (nearly 100,000 training points) is enabled due to the speedups realized by GPU evaluation. Several different scenarios were used to test various speed optimizations of GP evaluation on the GPU device, with a peak speedup factor of over 600 (when compared to sequential evaluation on a 2.4 GHz CPU). Also, it is found that increasing the number of stocks and the length of the training period can result in higher out-of-training testing profitability.

COMPARISON OF CPML IMPLEMENTATIONS FOR THE GPU-ACCELERATED FDTD SOLVER

Three distinctively difierent implementations of convolu- tional perfectly matched layer for the FDTD method on CUDA enabled graphics processing units are presented. All implementations store ad- ditional variables only inside the convolutional perfectly matched lay- ers, and the computational speeds scale according to the thickness of these layers. The merits of the difierent approaches are discussed, and a comparison of computational performance is made using complex real-life benchmarks.

Using GPU With CUDA to Accelerate MoM-Based Electromagnetic Simulation of Wire-Grid Models

In this letter, a CUDA-enabled graphics processing unit (GPU) accelerated implementation of the method of moments (MoM) for electromagnetic simulation of wire-grid models of arbitrary configurations of conducting surfaces and wires is presented. The solution based on the frequency-domain electric field integral equation (EFIE) discretized using piecewise-linear (triangular) functions for expansion and testing is considered. Some issues pertinent to porting a single-CPU sequential code to an inherently parallel GPU platform are addressed. The GPU numerical results for a user-created benchmark structure are backed up with comparison to CPU results. A noticeable speedup (about 6t) of the overall MoM simulation is achieved due to employing GPU.

Adapting MoM With RWG Basis Functions to GPU Technology Using CUDA

In this letter, a CUDA-enabled graphics processing unit (GPU)-accelerated implementation of the method of moments (MoM) for solving three-dimensional conducting body-wire problems is presented. The solution is based on the mixed potential integral equation (MPIE) discretized using Rao-Wilton-Glisson (RWG) basis functions. The CUDA environment is employed to port a single-CPU sequential code to the parallel GPU platform, and some relevant issues are discussed. Numerical results are given for a helical antenna with a cylindrical cup reflector. The measured speedup of about eight times over the CPU implementation is demonstrated.

CUDA–MEME: Accelerating motif discovery in biological sequences using CUDA-enabled graphics processing units

Motif discovery in biological sequences is of prime importance and a major challenge in computational biology. Consequently, numerous motif discovery tools have been developed to date. However, the rapid growth of both genomic sequence and gene transcription data, establishes the need for the development of scalable motif discovery tools. An approach to improve the runtime of motif discovery by an order-of-magnitude without losing sensitivity is to employ emerging many-core architectures such as CUDA-enabled GPUs. In this paper, we present a highly parallel formulation and implementation of the MEME motif discovery algorithm using the CUDA programming model. To achieve high efficiency, we introduce two parallelization approaches: sequence-level and substring-level parallelization. Furthermore, a hybrid computing framework is described to take advantage of both CPU and GPU compute resources. Our performance evaluation on a GeForce GTX 280 GPU, results in average runtime speedups of 21.4 (19.3) for the starting point search and 20.5 (16.4) for the overall runtime using the OOPS (ZOOPS) motif search model. The runtime speedups of CUDA–MEME on a single GPU are also comparable to those of ParaMEME running on 16 CPU cores of a high-performance workstation cluster. In addition to the fast speed, CUDA–MEME has the capability of finding motif instances consistent with the sequential MEME.