Search

Graphics processing units (GPUs) are the reference architecture to accelerate high-performance computing applications and the training/interference of convolutional neural networks. For both these domains, performance and reliability are two of the main constraints. It is believed that the only way to increase reliability is to sacrifice performance, e.g., using redundancies. We show in this paper that this is not always the case. As a very promising result, we found that most GPUs performance improvements also bring the benefit of increasing the number of executions correctly completed before experiencing a silent data corruption (SDC). We consider four different common GPUs' performance optimizations: architectural solutions, software implementations, compiler optimizations, and threads degree of parallelism. We compare different implementations of a variety of parallel codes and, through beam experiments and applications profiling, we show that the performance improvement typically (but not necessarily) increases the GPU SDC rate. Nevertheless, for the vast majority of the configurations the performance gain is much higher than the SDC rate increase, allowing to process a higher amount of correct data. As we show, the programmer choices can increase up to 25 × the number of correctly completed executions without redesigning the algorithm nor including specific hardening solutions. [ABSTRACT FROM AUTHOR]

This paper presents the graphics processing unit (GPU) implementation of two-dimensional discrete cosine transform (2D DCT) and inverse discrete cosine transform (2D IDCT) for image compression applications. Based on the trigonometric properties, the transform matrices are simplified, resulting in reduced computation over the naive implementation. To assess its performance, the output image quality is measured in terms of several metrics and found to be better than all other existing transforms. To further improve the timings, a GPU implementation of the proposed transforms is obtained by exploiting the inter-level parallelism among threads and blocks in addition to efficiently accessing data from the shared memory resources. This has resulted in significant improvement in speedup (more than 5k) for both the transforms. The proposed GPU implementation of 2D DCT is compared in terms of processing time and is shown to outperform the existing work across all image dimensions. [ABSTRACT FROM AUTHOR]

With the rapid expansion of industrialization and urbanization, fine Particulate Matter (PM2.5) pollution has escalated into a major global environmental crisis. This pollution severely affects human health and ecosystem stability. Accurately predicting PM2.5 levels is essential. However, air quality forecasting currently faces challenges in processing vast data and enhancing model accuracy. Deep learning models are widely applied for their superior learning and fitting abilities in haze prediction. Yet, they are limited by optimization challenges, long training periods, high data quality needs, and a tendency towards overfitting. Furthermore, the complex internal structures and mechanisms of these models complicate the understanding of haze formation. In contrast, traditional Support Vector Regression (SVR) methods perform well with complex non-linear data but struggle with increased data volumes. To address this, we developed CUDA-based code to optimize SVR algorithm efficiency. We also combined SVR with Genetic Algorithms (GA), Sparrow Search Algorithm (SSA), and Particle Swarm Optimization (PSO) to identify the optimal haze prediction model. Our results demonstrate that the model combining intelligent algorithms with Central Processing Unit-raphics Processing Unit (CPU-GPU) heterogeneous parallel computing significantly outpaces the PSO-SVR model in training speed. It achieves a computation time that is 6.21–35.34 times faster. Compared to other models, the Particle Swarm Optimization-Central Processing Unit-Graphics Processing Unit-Support Vector Regression (PSO-CPU-GPU-SVR) model stands out in haze prediction, offering substantial speed improvements and enhanced stability and reliability while maintaining high accuracy. This breakthrough not only advances the efficiency and accuracy of haze prediction but also provides valuable insights for real-time air quality monitoring and decision-making. [ABSTRACT FROM AUTHOR]

Global navigation satellite system reflectometry (GNSS-R) has considerable potential for monitoring sea surface height with high spatiotemporal resolution at low cost. However, because of the immaturity of reflected signal processing, no commercial GNSS-R receiver can provide reliable altimetry measurements. Typically, raw intermediate-frequency data are collected and processed using a software-defined receiver (SDR), which allows full access for signal processing and testing innovative algorithms. Since high-precision code-ranging measurements from open-loop tracking are needed for GNSS-R altimetry, the sampling rate of raw IF data is usually several times that of conventional data used for navigation and positioning. Therefore, the increased data load makes processing very slow when using a computer with only a conventional central processing unit (CPU). To overcome such inefficiency, a graphics processing unit (GPU) was utilized in this study to design the GNSS-R altimetry SDR. As GPU can provide massive parallel computing performance, the correlators were implemented on it, while some procedures with low computational requirements were still implemented on the CPU. The performance of the developed SDR was evaluated by processing GNSS-R raw IF data highly sampled at 62 MHz from a coastal experiment, which has a central frequency of 1176.45 MHz. Then, code-level altimetry solutions were retrieved from BeiDou navigation satellite system (BDS) B2a and quasi-zenith satellite system (QZSS)/global positioning system (GPS) L5 signals. To optimize the SDR, different integration times and error control methods were tested. Results showed that centimeter-level GNSS-R code altimetry solutions can be achieved using QZSS geostationary orbit satellite signals in the case of real-time operation. [ABSTRACT FROM AUTHOR]

The National Center for Atmospheric Research released a global atmosphere model named Community Atmosphere Model version 5.0 (CAM5), which aimed to provide a global climate simulation for meteorological research. Among them, the cloud microphysics scheme is extremely time-consuming, so developing efficient parallel algorithms faces large-scale and chronic simulation challenges. Due to the wide application of GPU in the fields of science and engineering and the NVIDIA's mature and stable CUDA platform, we ported the code to GPU to accelerate computing. In this paper, by analyzing the parallelism of CAM5 cloud microphysical schemes (CAM5 CMS) in different dimensions, corresponding GPU-based one-dimensional (1D) and two-dimensional (2D) parallel acceleration algorithms are proposed. Among them, the 2D parallel algorithm exploits finer-grained parallelism. In addition, we present a data transfer optimization method between the CPU and GPU to further improve the overall performance. Finally, GPU version of the CAM5 CMS (GPU-CMS) was implemented. The GPU-CMS can obtain a speedup of 141.69 × on a single NVIDIA A100 GPU with I/O transfer. In the case without I/O transfer, compared to the baseline performance on a single Intel Xeon E5-2680 CPU core, the 2D acceleration algorithm obtained a speedup of 48.75 × , 280.11 × , and 507.18 × on a single NVIDIA K20, P100, and A100 GPU, respectively. [ABSTRACT FROM AUTHOR]

Numerical simulation of the ocean general circulation remains one of the most computationally demanding problems. For both climate and forecast research, the speedup of the calculations is still an ongoing challenge. This problem can be remedied by developing new computationally efficient algorithms. Another, and in fact complementary, approach is to utilize massively parallel coprocessors such as Graphics Processing Units (GPUs). In this study, we consider the GPU implementation efficiency of the advection schemes commonly used in tracer transport algorithms for ocean modeling and compare it with the implementation on a Central Processing Unit (CPU). The simulations on refined grids were found to be highly efficient when implemented on the GPU, in contrast to the coarse resolution. We also consider a number of optimization techniques to improve GPU efficiency in the latter case. [ABSTRACT FROM AUTHOR]

The ocean general circulation model (OGCM) is an essential tool for researching oceanography and atmospheric science. The LASG/IAP climate system ocean model version 3 (LICOM3) is a parallel version of the OGCM. Our goal is to implement and optimize a GPU version of LICOM3 based on compute unified device architecture (CUDA) called LICOM3-CUDA. Considering the characteristics of LICOM3 and CUDA, we design and implement some pivotal optimization methods, including redesigning the numerical algorithms of complicated functions, decoupling data dependency, avoiding memory write conflicts, and optimizing communication. In this paper, we selected two experiments, including 1 ∘ (small-scale) and 0.1 ∘ (large-scale) resolutions to evaluate the performance of LICOM3-CUDA. Under the experimental environment of two Intel Xeon Gold 6148 CPUs and four NVIDIA Quadro GV100s, the LICOM3-CUDA (1 ∘ ) achieves a simulation speed of 114.3 simulation-year-per-day (SYPD). Compare with the performance of LICOM3, the LICOM3-CUDA can run much faster with 6.5 times, and the compute-intensive module achieves over 70 × speedup. In addition, the energy consumption for the simulation year is reduced by 41.3%. As for high-resolution and large-scale simulation, the number of GPUs increased from 96 to 1536 as well as the LICOM3-CUDA (0.1 ∘ ) time consumption decreased from 3261 to 720 seconds with approximately 4.5 × of speedup. [ABSTRACT FROM AUTHOR]

The sparse precision matrix plays an essential role in the Gaussian graphical model since a zero off-diagonal element indicates conditional independence of the corresponding two variables given others. In the Gaussian graphical model, many methods have been proposed, and their theoretical properties are given as well. Among these, the sparse precision matrix estimation via scaled lasso (SPMESL) has an attractive feature in which the penalty level is automatically set to achieve the optimal convergence rate under the sparsity and invertibility conditions. Conversely, other methods need to be used in searching for the optimal tuning parameter. Despite such an advantage, the SPMESL has not been widely used due to its expensive computational cost. In this paper, we develop a GPU-parallel coordinate descent (CD) algorithm for the SPMESL and numerically show that the proposed algorithm is much faster than the least angle regression (LARS) tailored to the SPMESL. Several comprehensive numerical studies are conducted to investigate the scalability of the proposed algorithm and the estimation performance of the SPMESL. The results show that the SPMESL has the lowest false discovery rate for all cases and the best performance in the case where the level of the sparsity of the columns is high. [ABSTRACT FROM AUTHOR]

Atmospheric radiation is one of the most important atmospheric physics, and its expensive computation cost severely restricts the numerical simulation of atmospheric general circulation models. Therefore, it is necessary to study an efficient radiation parameterization scheme. Due to the powerful computing power of GPU, more and more numerical models are being transplanted to GPU. The CUDA C version (CC-RRTMG_SW) of the rapid radiative transfer model for general circulation models (RRTMG) shortwave radiation scheme (RRTMG_SW) has successfully run on GPU, but its computing efficiency is not yet very high, and the performance potential of GPU computing needs to be realized further. This paper is dedicated to optimizing CC-RRTMG_SW and exploring its maximum computing performance on GPU. First, a three-dimensional acceleration algorithm for CC-RRTMG_SW is proposed. Then, some optimization methods, such as decoupling data dependency, optimizing memory access, and I/O optimization, are studied. Finally, the optimized version of CC-RRTMG_SW is developed, namely CC-RRTMG_SW++. The experimental results demonstrate that the proposed acceleration algorithm and performance optimization methods are effective. CC-RRTMG_SW++ achieved good acceleration effects on different GPU architectures, such as NVIDIA Tesla K20, K40, and V100. Compared to RRTMG_SW running on a single Intel Xeon E5-2680 v2 CPU core, CC-RRTMG_SW++ obtained a speedup of 99.09 × on a single V100 GPU without I/O transfer. Compared to CC-RRTMG_SW, the computing efficiency of CC-RRTMG_SW++ increased by 174.46%. [ABSTRACT FROM AUTHOR]

Bipartite graphs are used to model and represent many real-world problems in biological and physical sciences. Finding shortest paths in bipartite graphs is an important task and has numerous applications. Different dynamic programming based solutions to find the shortest paths exists which differ on complexity and structure of graph. The computational complexity of these algorithms is a major concern. This work formulates the parallel versions of Floyd-Warshall and Torgasin-Zimmermann algorithms to compute the shortest paths in bipartite graphs efficiently. These algorithms are mapped to graphics processing unit using tropical matrix product. The performance for different realizations and parameters are compared for Floyd-Warshall and Torgasin-Zimmermann algorithms. Parallel implementation of Torgasin-Zimmermann algorithm attained a speed-up factor of almost 274 when compared with serial Floyd-Warshall algorithm for random-generated undirected graphs. [ABSTRACT FROM AUTHOR]

Conventional drug discovery methods rely primarily on in-vitro experiments with a target molecule and an extensive set of small molecules to choose the suitable ligand. The exploration space for the selected ligand being huge; this approach is highly time-consuming and requires high capital for facilitation. Virtual screening, a computational technique used to reduce this search space and identify lead molecules, can speed up the drug discovery process. This paper proposes a ligand-based virtual screening method using an artificial neural network called self-organizing map (SOM). The proposed work uses two SOMs to predict the active and inactive molecules separately. This SOM based technique can uniquely label a small molecule as active, inactive, and undefined as well. This can reduce the number of false positives in the screening process and improve recall; compared to support vector machine and random forest based models. Additionally, by exploiting the parallelism present in the learning and classification phases of a SOM, a graphics processing unit (GPU) based model yields much better execution time. The proposed GPU-based SOM tool can successfully evaluate a large number of molecules in training and screening phases. The source code of the implementation and related files are available at https://github.com/jayarajpbalakrishnan/2_SOM_SCREEN [ABSTRACT FROM AUTHOR]

Efficient collision detection is critical in 3D geometric modeling. In this paper, we first implement three parallel triangle-triangle intersection algorithms on a GPU and then compare the computational efficiency of these three GPU-accelerated parallel triangle-triangle intersection algorithms in an application that detects collisions between triangulated models. The presented GPU-based parallel collision detection method for triangulated models has two stages: first, we propose a straightforward and efficient parallel approach to reduce the number of potentially intersecting triangle pairs based on AABBs, and second, we conduct intersection tests with the remaining triangle pairs in parallel based on three triangle-triangle intersection algorithms, i.e., the Möller's algorithm, Devillers' and Guigue's algorithm, and Shen's algorithm. To evaluate the performance of the presented GPU-based parallel collision detection method for triangulated models, we conduct four groups of benchmarks. The experimental results show the following: (1) the time required to detect collisions for the triangulated model consisting of approximately 1.5 billion triangle pairs is less than 0.5 s; (2) the GPU-based parallel collision detection method speedup over the corresponding serial version is 50x - 60x, and (3) Devillers' and Guigue's algorithm is comparatively and comprehensively the best of the three GPU-based parallel triangle-triangle intersection algorithms. The presented GPU-accelerated method is capable of efficiently detecting the potential collisions of triangulated models. Overall, the GPU-accelerated parallel Devillers' and Guigue's triangle-triangle intersection algorithm is recommended when performing practical collision detections between large triangulated models. [ABSTRACT FROM AUTHOR]

In the phase-field simulation of dendrite growth during the solidification of an alloy, the computational cost becomes extremely high when the diffusion length is significantly larger than the curvature radius of a dendrite tip. In such cases, the adaptive mesh refinement (AMR) method is effective for improving the computational performance. In this study, we perform a three-dimensional dendrite growth phase-field simulation in which AMR is implemented via parallel computing using multiple graphics processing units (GPUs), which provide high parallel computation performance. In the parallel GPU computation, we apply dynamic load balancing to parallel computing to equalize the computational cost per GPU. The accuracy of an AMR refinement condition is confirmed through the single-GPU computations of columnar dendrite growth during the directional solidification of a binary alloy. Next, we evaluate the efficiency of dynamic load balancing by performing multiple-GPU parallel computations for three different directional solidification simulations using a moving frame algorithm. Finally, weak scaling tests are performed to confirm the parallel efficiency of the developed code. [ABSTRACT FROM AUTHOR]

The world is creating ever more data and the applications are required to deal with ever-increasing datasets. To process such datasets heterogeneous and manycore accelerators are being deployed in various computing systems to improve energy efficiency. In this work, we present a runtime management system designed for such heterogeneous systems with manycore accelerators. More specifically, we design a resource-based runtime management system that considers application characteristics and respective execution properties on the nodes and accelerators. We propose scheduling heuristics and run time environment solutions to achieve better throughput and reduced energy in computing systems with different accelerators. We give implementation details about our framework; show different scheduling algorithms, and present experimental evaluation of our system. We also compare our approaches with an optimal scheme where integer linear programming approach has been implemented for mapping applications on the heterogeneous system. While it is possible to extend the proposed framework to a wide variety of accelerators, our initial focus is on Graphics Processing Units (GPUs). Our experimental evaluations show that including accelerator support in the management framework improves energy consumption and execution time significantly. We believe that this approach has the potential to provide an effective solution for next generation accelerator-based computing systems. [ABSTRACT FROM AUTHOR]

Possibilities for using general-purpose graphics processing units to simulate compressible gas flows are discussed. Consideration is given to different schemes of computation of flows through the faces of the flow control volume and to the features of their implementation on graphics processing units. A solution of a number of model problems of gas dynamics on graphics processing units is presented and consideration is given to approaches to optimization of the program code connected with the use of different types of memory. A comparison is made between the rates of counting on a graphics processing unit and a central processor using grids having different resolution capabilities and various difference schemes of computation of flows. [ABSTRACT FROM AUTHOR]

Atmospheric radiation physical process plays an important role in climate simulations. As a radiative transfer scheme, the rapid radiative transfer model for general circulation models (RRTMG) is widely used in weather forecasting and climate simulation systems. However, its expensive computational overhead poses a severe challenge to system performance. Therefore, improving the radiative transfer model's computational performance has significant scientific research and practical value. Numerous radiative transfer models have benefited from a widely used and powerful GPU. Nevertheless, few of them have exploited CPU/GPU cluster resources within heterogeneous high-performance computing platforms. In this paper, we endeavor to demonstrate an approach that runs a large-scale, computationally intensive, longwave radiative transfer model on a GPU cluster. First, a CUDA-based acceleration algorithm of the RRTMG longwave radiation scheme (RRTMG_LW) on multiple GPUs is proposed. Then, a heterogeneous, hybrid programming paradigm (MPI+CUDA) is presented and utilized with the RRTMG_LW on a GPU cluster. After implementing the algorithm in CUDA Fortran, a multi-GPU version of the RRTMG_LW, namely GPUs-RRTMG_LW, was developed. The experimental results demonstrate that the multi-GPU acceleration algorithm is valid, scalable, and highly efficient when compared to a single GPU or CPU. Running the GPUs-RRTMG_LW on a K20 cluster achieved a 77.78 × speedup when compared to a single Intel Xeon E5-2680 CPU core. [ABSTRACT FROM AUTHOR]

Full waveform inversion (FWI) is a procedure used to determine the elastic parameters of the Earth by reducing the misfit between observed elastodynamic wavefields and their numerically modelled counterparts. The numerical solution of the elastodynamic wave equation is computationally expensive, and its performance is typically bandwidth bound. Computing the gradient of the FWI misfit functional adds further complexity as it involves computing the zero-lag cross-correlation of two wavefields propagating in opposite temporal directions. In this paper, we utilize graphics processing units (GPUs) for their high memory bandwidth and combine two principal optimizations in order to compute FWI gradients on large models and for long simulation times. Wavefield reconstruction methods allow efficient gradient computations with minimal memory requirements and interconnection transfers. Time-space tiling techniques permit us to transcend the limited amount of GPU memory while avoiding dramatic slowdowns due to the low interconnection bandwidth. The implementation considers a task-oriented, hybrid usage of explicitly managed and Unified Memory in order to satisfy the requirements. Benchmarks demonstrate that the proposed approach is able to preserve 78–90% of the original performance, when oversubscribing the amount of physical memory available on GPUs. Comparison with existing methods highlights the benefits of the method. [ABSTRACT FROM AUTHOR]

In scientific computing and cryptography, there are many applications that involve large integer multiplication, which is a time-consuming operation. To reduce the computational complexity, number theoretic transform is widely used, wherein the multiplication can be performed in the frequency domain with reduced complexity. However, the speed performance of large integer multiplication is still not satisfactory if the operand size is very large (e.g., more than 100K-bit). In view of that, several researchers had proposed to accelerate the implementation of number theoretic transform using massively parallel GPU architecture. In this paper, we proposed several techniques to improve the performance of number theoretic transform implementation, which is faster than the state-of-the-art work by Dai et al. The proposed techniques include register-based twiddle factors storage and multi-stream asynchronous computation, which leverage on the features offered in new GPU architectures. The proposed number theoretic transform implementation was applied to CMNT fully homomorphic encryption scheme proposed by Coron et al. With the proposed implementation technique, homomorphic multiplications in CMNT take 0.27 ms on GTX1070 desktop GPU and 7.49 ms in Jetson TX1 embedded system, respectively. This shows that the proposed implementation is suitable for practical applications in server environment as well as embedded system. [ABSTRACT FROM AUTHOR]

Predicting the three-dimensional (3D) transport processes of reservoir temperature and pollutants is essential for water environmental protection and restoration, and introducing the lattice Boltzmann (LB) method into this prediction is necessary because of its simple algorithm, straightforward implementation of boundary conditions, and high computation efficiency. In this paper, a triple-distribution function (TDF) LB model for flow-temperature-concentration coupling simulations is introduced. Some essential techniques for implementing this method in 3D reservoirs are also described, including the treatment of water surface fluctuation, the consideration of surface heat exchange, and the hardware acceleration using the graphics processing unit (GPU). Two cases verified the proposed model, and then, the temporal-spatial variations of flow, temperature, and pollutants in the upper reservoir of a pumped-storage power station during both pumping and generating modes were analyzed to demonstrate its applicability. In the reservoir, the water forms several circulations, the cold water from the inlet flows as an undercurrent firstly, and then spread laterally, and the spreading of pollutants directly relates to the flow velocity. The results of flow, temperature, and concentration fields in different working conditions are consistent with model tests and physical laws, which shows good prospects of the proposed LB model. [ABSTRACT FROM AUTHOR]

Hardware/software partitioning is an essential step in hardware/software co-design. For large size problems, it is difficult to consider both solution quality and time. This paper presents an efficient GPU-based parallel tabu search algorithm (GPTS) for HW/SW partitioning. A single GPU kernel of compacting neighborhood is proposed to reduce the amount of GPU global memory accesses theoretically. A kernel fusion strategy is further proposed to reduce the amount of GPU global memory accesses of GPTS. To further minimize the transfer overhead of GPTS between CPU and GPU, an optimized transfer strategy for GPU-based tabu evaluation is proposed, which considers that all the candidates do not satisfy the given constraint. Experiments show that GPTS outperforms state-of-the-art work of tabu search and is competitive with other methods for HW/SW partitioning. The proposed parallelization is significant when considering the ordinary GPU platform. [ABSTRACT FROM AUTHOR]

The general pressure equation (GPE) based method is fully explicit, and the method does not require either solving the pressure Poisson equation nor executing sub-iteration for incompressible flow simulation. However, few numerical validations of GPE method are available, especially under complex flows like turbulence. In this work, GPE is used to conduct direct numerical simulations of the turbulent lid-driven cavity (LDC) flow at Re = 3200 and fully developed turbulent flow through a square duct at Re τ = 360. Predicted turbulence statistics are compared with existing numerical and experimental data, providing an excellent quantitative agreement. The intricate flow patterns such as the Taylor–Görtler-like vortices in LDC flow and the mean secondary flow at the cross-section in the square duct are captured, showing both qualitative and quantitative agreements with measurements. Results from the present study indicate the capability of the GPE method for accurate incompressible turbulent flow calculation. [ABSTRACT FROM AUTHOR]

In magnetic resonance imaging, the fidelity of image reconstruction is an important criterion. It has been suggested that the infinite-extent sinc kernel is the ideal interpolation kernel for ensuring the reconstruction quality of non-Cartesian trajectories. However, the application of the sinc function has been limited owing to its computational overheads. Recently, graphics processing units (GPUs) have been employed as fast computation tools because of their efficient and versatile parallel computation abilities. We implemented an accelerated convolution function with the sinc kernel using GPUs computing and evaluated the reconstruction performance. The computation time was significantly improved: Computation using the proposed method was approximately 270 times faster than that on a central processing unit (CPU) and approximately 4.6 times faster than that on a CPU optimized by level-3 Basic Linear Algebra Subprograms. The images reconstructed using the fast sinc function exhibited no adverse errors at all matrix sizes (resolutions). The total reconstruction time was approximately 0.3–3 s for all matrices, indicating that the sinc function could be a practical option for image reconstruction. Ultimately, its application would present a fundamental improvement to the performance of image reconstruction, and the GPU implementation of the convolution function with the sinc kernel could resolve various challenges in image data processing. [ABSTRACT FROM AUTHOR]

Geodesic based tractography on diffusion magnetic resonance data is a method to devise long distance connectivities among the brain regions. In this study, cellular automata technique is applied to the geodesic tractography problem and the algorithm is implemented on a graphics processing unit. Cellular automaton based method is preferable to current techniques due to its parallel nature and ability to solve the connectivity based segmentation problem with the same computational complexity, which has important applications in neuroimaging. An application to prior-less tracking and connectivity based segmentation of corpus callosum fibers is presented as an example. A geodesic tractography based corpus callosum atlas is provided, which reveals high projections to the cortical language areas. The developed method not only allows fast computation especially for segmentation but also provides a powerful and intuitive framework, suitable to derive new algorithms to perform connectivity calculations and allowing novel applications. [ABSTRACT FROM AUTHOR]

Utilizing parallel algorithms is an established way of increasing performance in systems that are bound to real-time restrictions. Sensor-based sorting is a machine vision application for which firm real-time requirements need to be respected in order to reliably remove potentially harmful entities from a material feed. Recently, employing a predictive tracking approach using multitarget tracking in order to decrease the error in the physical separation in optical sorting has been proposed. For implementations that use hard associations between measurements and tracks, a linear assignment problem has to be solved for each frame recorded by a camera. The auction algorithm can be utilized for this purpose, which also has the advantage of being well suited for parallel architectures. In this paper, an improved implementation of this algorithm for a graphics processing unit (GPU) is presented. The resulting algorithm is implemented in both an OpenCL and a CUDA based environment. By using an optimized data structure, the presented algorithm outperforms recently proposed implementations in terms of speed while retaining the quality of output of the algorithm. Furthermore, memory requirements are significantly decreased, which is important for embedded systems. Experimental results are provided for two different GPUs and six datasets. It is shown that the proposed approach is of particular interest for applications dealing with comparatively large problem sizes. [ABSTRACT FROM AUTHOR]

This research presents the design of a real-time system to remove the effects of haze in a sequence of monocular images. The system firstly estimates the medium transmission function from an observed hazy image using locally adaptive neighborhoods and calculation of order statistics. Next, the haze-free image is retrieved using the estimated transmission function and a physics-based restoration model. The performance of the proposed system is evaluated and compared with that of similar existing techniques in terms of objective metrics. The obtained results exhibit that the proposed system yields a higher performance in comparison with tested similar methods. Because of its high computational efficiency, the proposed system is able to operate at high rate and it is suitable for real-time applications. [ABSTRACT FROM AUTHOR]

Dinur and Shamir's cube attack has attracted significant attention in the literature. Nevertheless, the lack of implementations achieving effective results casts doubts on its practical relevance. On the theoretical side, promising results have been recently achieved leveraging on division trails. The present paper follows a more practical approach and aims at giving new impetus to this line of research by means of a cipher-independent flexible framework that is able to carry out the cube attack on GPU/CPU clusters. We address all issues posed by a GPU implementation, providing evidence in support of parallel variants of the attack and identifying viable directions for solving open problems in the future. We report the results of running our GPU-based cube attack against round-reduced versions of three well-known ciphers: Trivium, Grain-128 and SNOW 3G. Our attack against Trivium improves the state of the art, permitting full key recovery for Trivium reduced to (up to) 781 initialization rounds (out of 1152) and finding the first-ever maxterm after 800 rounds. In this paper, we also present the first standard cube attack (i.e., neither dynamic nor tester) to yield maxterms for Grain-128 up to 160 initialization rounds on non-programmable hardware. We include a thorough evaluation of the impact of system parameters and GPU architecture on the performance. Moreover, we demonstrate the scalability of our solution on multi-GPU systems. We believe that our extensive set of results can be useful for the cryptographic engineering community at large and can pave the way to further results in the area. [ABSTRACT FROM AUTHOR]

Super-resolution (SR) techniques constitute a key element in image applications, which need high-resolution reconstruction, while in the worst case, only a single low-resolution observation is available. SR techniques involve computationally demanding processes, and thus, researchers are currently focusing on SR performance acceleration. Aiming at improving the SR performance, the current paper builds up on the characteristics of the L-SEABI SR method to introduce parallelization techniques for GPUs and FPGAs. The proposed techniques accelerate GPU reconstruction of ultra-high definition content, by achieving three (3 × ) times faster than the real-time performance on mid-range and previous generation devices and at least nine times (9 × ) faster than the real-time performance on high-end GPUs. The FPGA design leads to a scalable architecture performing four (4 × ) times faster than the real-time on low-end Xilinx Virtex 5 devices and 69 times (69 × ) faster than the real-time on the Virtex 2000t. Moreover, we confirm the benefits of the proposed acceleration techniques by employing them on a different category of image processing algorithms: on window-based disparity functions, for which the proposed GPU technique shows an improvement over the CPU performance ranging from 14 times (14 × ) to 64 times (64 × ), while the proposed FPGA architecture provides 29 × acceleration. [ABSTRACT FROM AUTHOR]

Data gravitation-based classification model, a new physic law inspired classification model, has been demonstrated to be an effective classification model for both standard and imbalanced tasks. However, due to its large scale of gravitational computation during the feature weighting process, DGC suffers from high computational complexity, especially for large data sets. In this paper, we address the problem of speeding up gravitational computation using graphics processing unit (GPU). We design a GPU parallel algorithm namely GPU–DGC to accelerate the feature weighting process of the DGC model. Our GPU–DGC model distributes the gravitational computing process to parallel GPU threads, in order to compute gravitation simultaneously. We use 25 open classification data sets to evaluate the parallel performance of our algorithm. The relationship between the speedup ratio and the number of GPU threads is discovered and discussed based on the empirical studies. The experimental results show the effectiveness of GPU–DGC, with the maximum speedup ratio of 87 to the serial DGC. Its sensitivity to the number of GPU threads is also discovered in the empirical studies. [ABSTRACT FROM AUTHOR]

Biologically-inspired computer vision is a research area that offers prominent directions in a large variety of fields. Several processing algorithms inspired in natural vision enable detecting moving objects from video sequences so far. One example is lateral interaction in accumulative computation (LIAC), a classical bioinspired method that has been applied to numerous environments and applications. LIAC is the implementation for computer vision of two biologically-inspired methods denominated algorithmic lateral interaction and accumulative computation. The method has traditionally reached high precision but unfortunately requires high computing times. This paper introduces a proposal based on graphics processing units in order to speed up the original sequential code. This way not only excellent performance in terms of accuracy is maintained, but also real-time is obtained. A speed-up of 67× from the parallel over its sequential counterpart is achieved for several tested video sequences. [ABSTRACT FROM AUTHOR]

We propose and analyze a new Markov Chain Monte Carlo algorithm that generates a uniform sample over full and non-full-dimensional polytopes. This algorithm, termed “Matrix Hit and Run” (MHAR), is a modification of the Hit and Run framework. For a polytope in Rn\documentclass[12pt]{minimal}\usepackage{amsmath}\usepackage{wasysym}\usepackage{amsfonts}\usepackage{amssymb}\usepackage{amsbsy}\usepackage{mathrsfs}\usepackage{upgreek}\setlength{\oddsidemargin}{-69pt}\begin{document}$$\mathbb {R}^n$$\end{document} defined by m linear constraints, the regime n1+13≪m\documentclass[12pt]{minimal}\usepackage{amsmath}\usepackage{wasysym}\usepackage{amsfonts}\usepackage{amssymb}\usepackage{amsbsy}\usepackage{mathrsfs}\usepackage{upgreek}\setlength{\oddsidemargin}{-69pt}\begin{document}$$n^{1+\frac{1}{3}} \ll m$$\end{document} has a lower asymptotic cost per sample in terms of soft-O notation (O∗\documentclass[12pt]{minimal}\usepackage{amsmath}\usepackage{wasysym}\usepackage{amsfonts}\usepackage{amssymb}\usepackage{amsbsy}\usepackage{mathrsfs}\usepackage{upgreek}\setlength{\oddsidemargin}{-69pt}\begin{document}$$\mathcal {O}^*$$\end{document}) than do existing sampling algorithms after a warm start. MHAR is designed to take advantage of matrix multiplication routines that require less computational and memory resources. Our tests show this implementation to be substantially faster than the hitandrun R package, especially for higher dimensions. Finally, we provide a python library based on PyTorch and a Colab notebook with the implementation ready for deployment in architectures with GPU or just CPU. [ABSTRACT FROM AUTHOR]

Owing to many cores in its architecture, graphics processing unit (GPU) offers promise for parallel execution of the particle filter. A stage of the particle filter that is particularly challenging to parallelize is resampling. There are parallel resampling algorithms in the literature such as Metropolis resampling, which does not require a collective operation such as cumulative sum over weights and does not suffer from numerical instability. However, with large number of particles, Metropolis resampling becomes slow. This is because of the non-coalesced access problem on the global memory of the GPU. In this article, we offer solutions for this problem of Metropolis resampling. We introduce two implementation techniques, named Metropolis-C1 and Metropolis-C2, and compare them with the original Metropolis resampling on NVIDIA Tesla K40 board. In the first scenario where these two techniques achieve their fastest execution times, Metropolis-C1 is faster than the others, but yields the worst results in quality. However, Metropolis-C2 is closer to Metropolis resampling in quality. In the second scenario where all three algorithms yield similar quality, although Metropolis-C1 and Metropolis-C2 get slower, they are still faster than the original Metropolis resampling. [ABSTRACT FROM AUTHOR]

Viterbi algorithm is used in different scientific applications including biological sequence alignment, speech recognition, and probabilistic inference. However, high computational complexity of the Viterbi algorithm is a major concern. Accelerating the Viterbi algorithm is important, especially when the number of states or the length of the sequences increase significantly. In this paper, a parallel solution to improve the performance of Viterbi algorithm is presented. This is achieved by formulating a matrix product based algorithm. This algorithm has been mapped to a NVIDIA graphics processing unit. The performance for different parameters and realizations are compared. The results depicts matrix product is not a viable option for small number of states. However, matrix product solution using shared memory for large number of states gains good performance when compared with the serial version. [ABSTRACT FROM AUTHOR]

Cellular automata (CA) models are of interest to several scientific areas, and there is a growing interest in exploring large systems which would need high performance computing. In this work a CA implementation is presented which performs well in five different NVIDIA GPU architectures, from Tesla to Maxwell, simulating systems with up to a billion cells. Using the game of life (GoL) and a more complex variation of GoL as examples, a performance of 5.58e6 evaluated cells/s is achieved. The two optimizations most often used in previous studies are the use of shared memory and Multicell algorithms. Here, these optimizations do not improve performance in Fermi or newer architectures. The GoL CA code running in an NVIDIA Titan X obtained a speedup of up to $$\sim $$ 85 x and up to $$\sim $$ 230 x for a more complex CA, compared to an optimized serial CPU implementation. Finally, the efficiency of each GPU is analyzed in terms of cell performance/transistors and cell performance/bandwidth showing how the architectures improved for this particular problem. [ABSTRACT FROM AUTHOR]

Fast and accurate collision probability computations are essential for protecting space assets. Monte Carlo (MC) simulation is the most accurate but computationally intensive method. A Graphics Processing Unit (GPU) is used to parallelize the computation and reduce the overall runtime. Using MC techniques to compute the collision probability is common in literature as the benchmark. An optimized implementation on the GPU, however, is a challenging problem and is the main focus of the current work. The MC simulation takes samples from the uncertainty distributions of the Resident Space Objects (RSOs) at any time during a time window of interest and outputs the separations at closest approach. Therefore, any uncertainty propagation method may be used and the collision probability is automatically computed as a function of RSO collision radii. Integration using a fixed time step and a quartic interpolation after every Runge Kutta step ensures that no close approaches are missed. Two orders of magnitude speedups over a serial CPU implementation are shown, and speedups improve moderately with higher fidelity dynamics. The tool makes the MC approach tractable on a single workstation, and can be used as a final product, or for verifying surrogate and analytical collision probability methods. [ABSTRACT FROM AUTHOR]

Due to the difficulty to diagnose lung cancer, it is important to integrate content-based image retrieval methods with the pulmonary nodule classification process, since they are capable of retrieving similar cases from large image databases that were previously diagnosed. The goal of this paper is to evaluate an integrated image feature vector, composed of 3D attributes of margin sharpness and texture, on similar pulmonary nodule retrieval, and to optimize the runtime of nodule comparison process with a graphics processing unit (GPU). Retrieval efficiency was evaluated on the ten most similar cases, on different multiprocessor architectures. Results showed that integrated attributes obtained higher efficiency on similar nodule retrieval, with an increase of up to 2.6 percentage points compared to isolated margin sharpness and texture descriptors. Results also showed that GPU increased nodule retrieval performance with a speedup of 23.7 $$\times $$ on nodule comparison runtime. [ABSTRACT FROM AUTHOR]

The density peak (DP) algorithm has been widely used in scientific research due to its novel and effective peak density-based clustering approach. However, the DP algorithm uses each pair of data points several times when determining cluster centers, yielding high computational complexity. In this paper, we focus on accelerating the time-consuming density peaks algorithm with a graphics processing unit (GPU). We analyze the principle of the algorithm to locate its computational bottlenecks, and evaluate its potential for parallelism. In light of our analysis, we propose an efficient parallel DP algorithm targeting on a GPU architecture and implement this parallel method with compute unified device architecture (CUDA), called the 'CUDA-DP platform'. Specifically, we use shared memory to improve data locality, which reduces the amount of global memory access. To exploit the coalescing accessing mechanism of GPU, we convert the data structure of the CUDA-DP program from array of structures to structure of arrays. In addition, we introduce a binary search-and-sampling method to avoid sorting a large array. The results of the experiment show that CUDA-DP can achieve a 45-fold acceleration when compared to the central processing unit based density peaks implementation. [ABSTRACT FROM AUTHOR]

This paper presents a Graphics Processing Unit (GPU)-based implementation of a Bellman-Ford (BF) routing algorithm using NVIDIA's Compute Unified Device Architecture (CUDA). In the proposed GPU-based approach, multiple threads run concurrently over numerous streaming processors in the GPU to dynamically update routing information. Instead of computing the individual vertex distances one-by-one, a number of threads concurrently update a larger number of vertex distances, and an individual vertex distance is represented in a single thread. This paper compares the performance of the GPU-based approach to an equivalent CPU implementation while varying the number of vertices. Experimental results show that the proposed GPU-based approach outperforms the equivalent sequential CPU implementation in terms of execution time by exploiting the massive parallelism inherent in the BF routing algorithm. In addition, the reduction in energy consumption (about 99 %) achieved by using the GPU is reflective of the overall merits of deploying GPUs across the entire landscape of IP routing for emerging multimedia communications. [ABSTRACT FROM AUTHOR]

Motivated by the need to sequentially design experiments for the collection of data in batches or blocks, a new pseudo-marginal sequential Monte Carlo algorithm is proposed for random effects models where the likelihood is not analytic, and has to be approximated. This new algorithm is an extension of the idealised sequential Monte Carlo algorithm where we propose to unbiasedly approximate the likelihood to yield an efficient exact-approximate algorithm to perform inference and make decisions within Bayesian sequential design. We propose four approaches to unbiasedly approximate the likelihood: standard Monte Carlo integration; randomised quasi-Monte Carlo integration, Laplace importance sampling and a combination of Laplace importance sampling and randomised quasi-Monte Carlo. These four methods are compared in terms of the estimates of likelihood weights and in the selection of the optimal sequential designs in an important pharmacological study related to the treatment of critically ill patients. As the approaches considered to approximate the likelihood can be computationally expensive, we exploit parallel computational architectures to ensure designs are derived in a timely manner. [ABSTRACT FROM AUTHOR]

This work considers a parallel algorithm for solving multidimensional multiextremal optimization problems. This algorithm uses Peano-type space filling curves for dimension reduction. Conditions of non-redundant parallelization of the algorithm are considered. Efficiency of the algorithm on modern computing systems with the use of graphics processing units (GPUs) is investigated. Speedup of the algorithm using GPU as compared with the same algorithm implemented on CPU only is demonstrated experimentally. Computational experiments are carried out on a series of several hundred multidimensional multiextremal problems. [ABSTRACT FROM AUTHOR]

Phase contrast X-ray imaging can provide significantly enhanced visibility of soft tissues over absorption contrast imaging with spatial resolution on the micron scale. These characteristics have enabled the visualisation of lungs aerating at birth in real time. We have developed techniques to measure regional lung air volume from these images to help develop methods for safely ventilating the lungs of preterm infants. However, analyzing a large sequence of image data requires considerable computation time on traditional desktop computers. Real-time feedback of the regional ventilation would greatly benefit researches to optimize ventilation strategies. The present paper describes methods for improving the execution time of the lung volume measurements using graphics processing units (GPUs). We tested the performance of the GPU-accelerated lung volume computations using two different GPUs and compared the results with two CPUs. An overall speedup of 1.75-14.12× was achieved if an absorption contrast-based computation was used for volumetric computation, while a 2.43-15.78× speedup was attained in the case of a more compute bound phase retrieval technique. This speedup enabled us to perform lung air volume reconstruction on a local computer with the analysis taking only a few minutes, which is very helpful to guide our experiments in the laboratory. We also show that the accuracy of the GPU-based lung volume measurements was in excellent agreement with the CPU-based counterpart. [ABSTRACT FROM AUTHOR]

Models of electrical activity in excitable cells involve nonlinear interactions between many ionic currents. Changing parameters in these models can produce a variety of activity patterns with sometimes unexpected effects. Further more, introducing new currents will have different effects depending on the initial parameter set. In this study we combined global sampling of parameter space and local analysis of representative parameter sets in a pituitary cell model to understand the effects of adding K conductances, which mediate some effects of hormone action on these cells. Global sampling ensured that the effects of introducing K conductances were captured across a wide variety of contexts of model parameters. For each type of K conductance we determined the types of behavioral transition that it evoked. Some transitions were counterintuitive, and may have been missed without the use of global sampling. In general, the wide range of transitions that occurred when the same current was applied to the model cell at different locations in parameter space highlight the challenge of making accurate model predictions in light of cell-to-cell heterogeneity. Finally, we used bifurcation analysis and fast/slow analysis to investigate why specific transitions occur in representative individual models. This approach relies on the use of a graphics processing unit (GPU) to quickly map parameter space to model behavior and identify parameter sets for further analysis. Acceleration with modern low-cost GPUs is particularly well suited to exploring the moderate-sized (5-20) parameter spaces of excitable cell and signaling models. [ABSTRACT FROM AUTHOR]

Room impulse response (RIR) simulation based on the image-source method is widely used in room acoustic research. The calculation of the RIR in computer has to digitalize sound propagation delay into discrete samples. To carefully consider the digitalization error greatly increases the massive computational load of the image-source method. Therefore many real-time audio applications simply round-off the propagation delay to its nearest sample. This approximation, however, especially when the sampling frequency is low, degrades the phase precision that is required by applications such as microphone array. In this paper, by involving a Hanning-windowed ideal low-pass filter to reduce the digitalization error, a more precise image-source model is studied. We analyze its parallel calculation procedure and propose to use Graphics Processing Unit (GPU) to accelerate the calculation speed. The calculation procedure is divided into many parallel threads and arranged according the GPU architecture and its optimization criteria. We evaluate the calculation speeds of different RIRs using a general 5-core CPU, an ordinary GPU (GTX750) and an advanced GPU (K20C). The results show that, with similar precise RIR results, the speedup ratios of GTX750 and K20C over the general CPU can achieve 20 and 120 respectively. [ABSTRACT FROM AUTHOR]

A fully real-time coherent dedispersion system has been developed for the pulsar back-end at the Giant Metrewave Radio Telescope (GMRT). The dedispersion pipeline uses the single phased array voltage beam produced by the existing GMRT software back-end (GSB) to produce coherently dedispersed intensity output in real time, for the currently operational bandwidths of 16 MHz and 32 MHz. Provision has also been made to coherently dedisperse voltage beam data from observations recorded on disk. We discuss the design and implementation of the real-time coherent dedispersion system, describing the steps carried out to optimise the performance of the pipeline. Presently functioning on an Intel Xeon X5550 CPU equipped with a NVIDIA Tesla C2075 GPU, the pipeline allows dispersion free, high time resolution data to be obtained in real-time. We illustrate the significant improvements over the existing incoherent dedispersion system at the GMRT, and present some preliminary results obtained from studies of pulsars using this system, demonstrating its potential as a useful tool for low frequency pulsar observations. We describe the salient features of our implementation, comparing it with other recently developed real-time coherent dedispersion systems. This implementation of a real-time coherent dedispersion pipeline for a large, low frequency array instrument like the GMRT, will enable long-term observing programs using coherent dedispersion to be carried out routinely at the observatory. We also outline the possible improvements for such a pipeline, including prospects for the upgraded GMRT which will have bandwidths about ten times larger than at present. [ABSTRACT FROM AUTHOR]

A sub-voxel digital volume correlation (DVC) method combining the 3D inverse compositional Gauss-Newton (ICGN) algorithm with the 3D fast Fourier transform-based cross correlation (FFT-CC) algorithm is proposed to eliminate path-dependence in current iterative DVC methods caused by the initial guess transfer scheme. The proposed path-independent DVC method is implemented on NVIDIA compute unified device architecture (CUDA) for GPU devices. Powered by parallel computing technology, the proposed DVC method achieves a significant improvement in computation speed on a common desktop computer equipped with a low-end graphics card containing 1536 CUDA cores, i.e., up to 23.3 times faster than the sequential implementation and 3.7 times faster than the multithreaded implementation of the same DVC method running on a 6-core CPU. This speedup, which has no compromise with resolution, accuracy and precision, benefits from the coarse-grained parallelism that the points of interest (POIs) are processed simultaneously and also from the fine-grained parallelism that the calculation at each POI is performed with multiple threads in GPU. The experimental study demonstrates the superiority of the GPU-based parallel computing for acceleration of DVC over the multi-core CPU-based one, in particular on a PC level computer. [ABSTRACT FROM AUTHOR]

As a criterion used to describe the performance of an optical system, optical transfer function (OTF) can be calculated by autocorrelation of pupil function, dual Fourier transform, Zernike polynomial fitting, and so on. A fast OTF calculation method based on dual Fourier transform and graphics processing unit (GPU), in which the redundant computations of point spread function (PSF) and OTF are removed, is proposed in this paper. For an optical system with the pupil function of 512 × 512 pixels, the OTF computation is implemented on GPU platform. The result shows that the proposed method using the 128 × 128 pixels central regions of the PSF enhances the computational efficiency of about 4.88 times than the method using standard CUFFT. [ABSTRACT FROM AUTHOR]

The design, analysis and parallel implementation of particle filter (PF) were investigated. Firstly, to tackle the particle degeneracy problem in the PF, an iterated importance density function (IIDF) was proposed, where a new term associating with the current measurement information (CMI) was introduced into the expression of the sampled particles. Through the repeated use of the least squares estimate, the CMI can be integrated into the sampling stage in an iterative manner, conducing to the greatly improved sampling quality. By running the IIDF, an iterated PF (IPF) can be obtained. Subsequently, a parallel resampling (PR) was proposed for the purpose of parallel implementation of IPF, whose main idea was the same as systematic resampling (SR) but performed differently. The PR directly used the integral part of the product of the particle weight and particle number as the number of times that a particle was replicated, and it simultaneously eliminated the particles with the smallest weights, which are the two key differences from the SR. The detailed implementation procedures on the graphics processing unit of IPF based on the PR were presented at last. The performance of the IPF, PR and their parallel implementations are illustrated via one-dimensional numerical simulation and practical application of passive radar target tracking. [ABSTRACT FROM AUTHOR]

A novel lattice Boltzmann method (LBM) based 3D computational fluid dynamics (CFD) technique has been implemented on the graphics processing unit (GPU) for the purpose of simulating the indoor environment in real-time. We study the time evolution of the turbulent airflow and temperature inside a test chamber and in a simple model of a four-bed hospital room. The predicted results from LBM are compared with traditional CFD based large eddy simulations (LES). Reasonable agreement between LBM results and LES method is observed with significantly faster computational times. [ABSTRACT FROM AUTHOR]

The self-organizing map (SOM) model is an effective technique applicable in a wide range of areas, such as pattern recognition and image processing. In the SOM model, the most time-consuming procedure is the training process. It consists of two time-consuming parts. The first part is the calculation of the Euclidean distances between training vectors and codevectors. The second part is the update of the codevectors with the pre-defined neighborhood structure. This paper proposes a graphics processing unit (GPU) algorithm that accelerates these two parts using the graphics rendering ability of GPUs. The distance calculation is implemented in the form of matrix multiplication with compute shader, while the update process is treated as a point-rendering process with vertex shader and fragment shader. Experimental results show that our algorithm runs much faster than previous CUDA implementations, especially for the large neighborhood case. Also, our method can handle the case with large codebook size and high dimensional data. [ABSTRACT FROM AUTHOR]

Base stations have been built from ASICs, DSP processors, or FPGAs. This paper studies the feasibility of building wireless base stations from commercial graphics processing units (GPUs). GPUs are attractive because they are widely used massively parallel devices that can be programmed in a high level language. Base station workloads are highly parallel, making GPUs a potential candidate for a cost effective programmable solution. In this work, we develop parallel implementations of key kernels to evaluate the merits of using GPUs as the baseband signal processor. We also study the mapping method of key kernels onto a multi-GPU system to minimize the number of required GPUs and the overall subframe processing latency. Our results show that the baseband subsystem in an LTE base station, which supports ≤150 Mbps peak data rate, can be built with up to four NVIDIA GTX 680 GPUs and commercial motherboards. We also show that the digital processing subsystem for a 75 Mbps LTE base station can be built using two NVIDIA GTX 680 GPUs with power consumption of 188 W. [ABSTRACT FROM AUTHOR]