Search

The demand for specialized hardware to train AI models has increased in tandem with the increase in the model complexity over the recent years. Graphics processing unit (GPU) is one such hardware that is capable of parallelizing operations performed on a large chunk of data. Companies like Nvidia, AMD, and Google have been constantly scaling-up the hardware performance as fast as they can. Nevertheless, there is still a gap between the required processing power and processing capacity of the hardware. To increase the hardware utilization, the software has to be optimized too. In this paper, we present some general GPU optimization techniques we used to efficiently train the optiGAN model, a Generative Adversarial Network that is capable of generating multidimensional probability distributions of optical photons at the photodetector face in radiation detectors, on an 8GB Nvidia Quadro RTX 4000 GPU. We analyze and compare the performances of all the optimizations based on the execution time and the memory consumed using the Nvidia Nsight Systems profiler tool. The optimizations gave approximately a 4.5x increase in the runtime performance when compared to a naive training on the GPU, without compromising the model performance. Finally we discuss optiGANs future work and how we are planning to scale the model on GPUs.

Deep neural networks (DNNs) have emerged as an effective solution for many machine learning applications. However, the great success comes with the cost of excessive computation. The Volta graphics processing unit (GPU) from NVIDIA introduced a specialized hardware unit called tensor core (TC) aiming at meeting the growing computation demand needed by DNNs. Most previous studies on TCs have focused on performance improvement through the utilization of the TC's high degree of parallelism. However, as DNNs are deployed into security-sensitive applications such as autonomous driving, the reliability of TCs is as important as performance. In this work, we exploit the unique architectural characteristics of TCs and propose a simple and implementation-efficient hardware technique called fault detection in tensor core (FDTC) to detect transient faults in TCs. In particular, FDTC exploits the zero-valued weights that stem from network pruning as well as sparse activations arising from the common ReLU operator to verify tensor operations. The high level of sparsity in tensors allows FDTC to run original and verifying products simultaneously, leading to zero performance penalty. For applications with a low sparsity rate, FDTC relies on temporal redundancy to re-execute effectual products. FDTC schedules the execution of verifying products only when multipliers are idle. Our experimental results reveal that FDTC offers 100% fault coverage with no performance penalty and small energy overhead in TCs. [ABSTRACT FROM AUTHOR]

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]

Deep neural networks have achieved excellent results in natural language processing, computer vision and other fields. Due to the growth of the scale of data processed by intelligent applications and the rapid development of large models, the inference performance of deep neural networks is increasingly demanding. N:M semi-structured sparse scheme has become one of the hot technologies to balance the computing power demand and application effect. The domestic heterogeneous vector processor FT-M7032 provides more space for data parallelism and instruction parallelism development in intelligent model processing. In order to address the challenges of N:M semi-structured sparse model computation with various sparse patterns, a flexible configurable sparse matrix multiplication algorithm NM-SpMM is proposed for FT-M7032. NM-SpMM designs an efficient compressed offset address sparse encoding format COA, which avoids the impact of semi-structured parameter configuration on sparse data access. Based on the COA, NM-SpMM performs fine-grained optimization of sparse matrix multiplication in different dimensions. The experimental results on FT-M7032 single core show that NM-SpMM can obtain 1.73~21.00 times speedup compared to dense matrix multiplication, and 0.04~1.04 times speedup compared to NVIDIA V100 GPU with CuSPARSE. [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]

Abstract 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.

Solvent plays an essential role in a variety of chemical, physical, and biological processes that occur in the solution phase. The reference interaction site model (RISM) and its three‐dimensional extension (3D‐RISM) serve as powerful computational tools for modeling solvation effects in chemical reactions, biological functions, and structure formations. We present the RISM integrated calculator (RISMiCal) program package, which is based on RISM and 3D‐RISM theories with fast GPU code. RISMiCal has been developed as an integrated RISM/3D‐RISM program that has interfaces with external programs such as Gaussian16, GAMESS, and Tinker. Fast 3D‐RISM programs for single‐ and multi‐GPU codes written in CUDA would enhance the availability of these hybrid methods because they require the performance of many computationally expensive 3D‐RISM calculations. We expect that our package can be widely applied for chemical and biological processes in solvent. The RISMiCal package is available at https://rismical-dev.github.io. [ABSTRACT FROM AUTHOR]

Sparse General Matrix-Matrix Multiplication (SpGEMM) has played an important role in a number of applications. So far, many efficient algorithms have been proposed to improve the performance of SpGEMM on GPUs. However, the performance of each algorithm for matrices of different structures varies a lot. There is no algorithm that can achieve the optimal performance of SpGEMM computation on all matrices. In this article, we design a machine learning based approach for predicting the optimal SpGEMM algorithm on input matrices. By extracting features from input matrices, we utilize LightGBM and XGBoost to train different lightweight models. The models are capable of predicting the best performing algorithm with low inference overhead and high accuracy for the given input matrices. We also investigate the impact of tree depth on model accuracy and inference overhead. Our evaluation shows that an increase in tree depth leads to a corresponding increase in prediction accuracy, reaching a maximum of approximately 85%, while resulting in increased inference overhead of approximately 10 µs. Compared with the state-of-the-art algorithms on three GPU platforms, our method achieves better overall performance. [ABSTRACT FROM AUTHOR]

Smoothed particle hydrodynamics (SPH) method is widely accepted as a flexible numerical treatment for surface boundaries and interactions. High-resolution simulations of hydrodynamic events require high-performance computing (HPC). There is a need for an SPH code that runs efficiently on modern supercomputers involving accelerators such as NVIDIA or AMD graphics processing units. In this work, we applied half-precision, which is widely used in artificial intelligence, to the SPH method. However, improving HPC performance at such low-order precisions is a challenge. An as-is implementation with half-precision will have lower computational cost than that of float/double precision simulations, but also worsens the simulation accuracy. We propose a scaling and shifting method that maintains the simulation accuracy near the level of float/double precision. By examining the impact of half-precision on the simulation accuracy and time-to-solution, we demonstrated that the use of half-precision can improve the computational performance of SPH simulations for scientific purposes without sacrificing the accuracy. In addition, we demonstrated that the efficiency of half-precision depends on the architecture used. [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]

Identifying road obstacles hidden from the driver's field of view can ensure road safety in transportation. Current driver assistance systems such as 2D head‐up displays are limited to the projection area on the windshield of the car. An augmented reality holographic point cloud video projection system is developed to display objects aligned with real‐life objects in size and distance within the driver's field of view. Light Detection and Ranging (LiDAR) point cloud data collected with a 3D laser scanner is transformed into layered 3D replay field objects consisting of 400 k points. GPU‐accelerated computing generated real‐time holograms 16.6 times faster than the CPU processing time. The holographic projections are obtained with a Spatial Light Modulator (SLM) (3840×2160 px) and virtual Fresnel lenses, which enlarged the driver's eye box to 25 mm × 36 mm. Real‐time scanned road obstacles from different perspectives provide the driver a full view of risk factors such as generated depth in 3D mode and the ability to project any scanned object from different angles in 360°. The 3D holographic projection technology allows for maintaining the driver's focus on the road instead of the windshield and enables assistance by projecting road obstacles hidden from the driver's field of view. [ABSTRACT FROM AUTHOR]

The analysis of electrothermal coupling problems finds extensive application in engineering. However, for large-scale electrothermal coupling problems, the time cost and storage requirements for solving them using the finite element method (FEM) are substantial. We optimize the finite element electrothermal coupling computation from two aspects: computational speed and storage usage. Based on the assembly-free FEM, we explore the symmetry of element matrices to reduce storage for second-order tetrahedral elements and propose a graphics processing unit (GPU) parallel algorithm to improve computational speed. At the same time, we allocate the parallel parts of an electrothermal coupling problem to two GPUs to improve the speed further. In addition, for the three types of boundary conditions in electrothermal coupling problems, we design parallel application methods suitable for assembly-free FEM. Finally, we compare our strategy with methods from other literature through the numerical experiment. Our method reduces the element matrices' storage by 45%. Compared with the solution process using the element level method and degree of freedom level method, our strategy achieves average acceleration ratios of 5.83 and 1.38, respectively. [ABSTRACT FROM AUTHOR]

A 3D neutron transport computational code, STORK, has been developed based on a small-scale multi-GPU computing platform, utilizing the coupled approach of the two-dimensional full-core layer-by-layer transport calculation by the method of characteristics (MOC) and the 3D pin-by-pin simplified P3 (SP3) calculation. In this code, firstly, the core was layered according to the axial characteristics and the two-dimensional multi-group (69-group) transport equation was solved by MOC method (with fully reflective boundary conditions in the axial direction) for each axial layer. Secondly, utilizing the results from 2D MOC calculations, based on the equivalent homogenization theory and the super-homogenization (SPH) technology, the heterogenous cells were homogenized, which produced the few-group homogenous cross sections as well as SPH factors. Finally, the 3D whole-core pin-by-pin SP3 calculation was carried out to obtain cell flux and power distribution. Moreover, the constructive solid geometry (CSG) was applied to enhance the complex geometric modeling capability in STORK. A combination of the enhanced neutron flow method and the equivalence theory was used to perform resonance calculations and a pre-produced table of resonance interference factors was adopted to handle the resonance interference effects. During 2D transport calculation, a two-level unstructured coarse mesh finite difference method was applied to accelerate the convergence of the MOC calculation. In the 3D pin-by-pin calculation, the 3D SP3 equations were solved by the transverse integration technique and the nodal expansion method with group transverse-integrated neutron fluxes approximated by the parabola expansion in the radial direction and by semi-analytical expansion in the axial direction. In terms of code development, a hybrid programming of CUDA, C++ and Python was adopted, and all the computational modules were developed based on CUDA/C++ with a large number of performance optimizations, so that 2D MOC calculations at each layer of the core could be carried out on multiple GPUs at the same time. To maximize computational efficiency, the computationally-intensive modules in STORK, including MOC calculation, CMFD, resonance calculation, burnup calculation, and SP3 calculation modules, were executed on the GPU. The validation of the SRORK code through the C5G7 3D Rodded problem and VERA benchmark problems demonstrates its high computational accuracy, with a radial assembly power error of less than 1%. However, due to the code's direct utilization of the energy spectrum of the adjacent layers' active regions for the axial reflector and the lack of consideration for neutron leakage from neighboring axial layers, significant discrepancies in axial power occur near the reflector and in fuel layers containing spacer grids, but they remain below 3%. More importantly, developed based on the CPU/GPU heterogeneous system, the code exhibits significant advantages in terms of computational efficiency and cost compared to similar neutron transport softwares.

Incoherent digital holography (IDH) is a technique that enables single-shot three-dimensional (3D) imaging by recording holograms with incoherent light, such as sunlight and LEDs. IDH is expected to be a next-generation 3D measurement technique, but there are two challenges: speeding up both denoising required for IDH due to insufficient light and the diffraction calculations required to obtain reconstructed images. We propose a real-time IDH system in which single-exposure phase-shifting digital holography, which can record multiple phase-shifted holograms in a single exposure, is combined with an embedded graphic processing unit (GPU). The proposed system enables real-time color imaging of the real world from incoherent holograms with $2448 \times 2048$ pixels while reducing noise at 21.2 frames per second. The effect of the denoising was evaluated by speckle contrast, showing that noises were well reduced. Compared to five existing studies using field programable gate arrays and GPUs, the proposed system is capable of computing large hologram reproduction at high speed. The proposed system is a prototype for future incoherent holographic cameras.

The massive parallelism provided by Graphics Processing Units (GPUs) to accelerate compute-intensive tasks makes it preferable for Real-Time Systems such as autonomous vehicles. Such systems require the execution of heavy Machine Learning (ML) and Computer Vision applications because of the computing power of GPUs. However, such systems need a guarantee of timing predictability. It means the Worst-Case Execution Time (WCET) of the application is estimated tightly and safely to schedule each application before its deadline to avoid catastrophic consequences. As more applications use GPUs, running many applications simultaneously on the same GPU becomes necessary. To provide predictable performance while the application is running in parallel, it must be WCET-aware, which GPUs do not fully support in a multitasking environment. Nvidia recently added a feature called the Multi-Process Service. It allows the different applications to run simultaneously in the same CUDA context by partitioning the compute resources of the GPU. Using this feature, we can measure the interference from co-running GPU applications to estimate WCET. In this paper, we propose a novel technique to estimate the WCET of the GPU kernel using an ML approach. Our approach is based on the application’s source, and the model is trained based on the large data set. The approach is flexible and can be applied to different GPU-sharing mechanisms. We allow the victim and enemy kernel of the GPU to execute in parallel to get the maximum interference from the enemy to estimate the WCET of the victim kernel. Enemy kernels are chosen to cause a higher slowdown by acquiring the resources of the victim kernel. We compare our implementation with state-of-the-art approaches to show its effectiveness. Our ML approach reduces the time by 99% in most cases because inferences take only seconds to predict WCET, and the resource consumption required to estimate WCET compared to traditional approaches is minimal because we don’t need to execute the application on GPU for hours. Although our approach does not offer safety guarantees because of its empirical nature, we observed that predicted WCETs are always higher than any observed execution times for all benchmarks, and the maximum overestimation factor observed is 11x.

Copyright of Atomic Energy Science & Technology is the property of Editorial Board of Atomic Energy Science & Technology and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

A novel algorithm is proposed for quantitative comparisons between compact surfaces embedded in the three-dimensional Euclidian space. The key idea is to identify those objects with the associated surface measures and compute a weak distance between them using the Fourier transform on the ambient space. In particular, the inhomogeneous Sobolev norm of negative order for a difference between two surface measures is evaluated via the Plancherel theorem, which amounts to approximating a weighted integral norm of smooth data on the frequency space. This approach allows several advantages, including high accuracy due to fast-converging numerical quadrature rules, acceleration by the nonuniform fast Fourier transform, and parallelization on many-core processors. In numerical experiments, the 2-sphere, which is an example whose Fourier transform is explicitly known, is compared with its icosahedral discretization, and it is observed that the piecewise linear approximations converge to the smooth object at the quadratic rate up to small truncation. [ABSTRACT FROM AUTHOR]

Large-scale observational health databases are increasingly popular for conducting comparative effectiveness and safety studies of medical products. However, increasing number of patients poses computational challenges when fitting survival regression models in such studies. In this article, we use Graphics Processing Units (GPUs) to parallelize the computational bottlenecks of massive sample-size survival analyses. Specifically, we develop and apply time- and memory-efficient single-pass parallel scan algorithms for Cox proportional hazards models and forward-backward parallel scan algorithms for Fine-Gray models for analysis with and without a competing risk using a cyclic coordinate descent optimization approach. We demonstrate that GPUs accelerate the computation of fitting these complex models in large databases by orders of magnitude as compared to traditional multi-core CPU parallelism. Our implementation enables efficient large-scale observational studies involving millions of patients and thousands of patient characteristics. The above implementation is available in the open-source R package Cyclops. [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]

In recent years, the number of Earth Observation missions has been exponentially increasing. Satellites dedicated to these missions usually embark with payloads that produce large amount of data and that need to be transmitted towards ground stations, in time-limited windows. Moreover, the noisy nature of the link between satellites and ground stations makes it hard to achieve reliable communication. To address these problems, a standard for a flexible advanced coding and modulation scheme for high-rate telemetry applications has been defined by the Consultative Committee for Space Data Systems (CCSDS). The defined standard, referred to as CCSDS 131.2-B, makes use of Serially Concatenated Convolutional Codes (SCCC) based on 27 ModCods to optimize transmission quality. A limiting factor in the adoption of this standard is represented by the complexity and the cost of the hardware required for developing high-performance receivers. In the last decade, the performance of software has grown due to the advancement of general-purpose processing hardware, leading to the development of many high-performance software systems even in the telecommunication sector. These are commonly referred to as Software-Defined Radio (SDR), indicating a radio communication system in which components that are usually implemented in hardware, by means of FPGAs or ASICs, are instead implemented in software, offering many advantages such as flexibility, modularity, extensibility, cheaper maintenance, and cost saving. This paper proposes the development of an SDR based on NVIDIA Graphics Processing Units (GPU) for implementing the receiver end of the CCSDS 131.2-B standard. At first, a brief description of the CCSDS 131.2-B standard is given, focusing on the architecture of the transmitter and receiver sides. Then, the receiver architecture is shown, giving an overview of its functional blocks and of the implementation choices made to optimize the processing of the signal, especially for the SCCC Decoder. Finally, the performance of the system is analyzed in terms of data-rate and error correction and compared with other SW systems to highlight the achieved improvements. The presented system has been demonstrated to be a perfect solution for CCSDS 131.2-B-compliant device testing and for its use in science missions, providing a valid low-cost alternative with respect to the state-of-the-art HW receivers. [ABSTRACT FROM AUTHOR]

Summary: Real‐time hybrid simulation is a testing method that combines physical experiments and numerical simulations, which can increase the dimensions of experimental specimens and reduce the error of scaling testing. Currently, the maximum degrees of freedom of numerical models are 7000 in real time. To improve the scale of numerical simulation in real time, a testing framework based on Python and graphics processing unit was proposed in this paper. The maximum degrees of freedom of the numerical model exceeded 24,000 with the testing framework. The testing capacity of real‐time hybrid simulation was significantly improved by the graphics processing unit calculations. [ABSTRACT FROM AUTHOR]

Copyright of Journal of Signal Processing is the property of Journal of Signal Processing and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

In this paper proposes the design and implementation of the back-propagation algorithm (BPA) based neural network direct memory access (DMA) controller for use of multimedia applications. The proposed DMA controller work with the back propagation-training algorithm. The advantages of the BPA it will be work on the gradient loss w.r.t the network weights. So, this BPA is used as training algorithm for the DMA controller. The proposed method is test with the different workload characteristics like heavy workload, medium workload and normal workload. The performance parameters are considered here is like accuracy, precision, recall, and F1-score. The proposed method is compared with existing methods like convolutional neural network (CNN), recurrent neural network (RNN), long sort term memory (LSTM), and gated recurrent unit (GRU). Finally, the proposed design will give the better performance than existing methods. [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]

The Monte Carlo (MC) simulation, due to its ability to accurately simulate the backscattered signal of lidar, plays a crucial role in the design, optimization, and interpretation of the backscattered signal in lidar systems. Despite the development of several MC models for lidars, a suitable MC simulation model for underwater single-photon lidar, which is a vital ocean remote sensing technique utilized in underwater scientific investigations, obstacle avoidance for underwater platforms, and deep-sea environmental exploration, is still lacking. There are two main challenges in underwater lidar simulation. Firstly, the simulation results are significantly affected by near-field abnormal signals. Secondly, the simulation process is time-consuming due to the requirement of a high number of random processes to obtain reliable results. To address these issues, an algorithm is proposed to minimize the impacts of abnormal simulation signals. Additionally, a graphics processing unit (GPU)-accelerated semi-analytic MC simulation with a compute unified device architecture is proposed. The performance of the GPU-based program was validated using 109 photons and compared to a central processing unit (CPU)-based program. The GPU-based program achieved up to 68 times higher efficiency and a maximum relative deviation of less than 1.5%. Subsequently, the MC model was employed to simulate the backscattered signal in inhomogeneous water using the Henyey–Greenstein phase functions. By utilizing the look-up table method, simulations of backscattered signals were achieved using different scattering phase functions. Finally, a comparison between the simulation results and measurements derived from an underwater single-photon lidar demonstrated the reliability and robustness of our GPU-based MC simulation model. [ABSTRACT FROM AUTHOR]

Purpose. The purpose of this study is to compare two libraries dedicated to the Markov chain Monte Carlo method: pystan and numpyro. In the comparison, we mainly focused on the agreement of estimated latent parameters and the performance of sampling using the Markov chain Monte Carlo method in Bayesian item response theory (IRT). Materials and methods. Bayesian 1PL-IRT and 2PL-IRT were implemented with pystan and numpyro. Then, the Bayesian 1PL-IRT and 2PL-IRT were applied to two types of medical data obtained from a published article. The same prior distributions of latent parameters were used in both pystan and numpyro. Estimation results of latent parameters of 1PL-IRT and 2PL-IRT were compared between pystan and numpyro. Additionally, the computational cost of the Markov chain Monte Carlo method was compared between the two libraries. To evaluate the computational cost of IRT models, simulation data were generated from the medical data and numpyro. Results. For all the combinations of IRT types (1PL-IRT or 2PL-IRT) and medical data types, the mean and standard deviation of the estimated latent parameters were in good agreement between pystan and numpyro. In most cases, the sampling time using the Markov chain Monte Carlo method was shorter in numpyro than that in pystan. When the large-sized simulation data were used, numpyro with a graphics processing unit was useful for reducing the sampling time. Conclusion. Numpyro and pystan were useful for applying the Bayesian 1PL-IRT and 2PL-IRT. Our results show that the two libraries yielded similar estimation result and that regarding to sampling time, the fastest libraries differed based on the dataset size. [ABSTRACT FROM AUTHOR]

This study presents optimization models for large vehicle routing problems using a spreadsheet solver and Python programming language with extended graphic card boosting computing power. Near optimality is feasible and attainable with spreadsheet tools and models for solving real-life problems. However, increasing the availability of additional computing power through graphics processing and visualization is now a viable option for decision-makers and problem-solvers. This study shows that decision-makers can solve vehicle routing optimization problems with limited access to high-end optimization tools. This study shows managers and decision-makers can use vehicle routing optimization even with limited access to sophisticated optimization tools.

The numerical integration of the exchange–correlation (XC) potential is one of the primary computational bottlenecks in Gaussian basis set Kohn–Sham density functional theory (KS-DFT). To achieve optimal performance and accuracy, care must be taken in this numerical integration to preserve local sparsity as to allow for near linear weak scaling with system size. This leads to an integration scheme with several performance critical kernels which must be hand optimized for each architecture of interest. As the set of available accelerator hardware goes more diverse, a key challenge for developers of KS-DFT software is to maintain performance portability across a wide range of computational architectures. In this work, we examine a modular software design pattern which decouples the implementation details of performance critical kernels from the expression of high-level algorithmic workflows in a device-agnostic language such as C++; thus allowing for developers to target existing and emerging accelerator hardware within a single code base. We consider the efficacy of such a design pattern in the numerical integration of the XC potential by demonstrating its ability to achieve performance portability across a set of accelerator architectures which are representative of those on current and future U.S. Department of Energy Leadership Computing Facilities.

Biomedical named entity recognition (Bio-NER) is a highly complex and time-consuming research domain using natural language processing (NLP). It's widely used in information retrieval, knowledge summarization, biomolecular event extraction, and discovery applications. This paper proposes a method for the recognition and classification of named entities in the biomedical domain using machine learning (ML) techniques. Support vector machine (SVM), decision trees (DT), K-nearest neighbor (KNN), and its kernel versions are used. However, recent advancements in programmable, massively parallel graphics processing units (GPU) hold promise in terms of increased computational capacity at a lower cost to address multi-dimensional data and time complexity. We implement a novel parallel version of KNN by porting the distance computation step on GPU using the compute unified device architecture (CUDA) and compare the performance of all the algorithms using the BioNLP/NLPBA 2004 corpus. Results demonstrate that CUDA-KNN takes full advantage of the GPU's computational capacity and multi-leveled memory architecture, resulting in a 35× performance enhancement over the central processing unit (CPU). In a comparative study with existing research, the proposed model provides an option for a faster NER system for higher dimensionality and larger datasets as it offers balanced performance in terms of accuracy and speed-up, thus providing critical design insights into developing a robust BioNLP system. [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 artificial intelligence inference model is currently the best mathematical model based on artificial neural networks. The intelligent reasoning mode based on artificial intelligence has a large construction scale. In a completed inference, many multiplication and addition operations need to be completed. To establish an effective artificial intelligence inference model, its computational complexity is dozens or even more times higher than traditional artificial intelligence algorithms. This article focused on the research on the isomerization acceleration of FPGA (Field Programmable Gate Array). This article was looking for a method that reduces both system changes and migration, while maximizing the flexibility of FPGA programmability. In order to build on this foundation, a fast interface for fast computation using FPGA was designed. The characteristic of this project was that it could combine the FPGA acceleration platform with ordinary computers or servers, and could effectively utilize traditional computer software and toolchains. This article compared the computational time consumption between the inference model and the CPU. In the scale calculation logic scenario of the inference model designed in this article, it could achieve the same computing power as the CPU when processing 70000 multiplication calculations. The experimental results indicated that the increase in CPU computing power was greater than that of the inference model. This indicated that the larger the amount of computational data, the more significant the acceleration effect of the inference model in this article would be. [ABSTRACT FROM AUTHOR]

Big Bayes is the computationally intensive co-application of big data and large, expressive Bayesian models for the analysis of complex phenomena in scientific inference and statistical learning. Standing as an example, Bayesian multidimensional scaling (MDS) can help scientists learn viral trajectories through space-time, but its computational burden prevents its wider use. Crucial MDS model calculations scale quadratically in the number of observations. We partially mitigate this limitation through massive parallelization using multi-core central processing units, instruction-level vectorization and graphics processing units (GPUs). Fitting the MDS model using Hamiltonian Monte Carlo, GPUs can deliver more than 100-fold speedups over serial calculations and thus extend Bayesian MDS to a big data setting. To illustrate, we employ Bayesian MDS to infer the rate at which different seasonal influenza virus subtypes use worldwide air traffic to spread around the globe. We examine 5392 viral sequences and their associated 14 million pairwise distances arising from the number of commercial airline seats per year between viral sampling locations. To adjust for shared evolutionary history of the viruses, we implement a phylogenetic extension to the MDS model and learn that subtype H3N2 spreads most effectively, consistent with its epidemic success relative to other seasonal influenza subtypes. Finally, we provide MassiveMDS, an open-source, stand-alone C++ library and rudimentary R package, and discuss program design and high-level implementation with an emphasis on important aspects of computing architecture that become relevant at scale.

We have developed a phase retrieval holography system using a single-board computer (SBC) with a graphics processing unit (GPU) for particle size measurement. The system comprises two cameras connected to the SBC with a GPU (Jetson NanoTM, NVIDIA®), a diode-pumped solid-state green laser, and a beam splitter. The GPU enables us to reconstruct holograms in real-time and measure particle size. The system can record the shapes and positions of particles falling in a static flow in a three-dimensional volume as two holograms generating an interference pattern. Two holograms solve the twin image problem that arises because of the lack of phase information using phase retrieval holography. We also present the requirement of this system for experimentally recording and numerically reconstructing holograms of particles. Finally, we compare the particle size distribution obtained by the system to that of conventional two-dimensional image measurement.

Sparse partial correlation estimation is a popular topic in high-dimensional data analysis, where nonzero partial correlation represents the conditional dependency between two corresponding variables given the other variables. In the Gaussian graphical model, many methods have been developed using the $\ell _{1}$ regularization to achieve sparsity on conditional dependency. Most of the existing methods impose $\ell _{1}$ penalty on the off-diagonal entries of the precision matrix. This approach may fail to identify the conditional dependencies with partial correlations of moderate magnitudes when the corresponding elements of the precision matrix are relatively small. In this study, we propose a two-stage procedure to estimate sparse partial correlations using scaled Lasso. The proposed procedure resolves the non-convexity of partial correlation estimation by using a consistent estimator of the diagonal elements of the precision matrix from scaled Lasso. Moreover, we develop an efficient algorithm for the proposed method using graphics processing units based on the iterative shrinkage algorithm. Our numerical study shows that the proposed method performs better than the existing methods in terms of edge recovery and the estimation of the partial correlations under the Frobenius norm.

This study addresses the problem of real-time tracking of high-speed ballistic targets. Particle filters can be used to overcome the nonlinearity of motion and measurement models in ballistic targets. However, applying particle filters (PFs) to real-time systems is challenging since they generally require a significant computation time. So, most of the existing methods of accelerating PF using a graphics processing unit (GPU) for target tracking applications have accelerated computation weight function and resampling part. However, the computational time per part varies from application to application, and in this work, we confirm that it takes a lot of computational time in the model propagation part and propose accelerated PF by parallelizing the corresponding logic. The real-time performance of the proposed method was tested and analyzed using an embedded system. And compared to conventional PF on the central processing unit (CPU), the proposed method shows that the proposed method significantly reduces computational time by at least 10 times, improving real-time performance.

The demand for specialized hardware to train AI models has increased in tandem with the increase in the model complexity over the recent years. Graphics processing unit (GPU) is one such hardware that is capable of parallelizing operations performed on a large chunk of data. Companies like Nvidia, AMD, and Google have been constantly scaling-up the hardware performance as fast as they can. Nevertheless, there is still a gap between the required processing power and processing capacity of the hardware. To increase the hardware utilization, the software has to be optimized too. In this paper, we present some general GPU optimization techniques we used to efficiently train the optiGAN model, a Generative Adversarial Network that is capable of generating multidimensional probability distributions of optical photons at the photodetector face in radiation detectors, on an 8GB Nvidia Quadro RTX 4000 GPU. We analyze and compare the performances of all the optimizations based on the execution time and the memory consumed using the Nvidia Nsight Systems profiler tool. The optimizations gave approximately a 4.5x increase in the runtime performance when compared to a naive training on the GPU, without compromising the model performance. Finally we discuss optiGANs future work and how we are planning to scale the model on GPUs.

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]

In this study, a multi-phase-field (MPF) framework for predicting epitaxial grain growth in selective laser melting (SLM) additive manufacturing (AM) with multi-track and multi-layer scanning was developed. The spatiotemporal change in temperature was approximated using the Rosenthal equation, which provides a theoretical solution for the temperature distribution due to a moving point heat source. The powder bed was modeled as a polycrystalline layer. Large-scale MPF simulations for SLM-AM were performed using parallel computing with multiple graphics processing units. Using the MPF framework developed herein, we simulated SLM-AM with four tracks and four layers for 316L stainless steel. By observing the epitaxial grain growth process on two-dimensional cross-sections and in three dimensions, we clarified a typical growth procedure of grains with characteristic 3D shapes. The MPF framework will potentially enable a systematic estimation of the material microstructures formed during SLM-AM. [ABSTRACT FROM AUTHOR]

Unified Virtual Memory (UVM) relieves the developers from the onus of maintaining complex data structures and explicit data migration by enabling on-demand data movement between CPU memory and GPU memory. However, on-demand paging soon becomes a performance bottleneck of UVM due to the high latency caused by page table walks and data migration over interconnect. Prefetching is considered a promising solution to this problem given its ability to leverage the locality of program memory access patterns. However, existing locality-based prefetching schemes can not handle all the situations. An ideal prefetcher should not only look at narrow regions of the requested address space but also capture global context to deliver a good prediction of the memory access pattern. This paper proposes a novel framework for page prefetching for UVM through deep learning. We first show that a powerful Transformer learning model can provide high accuracy for UVM page prefetching. We then perform analysis to interpret this Transformer model and derive several insights that allow us to design a simpler model to match the unconstrained model's accuracy with orders of magnitude lower cost. We use a pattern-based method to make the UVM page preditor general to different GPU workloads. We evaluate this framework on a set of 11 memory-intensive benchmarks from popular benchmark suites. Our solution outperforms the state-of-the-art (SOTA) UVM framework, improving the performance by 10.89%, improving the device memory page hit rate by 16.98% (89.02% vs. 76.10% for prior art), and reducing the CPU-GPU interconnect traffic by 11.05%. According to our proposed unified metric, which combines the accuracy, coverage, and page hit rate, our solution is approaching the ideal prefetching scheme more than the SOTA design (0.90 vs. 0.85, with the perfect prefetcher of 1.0). • The first framework for CPU-GPU UVM page prefetching using deep learning. • Revealing insights about UVM prefetching to derive lightweight page predictors. • Significantly improves IPC and memory page hit rate while reducing PCI-e usage. [ABSTRACT FROM AUTHOR]

The predominance of Kohn-Sham density functional theory (KS-DFT) for the theoretical treatment of large experimentally relevant systems in molecular chemistry and materials science relies primarily on the existence of efficient software implementations which are capable of leveraging the latest advances in modern high-performance computing (HPC). With recent trends in HPC leading toward increasing reliance on heterogeneous accelerator-based architectures such as graphics processing units (GPU), existing code bases must embrace these architectural advances to maintain the high levels of performance that have come to be expected for these methods. In this work, we purpose a three-level parallelism scheme for the distributed numerical integration of the exchange-correlation (XC) potential in the Gaussian basis set discretization of the Kohn-Sham equations on large computing clusters consisting of multiple GPUs per compute node. In addition, we purpose and demonstrate the efficacy of the use of batched kernels, including batched level-3 BLAS operations, in achieving high levels of performance on the GPU. We demonstrate the performance and scalability of the implementation of the purposed method in the NWChemEx software package by comparing to the existing scalable CPU XC integration in NWChem.

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]

(1) Background: There was a need for 3D image reconstruction from a series of 2D projections in medical applications. However, additional exposure to X-ray projections may harm human health. To alleviate it, minimizing the projection numbers is a solution to reduce X-ray exposure, but this would cause significant image noise and artifacts. (2) Purpose: In this study, a method was proposed for the reconstruction of a 3D image from a minimal set of 2D X-ray projections using a B-spline-based deformable transformation. (3) Methods: The inputs of this method were a 3D image which was acquired in previous treatment and used as a prior image and a minimal set of 2D projections which were acquired during the current treatment. The goal was to reconstruct a new 3D image in current treatment from the two inputs. The new 3D image was deformed from the prior image via the displacement matrixes that were interpolated by the B-spline coefficients. The B-spline coefficients were solved with the objective function, which was defined as the mean square error between the reconstructed and the ground-truth projections. In the optimization process the gradient of the objective function was calculated, and the B-spline coefficients were then updated. For the acceleration purpose, the computation of the 2D and 3D image reconstructions and B-spline interpolation were implemented on a graphics processing unit (GPU). (4) Results: When the scan angles were more than 60°, the image quality was significantly improved, and the reconstructed image was comparable to that of the ground-truth image. As the scan angles were less than 30°, the image quality was significantly degraded. The influence of the scan orientation on the image quality was minor. With the application of GPU acceleration, the reconstruction efficiency was improved by hundred times compared to that of the conventional CPU. (5) Conclusions: The proposed method was able to generate a high-quality 3D image using a few 2D projections, which amount to ~ 20% of the total projections required for a standard image. The introduction of the B-spline-interpolated displacement matrix was effective in the suppressing noise in the reconstructed image. This method could significantly reduce the imaging time and the radiation exposure of patients under treatment. [ABSTRACT FROM AUTHOR]

Zero-knowledge proof is a critical cryptographic primitive. Its most practical type, called zero-knowledge Succinct Non-interactive ARgument of Knowledge (zkSNARK), has been deployed in various privacy-preserving applications such as cryptocurrencies and verifiable machine learning. Unfortunately, zkSNARK like Groth16 has a high overhead on its proof generation step, which consists of several time-consuming operations, including large-scale matrix-vector multiplication (MUL), number-theoretic transform (NTT), and multi-scalar multiplication (MSM). Therefore, this paper presents cuZK, an efficient GPU implementation of zkSNARK with the following three techniques to achieve high performance. First, we propose a new parallel MSM algorithm. This MSM algorithm achieves nearly perfect linear speedup over the Pippenger algorithm, a well-known serial MSM algorithm. Second, we parallelize the MUL operation. Along with our self-designed MSM scheme and well-studied NTT scheme, cuZK achieves the parallelization of all operations in the proof generation step. Third, cuZK reduces the latency overhead caused by CPU-GPU data transfer by 1) reducing redundant data transfer and 2) overlapping data transfer and device computation. The evaluation results show that our MSM module provides over 2.08x (up to 2.94x) speedup versus the state-of-the-art GPU implementation. cuZK achieves over 2.65x (up to 4.86x) speedup on standard benchmarks and 2.18× speedup on a GPU-accelerated cryptocurrency application, Filecoin.