Number Of Graphics Processing Units Research Articles

Accelerating genomic workflows using NVIDIA Parabricks

BackgroundAs genome sequencing becomes better integrated into scientific research, government policy, and personalized medicine, the primary challenge for researchers is shifting from generating raw data to analyzing these vast datasets. Although much work has been done to reduce compute times using various configurations of traditional CPU computing infrastructures, Graphics Processing Units (GPUs) offer opportunities to accelerate genomic workflows by orders of magnitude. Here we benchmark one GPU-accelerated software suite called NVIDIA Parabricks on Amazon Web Services (AWS), Google Cloud Platform (GCP), and an NVIDIA DGX cluster. We benchmarked six variant calling pipelines, including two germline callers (HaplotypeCaller and DeepVariant) and four somatic callers (Mutect2, Muse, LoFreq, SomaticSniper).ResultsWe achieved up to 65 × acceleration with germline variant callers, bringing HaplotypeCaller runtimes down from 36 h to 33 min on AWS, 35 min on GCP, and 24 min on the NVIDIA DGX. Somatic callers exhibited more variation between the number of GPUs and computing platforms. On cloud platforms, GPU-accelerated germline callers resulted in cost savings compared with CPU runs, whereas some somatic callers were more expensive than CPU runs because their GPU acceleration was not sufficient to overcome the increased GPU cost.ConclusionsGermline variant callers scaled well with the number of GPUs across platforms, whereas somatic variant callers exhibited more variation in the number of GPUs with the fastest runtimes, suggesting that, at least with the version of Parabricks used here, these workflows are less GPU optimized and require benchmarking on the platform of choice before being deployed at production scales. Our study demonstrates that GPUs can be used to greatly accelerate genomic workflows, thus bringing closer to grasp urgent societal advances in the areas of biosurveillance and personalized medicine.

3D inversion of vertical gravity gradient with multiple graphics processing units based on matrix compression

Among single-component inversions, vertical gravity gradient data have been proven to be sufficient to obtain reasonable density distribution. However, the increasing numbers of observations and model parameters inevitably produce a large-scale sensitivity matrix, causing problems such as large memory occupation and slow computations in the inversion. Aiming at solving these long-standing problems, we have introduced a matrix compression technique to reduce memory occupation and constructed a hybrid parallel algorithm for accelerating focusing inversion. We develop the source codes and the design pattern for the proposed algorithm using C language with open multiprocessing and compute unified device architecture for further improving algorithm feasibility and reusability. A graphical user interface and visualization tools also are developed using Python. In the tests with synthetic data produced by numerical simulation and real data from Vinton Dome, it is verified that the inversion can produce an accurate result of density values and object location. The performance analysis is conducted using different scales of data. The speedup increases with the increasing number of graphics processing units (GPUs) and model parameters, proving that the proposed parallel algorithm is scalable. We compare this algorithm with others without matrix compression to demonstrate how the compressed sensitivity matrix storing and accessing method influences inversion performance. More specifically, for an inversion with 100 × 100 × 20 cells, the average speed is approximately 6 s per iteration, with a maximum speedup of 36.94. Our algorithm has a short running time and high multiple-GPU parallel efficiency. Hence, the hybrid parallel algorithm is more powerful at implementing large-scale data calculations and could be used for solving computing problems in mass data inversions.

A memory optimization method combined with adaptive time-step method for cardiac cell simulation based on multi-GPU

Cardiac electrophysiological simulation is a very complex computational process, which can be run on graphics processing unit (GPU) to save computational cost greatly. The use of adaptive time-step can further effectively speed up the simulation of heart cells. However, if the adaptive time-step method applies to GPU, it suffers synchronization problem on GPU, weakening the acceleration of adaptive time-step method. The previous work ran on a single GPU with the adaptive time-step to get only 1.5 times (× 1.5) faster than the fixed time-step. This study proposes a memory allocation method, which can effectively implement the adaptive time-step method on GPU. The proposed method mainly focuses on the stimulus point and potential memory arrangement in order to achieve optimal memory storage efficiency. All calculation is implemented on GPU. Large matrices such as potential are arranged in column order, and the cells on the left are stimulated. The Luo-Rudy passive (LR1) and dynamic (LRd) ventricular action potential models are used with adaptive time-step methods, such as the traditional hybrid method (THM) and Chen-Chen-Luo's (CCL) "quadratic adaptive algorithm" method. As LR1 is solved by the THM or CCL on a single GPU, the acceleration is ×34 and ×75 respectively compared with the fixed time-step. With 2 or 4 GPUs, the acceleration of the THM and CCL is ×34 or ×35 and ×73 or ×75, but it would decrease to ×5 or ×3 and ×20 or ×15 without optimization. In an LRd model, the acceleration reaches ×27 or ×85 as solved by the THM or CCL compared with the fixed time-step on multi-GPU with linear speed up increase versus the number of GPU. However, with the increase of GPUs number, the acceleration of the THM and CCL is continuously weakened before optimization. The mixed root mean square error (MRMSE) lower than 5% is applied to ensure the accuracy of simulation. The result shows that the proposed memory arrangement method can save computational cost a lot to speed up the heart simulation greatly. Graphical abstract Acceleration ratio compared with CPU with fixed time-step (dt = 0.001ms).

Way of Measuring Data Transfer Delays among Graphics Processing Units at Different Nodes of a Computer Cluster

The basics of load tests for a computer cluster with a large number of GPUs (graphics processing units) distributed over the cluster’s nodes are presented and implemented as a program code. Information about the time delays in the transfer of data of different sizes among all GPUs in the system is collected as a result. Two modes of tests, ‘‘all to all’’ and ‘‘one to one,’’ are developed. In the first mode, all GPUs transfer data to all GPUs simultaneously. In the second mode, only the transfer between two GPUs proceeds at a single moment in time. Using test results obtained on the K60 computer cluster at the Keldysh Institute of Applied Mathematics, Russian Academy of Sciences, it is shown that the interconnector medium of the supercomputer is inhomogeneous in data transfer among the GPUs not only for transfer through the network, but also for the GPUs in a common node of the computer cluster.

Remote Sensing Big Data Classification with High Performance Distributed Deep Learning

High-Performance Computing (HPC) has recently been attracting more attention in remote sensing applications due to the challenges posed by the increased amount of open data that are produced daily by Earth Observation (EO) programs. The unique parallel computing environments and programming techniques that are integrated in HPC systems are able to solve large-scale problems such as the training of classification algorithms with large amounts of Remote Sensing (RS) data. This paper shows that the training of state-of-the-art deep Convolutional Neural Networks (CNNs) can be efficiently performed in distributed fashion using parallel implementation techniques on HPC machines containing a large number of Graphics Processing Units (GPUs). The experimental results confirm that distributed training can drastically reduce the amount of time needed to perform full training, resulting in near linear scaling without loss of test accuracy.

Implementation of the moving particle semi-implicit method for free-surface flows on GPU clusters

The moving particle semi-implicit (MPS) method performs well in simulating incompressible flows with free surfaces. Despite its applicability, the MPS method suffers from the fundamental instability problem and high computational cost in its practical application. Substantial research has been conducted on improving the stability and accuracy of the MPS method. Moreover, graphics processing units (GPUs), which are multi-processors that execute many three-dimensional geometric processes at high speed, provide unprecedented capability for scientific computations. However, the usage of a single GPU card is not sufficient for engineering applications that require several million particles that predict the desired physical processes, because the available memory space is insufficient. In this work, the dynamic stability (DS) algorithm and particle shifting (PS) algorithm have been used to overcome the instability and inaccuracies caused by tensile instability and non-uniform particle distribution, respectively. Based on the stable MPS method, a GPU-based MPS code that uses the compute unified device architecture (CUDA) language has been developed. An efficient neighborhood particle search is performed using an indirect method, and the matrix for the pressure Poisson equation (PPE) is assembled in parallel. Based on the single-GPU version, a multi-GPU MPS code has been developed. The approach uses a non-geometric dynamic domain decomposition method that provides homogeneous load balancing whereby different portions (subdomains) of the physical system under study are assigned to different GPUs. Communication between devices is achieved with the use of a message passing interface (MPI). Based on the neighborhood particle search, the techniques for building and updating the “halo” are described in detail. The speed-up of the single-GPU version is analyzed for different numbers of particles, and the scalability of the multi-GPU version is analyzed for different numbers of particles and different numbers of GPUs. Last, an application with more than 107 particles is presented to show the capability of the code in handling large-scale simulations.

Large scale parallelisation of the material point method with multiple GPUs

The material point method (MPM), which is a combination of the finite element and meshfree methods, suffers from significant computational workload due to the fine mesh required in spite of its advantages in simulating large deformations. This paper presents a parallel computing strategy for the MPM with multiple Graphics Processing Units (GPUs) to boost the method’s computational efficiency in large scale problems. Domain decomposition method is used to split the workload over subdomains onto a number of GPUs. Communication between the subdomains is implemented by the data transfer between GPUs and random access memory. On each GPU the MPM algorithm is parallelised over nodes or particles. Benchmark problems of slurry runout and surface pipe penetration are analysed to quantify the speedup of the multiple-GPU parallel simulations over the sequential counterparts on the central processing unit. The maximum speedup with 1 GPU is 84 and increases to ∼1280 using 16 GPUs.

Large-Scale Structured Sparsity via Parallel Fused Lasso on Multiple GPUs

ABSTRACTWe present a massively parallel algorithm for the fused lasso, powered by a multiple number of graphics processing units (GPUs). Our method is suitable for a class of large-scale sparse regression problems on which a two-dimensional lattice structure among the coefficients is imposed. This structure is important in many statistical applications, including image-based regression in which a set of images are used to locate image regions predictive of a response variable such as human behavior. Such large datasets are increasingly common. In our study, we employ the split Bregman method and the fast Fourier transform, which jointly have a high data-level parallelism that is distinct in a two-dimensional setting. Our multi-GPU parallelization achieves remarkably improved speed. Specifically, we obtained as much as 433 times improved speed over that of the reference CPU implementation. We demonstrate the speed and scalability of the algorithm using several datasets, including 8100 samples of 512 × 512 images. Compared to the single GPU counterpart, our method also showed improved computing speed as well as high scalability. We describe the various elements of our study as well as our experience with the subtleties in selecting an existing algorithm for parallelization. It is critical that memory bandwidth be carefully considered for multi-GPU algorithms. Supplementary material for this article is available online.

Solving Poisson’s equation using FFT in a GPU cluster

Poisson’s equation is present in many scientific computations and its efficient solution is achieved by means of several methods. One of the most efficient methods is the Fast Fourier Transform (FFT), which is very widely used in lots of computational problems. In this work we implement a Poisson solver that uses FFT as base method and runs in a cluster of Graphics Processing Units (GPU). We analyze the execution of our implementation to find the main bottlenecks and we compare the results to a CPU based solver. The results show a good scalability up to 16 GPUs, the number of GPUs we have available. Moreover, although the main time consuming part of the process is the network communication, the GPU implementation is about 2.5 times faster than the CPU implementation.

HASEonGPU—An adaptive, load-balanced MPI/GPU-code for calculating the amplified spontaneous emission in high power laser media

We present an adaptive Monte Carlo algorithm for computing the amplified spontaneous emission (ASE) flux in laser gain media pumped by pulsed lasers. With the design of high power lasers in mind, which require large size gain media, we have developed the open source code HASEonGPU that is capable of utilizing multiple graphic processing units (GPUs). With HASEonGPU, time to solution is reduced to minutes on a medium size GPU cluster of 64 NVIDIA Tesla K20m GPUs and excellent speedup is achieved when scaling to multiple GPUs. Comparison of simulation results to measurements of ASE in Y b3+:Y AG ceramics show perfect agreement. Program summaryProgram title: HASEonGPUCatalogue identifier: AFAM_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AFAM_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: GNU General Public License, version 3No. of lines in distributed program, including test data, etc.: 84610No. of bytes in distributed program, including test data, etc.: 3791861Distribution format: tar.gzProgramming language: C++, Matlab.Computer: GPU cluster or workstation with CUDA-capable GPUs (compute capability ≥2.0).Operating system: Linux.Has the code been vectorized or parallelized?: Yes, can utilize 1 CPU core per compatible GPU.RAM: Several Gb, depending on input size and number of GPUs. 4000000000 bytes (4 GB) per GPU is recommended.Classification: 4.13, 6.5, 15.External routines: CUDA, Boost Program Options, OpenMPINature of problem:The algorithm described by D. Albach in [1, 2] uses ray-tracing techniques and Monte Carlo integration to calculate Amplified Spontaneous Emission (ASE) with high precision. It requires a high number of sampling points as well as a high number of rays to reach the desired results. Additionally, reflections on the upper and lower surfaces of the medium increase the workload by an order of magnitude. On traditional CPU-based systems the computation is time-consuming, which limits the number of simulations that can be performed.Solution method:HASEonGPU uses a non-uniform distribution of sampling points within the gain medium to focus computation on areas of interest. This is further improved by combining the Monte Carlo integration with importance sampling [3]. To improve execution time further, the algorithm is highly parallelized to run on a GPU and supports adaptive sampling resolutions and random restarts. It can also be executed in a GPU cluster, where linear scaling is achieved by a coarse-granular load balancing that distributes the workload among all GPUs in a master–worker-scheme over MPI.Restrictions:Presently, the number of rays used for the Monte Carlo integration of a single sampling point within the gain medium is limited by the available memory on the GPU (about 108 rays per GB of GPU memory). Furthermore, when using MPI as a workload distribution mechanism, one of the MPI processes will act as a scheduling master and its GPU cannot participate in the computation.Unusual features:The software can run on a workstation (threaded) as well as on a large-scale GPU cluster (MPI) that provides the required GPU hardware. The simulation parameters include polychromatic laser pulses as well as surface coatings, cladding, and refractive indices of the gain medium. This also allows the simulation of reflections on the upper and lower surfaces of the medium. If a desired mean square error metric is not met with a set number of rays, the algorithm can automatically increase the number of rays to improve the results.Additional comments:The source code also includes a MATLAB script that can be used to call HASEonGPU directly from MATLAB code to integrate it into existing simulation setups. There are also examples included on how to execute HASEonGPU from the command line as well as an example experiment that uses MATLAB and the provided script. More detailed information can be found in the README file.Running time:Depending on the number of sampling points, desired sampling resolution for each point, and number of GPUs, the execution time can vary strongly. A typical cylindrical gain medium of 6 cm diameter simulated with 4210 non-uniformly distributed sampling points can be simulated with a sufficient precision in 1 min on a single NVIDIA Tesla K20m GPU. Running time as well as precision can be further optimized through various parameters.

Implementation of Multi-GPU Based Lattice Boltzmann Method for Flow Through Porous Media

AbstractThe lattice Boltzmann method (LBM) can gain a great amount of performance benefit by taking advantage of graphics processing unit (GPU) computing, and thus, the GPU, or multi-GPU based LBM can be considered as a promising and competent candidate in the study of large-scale fluid flows. However, the multi-GPU based lattice Boltzmann algorithm has not been studied extensively, especially for simulations of flow in complex geometries. In this paper, through coupling with the message passing interface (MPI) technique, we present an implementation of multi-GPU based LBM for fluid flow through porous media as well as some optimization strategies based on the data structure and layout, which can apparently reduce memory access and completely hide the communication time consumption. Then the performance of the algorithm is tested on a one-node cluster equipped with four Tesla C1060 GPU cards where up to 1732 MFLUPS is achieved for the Poiseuille flow and a nearly linear speedup with the number of GPUs is also observed.

IMPLEMENTATION OF THE LORENTZ–DRUDE MODEL INCORPORATED FDTD METHOD ON MULTIPLE GPUs FOR PLASMONICS APPLICATIONS

The Lorentz–Drude model incorporated Maxwell equations are simulated by using the three-dimensional finite difference time domain (FDTD) method and the method is parallelized on multiple graphics processing units (GPUs) for plasmonics applications. The compute unified device architecture (CUDA) is used for GPU parallelization. The Lorentz–Drude (LD) model is used to simulate the dispersive nature of materials in plasmonics domain and the auxiliary differential equation (ADE) approach is used to make it consistent with time domain Maxwell equations. Different aspects of multiple GPUs for the FDTD method are presented such as comparison of different numbers of GPUs, transfer time in between them, synchronous, and asynchronous passing. It is shown that by using multiple GPUs in parallel fashion, significant reduction in the simulation time can be achieved as compared to the single GPU.

MULTIBEAM GPU TRANSIENT PIPELINE FOR THE MEDICINA BEST-2 ARRAY

Radio transient discovery using next generation radio telescopes will pose several digital signal processing and data transfer challenges, requiring specialized high-performance backends. Several accelerator technologies are being considered as prototyping platforms, including Graphics Processing Units (GPUs). In this paper we present a real-time pipeline prototype capable of processing multiple beams concurrently, performing Radio Frequency Interference (RFI) rejection through thresholding, correcting for the delay in signal arrival times across the frequency band using brute-force dedispersion, event detection and clustering, and finally candidate filtering, with the capability of persisting data buffers containing interesting signals to disk. This setup was deployed at the BEST-2 SKA pathfinder in Medicina, Italy, where several benchmarks and test observations of astrophysical transients were conducted. These tests show that on the deployed hardware eight 20 MHz beams can be processed simultaneously for ~640 Dispersion Measure (DM) values. Furthermore, the clustering and candidate filtering algorithms employed prove to be good candidates for online event detection techniques. The number of beams which can be processed increases proportionally to the number of servers deployed and number of GPUs, making it a viable architecture for current and future radio telescopes.

Molecular dynamics simulations with many-body potentials on multiple GPUs—The implementation, package and performance

Molecular dynamics (MD) is an important research tool extensively applied in materials science. Running MD on a graphics processing unit (GPU) is an attractive new approach for accelerating MD simulations. Currently, GPU implementations of MD usually run in a one-host-process-one-GPU (OHPOG) scheme. This scheme may pose a limitation on the system size that an implementation can handle due to the small device memory relative to the host memory. In this paper, we present a one-host-process-multiple-GPU (OHPMG) implementation of MD with embedded-atom-model or semi-empirical tight-binding many-body potentials. Because more device memory is available in an OHPMG process, the system size that can be handled is increased to a few million or more atoms. In comparison with the serial CPU implementation, in which Newton’s third law is applied to improve the computational efficiency, our OHPMG implementation has achieved a 28.9x–86.0x speedup in double precision, depending on the system size, the cut-off ranges and the number of GPUs. The implementation can also handle a group of small simulation boxes in one run by combining the small boxes into a large box. This approach greatly improves the GPU computing efficiency when a large number of MD simulations for small boxes are needed for statistical purposes.

New multi-GPU implementation for smoothed particle hydrodynamics on heterogeneous clusters

A massively parallel SPH scheme using heterogeneous clusters of Central Processing Units (CPUs) and Graphics Processing Units (GPUs) has been developed. The new implementation originates from the single-GPU DualSPHysics code previously demonstrated to be powerful, stable and accurate. A combination of different parallel programming languages is combined to exploit not only one device (CPU or GPU) but also the combination of different machines. Communication among devices uses an improved Message Passing Interface (MPI) implementation which addresses some of the well-known drawbacks of MPI such as including a dynamic load balancing and overlapping data communications and computation tasks. The efficiency and scalability (strong and weak scaling) obtained with the new DualSPHysics code are analysed for different numbers of particles and different number of GPUs. Last, an application with more than 109 particles is presented to show the capability of the code to handle simulations that otherwise require large CPU clusters or supercomputers.

Distributed MLEM: An Iterative Tomographic Image Reconstruction Algorithm for Distributed Memory Architectures

The processing speed for positron emission tomography (PET) image reconstruction has been greatly improved in recent years by simply dividing the workload to multiple processors of a graphics processing unit (GPU). However, if this strategy is generalized to a multi-GPU cluster, the processing speed does not improve linearly with the number of GPUs. This is because large data transfer is required between the GPUs after each iteration, effectively reducing the parallelism. This paper proposes a novel approach to reformulate the maximum likelihood expectation maximization (MLEM) algorithm so that it can scale up to many GPU nodes with less frequent inter-node communication. While being mathematically different, the new algorithm maximizes the same convex likelihood function as MLEM, thus converges to the same solution. Experiments on a multi-GPU cluster demonstrate the effectiveness of the proposed approach.

Fast on‐site Monte Carlo tool for dose calculations in CT applications

Monte Carlo (MC) simulation is an established technique for dose calculation in diagnostic radiology. The major drawback is its high computational demand, which limits the possibility of usage in real-time applications. The aim of this study was to develop fast on-site computed tomography (CT) specific MC dose calculations by using a graphics processing unit (GPU) cluster. GPUs are powerful systems which are especially suited to problems that can be expressed as data-parallel computations. In MC simulations, each photon track is independent of the others; each launched photon can be mapped to one thread on the GPU, thousands of threads are executed in parallel in order to achieve high performance. For further acceleration, the authors considered multiple GPUs. The total computation was divided into different parts which can be calculated in parallel on multiple devices. The GPU cluster is an MC calculation server which is connected to the CT scanner and computes 3D dose distributions on-site immediately after image reconstruction. To estimate the performance gain, the authors benchmarked dose calculation times on a 2.6 GHz Intel Xeon 5430 Quad core workstation equipped with two NVIDIA GeForce GTX 285 cards. The on-site calculation concept was demonstrated for clinical and preclinical datasets on CT scanners (multislice CT, flat-detector CT, and micro-CT) with varying geometry, spectra, and filtration. To validate the GPU-based MC algorithm, the authors measured dose values on a 64-slice CT system using calibrated ionization chambers and thermoluminesence dosimeters (TLDs) which were placed inside standard cylindrical polymethyl methacrylate (PMMA) phantoms. The dose values and profiles obtained by GPU-based MC simulations were in the expected good agreement with computed tomography dose index (CTDI) measurements and reference TLD profiles with differences being less than 5%. For 10(9) photon histories simulated in a 256 × 256 × 12 voxel thorax dataset with voxel size of 1.36 × 1.36 × 3.00 mm(3), calculation times of about 70 and 24 min were necessary with single-core and multiple-core central processing unit (CPU) solutions, respectively. Using GPUs, the same MC calculations were performed in 1.27 min (single card) and 0.65 min (two cards) without a loss in quality. Simulations were thus speeded up by factors up to 55 and 36 compared to single-core and multiple-core CPU, respectively. The performance scaled nearly linearly with the number of GPUs. Tests confirmed that the proposed GPU-based MC tool can be easily adapted to different types of CT scanners and used as service providers for fast on-site dose calculations. The Monte Carlo software package provides fast on-site calculation of 3D dose distributions in the CT suite which makes it a practical tool for any type of CT-specific application.

GPU-Accelerated Multi-Profile Radiative Transfer Model for the Infrared Atmospheric Sounding Interferometer

In this paper, we develop a novel Graphics Processing Unit (GPU)-based high-performance Radiative Transfer Model (RTM) for the Infrared Atmospheric Sounding Interferometer (IASI) launched in 2006 onboard the first European meteorological polar-orbiting satellites, METOP-A. The proposed GPU RTM processes more than one profile at a time in order to gain a significant speedup compared to the case of processing just one profile at a time. The radiative transfer model performance in operational numerical weather prediction systems nowadays still limits the number of channels they can use in hyperspectral sounders to only a few hundreds. To take the full advantage of such high resolution infrared observations, a computationally efficient radiative transfer model is needed. Our GPU-based IASI radiative transfer model is developed to run on a low-cost personal supercomputer with 4 NVIDIA Tesla C1060 GPUs with total 960 cores, delivering near 4 TFlops theoretical peak performance. The model exhibited linear scaling with the number of graphics processing units. Computing 10 IASI radiance spectra simultaneously on a GPU, we reached 763x speedup for 1 GPU and 3024x speedup for all 4 GPUs, both with respect to the original single-threaded Fortran CPU code. The significant 3024x speedup means that the proposed GPU-based high-performance forward model is able to compute one day's amount of 1,296,000 IASI spectra within 6 minutes, whereas the original CPU-based version will impractically take more than 10 days. The GPU-based high-performance IASI radiative transfer model is suitable for the assimilation of the IASI radiance observations into the operational numerical weather forecast model.

Multi-GPU accelerated multi-spin Monte Carlo simulations of the 2D Ising model

A Modern Graphics Processing unit (GPU) is able to perform massively parallel scientific computations at low cost. We extend our implementation of the checkerboard algorithm for the two-dimensional Ising model [T. Preis et al., Journal of Chemical Physics 228 (2009) 4468–4477] in order to overcome the memory limitations of a single GPU which enables us to simulate significantly larger systems. Using multi-spin coding techniques, we are able to accelerate simulations on a single GPU by factors up to 35 compared to an optimized single Central Processor Unit (CPU) core implementation which employs multi-spin coding. By combining the Compute Unified Device Architecture (CUDA) with the Message Parsing Interface (MPI) on the CPU level, a single Ising lattice can be updated by a cluster of GPUs in parallel. For large systems, the computation time scales nearly linearly with the number of GPUs used. As proof of concept we reproduce the critical temperature of the 2D Ising model using finite size scaling techniques.

Line-by-line spectroscopic simulations on graphics processing units

We report here on software that performs line-by-line spectroscopic simulations on gases. Elaborate models (such as narrow band and correlated-K) are accurate and efficient for bands where various components are not simultaneously and significantly active. Line-by-line is probably the most accurate model in the infrared for blends of gases that contain high proportions of H 2O and CO 2 as this was the case for our prototype simulation. Our implementation on graphics processing units sustains a speedup close to 330 on computation-intensive tasks and 12 on memory intensive tasks compared to implementations on one core of high-end processors. This speedup is due to data parallelism, efficient memory access for specific patterns and some dedicated hardware operators only available in graphics processing units. It is obtained leaving most of processor resources available and it would scale linearly with the number of graphics processing units in parallel machines. Line-by-line simulation coupled with simulation of fluid dynamics was long believed to be economically intractable but our work shows that it could be done with some affordable additional resources compared to what is necessary to perform simulations on fluid dynamics alone. Program summary Program title: GPU4RE Catalogue identifier: ADZY_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/ADZY_v1_0.html Program obtainable from: CPC Program Library, Queen's University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 62 776 No. of bytes in distributed program, including test data, etc.: 1 513 247 Distribution format: tar.gz Programming language: C++ Computer: x86 PC Operating system: Linux, Microsoft Windows. Compilation requires either gcc/g++ under Linux or Visual C++ 2003/2005 and Cygwin under Windows. It has been tested using gcc 4.1.2 under Ubuntu Linux 7.04 and using Visual C++ 2005 with Cygwin 1.5.24 under Windows XP. RAM: 1 gigabyte Classification: 21.2 External routines: OpenGL ( http://www.opengl.org) Nature of problem: Simulating radiative transfer on high-temperature high-pressure gases. Solution method: Line-by-line Monte-Carlo ray-tracing. Unusual features: Parallel computations are moved to the GPU. Additional comments: nVidia GeForce 7000 or ATI Radeon X1000 series graphics processing unit is required. Running time: A few minutes.