Tesla C1060 Research Articles

Intelligent Classification of Large-Scale Remotely Sensed Hyperspectral Images using Multi-GPU Computing

Image classification is one of the most popular tasks used to analyze remote sensing signatures (RSS) of a geographical region from remotely sensed hyperspectral images. However, the high dimensionality of such hyperspectral images raises a series of new challenges. In this paper, a new approach for real-time intelligent classification of large-scale hyperspectral imagery which aggregates Fuzzy logic and the fused weighted order statistic (WOS) with the minimum distance to mean (MDM) techniques using commodity graphics processing units (GPUs) is addressed. Within this context, intelligent image processing methods are algorithmically adapted via parallel computing techniques and efficiently implemented in two NVIDIA Tesla C2075 GPUs. Experimental results demonstrate how such unification reduces drastically the computational load of the real-world hyperspectral classification tasks resulting in efficient numerical algorithms suitable for real-time multi-GPU-adapted implementation.

ВИКОРИСТАННЯ GPU NVIDIA ПРИ ВИРІШЕННІ ЗАВДАНЬ ЛІНІЙНОЇ АЛГЕБРИ

Research goals and objectives: the purpose of the article is to study the feasibility of graphics processors using in solving linear equations systems and calculating matrix multiplication as compared with conventional multi-core processors. The peculiarities of the MAGMA and CUBLAS libraries use for various graphics processors are considered. A performance comparison is made between the Tesla C2075 and GeForce GTX 480 GPUs and a six-core AMD processor. Subject of research: the software is developed basing on the MAGMA and CUBLAS libraries for the purpose of the NVIDIA Tesla C2075 and GeForce GTX 480 GPUs performance study for linear equation systems solving and matrix multiplication calculating. Research methods used: libraries were used to parallelize the linear algebra problems solution. For GPUs, these are MAGMA and CUBLAS, for multi-core processors, the ScaLAPACK and ATLAS libraries. To study the operational speed there are used methods and algorithms of computational procedures parallelization similar to these libraries. A software module has been developed for linear equations systems solving and matrix multiplication calculating by parallel systems. Results of the research: it has been determined that for double-precision numbers the GPU GeForce GTX 480 and the GPU Tesla C2075 performance is approximately 3.5 and 6.3 times higher than that of the AMD CPU. And the GPU GeForce GTX 480 performance is 1.3 times higher than the GPU Tesla C2075 performance for single precision numbers. To achieve maximum performance of the NVIDIA CUDA GPU, you need to use the MAGMA or CUBLAS libraries, which accelerate the calculations by about 6.4 times as compared to the traditional programming method. It has been determined that in equations systems solving on a 6-core CPU, it is possible to achieve a maximum acceleration of 3.24 times as compared to calculations on the 1st core using the ScaLAPACK and ATLAS libraries instead of 6-fold theoretical acceleration. Therefore, it is impossible to efficiently use processors with a large number of cores with considered libraries. It is demonstrated that the advantage of the GPU over the CPU increases with the number of equations.

Quantitative Cone-Beam CT Imaging in Radiotherapy: Parallel Computation and Comprehensive Evaluation on the TrueBeam System

Cone-beam CT (CBCT) imaging is used in the patient setup on the advance image-guided radiation therapy. However, the scatter contamination causes spatial non-uniformity, the error of the CT number, and image contrast loss, which is considered as one of the fundamental limitations for CBCT application. In this paper, we use both scatter correction and noise suppression for improving the quality of CBCT image and comprehensively evaluate our method on patient data. A CBCT software package with parallel computation is designed, which is easily compatible with the existing CBCT system of radiotherapy device with high computing efficiency and CT number accuracy. The primary signals of projections are estimated through the use of the forward projections from the registered planning CT (pCT). The errors of low frequency in the raw projections are obtained through subtracting the forward projections and the low-pass filter implementation. The penalty-weighted-least-square (PWLS) method is applied to reduce the high-frequency noise in the corrected CBCT projections. We use the graphics-processing unit (GPU) NVidia Tesla C2075 card with CUDA C programming to accelerate the time-consuming processes. The CBCT projections of a pelvis phantom and the two pelvis patients are obtained from the Varian TrueBeam system, which is a machine for the radiotherapy. The maximum errors of CT number are reduced over 70 HU on the TrueBeam result to below 15 HU, and the errors of spatial non-uniformity are decreased by a factor of around 7. The computation time is about 25 min on the GPU, which is reduced over 10 h on the CPU. The proposed software shows superior performance over the existing reconstruction. The proposed software demonstrates the reliability of the high-accuracy CBCT-based image-guided radiotherapy (IGRT), providing the high-precise CBCT with less computation time.

How to exploit high performance computing in population-based metaheuristics for solving association rule mining problem

The application of population-based metaheuristics approaches to the association rules mining problem is explored in this paper. The combination of GPU and cluster-based parallel computing techniques is investigated for the purpose of accelerating the process of extracting the correlations between items in sizeable data instances. We propose four parallel-based approaches that benefit from the cluster intensive computing in the generation process and the massively GPU threading. This is by evaluating the association rules in parallel on GPU. To validate the proposed approaches, the most used population-based metaheuristics (GA, PSO, and BSO) have been executed on a cluster of GPUs to solve benchmarks of large and big ARM instances. We used Intel Xeon 64bit quad-core processor E5520 coupled to an Nvidia Tesla C2075 GPU device. The results show that the BSO outperforms GA and PSO. They also show that the proposed solution outperforms the HPC-based ARM approaches when exploring Webdocs instance (the largest instance existing on the web). To our knowledge, this is the first work that explores the combination of GPU and cluster-based parallel computing with the population-based metaheuristics in association rule mining.

Lattice Boltzmann Simulations of Cavity Flows on Graphic Processing Unit with Memory Management

AbstractLattice Boltzmann method (LBM) is adopted to compute two and three-dimensional lid driven cavity flows to examine the influence of memory management on the computational performance using Graphics Processing Unit (GPU). Both single and multi-relaxation time LBM are adopted. The computations are conducted on nVIDIA GeForce Titan, Tesla C2050 and GeForce GTX 560Ti. The performance using global memory deteriorates greatly when multi relaxation time (MRT) LBM is used, which is due to the scheme requesting more information from the global memory than its single relaxation time (SRT) LBM counterpart. On the other hand, adopting on chip memory the difference using MRT and SRT is not significant. Also, performance of LBM streaming procedure using offset reading surpasses offset writing ranging from 50% to 100% and this applies to both SRT and MRT LBM. Finally, comparisons using different GPU platforms indicate that Titan as expected outperforms other devices, and attains 227 and 193 speedup over its Intel Core i7-990 CPU counterpart and four times faster than GTX 560Ti and Tesla C2050 for three dimensional cavity flow simulations respectively with single and double precisions.

A parallelization scheme of the periodic signals tracking algorithm for isochronous mass spectrometry on GPUs

The periodic signals tracking algorithm has been used to determine the revolution times of ions stored in storage rings in isochronous mass spectrometry (IMS) experiments. It has been a challenge to perform real-time data analysis by using the periodic signals tracking algorithm in the IMS experiments. In this paper, a parallelization scheme of the periodic signals tracking algorithm is introduced and a new program is developed. The computing time of data analysis can be reduced by a factor of ∼71 and of ∼346 by using our new program on Tesla C1060 GPU and Tesla K20c GPU, compared to using old program on Xeon E5540 CPU. We succeed in performing real-time data analysis for the IMS experiments by using the new program on Tesla K20c GPU.

Improved preconditioned conjugate gradient algorithm and application in 3D inversion of gravity-gradiometry data

With the continuous development of full tensor gradiometer (FTG) measurement techniques, three-dimensional (3D) inversion of FTG data is becoming increasingly used in oil and gas exploration. In the fast processing and interpretation of large-scale high-precision data, the use of the graphics processing unit process unit (GPU) and preconditioning methods are very important in the data inversion. In this paper, an improved preconditioned conjugate gradient algorithm is proposed by combining the symmetric successive over-relaxation (SSOR) technique and the incomplete Choleksy decomposition conjugate gradient algorithm (ICCG). Since preparing the preconditioner requires extra time, a parallel implement based on GPU is proposed. The improved method is then applied in the inversion of noisecontaminated synthetic data to prove its adaptability in the inversion of 3D FTG data. Results show that the parallel SSOR-ICCG algorithm based on NVIDIA Tesla C2050 GPU achieves a speedup of approximately 25 times that of a serial program using a 2.0 GHz Central Processing Unit (CPU). Real airborne gravity-gradiometry data from Vinton salt dome (southwest Louisiana, USA) are also considered. Good results are obtained, which verifies the efficiency and feasibility of the proposed parallel method in fast inversion of 3D FTG data.

The Case for Polymorphic Registers in Dataflow Computing

Heterogeneous systems are becoming increasingly popular, delivering high performance through hardware specialization. However, sequential data accesses may have a negative impact on performance. Data parallel solutions such as Polymorphic Register Files (PRFs) can potentially accelerate applications by facilitating high-speed, parallel access to performance-critical data. This article shows how PRFs can be integrated into dataflow computational platforms. Our semi-automatic, compiler-based methodology generates customized PRFs and modifies the computational kernels to efficiently exploit them. We use a separable 2D convolution case study to evaluate the impact of memory latency and bandwidth on performance compared to a state-of-the-art NVIDIA Tesla C2050 GPU. We improve the throughput up to 56.17X and show that the PRF-augmented system outperforms the GPU for 9times 9 or larger mask sizes, even in bandwidth-constrained systems.

A Two-Layered Parallel Static Security Assessment for Large-Scale Grids Based on GPU

The development of smart grid and the increasing scale of power system brings more and more pressure to the conventional power system simulators. The graphic processing unit which features the massive concurrent threads and excellent floating point performance brings a new chance to the area of power system simulation. This paper introduces a hierarchical parallel LU decomposition algorithm based on stratified elimination tree, and develops a graphic processing unit (GPU)-based parallel linear system solver on the algorithm. To boost the effectiveness of the solver, a hybrid improved matrix ordering algorithm is proposed which can reduce the height of the elimination tree. On the basis of the solver, this paper implements a coarse-grained task parallelism which can analyze several contingencies of static security assessment (SSA) in parallel, and develops a two-layered parallel SSA program. The performance of the proposed parallel SSA program is benchmarked on a Tesla C2050 GPU using several real world cases, whose scale is up to 21801 nodes, compared with a serial SSA program which runs on a Xeon E5620 CPU. The results of the case studies show that the introduced method’s speedup reaches 9.2 times, which can greatly accelerate SSA solution.

An investigation of GPU-based stiff chemical kinetics integration methods

A fifth-order implicit Runge–Kutta method and two fourth-order exponential integration methods equipped with Krylov subspace approximations were implemented for the GPU and paired with the analytical chemical kinetic Jacobian software pyJac. The performance of each algorithm was evaluated by integrating thermochemical state data sampled from stochastic partially stirred reactor simulations and compared with the commonly used CPU-based implicit integrator CVODE. We estimated that the implicit Runge–Kutta method running on a single Tesla C2075 GPU is equivalent to CVODE running on 12–38 Intel Xeon E5-4640 v2 CPU cores for integration of a single global integration time step of 10−6s with hydrogen and methane kinetic models. In the stiffest case studied—the methane model with a global integration time step of 10−4s—thread divergence and higher memory traffic significantly decreased GPU performance to the equivalent of CVODE running on approximately three CPU cores. The exponential integration algorithms performed more slowly than the implicit integrators on both the CPU and GPU. Thread divergence and memory traffic were identified as the main limiters of GPU integrator performance, and techniques to mitigate these issues were discussed. Use of a finite-difference Jacobian on the GPU—in place of the analytical Jacobian provided by pyJac—greatly decreased integrator performance due to thread divergence, resulting in maximum slowdowns of 7.11−240.96×; in comparison, the corresponding slowdowns on the CPU were just 1.39−2.61×, underscoring the importance of use of an analytical Jacobian for efficient GPU integration. Finally, future research directions for working towards enabling realistic chemistry in reactive-flow simulations via GPU/SIMT accelerated stiff chemical kinetics integration were identified.

A parallel algorithm for the initial screening of space debris collisions prediction using the SGP4/SDP4 models and GPU acceleration

Currently, a tremendous amount of space debris in Earth’s orbit imperils operational spacecraft. It is essential to undertake risk assessments of collisions and predict dangerous encounters in space. However, collision predictions for an enormous amount of space debris give rise to large-scale computations. In this paper, a parallel algorithm is established on the Compute Unified Device Architecture (CUDA) platform of NVIDIA Corporation for collision prediction. According to the parallel structure of NVIDIA graphics processors, a block decomposition strategy is adopted in the algorithm. Space debris is divided into batches, and the computation and data transfer operations of adjacent batches overlap. As a consequence, the latency to access shared memory during the entire computing process is significantly reduced, and a higher computing speed is reached. Theoretically, a simulation of collision prediction for space debris of any amount and for any time span can be executed. To verify this algorithm, a simulation example including 1382 pieces of debris, whose operational time scales vary from 1min to 3days, is conducted on Tesla C2075 of NVIDIA. The simulation results demonstrate that with the same computational accuracy as that of a CPU, the computing speed of the parallel algorithm on a GPU is 30 times that on a CPU. Based on this algorithm, collision prediction of over 150 Chinese spacecraft for a time span of 3days can be completed in less than 3h on a single computer, which meets the timeliness requirement of the initial screening task. Furthermore, the algorithm can be adapted for multiple tasks, including particle filtration, constellation design, and Monte-Carlo simulation of an orbital computation.

Modified Dijkstra’s Algorithm for Dense Graphs on GPU using CUDA

The objective of this research is to propose and implement a fast parallel Single source shortest path (SSSP) algorithm on Graphics Processing Unit (GPU) based highly parallel and cost effective platform for dense and complete graphs. The proposed algorithm is a variant of Dijkstra’s algorithm for SSSP calculation for complete and dense graphs. In place of relaxing all the edges of a selected node as in Dijkstra’s algorithm, it relaxes one-one selected edge of different nodes of the graph simultaneously at any iteration. This paper shows parallel implementation of both Dijkstra’s algorithm and our modified Dijkstra’s algorithm on a GPU-based machine. We evaluate these implementations on NVIDIA Tesla C2075 GPU- based machines. Parallel implementation of proposed modified Dijkstra’s algorithm gives a two to three times speed increase over a parallel Dijkstra’s algorithm on a GPU-based machine for complete and dense graphs. The proposed algorithm has minimized the number of edges relaxed by one parallel thread at any iteration of parallel Dijkstra’s algorithm.

Parallel simulation of Population Dynamics P systems: updates and roadmap

Population Dynamics P systems are a type of multienvironment P systems that serve as a formal modeling framework for real ecosystems. The accurate simulation of these probabilistic models, e.g. with Direct distribution based on Consistent Blocks Algorithm, entails large run times. Hence, parallel platforms such as GPUs have been employed to speedup the simulation. In 2012, the first GPU simulator of PDP systems was presented. However, it was able to run only randomly generated PDP systems. In this paper, we present current updates made on this simulator, involving an input modu le for binary files and an output module for CSV files. Finally, the simulator has been experimentally validated with a real ecosystem model, and its performance has been tested with two high-end GPUs: Tesla C1060 and K40.

GPU accelerated cell-based adaptive mesh refinement on unstructured quadrilateral grid

A GPU accelerated inviscid flow solver is developed on an unstructured quadrilateral grid in the present work. For the first time, the cell-based adaptive mesh refinement (AMR) is fully implemented on GPU for the unstructured quadrilateral grid, which greatly reduces the frequency of data exchange between GPU and CPU. Specifically, the AMR is processed with atomic operations to parallelize list operations, and null memory recycling is realized to improve the efficiency of memory utilization. It is found that results obtained by GPUs agree very well with the exact or experimental results in literature. An acceleration ratio of 4 is obtained between the parallel code running on the old GPU GT9800 and the serial code running on E3-1230 V2. With the optimization of configuring a larger L1 cache and adopting Shared Memory based atomic operations on the newer GPU C2050, an acceleration ratio of 20 is achieved. The parallelized cell-based AMR processes have achieved 2x speedup on GT9800 and 18x on Tesla C2050, which demonstrates that parallel running of the cell-based AMR method on GPU is feasible and efficient. Our results also indicate that the new development of GPU architecture benefits the fluid dynamics computing significantly.

An improved parallel fuzzy connected image segmentation method based on CUDA.

PurposeFuzzy connectedness method (FC) is an effective method for extracting fuzzy objects from medical images. However, when FC is applied to large medical image datasets, its running time will be greatly expensive. Therefore, a parallel CUDA version of FC (CUDA-kFOE) was proposed by Ying et al. to accelerate the original FC. Unfortunately, CUDA-kFOE does not consider the edges between GPU blocks, which causes miscalculation of edge points. In this paper, an improved algorithm is proposed by adding a correction step on the edge points. The improved algorithm can greatly enhance the calculation accuracy.MethodsIn the improved method, an iterative manner is applied. In the first iteration, the affinity computation strategy is changed and a look up table is employed for memory reduction. In the second iteration, the error voxels because of asynchronism are updated again.ResultsThree different CT sequences of hepatic vascular with different sizes were used in the experiments with three different seeds. NVIDIA Tesla C2075 is used to evaluate our improved method over these three data sets. Experimental results show that the improved algorithm can achieve a faster segmentation compared to the CPU version and higher accuracy than CUDA-kFOE.ConclusionsThe calculation results were consistent with the CPU version, which demonstrates that it corrects the edge point calculation error of the original CUDA-kFOE. The proposed method has a comparable time cost and has less errors compared to the original CUDA-kFOE as demonstrated in the experimental results. In the future, we will focus on automatic acquisition method and automatic processing.

Reducing thread divergence in GPU‐based bees swarm optimization applied to association rule mining

SummaryThe association rules mining (ARM) problem is one of the most important problems in the area of data mining. It aims at finding all relevant association rules from transactional databases. It is CPU time intensive and requires a huge computing power when dealing with large transactional databases. To deal with this issue, Graphics Processing Units (GPUs) are a powerful tool to speed up the search process. However, their performance is closely subject to thread/branch divergence resulting from the single instruction multiple data parallel model of GPUs. In this paper, we propose three approaches based on database reorganization, aiming to reduce thread divergence in GPU‐based bees swarm optimization metaheuristic for ARM, respectively, named block‐based reordering, transactions‐based reordering, and transactions‐based reordering with median value. Theoretical and experimental studies have been carried out using well‐known large ARM instances. The experiments have been performed on an Intel Xeon 64 bit quad‐core processor E5520 coupled to Nvidia Tesla C2075 448 cores. The results show that the proposed approaches minimize considerably the number of thread divergence and improve the overall execution time. Indeed, the number of thread divergence occurrences has been reduced by up to eight times making the execution much faster. Copyright © 2016 John Wiley & Sons, Ltd.

Leveraging FPGAs for Accelerating Short Read Alignment.

One of the key challenges facing genomics today is how to efficiently analyze the massive amounts of data produced by next-generation sequencing platforms. With general-purpose computing systems struggling to address this challenge, specialized processors such as the Field-Programmable Gate Array (FPGA) are receiving growing interest. The means by which to leverage this technology for accelerating genomic data analysis is however largely unexplored. In this paper, we present a runtime reconfigurable architecture for accelerating short read alignment using FPGAs. This architecture exploits the reconfigurability of FPGAs to allow the development of fast yet flexible alignment designs. We apply this architecture to develop an alignment design which supports exact and approximate alignment with up to two mismatches. Our design is based on the FM-index, with optimizations to improve the alignment performance. In particular, the n-step FM-index, index oversampling, a seed-and-compare stage, and bi-directional backtracking are included. Our design is implemented and evaluated on a 1U Maxeler MPC-X2000 dataflow node with eight Altera Stratix-V FPGAs. Measurements show that our design is 28 times faster than Bowtie2 running with 16 threads on dual Intel Xeon E5-2640 CPUs, and nine times faster than Soap3-dp running on an NVIDIA Tesla C2070 GPU.

GPU-LMDDA: a bit-vector GPU-based deadlock detection algorithm for multi-unit resource systems

This article presents the detailed description of a GPU-based multi-unit deadlock detection methodology, GPU-LMDDA with 12 pieces of pseudo code. Our design utilises the massively parallel hardware of the GPU to perform computations of deadlock detection in multi-unit resource systems. As a result, it is able to overcome the major limitations of prior software and hardware-based solutions by handling thousands of processes and resources concurrently. GPU-LMDDA employs a bit-vector technique with a novel bit-matrix multiplication algorithm to store and perform computations on algorithm matrices, thus decreasing the memory footprint and maximizing throughput. Our design treats deadlock detection as a service to the operating system by requiring minimal interaction with the CPU. By treating deadlock detection as an interactive service, all matrix management and algorithm computation are handled by the GPU, freeing CPU compute cycles. Our algorithm is implemented on three GPU cards: Tesla C2050, Tesla K20c, and Titan X, which showed speedups of 3-434X against single-threaded CPU equivalents.

Monte Carlo simulations of settlement dynamics in GPUs

Recently, a Monte Carlo model was proposed in order to simulate settlement dynamics in drylands, including several environmental factors, and it was implemented as a serial CPU code. In this work we present a parallel implementation of that code using graphics processing units (GPU) and NVIDIA CUDA. The code was tested with two experiments, a Baseline case and a Realistic case. We take advantage of the GPU architecture to obtain significant speedups: $$\sim $$~8$$\times $$× to $$\sim $$~20$$\times $$× with the Baseline case in a NVIDIA Tesla C2050 versus a Phenom 1055T CPU. The Realistic case obtained $$\sim $$~80$$\times $$× of speedup in the same hardware. The GPU performance of the code will allow the inclusion of additional factors affecting settlements and large grid sizes for detailed environmental degradation models.

GPU-OSDDA: a bit-vector GPU-based deadlock detection algorithm for single-unit resource systems

This article presents a GPU-based single-unit deadlock detection methodology and its algorithm, GPU-OSDDA. Our GPU-based design utilizes parallel hardware of GPU to perform computations and thus is able to overcome the major limitation of prior hardware-based approaches by having the capability of handling thousands of processes and resources, whilst achieving real-world run-times. By utilizing a bit-vector technique for storing algorithm matrices and designing novel, efficient algorithmic methods, we not only reduce memory usage dramatically but also achieve two orders of magnitude speedup over CPU equivalents. Additionally, GPU-OSDDA acts as an interactive service to the CPU, because all of the aforementioned computations and matrix management techniques take place on the GPU, requiring minimal interaction with the CPU. GPU-OSDDA is implemented on three GPU cards: Tesla C2050, Tesla K20c, and Titan X. Our design shows overall speedups of 6-595X over CPU equivalents.