OpenMP Implementation Research Articles

Multidimensional adaptative and deterministic integration in CUDA and OpenMP

Parallelization schemes on many-core architectures, in this case, CUDA and OpenMP, are used to accelerate and improve the accuracy of adaptive multidimensional integration algorithms. The one-dimensional Gauss–Kronrod adaptive method is generalized to 3, 4, 5 and 6 dimensions. The implementation of the traditional tensor product construction of the grid and weights for multidimensional integration is revisited and reformulated taking advantages of the multi and many-core architectures. Tests performed in a set of benchmark functions show that the algorithm is numerically accurate, with accelerations as high as 800X in CUDA and 300X in the OpenMP implementation both compared to a sequential multidimensional integration algorithm.

Efficient curvature-constrained least cost route optimization on parallel architectures

When choosing a path for a linear infrastructure between two terminals, several types of constraints apply for installation and operational criteria. For offshore pipelines or cables, curvature constraints are typically important not only due to the flexural rigidity but also the maneuverability of the laying vessels. Roads are subject to similar curvature constraints to ensure the safety of users travelling at the design speed. Yet, such constraints are not taken into account in traditional least cost routing methods, often based on Dijkstra’s algorithm. Post-process smoothing is often necessary, resulting in non-optimal routes. We present a new method for least cost route optimization, allowing to incorporate the curvature constraints into the primary calculations as opposed to a post-determination consideration. With this technique, smoothing of the least cost route becomes unnecessary, preserving its optimal character. Optimization algorithms for the trajectories of forward-moving vehicles were adapted for the routing of linear infrastructures and modified to include an angular discretization of variable resolution, resulting in faster and more accurate results. In addition to the inclusion of curvature constraints, the proposed method offers a higher flexibility in terms of local route orientation compared to the traditional Dijkstra’s algorithm, producing routes of lower cost. The numerical solver was implemented on parallel architectures, to compute optimal routes on realistic domains in reasonable computational times. For personal computers with a few computing cores, the OpenMP implementation on Central Processing Units does not significantly increase the iteration count and provides significant speedups. For certain configurations, the use of Graphical Processing Units reduces further the computational time.

GPU accelerated waterpixel algorithm for superpixel segmentation of hyperspectral images

The high computational cost of the superpixel segmentation algorithms for hyperspectral remote sensing images makes them ideal candidates for parallel computation. The waterpixel algorithm, in particular, extracts segmentation regions called waterpixels and consists of four stages called vectorial gradient, spatial regularization, marker selection, and watershed transform. In this paper, an efficient version of a GPU algorithm for waterpixel segmentation using the Compute Unified Device Architecture (CUDA) is presented. The algorithm extracts all the spectral information available in the bands of the hyperspectral image through the vectorial gradient. A cellular automaton is selected for the computation of the watershed transform using a block-asynchronous implementation with 8-connectivity. The experimental analysis shows high speedup values for the resulting GPU algorithm when it is compared to a multicore OpenMP implementation using 8 threads.

CCSDS-MHC on Raspberry Pi for Lossless Hyperspectral Image Compression

This paper is about Consultative Committee for Space Data System for Lossless Multispectral and Hyperspectral Image Compression (CCSDS-MHC) algorithm that is implemented on Raspberry Pi 3 Model B+ system using Open Multi-Processing (OpenMP). CCSDS-MHC algorithm along with the full prediction mode is opted due to its best compression ratio (CR) performance. The issue of Hyperspectral Image Compression is the loss of data when compress, thus CCSDS algorithm is used in this research. Besides, with current technologies that require low-power but high-performance devices, Raspberry Pi was chosen to be tested in terms of its performances while being compared to other platforms. AVIRIS (airborne) and Hyperion (spaceborne) are used to test the performance of the system. OpenMP is introduced to simplify the computational operation through parallelization to take advantage of the multi-core architecture of the hardware system. In term of execution time, CCSDS-MHC algorithm when parallelize using OpenMP gave the best performances about 69.4% for AVIRIS 1997 dataset, 69.3% for AVIRIS 2006 dataset and 67.7% for Hyperion dataset. The execution time of performance CCSDS-MHC in Raspberry Pi 3 Model B+ comparing with other different multicore platform is validate and the mean parallelize is measured. The result of comparison proves that faster performing task gives the best result due to higher speed of CPU-cores performances. From this research, it is proven that Raspberry Pi which is a low-power embedded platform able to compress the hyperspectral images at optimized speed with the implementation of OpenMP through CCSDS algorithm. Therefore, this research will be useful for further studies in lossless of hyperspectral images.

GPU-native gas dynamic solver on octree-based AMR grids

GPU implementation of the Godunov-type gas dynamic solver on three-dimensional octree-based grids is proposed. In this implementation, all dynamic adaptive mesh refinement (AMR) procedures are performed entirely on GPU as opposed to most of other implementations where grid metadata is transferred to CPU for further updating. Conducted bench tests show that eliminating regular CPU–GPU grid data transferring in the proposed parallel AMR algorithms makes it possible to reduce the grid modification overhead to lower than 2% on Nvidia Tesla V100. The results concerned with both CUDA and OpenMP implementation performance are also presented.

Real-Time Scheduling and Analysis of OpenMP DAG Tasks Supporting Nested Parallelism

OpenMP is a promising framework to develop parallel real-time software on multi-cores. Although similar to the DAG task model, OpenMP task systems are significantly more difficult to analyze due to constraints posed by OpenMP specifications. One of the most interesting features in OpenMP is the support for nested parallelism, enjoying benefits in enhancing performance transparency of parallel libraries and promoting reuse of black-box code. Previous researches on DAG task scheduling mainly restrict to only one level of parallelism. The problem whether OpenMP tasks with multiple levels of parallelism are suitable to real-time systems remains open. In this paper, we study the real-time scheduling and analysis of OpenMP task systems supporting nested parallelism. First, we show that under existing scheduling algorithms in OpenMP implementations, nested parallelism indeed may lead to extremely bad timing behaviors where the parallel workload is sequentially executed completely. To solve this problem, we propose a new scheduling algorithm and develop two sound response time bounds by considering the trade-off between simplicity and analysis precision. Experiments demonstrate the efficiency of our methods.

An OpenMP implementation of the MuMM solver for porous media flow problems

Multiscale methods are usually developed for solving second-order elliptic problems in which coef?cients are of multiscale heterogeneous nature. The Multiscale Mixed Method (MuMM) was introduced aiming at the ef?cient and accurate approximation of large ?ow problems in highly heterogeneous porous media. In the MuMM numerical solver, ?rst mixed multiscale basis functions are constructed, and next global domain decomposition iterations are performed to compute the discrete solution of the problems. However, this iterative procedure is a time-consuming step. In this paper, the authors improve the MuMM solver through the implementation of parallel computations in the step concerning the global iterative procedure. The parallel version of the solver employs the application programming interface Open Multi-Processing (OpenMP). The implementation with the OpenMP reduces signi?cantly the computational effort to perform the domain decomposition iterations, as indicated by the numerical results.

A parallel hybrid implementation of the 2D acoustic wave equation

Abstract In this paper, we propose a hybrid parallel programming approach for a numerical solution of a two-dimensional acoustic wave equation using an implicit difference scheme for a single computer. The calculations are carried out in an implicit finite difference scheme. First, we transform the differential equation into an implicit finite-difference equation and then using the alternating direction implicit (ADI) method, we split the equation into two sub-equations. Using the cyclic reduction algorithm, we calculate an approximate solution. Finally, we change this algorithm to parallelize on graphics processing unit (GPU), GPU + Open Multi-Processing (OpenMP), and Hybrid (GPU + OpenMP + message passing interface (MPI)) computing platforms. The special focus is on improving the performance of the parallel algorithms to calculate the acceleration based on the execution time. We show that the code that runs on the hybrid approach gives the expected results by comparing our results to those obtained by running the same simulation on a classical processor core, Compute Unified Device Architecture (CUDA), and CUDA + OpenMP implementations.

OpenMP Implementation of a Novel Potential-Field-Data Source-Growth-Based Inversion Approach for 3D Salt Imaging in Deepwater Gulf of Mexico

Potential-field-data imaging of complex geological features in deepwater salt-tectonic regions in the Gulf of Mexico remains an open active research field. There is still a lack of resolution in seismic imaging methods below and in the surroundings of allochthonous salt bodies. In this work, we present a novel three-dimensional potential-field-data simultaneous inversion method for imaging of salt features. This new approach incorporates a growth algorithm for source estimation, which progressively recovers geological structures by exploring a constrained parameter space; restrictions are posed from a priori geological knowledge of the study area. The algorithm is tested with synthetic data corresponding to a real complex salt-tectonic geological setting commonly found in exploration areas of deepwater Gulf of Mexico. Due to the huge amount of data involved in three-dimensional inversion of potential field data, the use of parallel computing techniques becomes mandatory. In this sense, to alleviate computational burden, an easy to implement parallelization strategy for the inversion scheme through OpenMP directives is presented. The methodology was applied to invert and integrate gravity, magnetic and full tensor gradient data of the study area.

Analysis of Threading Libraries for High Performance Computing

With the appearance of multi-/many core machines, applications and runtime systems have evolved in order to exploit the new on-node concurrency brought by new software paradigms. POSIX threads (Pthreads) was widely-adopted for that purpose and it remains as the most used threading solution in current hardware. Lightweight thread (LWT) libraries emerged as an alternative offering lighter mechanisms to tackle the massive concurrency of current hardware. In this article, we analyze in detail the most representative threading libraries including Pthread- and LWT-based solutions. In addition, to examine the suitability of LWTs for different use cases, we develop a set of microbenchmarks consisting of OpenMP patterns commonly found in current parallel codes, and we compare the results using threading libraries and OpenMP implementations. Moreover, we study the semantics offered by threading libraries in order to expose the similarities among different LWT application programming interfaces and their advantages over Pthreads. This article exposes that LWT libraries outperform solutions based on operating system threads when tasks and nested parallelism are required.

OpenMP 4.5 compiler optimization for GPU offloading

Ability to efficiently offload computational workloads to graphic processing units (GPUs) is critical for the success of hybrid CPU–GPU architectures, such as the Summit and Sierra supercomputing systems. OpenMP 4.5 is a high-level programming model that enables the development of architecture- and accelerator-independent applications. This article describes aspects of the OpenMP implementation in the IBM XL C/C++ and XL Fortran OpenMP compilers that aid programmers to achieve performance objectives. This includes an interprocedural static analysis the XL optimizer uses to specialize code generation of the OpenMP <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">distribute parallel do</i> loop within the dynamic context of a target region, and other compiler optimizations designed to reduce the overhead of data transferred to an offloaded target region. We introduce the heuristic used at runtime to select optimal grid sizes for offloaded target team constructs. These tuned heuristics lead to an average improvement of 2× in the runtime of several target regions in the SPEC ACCEL V1.2 benchmark suite. In addition to performance enhancement, this article also presents an advanced diagnostic feature implemented in the XL Fortran compiler to aid in debugging OpenMP applications offloaded to accelerators.

Experiences in porting mini‐applications to OpenACC and OpenMP on heterogeneous systems

SummaryThis article studies mini‐applications—Minisweep, GenASiS, GPP, and FF—that use computational methods commonly encountered in HPC. We have ported these applications to develop OpenACC and OpenMP versions, and evaluated their performance on Titan (Cray XK7 with K20x GPUs), Cori (Cray XC40 with Intel KNL), Summit (IBM AC922 with Volta GPUs), and Cori‐GPU (Cray CS‐Storm 500NX with Intel Skylake and Volta GPUs). Our goals are for these new ports to be useful to both application and compiler developers, to document and describe the lessons learned and the methodology to create optimized OpenMP and OpenACC versions, and to provide a description of possible migration paths between the two specifications. Cases where specific directives or code patterns result in improved performance for a given architecture are highlighted. We also include discussions of the functionality and maturity of the latest compilers available on the above platforms with respect to OpenACC or OpenMP implementations.

Parallel Grid-Based Colocation Mining Algorithms on GPUs for Big Spatial Event Data

Colocation patterns refer to subsets of spatial features whose instances are frequently located together. Mining colocation patterns is important in many applications such as identifying relationships between diseases and environmental factors, but is computationally challenging due to the large number of instances and candidate patterns. Existing algorithms are mostly sequential, and thus can be insufficient for big spatial event data. Recently, parallel colocation mining algorithms have been developed based on the Map-reduce framework, which is economically expensive. Another work proposed a GPU algorithm based on iCPI tree, but assumes that the number of neighbors for each instance is within a small constant, and thus cannot be used when instances are dense and unevenly distributed. To address these limitations, we recently proposed grid-based GPU colocation mining algorithms that include a novel cell-aggregate-based upper bound filter, and two refinement algorithms. In this paper, we provide theoretical analysis of running time. Furthermore using GPU profiling, we identify our recent GPU implementation, GPU-grid-join, as a memory bound problem and to address its bottlenecks, we proposes GPU-grid-join+, an optimized GPU algorithm. Our experimental results on real world data shows that GPU-grid-join+ achieves 4 to 12-fold speedup over GPU-grid-join both running on Nvidia P100 GPU as well as 56 to 126-fold speedup over OpenMP implementation over Intel(R) Xeon(R) CPU with 12 cores. Also for synthetic data, the speedup is in ranges 3 to 7-fold and 9 to 42-fold respectively.

Multicore implementation and performance analysis of a chaos based LSB steganography technique

Temporal complexity of data security algorithms for information exchange on internet is becoming a daunting challenge. Performance enhancement of these algorithms using multi core CPUs has now become the standard approach. An OpenMP implementation of chaos based least significant bit steganography technique is proposed in the paper to address this issue. The paper reports (i) standard statistical validation test results viz. histogram analysis, SSIM index, euclidean distance, PSNR for the test sample, (ii) results of the statistical testing on generated chaotic bit sequences, using the NIST suites and (iii) scalability analysis of the multi core implementation of the technique. Significant speed up and linear scalability have been reported with increase in the number of cores from 1 to 16 for Intel Haswell®Processor.

Process arrival pattern aware algorithms for acceleration of scatter and gather operations

Imbalanced process arrival patterns (PAPs) are ubiquitous in many parallel and distributed systems, especially in HPC ones. The collective operations, e.g. in MPI, are designed for equal process arrival times, and are not optimized for deviations in their appearance. We propose eight new PAP-aware algorithms for the scatter and gather operations. They are binomial or linear tree adaptations introducing additional process ordering and (in some cases) additional activities in a special background thread. The solution was implemented using one of the most popular open source MPI compliant library (OpenMPI), and evaluated in a typical HPC environment using a specially developed benchmark as well as a real application: FFT. The experimental results show a significant advantage of the proposed approach over the default OpenMPI implementation, showing good scalability and high performance with the FFT acceleration for the communication run time: 16.7% and for the total application execution time: 3.3%.

Supersonic turbulent flow simulation using a scalable parallel modal discontinuous Galerkin numerical method

The scalability and efficiency of numerical methods on parallel computer architectures is of prime importance as we march towards exascale computing. Classical methods like finite difference schemes and finite volume methods have inherent roadblocks in their mathematical construction to achieve good scalability. These methods are popularly used to solve the Navier-Stokes equations for fluid flow simulations. The discontinuous Galerkin family of methods for solving continuum partial differential equations has shown promise in realizing parallel efficiency and scalability when approaching petascale computations. In this paper an explicit modal discontinuous Galerkin (DG) method utilizing Implicit Large Eddy Simulation (ILES) is proposed for unsteady turbulent flow simulations involving the three-dimensional Navier-Stokes equations. A study of the method was performed for the Taylor-Green vortex case at a Reynolds number ranging from 100 to 1600. The polynomial order P = 2 (third order accurate) was found to closely match the Direct Navier-Stokes (DNS) results for all Reynolds numbers tested outside of Re = 1600, which had a normalized RMS error of 3.43 × 10−4 in the dissipation rate for a 603 element mesh. The scalability and performance study of the method was then conducted for a Reynolds number of 1600 for polynomials orders from P = 2 to P = 6. The highest order polynomial that was tested (P = 6) was found to have the most efficient scalability using both the MPI and OpenMP implementations.

Analysis of OpenMP 4.5 Offloading in Implementations: Correctness and Overhead

The OpenMP language features have been evolving to meet the rapid development in hardware platforms. This journal focuses on evaluating implementations of OpenMP 4.5 target offload features in compilers such as Clang, XL and GCC that are an integral part of the software harness on supercomputers and clusters. We use Summit (Top supercomputer in the world as of November 2018) as one of our experimental setup. Such an effort is particularly critical on such supercomputers as that is being widely used by application developers to run their scientific codes at scale. Our tests not only evaluate the OpenMP implementations but also expose ambiguities within the OpenMP 4.5 specification. We also assess the overhead of the different OpenMP runtimes in relationship to the different directives and clauses. This helps in assessing the interaction of different OpenMP directives independent of other application artifacts. We are aware that the implementations are constantly evolving and Summit is advertised as having only partial OpenMP 4.x support. This is a synergistic effort to help identify and fix bugs in features’ implementations that are required by applications and prevent deployment delays later on. Going forward, we also plan to interact with standard benchmarking organizations like SPEC/HPG to donate our tests and mini-apps/kernels for potential inclusion in the next release versions of SPEC benchmark suite.

Multithreaded parallelization of the energy and analytic gradient in the fragment molecular orbital method

AbstractThe fragment molecular orbital method in GAMESS is parallelized in a multithreaded OpenMP implementation combined with the MPI version of the two‐level generalized distributed data interface. The energy and analytic gradient in gas phase and the polarizable continuum model of solvation are parallelized in this hybrid three‐level scheme, achieving a large memory footprint reduction and a high parallel efficiency on Intel Xeon Phi processors. The parallel efficiency is demonstrated on the Stampede2 and Theta supercomputers using up to 2048 nodes (262 144 threads).

Task-Based Parallelism with OpenMP: a case study with DL_POLY_4

ABSTRACT When performing computations where load balancing is complex, dynamic load balancing is becoming increasingly necessary. In this paper, we examine one of these methods, Task-Based Parallelism. Many libraries implement Task-Based Parallelism, however, in this paper we examine the OpenMP standard and implementations, and apply it to the Classical Molecular Dynamics code, DL_POLY_4, focusing on the two body force calculations that make up a large percentage of the compute in many simulation runs. Our results show reasonable performance using OpenMP tasks, however, some of the extensions available in other libraries such as OmpSs or StarPU may help with performance for problems similar to Molecular Dynamics, where avoiding race conditions between tasks can have a substantial scheduling overhead.

CuPentBatch—A batched pentadiagonal solver for NVIDIA GPUs

We introduce cuPentBatch—our own pentadiagonal solver for NVIDIA GPUs. The development of cuPentBatch has been motivated by applications involving numerical solutions of parabolic partial differential equations, which we describe. Our solver is written with batch processing in mind (as necessitated by parameter studies of various physical models). In particular, our solver is directed at those problems where only the right-hand side of the matrix changes as the batch solutions are generated. As such, we demonstrate that cuPentBatch outperforms the NVIDIA standard pentadiagonal batch solver gpsvInterleavedBatch for the class of physically-relevant computational problems encountered herein. Program summaryProgram title: cuPentBatchProgram Files doi:http://dx.doi.org/10.17632/ccrp2pyyyj.1Licensing Provisions: Apache License 2.0Programming Languages: C, C++, CUDANature of Problem: cuPentBatch has been developed to solve batches of pentadiagonal systems in parallel. Pentadiagonal systems appear commonly in the numerical solution of 4th order derivatives and in 4th order accurate 2nd order derivatives. The need for batch solving these is apparent when preforming parameter studies or when solving 2D/3D systems with inversion methods such as ADI.Solution Method: cuPentBatch implements an LU factorisation for a banded pentadiagonal matrix on a GPU, solving batches of them in parallel across threads. This leads to greatly improved performance over serial and OpenMP implementations, also improves on current state of the art gpsvInterleavedBatch which is part of the cuSPRASE library in CUDA.