Shared Memory Parallel Machines Research Articles

Fast parallel IGA-ADS solver for time-dependent Maxwell's equations

We propose a simulator for time-dependent Maxwell's equations with linear computational cost. We employ B-spline basis functions as considered in the isogeometric analysis (IGA). We focus on non-stationary Maxwell's equations defined on a regular patch of elements. We employ the idea of alternating-directions splitting (ADS) and employ a second-order accurate time-integration scheme for the time-dependent Maxwell's equations in a weak form. After discretization, the resulting stiffness matrix exhibits a Kronecker product structure. Thus, it enables linear computational cost LU factorization. Additionally, we derive a formulation for absorbing boundary conditions (ABCs) suitable for direction splitting. We perform numerical simulations of the scattering problem (traveling pulse wave) to verify the ABC. We simulate the radiation of electromagnetic (EM) waves from the dipole antenna. We verify the order of the time integration scheme using a manufactured solution problem. We then simulate magnetotelluric measurements. Our simulator is implemented in a shared memory parallel machine, with the GALOIS library supporting the parallelization. We illustrate the parallel efficiency with strong and weak scalability tests corresponding to non-stationary Maxwell simulations.

HYPERGRAPH GRAMMAR BASED MULTI-THREAD MULTI-FRONTAL DIRECT SOLVER WITH GALOIS SCHEDULER

In this paper we analyze two dimensional grids with point and edge singularities in order to develop an efficient graph grammar based multi-frontal direct solver algorithm. We express these grids by hypergraph models. For these meshes we define a sequence of graph grammar productions expressing the construction of frontal matrices, elimination of fully assembled nodes, merging of resulting Schur complements, and repeating the process of elimination and merging until a single frontal matrix remains. The dependency relation between graph grammar productions is analyzed, and the dependency graph is plot, which is equivalent to the elimination tree of the multi-frontal solver algorithm. We utilize classical multi-frontal solver algorithm, and the graph grammar productions allows us to construct an efficient elimination tree, based on the graph representation of the computational mesh, and not the global matrix itself. The graph grammar productions are assigned to nodes of the dependency graph, and they are implemented as tasks in the GALOIS system and scheduled according to the developed dependency graph over the shared memory parallel machine. We show that our graph grammar based solver outperforms parallel MUMPS solver.

Scheduling parallel identical machines to minimize makespan:A parallel approximation algorithm

Approximation algorithms for scheduling parallel machines have been studied for decades, leading to significant progress in terms of their approximation guarantees. The algorithms that provide near optimal performance are not feasible to use in practice due to their huge execution time requirements, thus underscoring the importance of developing efficient parallel approximation algorithms with near-optimal performance guarantees that are suitable for execution on current parallel systems, such as multi-core systems. We present the design and analysis of a parallel approximation algorithm for the problem of scheduling jobs on parallel identical machines to minimize makespan. The design of the parallel approximation algorithm is based on the best existing polynomial-time approximation scheme (PTAS) for the problem. To the best of our knowledge, this is the first practical parallel approximation algorithm for the minimum makespan scheduling problem that maintains the approximation guarantees of the sequential PTAS and it is specifically designed for execution on shared-memory parallel machines. We implement and run the algorithm on a large multi-core system and perform an extensive experimental analysis on data generated from realistic probability distributions. The results show that our proposed parallel approximation algorithm achieves significant speedup with respect to both the sequential PTAS and the CPLEX-based solver that solves the mixed integer program formulation of the problem.

Concurrent computation of topological watershed on shared memory parallel machines

Abstract The watershed transform is considered as the most appropriate method for image segmentation in the field of mathematical morphology. In the following paper, we present an adapted topological watershed algorithm suited for a rapid and effective implementation on Shared Memory Parallel Machine (SMPM). The introduced algorithm allows a parallel watershed computing while preserving the given topology. No prior minima extraction is needed, nor the use of any sorting step or hierarchical queue. The strategy that guides the parallel watershed computing, labeled SDM-Strategy (equivalent to Split-Distributes and Merge), is also presented. Experimental analyses such as execution time, performance enhancement, cache consumption, efficiency and scalability are also presented and discussed.

VMP1-related autophagy induced by fructose rich diet in ß-cells: Its prevention by incretins

The watershed transform is considered as the most appropriate method for image segmentation in the field of mathematical morphology. In the following paper, we present an adapted topological watershed algorithm suited for a rapid and effective implementation on Shared Memory Parallel Machine (SMPM). The introduced algorithm allows a parallel watershed computing while preserving the given topology. No prior minima extraction is needed, nor the use of any sorting step or hierarchical queue. The strategy that guides the parallel watershed computing, labeled SDM-Strategy (equivalent to Split-Distributes and Merge), is also presented. Experimental analyses such as execution time, performance enhancement, cache consumption, efficiency and scalability are also presented and discussed.

Concurrent vs. Exclusive Reading in Parallel Decoding of LZ-Compressed Files

Broadcasting a message from one to many processors in a network corresponds to concurrent reading on a random access shared memory parallel machine. Computing the trees of a forest, the level of each node in its tree and the path between two nodes are problems that can easily be solved with concurrent reading in a time logarithmic in the maximum height of a tree. Solving such problems with exclusive reading requires a time logarithmic in the number of nodes, implying message passing between disjoint pairs of processors on a distributed system. Allowing concurrent reading in parallel algorithm design for distributed computing might be advantageous in practice if these problems are faced on shallow trees with some specific constraints. We show an application to LZC (Lempel-Ziv-Compress)-compressed file decoding, whose parallelization employs these computations on such trees for realistic data. On the other hand, zipped files do not have this advantage, since they are compressed by the Lempel–Ziv sliding window technique.

FSAIPACK

The Factorized Sparse Approximate Inverse (FSAI) is an efficient technique for preconditioning parallel solvers of symmetric positive definite sparse linear systems. The key factor controlling FSAI efficiency is the identification of an appropriate nonzero pattern. Currently, several strategies have been proposed for building such a nonzero pattern, using both static and dynamic techniques. This article describes a fresh software package, called FSAIPACK, which we developed for shared memory parallel machines. It collects all available algorithms for computing FSAI preconditioners. FSAIPACK allows for combining different techniques according to any specified strategy, hence enabling the user to thoroughly exploit the potential of each preconditioner, in solving any peculiar problem. FSAIPACK is freely available as a compiled library at http://www.dmsa.unipd.it/~janna/software.html, together with an open-source command language interpreter. By writing a command ASCII file, one can easily perform and test any given strategy for building an FSAI preconditioner. Numerical experiments are discussed in order to highlight the FSAIPACK features and evaluate its computational performance.

HYPERGRAMMAR-BASED PARALLEL MULTI-FRONTAL SOLVER FOR GRIDS WITH POINT SINGULARITIES

This paper describes the application of hypergraph grammars to drive a linear computational cost solver for grids with point singularities. Such graph gram- mar productions are the first mathematical formalisms used to describe solver algorithms, and each indicates the smallest atomic task that can be executed in parallel, which is very useful in the case of parallel execution. In particular, the partial order of execution of graph grammar productions can be found, and the sets of independent graph grammar productions can be localized. They can be scheduled set by set into a shared memory parallel machine. The graph- grammar-based solver has been implemented with NVIDIA CUDA for GPU. Graph grammar productions are accompanied by numerical results for a 2D case. We show that our graph-grammar-based solver with a GPU accelerator is, by order of magnitude, faster than the state-of-the-art MUMPS solver.

GRAMMAR BASED MULTI-FRONTAL SOLVER FOR ISOGEOMETRIC ANALYSIS IN 1D

In this paper we present multi-frontal direct solver for one dimensional isogeometric finiteelement method. The solver implementation is based on graph-grammar (GG) model. TheGG model allows to express the entire solver algorithm, including generation of frontalmatrices, maerging and eliminations, as a set of basic undividable tasks called graph grammarproductions. Having the solver algorithm expressed as GG productions we can find thepartial order of execution, and create the dependency graph allowing for scheduling of tasksinto shared memory parallel machine. We focus on the implementation of the solver withNVIDIA CUDA on the graphic processing unit (GPU). The solver has been tested for linear,quadratic, cubic and higher ordere B-splines, resulting in logarithmic scalability.

Efficient Hardware Barrier Synchronization in Many-Core CMPs

Traditional software-based barrier implementations for shared memory parallel machines tend to produce hotspots in terms of memory and network contention as the number of processors increases. This could limit their applicability to future many-core CMPs in which possibly several dozens of cores would need to be synchronized efficiently. In this work, we develop GBarrier, a hardware-based barrier mechanism especially aimed at providing efficient barriers in future many-core CMPs. Our proposal deploys a dedicated G-line-based network to allow for fast and efficient signaling of barrier arrival and departure. Since GBarrier does not have any influence on the memory system, we avoid all coherence activity and barrier-related network traffic that traditional approaches introduce and that restrict scalability. Through detailed simulations of a 32-core CMP, we compare GBarrier against one of the most efficient software-based barrier implementations for a set of kernels and scientific applications. Evaluation results show average reductions of 54 and 21 percent in execution time, 53 and 18 percent in network traffic, and also 76 and 31 percent in the energy-delay <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> product metric for the full CMP when the kernels and scientific applications, respectively, are considered.

Enhanced computation method of topological smoothing on shared memory parallel machines

To prepare images for better segmentation, we need preprocessing applications, such as smoothing, to reduce noise. In this paper, we present an enhanced computation method for smoothing 2D object in binary case. Unlike existing approaches, proposed method provides a parallel computation and better memory management, while preserving the topology (number of connected components) of the original image by using homotopic transformations defined in the framework of digital topology. We introduce an adapted parallelization strategy called split, distribute and merge (SDM) strategy which allows efficient parallelization of a large class of topological operators. To achieve a good speedup and better memory allocation, we cared about task scheduling and managing. Distributed work during smoothing process is done by a variable number of threads. Tests on 2D grayscale image (512*512), using shared memory parallel machine (SMPM) with 8 CPU cores (2× Xeon E5405 running at frequency of 2 GHz), showed an enhancement of 5.2 with cache success rate of 70%.

Parallel memory prediction for fused linear algebra kernels

The performance of many scientific programs is limited by data movement. Loop fusion is one optimization used to increase the speed of memory bound operations. To automate loop fusion for matrix computations, we developed the Build to Order (BTO) compiler. Within BTO, an analytic memory model efficiently and accurately reduces the number of serial loop fusion options considered. In this paper, we extend the model to shared memory parallel machines. We detail the differences between parallel and serial memory use and runtime prediction and explain the changes made to include parallel machines in the model. Analysis of the parallel model's predictions show that when it is included in BTO it will reduce the search space of considered routines.

Implementations of a Parallel Algorithm for Computing Euclidean Distance Map in Multicore Processors and GPUs

Given a 2-D binary image of size n×n, Euclidean Distance Map (EDM) is a 2-D array of the same size such that each element is storing the Euclidean distance to the nearest black pixel. It is known that a sequential algorithm can compute the EDM in O(n2) and thus this algorithm is optimal. Also, work-time optimal parallel algorithms for shared memory model have been presented. However, the presented parallel algorithms are too complicated to implement in existing shared memory parallel machines. The main contribution of this paper is to develop a simple parallel algorithm for the EDM and implement it in two different parallel platforms: multicore processors and Graphics Processing Units (GPUs). We have implemented our parallel algorithm in a Linux server with four Intel hexad-core processors (Intel Xeon X7460 2.66GHz). We have also implemented it in the following two modern GPU systems, Tesla C1060 and GTX 480, respectively. The experimental results have shown that, for an input binary image with size of 9216×9216, our implementation in the multicore system achieves a speedup factor of 18 over the performance of a sequential algorithm using a single processor in the same system. Meanwhile, for the same input binary image, our implementation on the GPU achieves a speedup factor of 26 over the sequential algorithm implementation.

Scalability and Communication in Parallel Low-Complexity Lossless Compression

Approximation schemes for optimal compression with static and sliding dictionaries which can run on a simple array of processors with distributed memory and no interconnections are presented. These approximation algorithms can be implemented on both small and large scale parallel systems. The sliding dictionary method requires large size files on large scale systems. As far as lossless image compression is concerned, arithmetic encoders enable the best lossless compressors but they are often ruled out because they are too complex. Storer extended dictionary text compression to bi-level images to avoid arithmetic encoders (BLOCK MATCHING). We were able to partition an image into up to a hundred areas and to apply the BLOCK MATCHING heuristic independently to each area with no loss of compression effectiveness. Therefore, the approach is suitable for a small scale parallel system at no communication cost. On the other hand, bi-level image compression seems to require communication on large scale systems. With regard to grey scale and color images, parallelizable lossless image compression (PALIC) is a highly parallelizable and scalable lossless compressor since it is applied independently to blocks of 8 × 8 pixels. We experimented the BLOCK MATCHING and PALIC heuristics with up to 32 processors of a 256 Intel Xeon 3.06 GHz processors machine (http://avogadro.cilea.it) on a test set of large topographic bi-level images and color images in RGB format. We obtained the expected speed-up of the compression and decompression times, achieving parallel running times about 25 times faster than the sequential ones. Finally, scalable algorithms computing static and sliding dictionary optimal text compression on an exclusive read, exclusive write shared memory parallel machine are presented. On the same model, compression by block matching of bi-level images is shown which can be implemented on a full binary tree architecture under some realistic assumptions with no scalability issues.

VINE—A NUMERICAL CODE FOR SIMULATING ASTROPHYSICAL SYSTEMS USING PARTICLES. I. DESCRIPTION OF THE PHYSICS AND THE NUMERICAL METHODS

We present a numerical code for simulating the evolution of astrophysical systems using particles to represent the underlying fluid flow. The code is written in Fortran 95 and is designed to be versatile, flexible and extensible, with modular options that can be selected either at the time the code is compiled or at run time through a text input file. We include a number of general purpose modules describing a variety of physical processes commonly required in the astrophysical community and we expect that the effort required to integrate additional or alternate modules into the code will small. In its simplest form the code can evolve the dynamical trajectories of a set of particles in two or three dimensions using a module which implements either a Leapfrog or Runge-Kutta-Fehlberg integrator, selected by the user at compile time. The user may choose to allow the integrator to evolve the system using individual timesteps for each particle or with a single, global time step for all. Particles may interact gravitationally as N-body particles, and all or any subset may also interact hydrodynamically, using the Smoothed Particle Hydrodynamic (SPH) method by selecting the SPH module. A third particle species can be included with a module to model massive point particles which may accrete nearby SPH or N-body particles. Such particles may be used to model, e.g., stars in a molecular cloud. Free boundary conditions are implemented by default, and a module may be selected to include periodic boundary conditions. We use a binary ‘Press’ tree to organize particles for rapid access in gravity and SPH calculations. Modules implementing an interface with special purpose ‘GRAPE’ hardware may also be selected to accelerate the gravity calculations. If available, forces obtained from the GRAPE coprocessors may be transparently substituted for those obtained from the tree, or both tree and GRAPE may be used as a combination GRAPE/tree code. The code may be run without modification on single processors or in parallel using OpenMP compiler directives on large scale, shared memory parallel machines. We present simulations of several test problems, including a merger simulation of two elliptical galaxies with 800000 particles. In comparison to the Gadget-2 code of Springel (2005), the gravitational force calculation, which is the most costly part of any simulation including self-gravity, is ∼ 4.6 − 4.9 times faster with VINE when tested on different snapshots of the elliptical galaxy merger simulation when run on an Itanium 2 processor in an SGI Altix. A full simulation of the same setup with 8 processors is a factor of 2.91 faster with VINE. The code is available to the public under the terms of the Gnu General Public License. Subject headings: methods: numerical — methods: N-body simulations — galaxies: interactions

VINE—A NUMERICAL CODE FOR SIMULATING ASTROPHYSICAL SYSTEMS USING PARTICLES. II. IMPLEMENTATION AND PERFORMANCE CHARACTERISTICS

We continue our presentation of VINE. In this paper, we begin with a description of relevant architectural properties of the serial and shared memory parallel computers on which VINE is intended to run, and describe their influences on the design of the code itself. We continue with a detailed description of a number of optimizations made to the layout of the particle data in memory and to our implementation of a binary tree used to access that data for use in gravitational force calculations and searches for SPH neighbor particles. We describe the modifications to the code necessary to obtain forces efficiently from special purpose ‘GRAPE’ hardware, the interfaces required to allow transparent substitution of those forces in the code instead of those obtained from the tree, and the modifications necessary to use both tree and GRAPE together as a fused GRAPE/tree combination. We conclude with an extensive series of performance tests, which demonstrate that the code can be run efficiently and without modification in serial on small workstations or in parallel using the OpenMP compiler directives on large scale, shared memory parallel machines. We analyze the effects of the code optimizations and estimate that they improve its overall performance by more than an order of magnitude over that obtained by many other tree codes. Scaled parallel performance of the gravity and SPH calculations, together the most costly components of most simulations, is nearly linear up to at least 120 processors on moderate sized test problems using the Origin 3000 architecture, and to the maximum machine sizes available to us on several other architectures. At similar accuracy, performance of VINE, used in GRAPE-tree mode, is approximately a factor two slower than that of VINE, used in host-only mode. Further optimizations of the GRAPE/host communications could improve the speed by as much as a factor of three, but have not yet been implemented in VINE. Finally, we find that although parallel performance on small problems may reach a plateau beyond which more processors bring no additional speedup, performance never decreases, a factor important for running large simulations on many processors with individual time steps, where only a small fraction of the total particles require updates at any given moment. Subject headings: methods: numerical — methods: N-body simulations

A Fully Pipelined Multishift QR Algorithm for Parallel Solution of Symmetric Tridiagonal Eigenproblems

In this paper, we propose a fully pipelined multishift QR algorithm to compute all the eigenvalues of a symmetric tridiagonal matrix on parallel machines. Existing approaches for parallelizing the tridiagonal QR algorithm, such as the conventional multishift QR algorithm and the deferred shift QR algorithm, have suffered from either inefficiency of processor utilization or deterioration of convergence properties. In contrast, our algorithm realizes both efficient processor utilization and improved convergence properties at the same time by adopting a new shifting strategy. Numerical experiments on a shared memory parallel machine (Fujitsu PrimePower HPC2500) with 32 processors show that our algorithm is up to 1.9 times faster than the conventional multishift algorithm and up to 1.7 times faster than the deferred shift algorithm.

INTRA- AND INTER-ITERATION 3D OSEM PET IMAGE RECONSTRUCTION

Most of the recent medical imaging modalities use noninvasive means to obtain the activity information inside human organs, so doctors may detect the initial symptoms of a disease as early as possible and give appropriate treatment. PET is to use radio-isotopes which can emit positrons in its clinical and research uses. By injecting the nuclear medicine drug formed by labeling a radioelement to molecules of deoxidized glucose to a patient and after the cells in the patient body absorbing it through metabolic functions, the detectors will receive annihilation coincidence events formed from the number of the positrons generated from the response of the labeled deoxidized glucose molecules. The most critical module of the modality therefore is the procedure regarding how to reconstruct good quality images using the collected projection information. However, in the reconstruction process, MLEM involves massive data in considerable number of iterations in order to yield accurate images and takes quite a long time in computation. Ordered Subsets Expectation Maximization (OSEM) was proposed to accelerate the reconstruction process by expediting the convergence while maintaining the same image quality as those produced by MLEM. Since then, OSEM iterative algorithm has become the de facto reconstruction method adopted by most PET installations. To further improve the image quality, both clinical and research data have been acquired in 3D mode on the majority of the current systems. The accompanied computational load of iterative reconstruction increases considerably resulting from the 3D OSEM method. Attributed to the fact of the recent technological advancement, many high-performance parallel methods have been proposed to speed up the reconstruction process. These methods in general are to partition data into several sets before applying any parallel acceleration. They do not take on the nature of OSEM method to identify the intrinsic data dependencies. This project intends to analyze the iterative natures of the 3D OSEM method, particularly the intra- and inter-iteration aspects of the reconstruction method along with the latest shared-memory parallel machine architecture. Experiments will be conducted to demonstrate its superior performance over the existing methods.

Toward an automated parallel computing environment for geosciences

Software for geodynamic modeling has not kept up with the fast growing computing hardware and network resources. In the past decade supercomputing power has become available to most researchers in the form of affordable Beowulf clusters and other parallel computer platforms. However, to take full advantage of such computing power requires developing parallel algorithms and associated software, a task that is often too daunting for geoscience modelers whose main expertise is in geosciences. We introduce here an automated parallel computing environment built on open-source algorithms and libraries. Users interact with this computing environment by specifying the partial differential equations, solvers, and model-specific properties using an English-like modeling language in the input files. The system then automatically generates the finite element codes that can be run on distributed or shared memory parallel machines. This system is dynamic and flexible, allowing users to address different problems in geosciences. It is capable of providing web-based services, enabling users to generate source codes online. This unique feature will facilitate high-performance computing to be integrated with distributed data grids in the emerging cyber-infrastructures for geosciences. In this paper we discuss the principles of this automated modeling environment and provide examples to demonstrate its versatility.

CTL* model checking on a shared-memory architecture

In this article we present the parallelisation of an explicit-state CTL* model checking algorithm for a virtual shared-memory high-performance parallel machine architecture. The algorithm uses a combination of private and shared data structures for implicit and dynamic load balancing with minimal synchronisation overhead. The performance of the algorithm and the impact that different design decisions have on the performance are analysed using both mathematical cost models and experimental results. The analysis shows not only the practicality and effective speedup of the algorithm, but also the main pitfalls of parallelising model checking for shared-memory architectures.