MPI Paradigm Research Articles

Lifex-cfd: An open-source computational fluid dynamics solver for cardiovascular applications

Computational fluid dynamics (CFD) is an important tool for the simulation of the cardiovascular function and dysfunction. Due to the complexity of the anatomy, the transitional regime of blood flow in the heart, and the strong mutual influence between the flow and the physical processes involved in the heart function, the development of accurate and efficient CFD solvers for cardiovascular flows is still a challenging task. In this paper we present life▪-cfd, an open-source CFD solver for cardiovascular simulations based on the life▪ finite element library, written in modern C++ and exploiting distributed memory parallelism. We model blood flow in both physiological and pathological conditions via the incompressible Navier-Stokes equations, accounting for moving cardiac valves, moving domains, and transition-to-turbulence regimes. In this paper, we provide an overview of the underlying mathematical formulation, numerical discretization, implementation details and examples on how to use life▪-cfd. We verify the code through rigorous convergence analyses, and we show its almost ideal parallel speedup. We demonstrate the accuracy and reliability of the numerical methods implemented through a series of idealized and patient-specific vascular and cardiac simulations, in different physiological flow regimes. The life▪-cfd source code is available under the LGPLv3 license, to ensure its accessibility and transparency to the scientific community, and to facilitate collaboration and further developments. Program summaryProgram Title:life▪-cfdCPC Library link to program files:https://doi.org/10.17632/hzsnc3jgds.1Developer's repository link:https://gitlab.com/lifex/lifex-cfdLicensing provisions:LGPLv3Programming language: C++ (standard ≥17)Supplementary material:https://doi.org/10.5281/zenodo.7852088 contains the application executable in binary form, compatible with any recent enough x86-64 Linux system, assuming that glibc version ≥ 2.28 is installed. Data and parameter files necessary to replicate the test cases described in this manuscript are also available.Nature of problem: The program allows to run computational fluid dynamics simulations of cardiovascular blood flows in physiological and pathological conditions, modeled through incompressible Navier-Stokes equations, including moving cardiac valves, moving domains (such as contracting cardiac chambers) in the arbitrary Lagrangian-Eulerian framework, and transition-to-turbulence flow. Given the scale of the typical applications, the program is designed for parallel execution.Solution method: The equations are discretized using the Finite Element method, on either tetrahedral or hexahedral meshes. The software builds on top of deal.II, implementing the mathematical models and numerical methods specific for CFD cardiovascular simulations. Parallel execution exploits the MPI paradigm. The software supports both Trilinos and PETSc as linear algebra backends.Additional comments including restrictions and unusual features: The program provides a general-purpose executable that can be used to run CFD simulations without having to access or modify the source code. The program allows to setup simulations through a user-friendly yet flexible interface, by means of readable and self-documenting parameter files. On top of that, more advanced users can modify the source code to implement more sophisticated test cases. life▪-cfd supports checkpointing, i.e. simulations can be stopped and restarted at a later time.

PageRank Implemented with the MPI Paradigm Running on a Many-Core Neuromorphic Platform

SpiNNaker is a neuromorphic hardware platform, especially designed for the simulation of Spiking Neural Networks (SNNs). To this end, the platform features massively parallel computation and an efficient communication infrastructure based on the transmission of small packets. The effectiveness of SpiNNaker in the parallel execution of the PageRank (PR) algorithm has been tested by the realization of a custom SNN implementation. In this work, we propose a PageRank implementation fully realized with the MPI programming paradigm ported to the SpiNNaker platform. We compare the scalability of the proposed program with the equivalent SNN implementation, and we leverage the characteristics of the PageRank algorithm to benchmark our implementation of MPI on SpiNNaker when faced with massive communication requirements. Experimental results show that the algorithm exhibits favorable scaling for a mid-sized execution context, while highlighting that the performance of MPI-PageRank on SpiNNaker is bounded by memory size and speed limitations on the current version of the hardware.

JAMPI: Efficient Matrix Multiplication in Spark Using Barrier Execution Mode

The new barrier mode in Apache Spark allows for embedding distributed deep learning training as a Spark stage to simplify the distributed training workflow. In Spark, a task in a stage does not depend on any other tasks in the same stage, and hence it can be scheduled independently. However, several algorithms require more sophisticated inter-task communications, similar to the MPI paradigm. By combining distributed message passing (using asynchronous network IO), OpenJDK’s new auto-vectorization and Spark’s barrier execution mode, we can add non-map/reduce-based algorithms, such as Cannon’s distributed matrix multiplication to Spark. We document an efficient distributed matrix multiplication using Cannon’s algorithm, which significantly improves on the performance of the existing MLlib implementation. Used within a barrier task, the algorithm described herein results in an up to 24% performance increase on a 10,000 × 10,000 square matrix with a significantly lower memory footprint. Applications of efficient matrix multiplication include, among others, accelerating the training and implementation of deep convolutional neural network-based workloads, and thus such efficient algorithms can play a ground-breaking role in the faster and more efficient execution of even the most complicated machine learning tasks.

An evaluation of MPI and OpenMP paradigms in finite‐difference explicit methods for PDEs on shared‐memory multi‐ and manycore systems

SummaryThis paper focuses on parallel implementations of three two‐dimensional explicit numerical methods on Intel® Xeon® Scalable Processor and the coprocessor Knights Landing. In this study, the performance of a hybrid parallel programming with message passing interface (MPI) and Open Multi‐Processing (OpenMP) and a pure MPI implementation used with two thread binding policies is compared with an improved OpenMP‐based implementation in three explicit finite‐difference methods for solving partial differential equations on shared‐memory multicore and manycore systems. Specifically, the improved OpenMP‐based version is a strategy that synchronizes adjacent threads and eliminates the implicit barriers of a naïve OpenMP‐based implementation. The experiments show that the most suitable approach depends on several characteristics related to the nonuniform memory access (NUMA) effect and load balancing, such as the size of the MPI domain and the number of synchronization points used in the parallel implementation. In algorithms that use four and five synchronization points, hybrid MPI/OpenMP approaches yielded better speedups than the other versions did in runs performed on both systems. The pure MPI‐based strategy, however, achieved better results than the other proposed approaches did in the method that employs only one synchronization point.

Carbon dioxide adsorption through carbon adsorbent structures: Effect of the porosity size, chemical potential and temperature

In the present paper, the carbon dioxide molecule adsorption through nanoporous carbons has been studied at 248 [K], 298 [K] and 323 [K]. The 3-stage graphite, turbostratic carbon and activated carbon have been taken into account as nanoporous carbon structures with nearly the same simulation box size, i.e. 30 × 30 × 30 [Å]. The numerical experiments of the adsorption phenomenon of CO2 molecule have been successfully achieved by user-written massively parallel codes via MPI paradigm which has been carefully examined and evaluated including electrostatic charges, 3-site CO2 molecule and linear scalability issues for the parallel programming purposes. By taking advantage of the parallel programming and efficient algorithm paradigm, very accurate outcomes and highly portable implementations for High Performance Computing (HPC) have been obtained. The effect of nanoscale pore size and its distribution for the above-mentioned nanoporous carbons which are generated via user-written C++ codes, have been studied by means of scalable parallel code. In the first stage, the carbon dioxide at bulk state has been investigated. Afterwards, the adsorption simulations have been achieved on regular and nearly regular nanoporous structures, i.e. 3-stage graphite including 6 [Å] and 12 [Å] interlayer distances (pore width), receptively. The activated carbon structure which is generated via Reverse Monte Carlo in Pikunic et al. (2003), has been considered for numerical experiments of adsorption as well. The comparison among these nanoporous carbons reveals a cross-over trend beyond a specific Adams constant value and this issue can be found out for the above-mentioned carbons as well as bulk case.

Searching for common patterns on protein sequences by means of a parallel hybrid honey-bee mating optimization algorithm

Abstract At present, most computing systems have multiple cores accessing to a shared memory space. In the case of computing systems devoted to research, it is common to cluster several shared memory architectures together in order to go beyond the limits of a single shared memory architecture. These clusters can represent a significant resource for those researchers who accomplish to exploit them to the fullest. One of the most applied techniques to achieve this purpose is the mixed mode parallel programming which combines both OpenMP and MPI paradigms. In this paper, we present a parallel implementation of a swarm-based evolutionary algorithm designed for solving a complex biological optimization problem. In order to obtain the maximum possible performance, we have combined MPI and OpenMP. Furthermore, in order to solve the addressed problem in a realistic way, we have applied multiobjective optimization. For assessing the performance achieved by our proposal we have conducted experiments under different systems on six biological instances with different sizes. Results point out the relevance of combining mixed mode parallel programming, a swarm-based evolutionary algorithm, and multiobjective optimization from both parallelism and biology points of view.

Advances in numerical simulation of sonic boom in realistic atmospheres

Efficient and accurate numerical simulation of sonic boom is a key issue for both the design of low boom aircraft and the definition of a standard on supersonic overland flights. Atmospheric turbulence is known since the 1960s to significantly alter the ideal N-wave boom waveform. Such random fluctuations cannot be reproduced by the standard ray tracing method. Neither can it simulate the lateral boom beyond the geometrical carpet edge. There occur many non-geometrical features such as creeping waves, wave guiding or scattering. To progress in the direction of boom simulation beyond the geometrical approximation, we developed the so-called FLHOWARD3D software. For accuracy, it can handle 3D temperature, density or wind heterogeneities, atmospheric absorption, and nonlinear propagation effects. For efficiency, a one-way approximation is performed, neglecting the backscattered field. Nevertheless, the forward field satisfies an accurate dispersion relation, even in moving atmospheres. Involved physical effects are handled separately by optimized algorithms, combined by a second-order split-step approach. The resulting software is parallelized using the MPI paradigm. The performances of the software will be illustrated by two cases: boom scattering by turbulence, and lateral boom propagation in case of temperature inversion. This last case will be compared with flight test data.

Hybridisation strategies and data structures for the NEMO ocean model

This work describes the introduction of a second level of parallelism based on the OpenMP shared memory paradigm to NEMO, one of the most widely used ocean models in the European climate community. Although the existing parallelisation scheme in NEMO, based on the MPI paradigm, has served it well for many years, it is becoming unsuited to current high-performance computing architectures due to their increasing tendency to have fat nodes containing tens of compute cores. Three different parallel approaches for introducing OpenMP are presented, discussed and compared on several platforms. Finally we have also considered the effect on performance of the data layout employed in NEMO.

Par-PSSE: Software for Pairwise Statistical Significance Estimation in Parallel for Local Sequence Alignment

Pairwise statistical significance (PSS) has been recognized as a very useful method for homology detection. It can help in estimating whether the output of sequence alignment is evolutionarily link or just arisen by accident. However, pairwise statistical significance estimation (PSSE) poses a big challenge in terms of performance and scalability since it is both computationally intensive and data intensive to construct the empirical score distribution during the estimation. This paper presents a software library for estimating pairwise statistical significance in parallel, named Par-PSSE, implemented in C++ using OpenMP, MPI paradigms and their hybrids. Further, we apply the parallelization technique to estimate non-conservative PSS using standard, sequence-specific, and position-specific substitution matrices. These extensions have been found superior compared to the standard pairwise statistical significance in term of retrieval accuracy. Through distributing the compute-intensive kernels of the pairwise statistical significance estimation across multiple computational units, we achieve a speedup of up to 621.73× over the corresponding sequential implementation when using1024 cores.

An Approach Using Parallel Architecture to Storage DICOM Images in Distributed File System

Telemedicine is a very important area in medical field that is expanding daily motivated by many researchers interested in improving medical applications. In Brazil was started in 2005, in the State of Santa Catarina has a developed server called the CyclopsDCMServer, which the purpose to embrace the HDF for the manipulation of medical images (DICOM) using a distributed file system. Since then, many researches were initiated in order to seek better performance. Our approach for this server represents an additional parallel implementation in I/O operations since HDF version 5 has an essential feature for our work which supports parallel I/O, based upon the MPI paradigm. Early experiments using four parallel nodes, provide good performance when compare to the serial HDF implemented in the CyclopsDCMServer.

High Performance Parallelization of COMPSYN on a Cluster of Multicore Processors with GPUs

In this work we propose a high performance parallelization of the software package COMPSYN, devoted to the production of syntethic seismograms, on a cluster of multicore processors with multiple GPUs. To design and implement the proposed high performance version, we started from a naıve parallel version of COMPSYN. The naıve version consists in a simple parallelization on both device side, obtained by exploiting CUDA, and host side, obtained by exploiting the MPI paradigm and OpenMP API. The proposed high performance version implements several practical techniques of CUDA programming and deeply exploits the GPU architecture, thus achieving a much better performance with respect to the naıve version. We compare the performance of the proposed high performance version and that of the naıve one with the performance of the version running on the cluster of multicore processors without invoking the GPUs. We obtain for the high performance GPU version a speedup of 25x over the version running on the cluster of multicore processors without GPUs against the 10x of the naıve version. Regarding the sequential version, we estimate about 380x the speedup of the high performance GPU version against the about 140x of the naıve version.

FANTOM: Two- and three-dimensional numerical modelling of creeping flows for the solution of geological problems

A new finite element code for the solution of the Stokes and heat transport equations is presented. It has purposely been designed to address geological flow problems in two and three dimensions at crustal and lithospheric scales. A variety of rheologies has been implemented including nonlinear thermally activated creep and brittle (or plastic) frictional models. A cloud of particles is used to track materials in the simulation domain which allows to record the integrated history of deformation; its density is variable and dynamically adapted. The code is built on the Arbitrary Lagrangian–Eulerian kinematical description: the computational grid deforms vertically and allows for a true free surface while the computational domain remains of constant width in the horizontal direction. The code can be run in sequential or parallel mode. The parallelisation is based on the MPI paradigm and the domain decomposition algorithm is presented. The solution to the large system of algebraic equations resulting from the finite element discretisation and linearisation of the set of coupled partial differential equations to be solved is obtained by means of an efficient (sequential or massively parallel) direct solver. Details of implementation concerning plasticity, cloud handing, nonlinear convergence, strain accumulation and pressure smoothing are given. The sequential 2D version of the code is used to run the numerical sandbox benchmark at normal and high resolutions. The 2D parallel version is used in the case of a thermo-mechanically coupled extension experiment in which the mantle is present. The 3D parallel version is used to run a crustal scale orogeny experiment. The overall performance of the code, as well as the respect of the incompressibility constraint, of the yield stress criterion and of the volume conservation are discussed, along with parallel scalability. Benchmark results of scalar field advection, the Rayleigh–Taylor experiment and the falling block experiment are presented in Appendix.

Parallel Implementation of 2D Daubechies - D4 Transform in a Cluster

Wavelet transform is an important mathematical tool with strong application in signal processing. From the mathematical point of view many different wavelet transforms are developed, where orthogonal wavelet transforms are more important. Also, various algorithms for their computations are developed. In this paper we present the parallel implementation of the orthogonal wavelet transform named Daubechies D4 transform, which consists of four taps filters. At the beginning, a short mathematical introduction of the Daubechies D4 transform is presented. After that the sequential and parallel algorithm implementations are analyzed. A parallel implementation for the PC cluster environment is done. We have analyzed two ways of parallel implementation, one with row mapping and the other with block mapping (mesh architecture of the processing elements). For practical implementation the C++ programming language and MPI paradigm (for parallel environment) are used. Finally, the mathematical complexity of these implementations is presented. In particular, we have analyzed separately the complexity of computations and communications. It is shown, also, that the complexity is between O(log 2 n) and O(n2 / p). At the end, a comparison of sequential and parallel implementations is presented according to the results obtained by testing the practical implementations.

Parallel Dichotomy Algorithm for solving tridiagonal system of linear equations with multiple right-hand sides

A parallel algorithm for solving a series of matrix equations with a constant tridiagonal matrix and different right-hand sides is proposed and studied. The process of solving the problem is represented in two steps. The first preliminary step is calculating some rows of the inverse matrix of system of linear algebraic equations. The second step consists in calculating solutions for all right-hand sides. For reducing the communication interactions, based on the formulated and proved the main Gaussian Parallel Elimination Theorem for tridiagonal system of equations, we propose an original algorithm for calculating share components of the solution vector. Theoretical estimates validating the efficiency of the approach for both the common- and distributed-memory supercomputers are obtained. Direct and iterative methods of solving a 2D Poisson equation, which include procedures of tridiagonal matrix inversion, are realized using the MPI paradigm. Results of computational experiments on a multicomputer demonstrate a high efficiency and scalability of the parallel Dichotomy Algorithm.

Computation Of The Starting Flow In A Shock Tunnel 2D Nozzle

This paper summarizes the results obtained with a Reynolds Averaged NavierStokes solver applied to the case of the starting flow in the two-dimensional nozzle section of a shock tube and which constitutes a numerical test to assess the accuracy of the code when dealing with highly non-stationary internal flows with shock waves interactions. Since the shock-boundary layer phenomenon drives the flow separation on the nozzle flaps and turbulence plays an important role on the evolution of the structures which arise, the need of an adequate turbulence closure, as well as the temporal resolution of the flow by using a small enough time-step, makes the computations expensive. Within this framework and to drop the computing time down, the parallel implementation of the solver based on the MPI paradigm has been exploited to carry out a set of simulations with various eddy viscosity models,

OpenMP: Experiences, Implementations and Applications

The rapid emergence of OpenMP as a preferred parallel programming paradigm for small-to-medium scale parallelism is attracting the scientific community. OpenMP is an industry standard interface for shared-memory programming of parallel computer applications. This standard offers a way to write portable applications to a wide range of shared-memory machines or, through hybrid (OpenMP + MPI) programming model, to cluster of share-memory nodes. This special issue features six papers that explore the experiences of application developers in the use of the language and parallelization of applications with OpenMP. The first paper, MPI and OpenMP Paradigms on Cluster of SMP Architectures: the Vacancy Tracking Algorithm for Multi-Dimensional Array Transposition by Yun He and Chris H. Q. Ding, investigates remapping multi-dimensional arrays on a cluster of SMP architectures under OpenMP, MPI, and hybrid paradigms. The traditional method of array transpose needs an auxiliary array of the same size and a copy-back stage. The authors developed an in-place method using vacancy tracking cycles. The vacancy tracking algorithm outperforms the traditional 2-array method as demonstrated by extensive comparisons. In the second, paper Comparing MPI and OpenMP implementations of the 0-1 Knapsack Problem, Isabel Dorta, Coromoto Leon and Casiano Rodriguez present and compare two parallel implementations of the 0-1 Knapsack Problem. Using the C ++ programming language, two exact algorithms based on the Branch-and-Bound technique have been implemented. MPI has been used to develop the Message Passing algorithm and for the Shared Memory the OpenMP has been chosen. V. Blanco, L. Garcia, J. A Gonzalez, C. Rodriguez and G. Rodriguez, in their paper, A Performance Model for the Analysis of OpenMP Programs, attempt to build a bridge between theoretical complexity models and the performance analysis and tuning of OpenMP programs. They start with the assumption that the theoretical analysis of an OpenMP code produces a complexity function that gives an approach to the asymptotic number of operations performed by the algorithm. The shared-memory platform is characterized by a number of parameters that are computed through a benchmarking program. The authors propose an algorithm that determines the algorithmic constants associated with the complexity formula in terms of the architecture parameters. To predict the performance for a new computing platform, they use the parameters characterizing the platform to solve a random linear equation system. P. E. Handjidoukas, E. D. Polychronopoulos, and T. S. Papatheodorou present in their paper, A Modular OpenMP Implementation for Clusters of Multiprocessors, a prototype runtime system that provides support at the backend of the NANOS OpenMP compiler. This enables the execution of unmodified OpenMP Fortran programs on both SMPs and clusters of multiprocessors, either through the hybrid (MPI + OpenMP) programming model or directly on top of Software Distributed Shared Memory. F. Garcia Lopez and N. L. Frais Arrocha propose in their paper, Expanding the Synchronization Model for OpenMP, an extension to the OpenMP model consisting of a new and efficient synchronization model based on the Monitor model. The motivation behind this proposal is to support an application based on backtracking, branch and bound, and dynamic programming approaches. Finally, Mohammad Towhidul Islam, Parimala Thulasiraman, and Ruppa K. Thulasiram, in their paper Implementation of Ant Colony Optimization Algorithm for Mobile Ad Hoc Network Applications: OpenMP Experiences, present experiences in design, development and implementation of a parallel algorithm for mobile ad hoc networks (MANETs) using the Ant Colony Optimization technique on a shared memory architecture with OpenMP. They have experimented with three scheduling policies provided by OpenMP for varying data sizes and compare performance results with MPI. I would like to thank each of the participating reviewers for their help in ensuring the quality of the papers in this issue. Ami Marowka School of Computer Science and Engineering The Computer Aided Design Laboratory The Hebrew University of Jerusalem