Graphics Processing Units Hardware Research Articles

Sustainable Optimizing Performance and Energy Efficiency in Proof of Work Blockchain: A Multilinear Regression Approach

The energy-intensive characteristics of the computations performed by graphics processing units (GPUs) in proof-of-work (PoW) blockchain technology are readily apparent. The optimization of GPU feature configuration is a complex subject that significantly impacts a system’s energy consumption and performance efficiency. The primary objectives of this study are to examine and improve the energy consumption characteristics of GPUs, which play a crucial role in the functioning of blockchains and the mining of cryptocurrencies. This study examines the complex relationship between GPU configurations and system architecture components and their effects on energy efficiency and sustainability. The methodology of this study conducts experiments involving various GPU models and mining software, evaluating their effectiveness across various configurations and environments. Multilinear regression analysis is used to study the complex relationships between critical performance indicators like power consumption, thermal dynamics, core speed, and hash rate and their effects on energy efficiency and performance. The results reveal that strategically adjusting GPU hardware, software, and configuration can preserve substantial energy while preserving computational efficiency. GPU core speed, temperature, core memory speed, ETASH algorithms, fan speed, and energy usage significantly affected the dependent computational-efficiency variable (p = 0.000 and R2 = 0.962) using multilinear regression analysis. GPU core speed, temperature, core memory speed, fan speed, and energy usage significantly affected efficient energy usage (p = 0.000 and R2 = 0.989). The contributions of this study offer practical recommendations for optimizing the feature configurations of GPUs to reduce energy consumption, mitigate the environmental impacts of blockchain operations, and contribute to the current research on performance in PoW blockchain applications.

Faster inference from state space models via GPU computing

Inexpensive Graphics Processing Units (GPUs) offer the potential to greatly speed up computation by employing their massively parallel architecture to perform arithmetic operations more efficiently. Population dynamics models are important tools in ecology and conservation. Modern Bayesian approaches allow biologically realistic models to be constructed and fitted to multiple data sources in an integrated modelling framework based on a class of statistical models called state space models. However, model fitting is often slow, requiring hours to weeks of computation. We demonstrate the benefits of GPU computing using a model for the population dynamics of British grey seals, fitted with a particle Markov chain Monte Carlo algorithm. Speed-ups of two orders of magnitude were obtained for estimations of the log-likelihood, compared to a traditional ‘CPU-only’ implementation, allowing for an accurate method of inference to be used where this was previously too computationally expensive to be viable. GPU computing has enormous potential, but one barrier to further adoption is a steep learning curve, due to GPUs' unique hardware architecture. We provide a detailed description of hardware and software setup, and our case study provides a template for other similar applications. We also provide a detailed tutorial-style description of GPU hardware architectures, and examples of important GPU-specific programming practices.

Rapid virtual fractional flow reserve using 3D computational fluid dynamics.

Over the last ten years, virtual Fractional Flow Reserve (vFFR) has improved the utility of Fractional Flow Reserve (FFR), a globally recommended assessment to guide coronary interventions. Although the speed of vFFR computation has accelerated, techniques utilising full 3D computational fluid dynamics (CFD) solutions rather than simplified analytical solutions still require significant time to compute. This study investigated the speed, accuracy and cost of a novel 3D-CFD software method based upon a graphic processing unit (GPU) computation, compared with the existing fastest central processing unit (CPU)-based 3D-CFD technique, on 40 angiographic cases. The novel GPU simulation was significantly faster than the CPU method (median 31.7 s (Interquartile Range (IQR) 24.0-44.4s) vs. 607.5 s (490-964 s), P < 0.0001). The novel GPU technique was 99.6% (IQR 99.3-99.9) accurate relative to the CPU method. The initial cost of the GPU hardware was greater than the CPU (£4080 vs. £2876), but the median energy consumption per case was significantly less using the GPU method (8.44 (6.80-13.39) Wh vs. 2.60 (2.16-3.12) Wh, P < 0.0001). This study demonstrates that vFFR can be computed using 3D-CFD with up to 28-fold acceleration than previous techniques with no clinically significant sacrifice in accuracy.

Metaheuristics for the optimization of Terrestrial LiDAR set-up

3D point clouds have a significant impact on a wide range of applications, although their acquisition is frequently conditioned by the occlusion of the objects in the scene. To address this problem, this paper describes an approach for optimizing LiDAR (Light Detection and Ranging) surveys using metaheuristics such as local searches and genetic algorithms. The method generates a set of optimal scanning locations to densely cover the real-world environment represented through 3D synthetic models. Compared to previous research, this paper handles 3D occlusion by varying the height of the sensor. Also, previously used metrics are compressed into three functions to avoid multi-objective optimization. Regarding performance, a LiDAR scanning solution based on GPU (Graphics Processing Unit) hardware is used. Several tests were conducted to show that the combination of local searches and genetic algorithms generates a reduced set of locations capable of optimizing the scanning of buildings.

GPU-accelerated approximate kernel method for quantum machine learning.

We introduce Quantum Machine Learning (QML)-Lightning, a PyTorch package containing graphics processing unit (GPU)-accelerated approximate kernel models, which can yield trained models within seconds. QML-Lightning includes a cost-efficient GPU implementation of FCHL19, which together can provide energy and force predictions with competitive accuracy on a microsecond per atom timescale. Using modern GPU hardware, we report learning curves of energies and forces as well as timings as numerical evidence for select legacy benchmarks from atomistic simulation including QM9, MD-17, and 3BPA.

GENGA. II. GPU Planetary N-body Simulations with Non-Newtonian Forces and High Number of Particles

We present recent updates and improvements of the graphical processing unit (GPU) N-body code GENGA. Modern state-of-the-art simulations of planet formation require the use of a very high number of particles to accurately resolve planetary growth and to quantify the effect of dynamical friction. At present the practical upper limit is in the range of 30,000–60,000 fully interactive particles; possibly a little more on the latest GPU devices. While the original hybrid symplectic integration method has difficulties to scale up to these numbers, we have improved the integration method by (i) introducing higher level changeover functions and (ii) code improvements to better use the most recent GPU hardware efficiently for such large simulations. We added treatments of non-Newtonian forces such as general relativity, tidal interaction, rotational deformation, the Yarkovsky effect, and Poynting–Robertson drag, as well as a new model to treat virtual collisions of small bodies in the solar system. We added new tools to GENGA, such as semi-active test particles that feel more massive bodies but not each other, a more accurate collision handling and a real-time openGL visualization. We present example simulations, including a 1.5 billion year terrestrial planet formation simulation that initially started with 65,536 particles, a 3.5 billion year simulation without gas giants starting with 32,768 particles, the evolution of asteroid fragments in the solar system, and the planetesimal accretion of a growing Jupiter simulation. GENGA runs on modern NVIDIA and AMD GPUs.

An MPI+OpenACC-based PRM scalar advection scheme in the GRAPES model over a cluster with multiple CPUs and GPUs

A moisture advection scheme is an essential module of a numerical weather/climate model representing the horizontal transport of water vapor. The Piecewise Rational Method (PRM) scalar advection scheme in the Global/Regional Assimilation and Prediction System (GRAPES) solves the moisture flux advection equation based on PRM. Computation of the scalar advection involves boundary exchange, and computation of higher bandwidth requirements is complicated and time-consuming in GRAPES. Recently, Graphics Processing Units (GPUs) have been widely used to solve scientific and engineering computing problems owing to advancements in GPU hardware and related programming models such as CUDA/OpenCL and Open Accelerator (OpenACC). Herein, we present an accelerated PRM scalar advection scheme with Message Passing Interface (MPI) and OpenACC to fully exploit GPUs' power over a cluster with multiple Central Processing Units (CPUs) and GPUs, together with optimization of various parameters such as minimizing data transfer, memory coalescing, exposing more parallelism, and overlapping computation with data transfers. Results show that about 3.5 times speedup is obtained for the entire model running at medium resolution with double precision when comparing the scheme's elapsed time on a node with two GPUs (NVIDIA P100) and two 16-core CPUs (Intel Gold 6142). Further, results obtained from experiments of a higher resolution model with multiple GPUs show excellent scalability.

The Megopolis resampler: Memory coalesced resampling on GPUs

The resampling process employed in widely used methods such as Importance Sampling (IS), with its adaptive extension (AIS), are used to solve challenging problems requiring approximate inference; for example, non-linear, non-Gaussian state estimation problems. However, the re-sampling process can be computationally prohibitive for practical problems with real-time requirements. We consider the problem of developing highly parallelisable resampling algorithms for massively parallel hardware architectures of modern graphics processing units (GPUs) to accomplish real-time performance. We develop a new variant of the Metropolis algorithm—Megopolis—that improves performance without requiring a tuning parameter or reducing resampling quality. The Megopolis algorithm is built upon exploiting the memory access patterns of modern GPU units to reduce the number of memory transactions without the need for tuning parameters. Extensive numerical experiments on GPU hardware demonstrate that the proposed Megopolis algorithm is numerically stable and outperforms the original Metropolis algorithm and its variants—Metropolis-C1 and Metropolis-C2–in speed and quality metrics. Further, given the absence of open tools in this domain and facilitating fair comparisons in the future and supporting the signal processing community, we also open source the complete project, including a repository of source code with Megopolis and all other comparison methods.

A fast GPU Monte Carlo implementation for radiative heat transfer in graded-index media

Simulating radiative heat transfer in a graded-index (GRIN) medium is particularly challenging because of curve ray propagation trajectories. As an effective method, the Monte Carlo method is easy to implement with high precision. However, the Monte Carlo method is time consuming, and the computing time increased substantially when combined with the Runge-Kutta ray tracing technique to obtain the ray trajectories in the GRIN medium. Because the Monte Carlo method is ideally suited for parallel processing architectures and acceleration with graphics processing units (GPUs), we have developed a fast GPU Monte Carlo implementation for radiative heat transfer in GRIN media. The performance of the GPU implementation has been improved by combining the ray tracing process with the binary search and optimizing the code based on the architecture of GPUs. In particular, the utilization of the GPU hardware has been maximized, and the warp inactivity has been substantially reduced. Two- and three-dimensional GRIN medium models were evaluated to assess the accuracy and performance of the GPU implementations. Compared with the equivalent central processing unit (CPU) implementations, the GPU implementations provided in this paper show a great capability for producing physically accurate results with substantial speedups. The speedup of the GPU implementation on a single GPU for the two-dimensional case reaches 43.13 × against the equivalent CPU implementation using a single CPU core and 5.65 × against the equivalent CPU implementation using 6 CPU cores (12 threads). The speedup of the GPU implementation on a single GPU for the three-dimensional case reaches 35.61 × against the equivalent CPU implementation using a single CPU core and 2.07 × against the equivalent CPU implementation using 14 CPU cores (28 threads).

Open GL–Open CL Solar Radiation Pressure Modeling with Time-Varying Spacecraft Geometries

A method for the fast computation of spacecraft force and torque due to solar radiation pressure (SRP) is presented. A faceted model is employed that tracks which elements of a time-varying geometry are exposed to the sunlight, but sunlight reflections are not modeled. The method uses the highly parallel execution capabilities of commodity graphics processing unit (GPU) and the Open Graphics Library (OpenGL) and Open Compute Language (OpenCL) to render a spacecraft mesh on the GPU. A custom-developed OpenGL render pipeline computes the per-model facet SRP forces and torques that are summed on the GPU before the resultant spacecraft force and torque vectors are copied back to the CPU bound process. The process is validated on spherical and cubic test shapes. The evaluation accommodates spacecraft self-shadowing and is capable of accounting for arbitrary spacecraft articulation. Material properties are encoded with the model to provide realistic specular, diffuse, and absorption surface light interactions. Numerical simulations illustrate the impact of geometric fidelity and articulated surfaces. The faceted OpenGL-OpenCL method is up to an order of magnitude faster on integrated GPU hardware than high-end graphics card as the process is not demanding on the GPU and benefits from the fast memory transfer of on-chip processors.

Analysis of GPU Computation of Parabolic, Bessel, Wright and Riemann Zeta Functions

This paper deals with GPU computing of special mathematical functions that are used in Fractional Calculus. The graphics processing unit (GPU) has grown to be an integral part of nowadays’s mainstream computing structures. The special mathematical functions are an integral part of Fractional Calculus. This paper deals with a novel parallel approach for computing special mathematical functions used in Fractional Calculus. NVIDIA’s GPU hardware is used to speed up the parallel algorithm. A comparison of the sequential code, vectorized code and GPU code is performed. We have successfully reduced the computation time of special mathematical functions using the parallel computing capabilities of GPU.

NeuDATool: An open source neutron data analysis tools, supporting GPU hardware acceleration, and across-computer cluster nodes parallel

Empirical potential structure refinement is a neutron scattering data analysis algorithm and a software package. It was developed by the disordered materials group in the British spallation neutron source (ISIS) in 1980s, and aims to construct the most-probable atomic structures of disordered materials in the field of chemical physics. It has been extensively used during the past decades, and has generated reliable results. However, it implements a shared-memory architecture with open multi-processing (OpenMP). With the extensive construction of supercomputer clusters and the widespread use of graphics processing unit (GPU) acceleration technology, it is now possible to rebuild the EPSR with these techniques in the effort to improve its calculation speed. In this study, an open source framework NeuDATool is proposed. It is programmed in the object-oriented language C++, can be paralleled across nodes within a computer cluster, and supports GPU acceleration. The performance of NeuDATool has been tested with water and amorphous silica neutron scattering data. The test shows that the software can reconstruct the correct microstructure of the samples, and the calculation speed with GPU acceleration can increase by more than 400 times, compared with CPU serial algorithm at a simulation box that has about 100 thousand atoms. NeuDATool provides another choice to implement simulation in the (neutron) diffraction community, especially for experts who are familiar with C++ programming and want to define specific algorithms for their analysis.

MULTITHREADED RENDERING FOR CROSS-PLATFORM 3D VISUALIZATION BASED ON VULKAN API

Abstract. The visualization of large-sized 3D geospatial models is a graphics intensive task. With ever increasing size and complexity, more computing resources are needed to attain speed and visual quality. Exploiting the parallelism and the multi-core performance of the Graphics Processing Unit (GPU), a cross-platform 3D viewer is developed based on the Vulkan API and modern C++. The proposed prototype aims at the visualization of a textured 3D mesh of the Cultural Heritage by enabling a multi-threaded rendering pipeline. The rendering workload is distributed across many CPU threads by recording multiple command buffers in parallel and coordinating the host and the GPU rendering phases. To ensure efficient multi-threading behavior and a minimum overhead, synchronization primitives are exploiting for ordering the execution of queues and command buffers. Furthermore, push-constants are used to send uniform data to the GPU and render passes to adapt to the tile-based rendering of the mobile devices. The proposed methodology and technical solution are designed, implemented and tested for Windows, MacOS and Android on Vulkan-compatible GPU hardware by compiling the same codebase. The benchmarking on multiple hardware, architectures and platforms explores the performance improvement for the different approaches compared to one-thread and showcase the potential of the 3D viewer to handle large datasets at no expense of visual quality and geometric fidelity in the absence of high-end technological resources.

Graphics Processing Unit-Accelerated Semiempirical Born Oppenheimer Molecular Dynamics Using PyTorch.

A new open-source high-performance implementation of Born Oppenheimer molecular dynamics based on semiempirical quantum mechanics models using PyTorch called PYSEQM is presented. PYSEQM was designed to provide researchers in computational chemistry with an open-source, efficient, scalable, and stable quantum-based molecular dynamics engine. In particular, PYSEQM enables computation on modern graphics processing unit hardware and, through the use of automatic differentiation, supplies interfaces for model parameterization with machine learning techniques to perform multiobjective training and prediction. The implemented semiempirical quantum mechanical methods (MNDO, AM1, and PM3) are described. Additional algorithms include a recursive Fermi-operator expansion scheme (SP2) and extended Lagrangian Born Oppenheimer molecular dynamics allowing for rapid simulations. Finally, benchmark testing on the nanostar dendrimer and a series of polyethylene molecules provides a baseline of code efficiency, time cost, and scaling and stability of energy conservation, verifying that PYSEQM provides fast and accurate computations.

Don't forget about synchronization! Guidelines for using locks on graphics processing units

SummaryHeterogeneous devices are becoming necessary components of high performance computing infrastructures, and the graphics processing unit (GPU) plays an important role in this landscape. Given a problem, the established approach for exploiting the GPU is to design solutions that are parallel, without data dependencies. These solutions are then offloaded to the GPU's massively parallel capability. This design principle often leads to developing applications that cannot maximize GPU hardware utilization. The goal of this article is to challenge this common belief by empirically showing that allowing even simple forms of synchronization enables programmers to design solutions that admit conflicts and achieve better performance. Our experience shows that lock‐based solutions to the k‐means clustering problem, implemented using two well‐known locking strategies, outperform the well‐engineered and parallel KMCUDA on both synthetic and real datasets; with an average 8× faster runtimes across all locking algorithms on a synthetic dataset and 1.7× faster on a real world dataset across all locking algorithms (and max speedups of 71.3× and 2.75×, respectively). We validate these results using a more sophisticated clustering algorithm, namely fuzzy c‐means and summarize our findings by identifying three guidelines to help make concurrency effective when programming GPU applications.

Initial Results From the Super‐Parameterized E3SM

AbstractResults from the new Department of Energy super‐parameterized (SP) Energy Exascale Earth System Model (SP‐E3SM) are analyzed and compared to the traditionally parameterized E3SMv1 and previous studies using SP models. SP‐E3SM is unique in that it utilizes Graphics Processing Unit hardware acceleration, cloud resolving model mean‐state acceleration, and reduced radiation to dramatically increase the model throughput and allow decadal experiments at 100‐km external resolution. It also differs from other SP models by using a spectral element dynamical core on a cubed‐sphere grid and a finer vertical grid with a higher model top. Despite these differences, SP‐E3SM generally reproduces the behavior of other SP models. Tropical wave variability is improved relative to E3SM, including the emergence of a Madden‐Julian Oscillation and a realistic slowdown of Moist Kelvin Waves. However, the distribution of precipitation exhibits indicates an overly frequent occurrence of rain rates less than 1 mm day , and while the timing of diurnal rainfall shows modest improvements the signal is not as coherent as observations. A notable grid imprinting bias is identified in the precipitation field and attributed to a unique feedback associated with the interactions between the explicit cloud resolving model convection and the spectral element grid structure. Spurious zonal mean column water tendencies due to grid imprinting are quantified—while negligible for the conventionally parameterized E3SM, they become large with super‐parameterization, approaching 10% of the physical tendencies. The implication is that finding a remedy to grid imprinting will become especially important as spectral element dynamical cores begin to be combined with explicitly resolved convection.

A Low-Power Spike-Like Neural Network Design

Modern massively-parallel Graphics Processing Units (GPUs) and Machine Learning (ML) frameworks enable neural network implementations of unprecedented performance and sophistication. However, state-of-the-art GPU hardware platforms are extremely power-hungry, while microprocessors cannot achieve the performance requirements. Biologically-inspired Spiking Neural Networks (SNN) have inherent characteristics that lead to lower power consumption. We thus present a bit-serial SNN-like hardware architecture. By using counters, comparators, and an indexing scheme, the design effectively implements the sum-of-products inherent in neurons. In addition, we experimented with various strength-reduction methods to lower neural network resource usage. The proposed Spiking Hybrid Network (SHiNe), validated on an FPGA, has been found to achieve reasonable performance with a low resource utilization, with some trade-off with respect to hardware throughput and signal representation.

A High-performance Cross-platform Map Rendering Engine for Mobile Geographic Information System (GIS)

With the diversification of terminal equipment and operating systems, higher requirements are placed on the rendering performance of maps. The traditional map rendering engine relies on the corresponding operating system graphics library, and there are problems such as the inability to cross the operating system, low rendering performance, and inconsistent rendering style. With the development of hardware, graphics processing unit (GPU) appears in various platforms. How to use GPU hardware to improve map rendering performance has become a critical challenge. In order to address the above problems, this study proposes a cross-platform and high-performance map rendering (Graphics Library engine, GL engine), which uses mask drawing technology and texture dictionary text rendering technology. It can be used on different hardware platforms and different operating systems based on the OpenGL graphics library. The high-performance map rendering engine maintains a consistent map rendering style on different platforms. The results of the benchmark experiments show that the performance of GL engine is 1.75 times and 1.54 times better than the general map rendering engine in the iOS system and in the Android system, respectively, and the rendering performance for vector tiles is 11.89 times and 9.52 times better than rendering in the Mapbox in the iOS system and in the Android system, respectively.

GPU-accelerated algorithm for asteroid shape modeling

Abstract Modeling asteroid shapes from optical and radio telescope data is computationally expensive and current sequential-fit inversion algorithms are very slow, up until recently often taking days or weeks for larger models. The modeling process is comprised of many serialized independent calculations that can be parallelized with inexpensive and ubiquitous graphical processing unit (GPU) hardware. We have accelerated the SHAPE modeling algorithm (Hudson, 1994) with an Nvidia GPU and algorithm optimization while maintaining full backward compatibility, achieving speed boosts of 2.2x-19.3x over the established algorithm. The highest speed boosts achieved were for portions of the modeling process taking up a majority of processing time on the existing algorithm, moving the average speedup factor towards the upper end of the range. We use scale model asteroids to show that our method can model shapes that are both unique to the observed data and stable. High resolution complex vertex models benefit the most from the new algorithm because of its better scalability to problem size on GPU hardware. Specific algorithm changes include facet-parallel rendering, pixel-parallel delay-Doppler mapping, parallel reductions, and streamed frame operations.

LTTng‐HSA: Bringing LTTng tracing to HSA‐based GPU runtimes

SummaryIn this paper, we propose LTTng‐HSA, a set of tools that allow for the collection of a single, unified software graphics processing unit (GPU) trace in ROCr, a Heterogeneous System Architecture (HSA)‐based API and runtime. HSA is a cross‐vendor standard facilitating the programming of heterogeneous systems that include CPUs, GPUs, and possibly other types of devices. Our open‐source solution is generic and easily adaptable to diverse GPU runtimes or APIs. Using Linux Trace Toolkit Next Generation (LTTng), a highly efficient Linux tracer, it collects different types of events over multiple executions of an application and aims to gather all the data into a single trace, offering an easy way to generate GPU‐related traces. Our instrumentation is achieved simply by preloading libraries, without recompiling the target application, which makes it flexible and easy to use. The resulting traces, which include API call stack information, GPU hardware metrics, command queue, and compute kernel profiling, are well adapted for postprocessing and further analysis. Our solution also includes tracing data from the Linux kernel and proposes views for Trace Compass, an interactive trace visualizer.