Central Processing Unit Version Research Articles

Abstract 1900: Rapid variant detection and annotations from next generation sequencing data using a GPU accelerated framework

Abstract Introduction Next Generation Sequencing (NGS) played a crucial role in revolutionizing the field of human genetics to become an integral part of research and clinical management. Some examples are diagnosis and treatment of cancer patients, identifying syndromes in the NICU (Neonatal Intensive Care Units), insights into neuro-degenerative disease to name a few. NGS integrated with multi-omics data provides greater insight to underlying molecular mechanisms and helps to identify alterations specific to the disease condition. Accurate and robust detection of somatic and germline genomic alterations from whole genome sequencing (WGS) data is complex where the datasets tend to be very large, and they require highly compute intensive operations that often take days to weeks to complete. By leveraging the Graphical Processing Unit (GPU) accelerated framework, it is possible to analyze the WGS data and identify clinically actionable variants with fast turnaround times without compromising on the accuracy. In this study, we implemented a GPU accelerated framework for most used variant callers ie. Mutect2, MuSE, Somatic Sniper and LoFreq with significantly faster run times in comparison to their Central Processing Unit (CPU) counterpart. Methods Commonly used CPU based somatic variant calling algorithms Mutect2, MuSE, Somatic Sniper and LoFreq, were selected and subsequently accelerated to run on GPUs. The goal of this work is to generate results that are equivalent to the CPU version of these algorithms, but at much faster run times. As a control data set, we utilize the SEQC2 consortium WGS dataset consisting of ~50x tumor and normal samples to assess the performance of individual CPU variant callers to their GPU equivalents. Results The GPU accelerated framework overall provides 10-66x faster run times compared to their CPU-based counterparts. Individually, CPU vs GPU comparisons are, Mutect2 achieved a maximum acceleration of 66x, followed by MuSE, LoFreq both 11x and Somatic Sniper 10x acceleration respectively. The results from accelerated MuSE, LoFreq, Somatic sniper are identical in comparison to the CPU-based somatic variant callers, For Mutect2 we achieve 99.9% sensitivity and 99.85% precision. Discussion Recently, machine-learning based variant detection algorithms exhibited better performance compared to the statistics based heuristic approaches. Here, we have presented the results for an ensemble of four variant callers to be used as the starting point for an ongoing effort to develop a deep learning-based approach for somatic variant detection and smart filtering algorithms. The goal is to enable improved variant calling and provide a GPU computing framework for faster, better, and reproducible workflows to analyze large scale NGS datasets. Citation Format: Pankaj Vats, Ankit Sethia, Mehrzad Samadi, Timothy T. Harkins. Rapid variant detection and annotations from next generation sequencing data using a GPU accelerated framework [abstract]. In: Proceedings of the American Association for Cancer Research Annual Meeting 2022; 2022 Apr 8-13. Philadelphia (PA): AACR; Cancer Res 2022;82(12_Suppl):Abstract nr 1900.

Development of a parallel CUDA algorithm for solving 3D guiding center problems

In this study, we develop a novel compute unified device architecture (CUDA) algorithm, which we call C-ECM3, for solving a three-dimensional (3D) guiding center problem. The C-ECM3 is a parallel algorithm for the iterative-free backward semi-Lagrangian method with third-order temporal accuracy (ECM3). One well known challenge in speeding up a CUDA program is to efficiently design kernel functions that can optimally use hierarchical memory classified according to access speed. To solve this challenge, the C-ECM3 is mainly devoted to making a decomposition strategy for solving the tremendous number of generated Cauchy problems. The decomposition strategy divides the 9×9 linear system for each Cauchy problem in the ECM3 into two 3×3 linear systems, more solverable parts. In addition, the strategy explicitly solves these small systems using Cramer's rule. It turns out that the proposed C-ECM3 enables us to design an array-free kernel function that efficiently uses hierarchical memory. In addition, the C-ECM3 significantly reduces the run-time for tracing trajectories of particles compared to other graphics processing unit (GPU) programs that use the usual Gaussian algorithm. The Kelvin-Helmholtz instability and a 3D guiding center problem are simulated to demonstrate the numerical evidence for the C-ECM3. With these numerical experiments, we verify that the proposed C-ECM3 significantly improves computational speed compared to other methods while maintaining the accuracy of the CPU (central processing unit) version of ECM3. The validity of the C-ECM3 is also confirmed by showing that it satisfies Shoucri's analysis for Kelvin-Helmholtz instability.

Comparing Different Approaches for Solving Large Scale Power-Flow Problems With the Newton-Raphson Method

This paper focuses on using the Newton-Raphson method to solve the power-flow problems. Since the most computationally demanding part of the Newton-Raphson method is to solve the linear equations at each iteration, this study investigates different approaches to solve the linear equations on both central processing unit (CPU) and graphical processing unit (GPU). Six different approaches have been developed and evaluated in this paper: two approaches of these run entirely on CPU while other two of these run entirely on GPU, and the remaining two are hybrid approaches that run on both CPU and GPU. All six direct linear solvers use either $LU$ or $QR$ factorization to solve the linear equations. Two different hardware platforms have been used to conduct the experiments. The performance results show that the CPU version with $LU$ factorization gives better performance compared to the GPU version using standard library called cuSOLVER even for the larger power-flow problems. Moreover, it has been proven that the best performance is achieved using a hybrid method where the Jacobian matrix is assembled on GPU, the preprocessing with a sparse high performance linear solver called KLU is performed on the CPU in the first iteration, and the linear equation is factorized on the GPU and solved on the CPU. Maximum speed up in this study is obtained on the largest case with 25000 buses. The hybrid version shows a speedup factor of 9.6 with a NVIDIA P100 GPU while 13.1 with a NVIDIA V100 GPU in comparison with baseline CPU version on an Intel Xeon Gold 6132 CPU.

Implementation of GPU accelerated SPECT reconstruction with Monte Carlo-based scatter correction.

Statistical SPECT reconstruction can be very time-consuming especially when compensations for collimator and detector response, attenuation, and scatter are included in the reconstruction. This work proposes an accelerated SPECT reconstruction algorithm based on graphics processing unit (GPU) processing. Ordered subset expectation maximization (OSEM) algorithm with CT-based attenuation modelling, depth-dependent Gaussian convolution-based collimator-detector response modelling, and Monte Carlo-based scatter compensation was implemented using OpenCL. The OpenCL implementation was compared against the existing multi-threaded OSEM implementation running on a central processing unit (CPU) in terms of scatter-to-primary ratios, standardized uptake values (SUVs), and processing speed using mathematical phantoms and clinical multi-bed bone SPECT/CT studies. The difference in scatter-to-primary ratios, visual appearance, and SUVs between GPU and CPU implementations was minor. On the other hand, at its best, the GPU implementation was noticed to be 24 times faster than the multi-threaded CPU version on a normal 128 × 128 matrix size 3 bed bone SPECT/CT data set when compensations for collimator and detector response, attenuation, and scatter were included. GPU SPECT reconstructions show great promise as an every day clinical reconstruction tool.

Parallelization Experience with Four Canonical Econometric Models Using ParMitISEM

This paper presents the parallel computing implementation of the MitISEM algorithm, labeled Parallel MitISEM. The basic MitISEM algorithm provides an automatic and flexible method to approximate a non-elliptical target density using adaptive mixtures of Student-t densities, where only a kernel of the target density is required. The approximation can be used as a candidate density in Importance Sampling or Metropolis Hastings methods for Bayesian inference on model parameters and probabilities. We present and discuss four canonical econometric models using a Graphics Processing Unit and a multi-core Central Processing Unit version of the MitISEM algorithm. The results show that the parallelization of the MitISEM algorithm on Graphics Processing Units and multi-core Central Processing Units is straightforward and fast to program using MATLAB. Moreover the speed performance of the Graphics Processing Unit version is much higher than the Central Processing Unit one.

Efficient methods for implementation of multi-level nonrigid mass-preserving image registration on GPUs and multi-threaded CPUs

Background and objectiveFaster and more accurate methods for registration of images are important for research involved in conducting population-based studies that utilize medical imaging, as well as improvements for use in clinical applications. We present a novel computation- and memory-efficient multi-level method on graphics processing units (GPU) for performing registration of two computed tomography (CT) volumetric lung images. MethodsWe developed a computation- and memory-efficient Diffeomorphic Multi-level B-Spline Transform Composite (DMTC) method to implement nonrigid mass-preserving registration of two CT lung images on GPU. The framework consists of a hierarchy of B-Spline control grids of increasing resolution. A similarity criterion known as the sum of squared tissue volume difference (SSTVD) was adopted to preserve lung tissue mass. The use of SSTVD consists of the calculation of the tissue volume, the Jacobian, and their derivatives, which makes its implementation on GPU challenging due to memory constraints. The use of the DMTC method enabled reduced computation and memory storage of variables with minimal communication between GPU and Central Processing Unit (CPU) due to ability to pre-compute values. The method was assessed on six healthy human subjects. ResultsResultant GPU-generated displacement fields were compared against the previously validated CPU counterpart fields, showing good agreement with an average normalized root mean square error (nRMS) of 0.044±0.015. Runtime and performance speedup are compared between single-threaded CPU, multi-threaded CPU, and GPU algorithms. Best performance speedup occurs at the highest resolution in the GPU implementation for the SSTVD cost and cost gradient computations, with a speedup of 112 times that of the single-threaded CPU version and 11 times over the twelve-threaded version when considering average time per iteration using a Nvidia Tesla K20X GPU. ConclusionsThe proposed GPU-based DMTC method outperforms its multi-threaded CPU version in terms of runtime. Total registration time reduced runtime to 2.9min on the GPU version, compared to 12.8min on twelve-threaded CPU version and 112.5min on a single-threaded CPU. Furthermore, the GPU implementation discussed in this work can be adapted for use of other cost functions that require calculation of the first derivatives.

Scaling soft matter physics to thousands of graphics processing units in parallel

We describe a multi-graphics processing unit (GPU) implementation of the Ludwig application, which specialises in simulating a variety of complex fluids via lattice Boltzmann fluid dynamics coupled to additional physics describing complex fluid constituents. We describe our methodology in augmenting the original central processing unit (CPU) version with GPU functionality in a maintainable fashion. We present several optimisations that maximise performance on the GPU architecture through tuning for the GPU memory hierarchy. We describe how we implement particles within the fluid in such a way to avoid a major diversion of the CPU and GPU codebases, whilst minimising data transfer at each time step. We detail our halo-exchange communication phase for the code, which exploits overlapping to allow efficient parallel scaling to many GPUs. We present results showing that the application demonstrates excellent scaling to at least 8192 GPUs in parallel, the largest system tested at the time of writing. The GPU version (on NVIDIA K20X GPUs) is around 3.5–5 times faster that the CPU version (on fully utilised AMD Opteron 6274 16-core CPUs), comparing equal numbers of CPUs and GPUs.

Fast reconstruction of 3D volumes from 2D CT projection data with GPUs.

BackgroundBiomedical image reconstruction applications require producing high fidelity images in or close to real-time. We have implemented reconstruction of three dimensional conebeam computed tomography(CBCT) with two dimensional projections. The algorithm takes slices of the target, weights and filters them to backproject the data, then creates the final 3D volume. We have implemented the algorithm using several hardware and software approaches and taken advantage of different types of parallelism in modern processors. The two hardware platforms used are a Central Processing Unit (CPU) and a heterogeneous system with a combination of CPU and GPU. On the CPU we implement serial MATLAB, parallel MATLAB, C and parallel C with OpenMP extensions. These codes are compared against the heterogeneous versions written in CUDA-C and OpenCL.FindingsOur results show that GPUs are particularly well suited to accelerating CBCT. Relative performance was evaluated on a mathematical phantom as well as on mouse data. Speedups of up to 200x are observed by using an AMD GPU compared to a parallel version in C with OpenMP constructs.ConclusionsIn this paper, we have implemented the Feldkamp-Davis-Kress algorithm, compatible with Fessler’s image reconstruction toolbox and tested it on different hardware platforms including CPU and a combination of CPU and GPU. Both NVIDIA and AMD GPUs have been used for performance evaluation. GPUs provide significant speedup over the parallel CPU version.

Importance of explicit vectorization for CPU and GPU software performance

Much of the current focus in high-performance computing is on multi-threading, multi-computing, and graphics processing unit (GPU) computing. However, vectorization and non-parallel optimization techniques, which can often be employed additionally, are less frequently discussed. In this paper, we present an analysis of several optimizations done on both central processing unit (CPU) and GPU implementations of a particular computationally intensive Metropolis Monte Carlo algorithm. Explicit vectorization on the CPU and the equivalent, explicit memory coalescing, on the GPU are found to be critical to achieving good performance of this algorithm in both environments. The fully-optimized CPU version achieves a 9× to 12× speedup over the original CPU version, in addition to speedup from multi-threading. This is 2× faster than the fully-optimized GPU version, indicating the importance of optimizing CPU implementations.

Parallel garment drape simulation of triangular mesh using GPU programming

PurposeThe purpose of this paper is to determine the possibility of implementing parallel processing feature of graphic processor unit (GPU) in garment drape simulation.Design/methodology/approachVelocity‐Verlet method based on explicit integration is used to drape triangular table cloth meshes. Both drape simulation and collision detection engines are converted to GPU version. Simulation speeds of simple linear algebra and actual free fall table cloth simulation are compared with those of the central processing unit (CPU) version.FindingsThere is apparent calculation speed increase when the parallel computation of GPU is implemented. But the current GPUs have several limits for general purpose computation, so the original CPU version algorithm should be split and modified to be used in GPU.Originality/valueThis paper implemented GPU parallel processing technique in both drape simulation and collision detection. Voxel‐based method is used to find possible collision pairs. Triangular meshes, which are more difficult to implement than quadrilateral ones in GPU programming, are successfully implemented.