CPU Version Research Articles

DualSPHysics+: An enhanced DualSPHysics with improvements in accuracy, energy conservation and resolution of the continuity equation

This paper presents an enhanced version of the well-known SPH (Smoothed Particle Hydrodynamics) open-source code DualSPHysics for the simulation of free-surface fluid flows, leading to the DualSPHysics+ code. The enhancements are made through incorporation of several schemes with respect to stability, accuracy and energy/volume conservation issues in simulating incompressible free-surface fluid flows within the weakly compressible SPH formalism. The Optimized Particle Shifting (OPS) scheme is implemented to improve the accuracy of particle shifting vectors in the free-surface region. To mitigate energy dissipation and maintain consistency, the artificial viscosity in δ-SPH is substituted with a Riemann stabilization term, leading to the δR-SPH. The Velocity divergence Error Mitigating (VEM) and Volume Conservation Shifting (VCS) schemes are adopted in DualSPHysics+ to mitigate the velocity divergence error and improve the volume conservation, and hence to enhance the resolution of the continuity equation. To further reduce both the instantaneous and accumulated errors in velocity divergence, a Hyperbolic/Parabolic Divergence Cleaning (HPDC) scheme is incorporated in addition to the VEM scheme. The implementations of the introduced schemes on both CPU and GPU-based versions of the DualSPHysics+ code along with details on the compilation, running and computational performance are presented. Validations in terms of accuracy, energy conservation and convergence of DualSPHysics+ are shown via several relevant benchmarks. It is demonstrated that a better velocity divergence error cleaning in both instantaneous and accumulated errors can be achieved by the combination of VEM and HPDC. Meanwhile, the excessive energy dissipation by the artificial viscosity is shown to be suppressed by adopting the Riemann stabilization term. Enhanced resolution of the continuity equation along with improved energy conservation of DualSPHysics+ advance the SPH-based simulation of incompressible free-surface fluid flows.

Robust and effective ab initio molecular dynamics simulations on the GPU cloud infrastructure using the Schrödinger Materials Science Suite

Ab initio Born-Oppenheimer molecular dynamics (AIMD) is a valuable method for simulating physico-chemical processes of complex systems, including reactive systems, and for training machine learning models and force fields. Speed and stability issues on traditional hardware preclude routine AIMD simulations for larger systems and longer timescales. We postulate that any practically useful AIMD simulation must generate a trajectory of a minimum 1000 MD steps a day on a moderate cloud resource. In this work, we implement a computing workflow that enables routine calculations at this throughput and demonstrate results for several non-trivial atomistic dynamical systems. In particular, we have employed the GPU implementation of the Quantum ESPRESSO code which we will show increases AIMD productivity compared to the CPU version. In order to take advantage of transient servers (which are more cost and energy effective compared to the stable servers), we have implemented automatic restart/continuation of the AIMD runs within the Schrödinger Materials Science Suite. Finally, to reduce simulation size and thus reduce compute time when modeling surfaces, we have implemented a wall potential constraint. Our benchmarks using several reactive systems (lithium anode surface/solvent interface, hydrogen diffusion in an iron grain boundary) show a significant speed up when running on a GPU-enabled transient server using our updated implementation.

Matrix‐based implementation and GPU acceleration of hybrid FEM and peridynamic model for hydro‐mechanical coupled problems

AbstractThe hybrid finite element‐peridynamic (FEM‐PD) models have been evidenced for their exceptional ability to address hydro‐mechanical coupled problems involving cracks. Nevertheless, the non‐local characteristics of the PD equations and the required inversion operations when solving fluid equations result in prohibitively high computational costs. In this paper, a fast explicit solution scheme for FEM‐PD models based on matrix operation is introduced, where the graphics processing units (GPUs) are used to accelerate the computation. An in‐house software is developed in MATLAB in both CPU and GPU versions. We first solve a problem related to pore pressure distribution in a single crack, demonstrating the accuracy of the proposed method by a comparison of FEM‐PD solutions with those of PD‐only models and analytical solutions. Subsequently, several examples are solved, including a one‐dimensional dynamic consolidation problem and the fluid‐driven hydraulic fracture propagation problems in both 2D and 3D cases, to comprehensively validate the effectiveness of the proposed methods in simulating deformation and fracture in saturated porous media under the influence of hydro‐mechanical coupling. In the presented numerical results, some typical strong dynamic phenomena, such as stepwise crack advancement, crack branching, and pressure oscillations, are observed. In addition, we compare the wall times of all the cases executed on both the GPU and CPU, highlighting the substantial acceleration performance of the GPU, particularly when tackling problems with a significant computational workload.

Exact Analytical Algorithm for the Solvent-Accessible Surface Area and Derivatives in Implicit Solvent Molecular Simulations on GPUs.

In this paper, we present differentiable solvent-accessible surface area (dSASA), an exact geometric method to calculate SASA analytically along with atomic derivatives on GPUs. The atoms in a molecule are first assigned to tetrahedra in groups of four atoms by Delaunay tetrahedralization adapted for efficient GPU implementation, and the SASA values for atoms and molecules are calculated based on the tetrahedralization information and inclusion-exclusion method. The SASA values from the numerical icosahedral-based method can be reproduced with >98% accuracy for both proteins and RNAs. Having been implemented on GPUs and incorporated into AMBER, we can apply dSASA to implicit solvent molecular dynamics simulations with the inclusion of this nonpolar term. The current GPU version of GB/SA simulations has been accelerated up to nearly 20-fold compared to the CPU version, outperforming LCPO, a commonly used, fast algorithm for calculating SASA, as the system size increases. While we focus on the accuracy of the SASA calculations for proteins and nucleic acids, we also demonstrate stable GB/SA MD mini-protein simulations.

CAREx: context-aware read extension of paired-end sequencing data

BackgroundCommonly used next generation sequencing machines typically produce large amounts of short reads of a few hundred base-pairs in length. However, many downstream applications would generally benefit from longer reads.ResultsWe present CAREx—an algorithm for the generation of pseudo-long reads from paired-end short-read Illumina data based on the concept of repeatedly computing multiple-sequence-alignments to extend a read until its partner is found. Our performance evaluation on both simulated data and real data shows that CAREx is able to connect significantly more read pairs (up to 99%\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$99\\%$$\\end{document} for simulated data) and to produce more error-free pseudo-long reads than previous approaches. When used prior to assembly it can achieve superior de novo assembly results. Furthermore, the GPU-accelerated version of CAREx exhibits the fastest execution times among all tested tools.ConclusionCAREx is a new MSA-based algorithm and software for producing pseudo-long reads from paired-end short read data. It outperforms other state-of-the-art programs in terms of (i) percentage of connected read pairs, (ii) reduction of error rates of filled gaps, (iii) runtime, and (iv) downstream analysis using de novo assembly. CAREx is open-source software written in C++ (CPU version) and in CUDA/C++ (GPU version). It is licensed under GPLv3 and can be downloaded at (https://github.com/fkallen/CAREx).

CPU and GPU oriented optimizations for LiDAR data processing

Digital Terrain Models (DTM) can be accurately obtained from clouds of LiDAR points but the corresponding cloud processing time can be prohibitive. This paper describes several optimization techniques that have been applied to the Overlap Window Method (OWM) that is a key component in DTM applications. OWM was originally implemented in R which translates into serious limitations in terms of the size of the LiDAR point cloud that can be processed. We have ported the code to C++, significantly optimized the data structure to minimize memory accesses, and developed parallel implementations for CPU and GPU commodity devices using oneAPI libraries and tools. This results in CPU and GPU versions that are up to 19x and 83x faster, respectively, than an OpenMP baseline that uses eight CPU cores. Most importantly, the proposed optimizations for CPU and GPU can be paramount to get the most out of other LiDAR-based algorithms in which the careful selection of the right data structure, parallelization strategies and memory access reduction techniques will certainly result in significant performance improvements.

A GPU-accelerated linear system solution for the Galerkin finite element method applied to neutron diffusion equation

The In-Core Fuel Management or Loading Pattern Optimization (LPO) is the problem of finding an optimal configuration of nuclear fuel assemblies in a reactor core. Over the years Optimization Metaheuristics based on populations have been used successfully for solving the LPO. However, for such methods, thousands of evaluations of candidate loading patterns with reactor physics codes are required. In addition, more precise calculations are also desirable, which in principle may conflict with faster evaluations. For coping with both criteria simultaneously, a code based on the Galerkin Finite Element Method (GFEM) for solving the neutron diffusion equation designed for Graphics Processing Unit (GPU) is proposed in the present work. The resulting program GFEM_GPU has been implemented in Python language with a library for GPU-accelerated computing. A comparison between GFEM_GPU and the CPU version of GFEM regarding three nuclear reactor benchmarks (IAEA-2D, BIBLIS-2D, and ZION-2D) is provided and the accuracy of the results is compared to the Nodal Expansion Method (NEM). The implementation of the GFEM solve-phase with GFEM_GPU provides iterative solutions up to 50% faster than the CPU version depending on the discretization of the problem. This approach presents several advantages, such as a high-level implementation, faster prototyping, and application to LPO problems, while keeping the high accuracy provided by fine mesh methods.

High level GPU-accelerated 2D PIV framework in Python

The Particle Image Velocimetry (PIV) method is widely used for optical measurment of flow velocity fields. This paper demonstrates the possibilities of using high-level libraries for GPU-accelerated PIV data analysis in Python. The Torch PIV library for the analysis of 2D PIV experiments based on the deep learning framework PyTorch with CUDA support was developed. The library implements a multi pass cross-correlation FFT PIV algorithm with an interrogation window shift. The chosen implementation does not require compilation from the user, has a compact codebase, is able to run both on the CPU and the GPU depending on the user choice, and also it is as flexible as the Python module. In this work, the performance of the CPU version of the developed method was compared with existing open source implementations. It is shown that the main functions of the developed module can be executed on the GPU at the speed of CUDA implementations. The developed library is tested on synthetic images and experimental data. Program SummaryProgram title: TorchPIV.CPC Library link to program files: https://doi.org/10.17632/yw43vjc36h.1.Developer's repository link: https://github.com/NikNazarov/TorchPIV.Licensing provisions: MIT license.Programming language: Python.Nature of problem: PIV experiments often require analyzing a large number of images in order to determine the statistical characteristics of the flow. GPUs are actively used in this field to speed up the data analysis process. Open-source software solutions to this problem usually require build and are difficult to integrate into the analysis pipelines.Solution method: The main feature of the developed module is its flexibility and simple distribution. The module is cross-platform, and installation does not require compilation from the user. The developed library can be imported as an ordinary Python module, at the same time it allows to get a significant performance gain when analyzing PIV experiments by using NVIDIA GPUs. Implementation in pure Python allows the module to serve as a backend for more complex experimental data processing systems. The core library of this method is one of the most reliable and widespread in the field of machine learning.

Analytic ray tracer on GPU for central receiver systems

An accurate ray tracer is essential to calculate the efficiency of central receiver systems. Furthermore, its runtime has a direct influence on the applicable optimization method for finding optimal layouts of heliostat fields. Developing a ray tracer that achieves both objectives is the main focus of this study. There exist several different ray tracing techniques, starting from the classical Monte Carlo method to analytical convolution methods. Within this work, we introduce a new analytical ray tracer with high accuracy at low runtime. This is achieved by integrating over the bivariate Gaussian distributions used in our convolution ray tracer. In such a way the raytracer is capable of including the effect of multiple solar rays without the need of simulating each ray. Besides the overall efficiency, the new ray tracer can also compute accurate flux maps with thousand times fewer rays than the Monte Carlo method. To further improve the overall model accuracy, a new equation to convolute the sun, slope and tracking error is derived. We show that it perfectly matches the results of a separate accounting for these errors. The newly integrated convolution ray tracer is developed on the same platform as a bidirectional Monte Carlo ray tracer and a convolution method. Besides a large cross-validation of the results, this allows for a reasonable direct run time comparison. With extensive case studies, the quality of the solution, the run time, and various other aspects are investigated. Furthermore, all ray tracers are also implemented on the GPU improving the run time compared to the CPU version by a factor of 50. We show that the integrated convolution ray tracer running on the GPU achieves an accuracy of 99.95% for an annual simulation in 0.7 s for the PS10 and in 1.8 s for the Gemasolar.

Accelerating Machine Learning Inference with GPUs in ProtoDUNE Data Processing

We study the performance of a cloud-based GPU-accelerated inference server to speed up event reconstruction in neutrino data batch jobs. Using detector data from the ProtoDUNE experiment and employing the standard DUNE grid job submission tools, we attempt to reprocess the data by running several thousand concurrent grid jobs, a rate we expect to be typical of current and future neutrino physics experiments. We process most of the dataset with the GPU version of our processing algorithm and the remainder with the CPU version for timing comparisons. We find that a 100-GPU cloud-based server is able to easily meet the processing demand, and that using the GPU version of the event processing algorithm is two times faster than processing these data with the CPU version when comparing to the newest CPUs in our sample. The amount of data transferred to the inference server during the GPU runs can overwhelm even the highest-bandwidth network switches, however, unless care is taken to observe network facility limits or otherwise distribute the jobs to multiple sites. We discuss the lessons learned from this processing campaign and several avenues for future improvements.

Parallel Immersed Boundary Method for Two-Phase Flows on DCU Clusters

The immersed boundary method (IBM) is widely used in simulating multiphase flows. DCU (Deep Computing Unit) acceleration device is a kind of GPU-like device, which is developed by GPU technology authorised by AMD. To achieve an efficient numerical simulation of two-phase flows, we develop a parallel DCU-based immersed boundary method using the MPI+HIP programming model. To solve the slow convergence problem caused by domain partitioning in multigrid methods, a coarse grid aggregation (CGA) technique is effectively employed. We adopt a nonblocking communication approach with HIP streams to overlap computation and communication. To validate the proposed method running on DCU clusters, we conducted two numerical experiments of droplet deformation in shear flow and the rising bubble. Performance tests show that a speedup of 181 times more than the CPU version can be achieved with 32 DCUs in a 1024 × 512 × 512 mesh grid.

Mining timed sequential patterns: The Minits-AllOcc technique

<p>Sequential pattern mining is one of the data mining tasks used to find the subsequences in a sequence dataset that appear together in order based on time. Sequence data can be collected from devices, such as sensors, GPS, or satellites, and ordered based on timestamps, which are the times when they are generated/collected. Mining patterns in such data can be used to support many applications, including transportation recommendation systems, transportation safety, weather forecasting, and disease symptom analysis. Numerous techniques have been proposed to address the problem of how to mine subsequences in a sequence dataset; however, current traditional algorithms ignore the temporal information between the itemset in a sequential pattern. This information is essential in many situations. Though knowing that measurement Y occurs after measurement X is valuable, it is more valuable to know the estimated time before the appearance of measurement Y, for example, to schedule maintenance at the right time to prevent railway damage. Considering temporal relationship information for sequential patterns raises new issues to be solved, such as designing a new data structure to save this information and traversing this structure efficiently to discover patterns without re-scanning the database. In this paper, we propose an algorithm called Minits-AllOcc (MINIng Timed Sequential Pattern for All-time Occurrences) to find sequential patterns and the transition time between itemsets based on all occurrences of a pattern in the database. We also propose a parallel multi-core CPU version of this algorithm, called MMinits-AllOcc (Multi-core for MINIng Timed Sequential Pattern for All-time Occurrences), to deal with Big Data. Extensive experiments on real and synthetic datasets show the advantages of this approach over the brute-force method. Also, the multi-core CPU version of the algorithm is shown to outperform the single-core version on Big Data by 2.5X.</p>

PaScaL_TDMA 2.0: A multi-GPU-based library for solving massive tridiagonal systems

PaScaL_TDMA 2.0: A multi-GPU-based library for solving massive tridiagonal systems

Acceleration of a Production-Level Unstructured Grid Finite Volume CFD Code on GPU

Due to the complex topological relationship, poor data locality, and data racing problems in unstructured CFD computing, how to parallelize the finite volume method algorithms in shared memory to efficiently explore the hardware capabilities of many-core GPUs has become a significant challenge. Based on a production-level unstructured CFD software, three shared memory parallel programming strategies, atomic operation, colouring, and reduction were designed and implemented by deeply analysing its computing behaviour and memory access mode. Several data locality optimization methods—grid reordering, loop fusion, and multi-level memory access—were proposed. Aimed at the sequential attribute of LU-SGS solution, two methods based on cell colouring and hyperplane were implemented. All the parallel methods and optimization techniques implemented were comprehensively analysed and evaluated by the three-dimensional grid of the M6 wing and CHN-T1 aeroplane. The results show that using the Cuthill–McKee grid renumbering and loop fusion optimization techniques can improve memory access performance by 10%. The proposed reduction strategy, combined with multi-level memory access optimization, has a significant acceleration effect, speeding up the hot spot subroutine with data races three times. Compared with the serial CPU version, the overall speed-up of the GPU codes can reach 127. Compared with the parallel CPU version, the overall speed-up of the GPU codes can achieve more than thirty times the result in the same Message Passing Interface (MPI) ranks.

An efficient large-deformation fluid-structure interaction model for flow induced oscillation of an elastic thin structure

An efficient large-deformation fluid-structure interaction (FSI) model with GPU parallel framework is presented to simulate flow induced oscillation of an elastic slender structure, even light-weight and high-rigidity structures. A grid refinement and asynchronous advancement strategy is developed to ensure the matching of the different time-steps and grid sizes by flexibly coupling the fluid solver of a multi-direct forcing immersed boundary method (IBM) and the structure solver of a geometrically accurate Euler-Bernoulli beam model. This strategy can achieve good numerical stability and improve the computational performance of the present model. Free falling of a flexible pendulum, uniform flows around a stationary cylinder, and the flow induced oscillation of a flexible filament are simulated to validate the accuracy and capability of the structure solver, the fluid solver, and the coupled model, respectively. The results show that the present model can predict the large-displacement and large-deformation coupled responses of the elastic boundary. Also, the present model can obtain near 100 of acceleration ratio compared with the corresponding CPU version. Further, the effects of the density ratio and the bending coefficient on the flapping mode, the motion trajectory, and the fluid field are examined.

Highly-parallelized simulation of a pixelated LArTPC on a GPU

The rapid development of general-purpose computing on graphics processing units (GPGPU) is allowing the implementation of highly-parallelized Monte Carlo simulation chains for particle physics experiments. This technique is particularly suitable for the simulation of a pixelated charge readout for time projection chambers, given the large number of channels that this technology employs. Here we present the first implementation of a full microphysical simulator of a liquid argon time projection chamber (LArTPC) equipped with light readout and pixelated charge readout, developed for the DUNE Near Detector. The software is implemented with an end-to-end set of GPU-optimized algorithms. The algorithms have been written in Python and translated into CUDA kernels using Numba, a just-in-time compiler for a subset of Python and NumPy instructions. The GPU implementation achieves a speed up of four orders of magnitude compared with the equivalent CPU version. The simulation of the current induced on 10^3 pixels takes around 1 ms on the GPU, compared with approximately 10 s on the CPU. The results of the simulation are compared against data from a pixel-readout LArTPC prototype.

Scrooge: A Fast and Memory-Frugal Genomic Sequence Aligner for CPUs, GPUs, and ASICs.

Pairwise sequence alignment is a very time-consuming step in common bioinformatics pipelines. Speeding up this step requires heuristics, efficient implementations, and/or hardware acceleration. A promising candidate for all of the above is the recently proposed GenASM algorithm. We identify and address three inefficiencies in the GenASM algorithm: it has a high amount of data movement, a large memory footprint, and does some unnecessary work. We propose Scrooge, a fast and memory-frugal genomic sequence aligner. Scrooge includes three novel algorithmic improvements which reduce the data movement, memory footprint, and the number of operations in the GenASM algorithm. We provide efficient open-source implementations of the Scrooge algorithm for CPUs and GPUs, which demonstrate the significant benefits of our algorithmic improvements. For long reads, the CPU version of Scrooge achieves a 20.1×, 1.7×, and 2.1× speedup over KSW2, Edlib, and a CPU implementation of GenASM, respectively. The GPU version of Scrooge achieves a 4.0× 80.4×, 6.8×, 12.6× and 5.9× speedup over the CPU version of Scrooge, KSW2, Edlib, Darwin-GPU, and a GPU implementation of GenASM, respectively. We estimate an ASIC implementation of Scrooge to use 3.6× less chip area and 2.1× less power than a GenASM ASIC while maintaining the same throughput. Further, we systematically analyze the throughput and accuracy behavior of GenASM and Scrooge under various configurations. As the best configuration of Scrooge depends on the computing platform, we make several observations that can help guide future implementations of Scrooge. https://github.com/CMU-SAFARI/Scrooge.

Introducing bellhopcxx/bellhopcuda: Modern, parallel BELLHOP(3D)

BELLHOP and BELLHOP3D are popular ray/beam based underwater acoustics simulation programs, written in Fortran by Dr. Michael B. Porter starting in 1983. We introduce bellhopcxx/bellhopcuda, a translation of these programs into a modern, multithreaded C + +/CUDA codebase. This open-source codebase can be built and run on a multicore CPU or an NVIDIA GPU and can also be built as a library for integration into other software without requiring output data to be written to files. The new version is typically somewhat faster than the Fortran version even in single-threaded mode, and in multithreaded mode usually scales roughly with the number of logical CPU cores minus some overhead. In runs with large numbers of rays, depending on the hardware, the CUDA version can bring several times additional performance gain over the multithreaded CPU version, sometimes reaching over 100x the performance of BELLHOP or BELLHOP3D. The results of the new version closely match those of the original version in most cases, but there are occasionally mismatches, partly due to edge case issues inherent in the BELLHOP physics model. We have improved the handling of these cases and made other improvements to the Fortran version, bringing these changes to the new version.

Accelerating item factor analysis on GPU with Python package xifa.

Item parameter estimation is a crucial step when conducting item factor analysis (IFA). From the view of frequentist estimation, marginal maximum likelihood (MML) seems to be the gold standard. However, fitting a high-dimensional IFA model by MML is still a challenging task. The current study demonstrates that with the help of a GPU (graphics processing unit) and carefully designed vectorization, the computational time of MML could be largely reduced for large-scale IFA applications. In particular, a Python package called xifa (accelerated item factor analysis) is developed, which implements a vectorized Metropolis-Hastings Robbins-Monro (VMHRM) algorithm. Our numerical experiments show that the VMHRM on a GPU may run 33 times faster than its CPU version. When the number of factors is at least five, VMHRM (on GPU) is much faster than the Bock-Aitkin expectation maximization, MHRM implemented by mirt (on CPU), and the importance-weighted autoencoder (on GPU). The GPU-implemented VMHRM is most appropriate for high-dimensional IFA with large data sets. We believe that GPU computing will play a central role in large-scale psychometric modeling in the near future.

Electron tracks simulation in water: Performance comparison between GPU CPU and the EUMED grid installation

PurposeWe explored different technologies to minimize simulation time of the Monte-Carlo method for track generation following the Geant4-DNA processes for electrons in water. MethodsA GPU software tool is developed for electron track simulations. A similar CPU version is also developed using the same collision models. CPU simulations were carried out on a single user desktop computer and on the computing grid France Grilles using 10 and 100 computing nodes. Computing time results for CPU, GPU, and grid simulations are compared with those using Geant4-DNA processes. ResultsThe CPU simulations better performs when the number of electrons is less than 104 with 100 eV initial energy, this number decreases as the energy increases. The GPU simulations gives better results when the number of electrons is more than 104 with initial energy of 100 eV, this number decreases to 103 for electrons with 10KeV and increases back with higher energy. The use of the grid introduces an additional queuing time which slows down the overall simulation performance. Thus, the Grid gives better performance when the number of electrons is over 105 with initial energy of 10KeV, and this number decreases as the energy increases. ConclusionsThe CPU is best suited for small numbers of primary incident electrons. The GPU is best suited when the number of primary incident particles occupies sufficient resources on GPU card in order to get an important computing power. The grid is best suited for simulations with high number of primary incident electrons with high initial energy.