NVIDIA Graphics Processing Units Research Articles

Efficient implementation of low-order-precision smoothed particle hydrodynamics

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.

IDEFIX: A versatile performance-portable Godunov code for astrophysical flows

Context. The exascale super-computers becoming available rely on hybrid energy-efficient architectures that involve an accelerator such as a graphics processing unit (GPU). Leveraging the computational power of these machines often means a significant rewrite of the numerical tools each time a new architecture becomes available. Aims. We present IDEFIX, a new code for astrophysical flows that relies on the KOKKOS meta-programming library to guarantee performance portability on a wide variety of architectures while keeping the code as simple as possible to the user. Methods. IDEFIX is based on a Godunov finite-volume method that solves the nonrelativistic hydrodynamical (HD) and magnetohy-drodynamical (MHD) equations on various grid geometries. IDEFIX includes a large choice of solvers and several additional modules (constrained transport, orbital advection, nonideal MHD), allowing users to address complex astrophysical problems. Results. IDEFIX has been successfully tested on Intel and AMD CPUs (up to 131 072 CPU cores on Irene-Rome at TGCC) as well as NVidia and AMD GPUs (up to 1024 GPUs on Adastra at CINES). IDEFIX achieves more than 108 cell s−1 in MHD on a single NVidia V100 GPU and 3 × 1011 cell s−1 on 256 Adastra nodes (1024 GPUs) with 95% parallelization efficiency (compared to single node). For the same problem, IDEFIX is up to six times more energy efficient on GPUs compared to Intel Cascade Lake CPUs. Conclusions. IDEFIX is now a mature exascale-ready open-source code that can be used on a large variety of astrophysical and fluid dynamics applications.

A Multi-GPU Aggregation-Based AMG Preconditioner for Iterative Linear Solvers

We present and release in open source format a sparse linear solver which efficiently exploits heterogeneous parallel computers. The solver can be easily integrated into scientific applications that need to solve large and sparse linear systems on modern parallel computers made of hybrid nodes hosting Nvidia Graphics Processing Unit (GPU) accelerators. The work extends previous efforts of some of the authors in the exploitation of a single GPU accelerator and proposes an implementation, based on the hybrid MPI-CUDA software environment, of a Krylov-type linear solver relying on an efficient Algebraic MultiGrid (AMG) preconditioner already available in the <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">BootCMatchG</i> library. Our design for the hybrid implementation has been driven by the best practices for minimizing data communication overhead when multiple GPUs are employed, yet preserving the efficiency of the GPU kernels. Strong and weak scalability results of the new version of the library on well-known benchmark test cases are discussed. Comparisons with the Nvidia AmgX solution show a speedup, in the solve phase, up to 2.0x.

Program Analysis and Machine Learning–based Approach to Predict Power Consumption of CUDA Kernel

The General Purpose Graphics Processing Unit has secured a prominent position in the High-Performance Computing world due to its performance gain and programmability. Understanding the relationship between Graphics Processing Unit (GPU) power consumption and program features can aid developers in building energy-efficient sustainable applications. In this work, we propose a static analysis-based power model built using machine learning techniques. We have investigated six machine learning models across three NVIDIA GPU architectures: Kepler, Maxwell, and Volta with Random Forest, Extra Trees, Gradient Boosting, CatBoost, and XGBoost reporting favorable results. We observed that the XGBoost technique-based prediction model is the most efficient technique with an R 2 value of 0.9646 on Volta Architecture. The dataset used for these techniques includes kernels from different benchmarks suits, sizes, nature (e.g., compute-bound, memory-bound), and complexity (e.g., control divergence, memory access patterns). Experimental results suggest that the proposed solution can help developers precisely predict GPU applications power consumption using program analysis across GPU architectures. Developers can use this approach to refactor their code to build energy-efficient GPU applications.

Security Issues of GPUs and FPGAs for AI-powered near &amp; far Edge Services

Graphics Processing Units (GPUs) and Field Programmable Gate Arrays (FPGAs) are widely applied to cloud and embedded applications in which such devices are applied to near and far edge computing operations. This pool of available devices has a wide range of power/size specifications to support servers ranging from big data centres to small cloudlets, or even down to embedded systems and IoT boards. Overall, the most prominent devices and vendors in the market today are the following Xilinx for FPGA-based accelerators, Nvidia and AMD for GPUs, Intel for FPGA- /GPU-based accelerators. Decreasing the latency and increasing the throughput of Artificial Intelligence Functions (AIF), either for network automation or user applications, requires some sort of parallelization inside such purpose-built hardware acceleration. The AI@EDGE project is developing a Connect-Compute Platform (CCP) in which hardware accelerators (1 Nvidia GPU Tesla V100 (near edge device) and 1 Jetson AGX and 1 Jetson Nano (far edge devices), as well as 2 Xilinx FPGAs Alveo U280+U200 (near edge devices) and 1 Versal VCK190 and 2 Zynq ZCU104) are placed inside a server node and execute edge computing scenarios involving multiple nodes of diverse compute capabilities each, to test various integration approaches, to study orchestration techniques measure AIF deployment efficiency, all while developing certain FPGA/GPU code to accelerate representative AIFs of AI@EDGE. In this paper we compare the power/size/performance specifications of all accelerators and highlight the security issues associated with the cloud and embedded accelerators. This study presents the security issues announced by the vendors with the results of our tests and proposes tests and security functions (policies and objectives) which will be applied to the CCP to increase the security level of CCP. It also considers security issues related with the hardware set-up (accelerators inside server nodes) from the network point of view.

The Need for Speed and Energy Efficiency in Genome Analysis

The Need for Speed and Energy Efficiency in Genome Analysis

RTGPU: Real-Time GPU Scheduling of Hard Deadline Parallel Tasks With Fine-Grain Utilization

Many emerging cyber-physical systems, such as autonomous vehicles and robots, rely heavily on artificial intelligence and machine learning algorithms to perform important system operations. Since these highly parallel applications are computationally intensive, they need to be accelerated by graphics processing units (GPUs) to meet stringent timing constraints. However, despite the wide adoption of GPUs, efficiently scheduling multiple GPU applications while providing rigorous real-time guarantees remains a challenge. Each GPU application has multiple CPU execution and memory copy segments, with GPU kernels running on different hardware resources. Because of the complicated interactions between heterogeneous segments of parallel tasks, high schedulability is hard to achieve with conventional approaches. This paper proposes RTGPU, which combines fine-grain GPU partitioning on the system side with a novel scheduling algorithm on the theory side. Through system and theory co-design, RTGPU achieves superior system throughput and real-time schedulability. In this paper, we start by building a model for the CPU and memory copy segments. Leveraging persistent threads, we then implement fine-grained GPU partitioning with improved performance through interleaved execution. To reap the benefits of fine-grained GPU partitioning and schedule multiple parallel GPU applications, we propose a novel real-time scheduling algorithm based on federated scheduling and grid search with uniprocessor fixed-priority scheduling. Our approach provides real-time guarantees to meet hard deadlines, and achieves over 11% improvement in system throughput and up to 57% schedulability improvement compared with previous work. We validate and evaluate RTGPU on NVIDIA GTX1080Ti GPU systems. Our system side techniques can be applied on mainstream NVIDIA GPUs, and the proposed scheduling theory can be used in general heterogeneous computing platforms which have a similar task execution pattern.

Parallel implementations of the fast nearfield method for continuous-wave and transient pressure calculations

FOCUS, the “Fast Object-oriented C + + Simulator” (https://www.egr.msu.edu/∼fultras-web/), enables rapid calculations of continuous-wave and transient pressure fields generated by single transducers and phased arrays. FOCUS achieves small errors in relatively short computation times through memory-efficient calculations with the fast nearfield method, which converges exponentially. The fast nearfield method is also an embarrassingly parallel algorithm that supports further reductions in the computation time through hardware acceleration. Previous efforts to accelerate calculations with the fast nearfield method successfully implemented multithreading within multiple central processing unit (CPU) cores using OpenMP, and this capability is presently included with FOCUS. Prior success with OpenMP motivates ongoing efforts to further extend the functionality of FOCUS by interfacing the fast nearfield method to an NVIDIA graphics processing unit (GPU). To facilitate FOCUS calculations on a GPU, calculations with the fast nearfield method are implemented in CUDA for time-harmonic and transient pressure computations with each supported transducer shape. This combination achieves a significant reduction in the computation time compared to single-threaded execution. When evaluated on an NVIDIA 1670 GPU, the computation time is also approximately halved relative to the multithreaded OpenMP implementation. These results encourage further efforts to parallelize existing and future FOCUS routines.

Dynamic Precision Approach for Accelerating Large-Scale Eigenvalue Solvers in Electronic Structure Calculations on Graphics Processing Units.

Single precision (SP) arithmetic can be greatly accelerated as compared to double precision (DP) arithmetic on graphics processing units (GPUs). However, the use of SP in the whole process of electronic structure calculations is inappropriate for the required accuracy. We propose a 3-fold dynamic precision approach for accelerated calculations but still with the accuracy of DP. Here, SP, DP, and mixed precision are dynamically switched during an iterative diagonalization process. We applied this approach to the locally optimal block preconditioned conjugate gradient method to accelerate a large-scale eigenvalue solver for the Kohn-Sham equation. We determined a proper threshold for switching each precision scheme by examining the convergence pattern on the eigenvalue solver only with the kinetic energy operator of the Kohn-Sham Hamiltonian. As a result, we achieved up to 8.53× and 6.60× speedups for band structure and self-consistent field calculations, respectively, for test systems under various boundary conditions on NVIDIA GPUs.

A GPU-accelerated sharp interface immersed boundary method for versatile geometries

We present a Graphical Processing Unit (GPU) accelerated sharp interface Immersed Boundary (IB) method that can be applied to versatile geometries on a staggered Cartesian grid. The current IB solver predicts the flow around arbitrary surfaces of both finite and negligible thicknesses with improved accuracy near the sharp edges. The proposed methodology first uses a modified signed distance algorithm to track the complex geometries on the structured Cartesian grid accurately. Afterwards, we impose the boundary conditions by reconstructing the flow variables on the near boundary nodes in both fluid and solid domains. We have also shown a reduction of Spurious Force Oscillations (SFOs) near the moving boundaries with reduced divergence error. The accuracy of the present solver is demonstrated at low Reynolds numbers over different stationary and moving rigid geometries associated with sharp edges pertaining to several engineering applications. We have discussed the steps for GPU optimisation of the present solver. Our implementation ensures the concurrent execution of threads for the field extension-based velocity and pressure reconstruction algorithm on a GPU. More than 100x speedup is obtained on NVIDIA V100 GPU for the three-dimensional oscillating sphere simulation. It is observed that the speedup is higher for larger mesh sizes. The computational performance over both the multi-core Control Processing Units (CPUs) and NVIDIA GPUs (V100 and A100) using OpenACC is also provided for the insect flow simulation.

Quantum Mechanics/Molecular Mechanics Simulations on NVIDIA and AMD Graphics Processing Units.

We have ported and optimized the graphics processing unit (GPU)-accelerated QUICK and AMBER-based ab initio quantum mechanics/molecular mechanics (QM/MM) implementation on AMD GPUs. This encompasses the entire Fock matrix build and force calculation in QUICK including one-electron integrals, two-electron repulsion integrals, exchange-correlation quadrature, and linear algebra operations. General performance improvements to the QUICK GPU code are also presented. Benchmarks carried out on NVIDIA V100 and AMD MI100 cards display similar performance on both hardware for standalone HF/DFT calculations with QUICK and QM/MM molecular dynamics simulations with QUICK/AMBER. Furthermore, with respect to the QUICK/AMBER release version 21, significant speedups are observed for QM/MM molecular dynamics simulations. This significantly increases the range of scientific problems that can be addressed with open-source QM/MM software on state-of-the-art computer hardware.

A Scheme of Full Kinetic Particle-in-cell Algorithms for GPU Acceleration Using CUDA Fortran Programming

The emerging computable devices, graphical processing units (GPUs), are gradually applied in the simulations of space physics. In this paper, we introduce an approach that implements full kinetic particle-in-cell simulations on GPU architecture devices using the CUDA Fortran language programming for the first time. Using the latest high-performance computing NVIDIA GPUs, this program, which follows the second-order leap-frog iteration method, can speed up the computing process by a factor of 150–285 on a single device compared with the time cost of running with a single core of an Intel Xeon Gold processor. Our scheme improves fast accessibility to the simulation results and provides valuable assistance in studying the physical process.

Portable C++ Code that can Look and Feel Like Fortran Code with Yet Another Kernel Launcher (YAKL)

This paper introduces the Yet Another Kernel Launcher (YAKL) C++ portability library, which strives to enable user-level code with the look and feel of Fortran code. The intended audience includes both C++ developers and Fortran developers unfamiliar with C++. The C++ portability approach is briefly explained, YAKL’s main features are described, and code examples are given that demonstrate YAKL’s usage. YAKL fills a niche capability important particularly to scientific applications seeking to port Fortran code quickly to a portable C++ library. YAKL places heavy emphasis on simplicity, readability, and productivity with performance mainly emphasizing Graphics Processing Units (GPUs). Central to YAKL’s ability to allow Fortran-like user-level code are three features: (1) a multi-dimensional Array class that allows Fortran behavior; (2) a limited library of Fortran intrinsic functions; and (3) an efficient pool allocator that transparently enables cheap frequent allocations and deallocations of YAKL Arrays. While YAKL allows Fortran-style code, it also allows Arrays that exhibit C-like behavior as well, including row-major index ordering and lower bounds of “0”. YAKL currently supports CPUs, CPU threading, and Nvidia, AMD, and Intel GPUs.

Coupling of an SPH-based solver with a multiphysics library

A two-way coupling between the Smoothed Particle Hydrodynamics-based (SPH) code with a multiphysics library to solve complex fluid-solid interaction problems is proposed. This work provides full access to the package for the use of this coupling by releasing the source code, completed with guidelines for its compilation and utilization, and self-contained template setups for practical uses of the novel implemented features, is provided here. The presented coupling expands the applicability of two different solvers allowing to simulate fluids, multibody systems, collisions with frictional contacts using either non-smooth contact (NSC) or smooth contact (SMC) methods, all integrated under the same framework. The fluid solver is the open-source code DualSPHysics, highly optimised for simulating free-surface phenomena and structure interactions, uniquely positioned as a general-purpose Computational Fluid Dynamics (CFD) software with a GPU-accelerated solver. Mechanical systems that comprise collision detection and/or multibody dynamics are solved by the multiphysics library Project Chrono, which uses a Discrete Element Method (DEM). Therefore, this SPH-DEM coupling approach can manage interactions between fluid and complex multibody systems with relative constraints, springs, or mechanical joints. Program summaryProgram title: DualSPHysics-ChronoCPC Library link to program files:https://doi.org/10.17632/g2cc37dw4f.1Licensing provisions: DualSPHysics and DSPHChronoLib under GNU Lesser General Public License (LGPL); Project Chrono under BSD-3-Clause License.Programming language: C++ and CUDANature of problem: The simulation of turbulent free-surface flows in interaction with complex fixed or floating structures is essential to address typical marine and coastal engineering problems. The Smoothed Particle Hydrodynamics (SPH) method is particularly suitable for solving this type of nonlinear problems. However, this type of application usually requires mechanical restrictions between the different structural elements (spherical joints, hinges, or springs), as well as the correct simulation of collisions between solid objects. In these cases, it is necessary to combine the SPH method with other numerical methods that allow performing these multiphysics simulations.Solution method: DualSPHysics-Chrono is a two-way coupling between an SPH solver and a multiphysics library that combines fluid simulation using a Lagrangian approximation and interactions between solids using Discrete Element Method (DEM). DualSPHysics solver is a GPU-optimized implementation of the SPH method that allows efficient simulation of fluid-structure interaction problems. Whereas Project Chrono is a DEM implementation for simulating multibody dynamics that includes collision detection and numerous mechanical constraints to solve complex mechanisms. The coupling of DualSPHysics and Project Chrono combines the capabilities of both models under a free software framework.Additional comments including restrictions and unusual features: The SPH solver includes a version implemented with CUDA (Compute Unified Device Architecture) to exploit the parallelism of NVIDIA graphics processing units (GPUs).

Computing large 2D convolutions on GPU efficiently with the im2tensor algorithm

Attaining the best possible throughput when computing convolutions is a challenge for signal and image processing systems, be they HPC (High-Performance Computing) machines or embedded real-time targets. This importance is highlighted by the numerous methods and implementations available, often optimized for particular settings: small batched kernels or very large kernels, for example. In the meantime, GPUs (Graphics Processing Units) have become a first-class architecture for real-time and embedded processing. The power offered by those chips stems from their parallel nature, and this advantage has been exploited for convolutions in several libraries. Even more recently, the introduction of tensor cores on NVIDIA GPUs has opened up new limits in terms of attainable FLOPS (Floating-Point Operations per Second). For reaching that performance, GPU applications must use GEMMs (GEneral Matrix Multiplications), that tensor cores accelerate. We then developed an efficient GEMM-based 2D convolution algorithm in a general setting. On relatively large kernels (30–50-pixel wide), im2tensor is, to the best of our knowledge, the fastest method for computing 2D convolutions. We provide detailed performance analysis for different scenarios: small (1024\(\times\)1024) and large (4096\(\times\)4096) images, with convolutions kernels of sizes ranging 1 to 60-pixel wide, on two GPU cards: Jetson AGX Xavier (embedded) and Titan V (server-class). Moreover, the accuracy of im2tensor surpasses non-GEMM based methods, thanks to the larger-precision registers used by tensor cores for intermediate representations.

Cutting-Edge AI Technologies Meet Precision Medicine to Improve Cancer Care.

To provide precision medicine for better cancer care, researchers must work on clinical patient data, such as electronic medical records, physiological measurements, biochemistry, computerized tomography scans, digital pathology, and the genetic landscape of cancer tissue. To interpret big biodata in cancer genomics, an operational flow based on artificial intelligence (AI) models and medical management platforms with high-performance computing must be set up for precision cancer genomics in clinical practice. To work in the fast-evolving fields of patient care, clinical diagnostics, and therapeutic services, clinicians must understand the fundamentals of the AI tool approach. Therefore, the present article covers the following four themes: (i) computational prediction of pathogenic variants of cancer susceptibility genes; (ii) AI model for mutational analysis; (iii) single-cell genomics and computational biology; (iv) text mining for identifying gene targets in cancer; and (v) the NVIDIA graphics processing units, DRAGEN field programmable gate arrays systems and AI medical cloud platforms in clinical next-generation sequencing laboratories. Based on AI medical platforms and visualization, large amounts of clinical biodata can be rapidly copied and understood using an AI pipeline. The use of innovative AI technologies can deliver more accurate and rapid cancer therapy targets.

A Survey of GPU Multitasking Methods Supported by Hardware Architecture

The ability to support multitasking becomes more and more important in the development of graphic processing unit (GPU). GPU multitasking methods are classified into three types: temporal multitasking, spatial multitasking, and simultaneous multitasking (SMK). This article first introduces the features of some commercial GPU architectures to support multitasking and the common metrics used for evaluating the performance of GPU multitasking methods, and then reviews the GPU multitasking methods supported by hardware architecture (i.e., hardware GPU multitasking methods). The main problems of each type of hardware GPU multitasking methods to be solved are illustrated. Meanwhile, the key idea of each previous hardware GPU multitasking method is introduced. In addition, the characteristics of hardware GPU multitasking methods belonging to the same type are compared. This article also gives some valuable suggestions for the future research. An enhanced GPU simulator is needed to bridge the gap between academia and industry. In addition, it is promising to expand the research space with machine learning technologies, advanced GPU architectural innovations, 3D stacked memory, etc. Because most previous GPU multitasking methods are based on NVIDIA GPUs, this article focuses on NVIDIA GPU architecture, and uses NVIDIA's terminology. To our knowledge, this article is the first survey about hardware GPU multitasking methods. We believe that our survey can help the readers gain insights into the research field of hardware GPU multitasking methods.

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.

BitCracker: BitLocker meets GPUs

BitLocker is a full-disk encryption feature available in recent Windows versions. It is designed to protect data by providing encryption for entire volumes and it makes use of a number of different authentication methods. In this paper we present a solution, named BitCracker, to attempt the decryption, by means of a dictionary attack, of storage units encrypted by BitLocker with a user supplied password or the recovery password. To that purpose, we resort to Graphics Processing Units (GPU) that are, by now, widely used as general-purpose coprocessors in high performance computing applications. BitLocker decryption process requires the computation of a very large number of SHA-256 hashes and also AES, so we propose a very fast solution, highly tuned for Nvidia GPU, for both of them. We analyze the performance of our CUDA implementation on several Nvidia GPUs and we carry out a comparison of our SHA-256 hash with the Hashcat password cracker tool. Finally, we present our OpenCL version, recently released as a plugin of the John The Ripper tool.

An Automated Tool for Analysis and Tuning of GPU-Accelerated Code in HPC Applications

The US Department of Energy’s fastest supercomputers and forthcoming exascale systems employ Graphics Processing Units (GPUs) to increase the computational performance of compute nodes. However, the complexity of GPU architectures makes tailoring sophisticated applications to achieve high performance on GPU-accelerated systems a major challenge. At best, prior performance tools for GPU code only provide coarse-grained tuning advice at the kernel level. In this article, we describe GPA, a performance advisor that suggests potential code optimizations at a hierarchy of levels, including individual lines, loops, and functions. To gather the fine-grained measurements needed to produce such insights, GPA uses instruction sampling and binary instrumentation to monitor execution of GPU code. At the time of this writing, GPU instruction sampling is only available on NVIDIA GPUs. To understand performance losses, GPA uses data flow analysis to approximately attribute measured instruction stalls back to their causes. GPA then analyzes patterns of stalls using information about a program’s structure and the GPU architecture to identify optimization strategies that address inefficiencies observed. GPA then employs detailed performance models to estimate the potential speedup that each optimization might provide. Experiments with benchmarks and applications show that GPA provides useful advice for tuning GPU code. We applied GPA to analyze and tune a collection of codes on NVIDIA V100 and A100 GPUs. GPA suggested optimizations that it estimates will accelerate performance across the set of codes by a geometric mean of 1.21×. Applying these optimizations suggested by GPA accelerated these codes by a geometric mean of 1.19×.