Global Data Dependencies Research Articles

Verification of concurrent code from synchronous specifications

• Methodology to generate concurrent code automatically from SIGNAL specifications. • New clock calculus method to explore the clock relations among signals. • Verification of concurrent code from SIGNAL specifications. The synchronous language SIGNAL is a formal specification formalism for developing safety-critical real-time systems. It is a multi-clocked data-flow modeling language suitable for specifying deterministic concurrent behaviors. Its model of computation and communication very well matches recent trends to utilize multi-core processors for executing real-time systems, by taking advantage of its concurrent semantics. The SIGNAL compiler generates code from data-flow specifications while analyzing and verifying safety properties of the system under design: deadlock-freedom, determinism. However, most of recent works have focused on generating sequential code from SIGNAL. Choosing the parallel library OpenMP as the target, this paper proposes a methodology to generate and verify concurrent code automatically from SIGNAL specifications. This is done by first exploring clock relations among signals by application of a so-called clock calculus. Then, specifications are translated into EDGs (Equation-Dependency Graphs) to analyze global data-dependency relations. An EDG is then partitioned into concurrent tasks to help explore parallelism in the original specification while preserving its semantic. Combined with clock relations, parallel tasks are finally mapped onto the OpenMP structures. The proposed approach is illustrated by a realistic case study.

Efficient GPU path rendering using scanline rasterization

We introduce a novel GPU path rendering method based on scan-line rasterization, which is highly work-efficient but traditionally considered as GPU hostile. Our method is parallelized over boundary fragments , i.e., pixels directly intersecting the path boundary. Non-boundary pixels are processed in bulk as horizontal spans like in CPU scanline rasterizers, which saves a significant amount of winding number computation workload. The distinction also allows the majority of our algorithmic steps to focus on boundary fragments only, which leads to highly balanced workload among the GPU threads. In addition, we develop a ray shooting pattern that minimizes the global data dependency when computing winding numbers at anti-aliasing samples. This allows us to shift the majority of winding-number-related workload to the same kernel that consumes its result, which saves a significant amount of GPU memory bandwidth. Experiments show that our method gives a consistent 2.5X speedup over state-of-the-art alternatives for high-quality rendering at Ultra HD resolution, which can increase to more than 30X in extreme cases. We can also get a consistent 10X speedup on animated input.

A single-cycle parallel multi-slice connected components analysis hardware architecture

In this paper, a memory-efficient architecture for single-pass connected components analysis suited for high-throughput embedded image processing systems is proposed which achieves a speedup by partitioning the image into slices. Although global data dependencies of image segments spanning several image slices exist, a temporal and spatial local algorithm is proposed, together with a suited FPGA hardware architecture processing pixel data at low latency. The low latency of the proposed architecture allows reuse of labels associated with the image objects. This reduces the amount of memory by a factor of more than 5 in the considered implementations which is a significant contribution since memory is a critical resource in embedded image processing on FPGAs. Therefore, a significantly higher bandwidth of pixel data can be processed with this architecture compared to the state-of-the-art architectures using the same amount of hardware resources.

Blue Matter: Scaling of N-body simulations to one atom per node

N-body simulations present some of the most interesting challenges in the area of massively parallel computing, especially when the object is to improve the time to solution for a fixed-size problem. The Blue Matter molecular simulation framework was developed specifically to address these challenges, to explore programming models for massively parallel machine architectures in a concrete context, and to support the scientific goals of the IBM Blue Gene® Project. This paper reviews the key issues involved in achieving ultrastrong scaling of methodologically correct biomolecular simulations, particularly the treatment of the long-range electrostatic forces present in simulations of proteins in water and membranes. Blue Matter computes these forces using the particle-particle particle-mesh Ewald (P3ME) method, which breaks the problem up into two pieces, one that requires the use of three-dimensional fast Fourier transforms with global data dependencies and another that involves computing interactions between pairs of particles within a cutoff distance. We summarize our exploration of the parallel decompositions used to compute these finite-ranged interactions, describe some of the implementation details involved in these decompositions, and present the evolution of strong-scaling performance achieved over the course of this exploration, along with evidence for the quality of simulation achieved.

Parallel iterative solvers for unstructured grids using a directive/MPI hybrid programming model for the GeoFEM platform on SMP cluster architectures

AbstractIn this paper, an efficient parallel iterative method for unstructured grids developed by the authors for shared memory symmetric multiprocessor (SMP) cluster architectures on the GeoFEM platform is presented. The method is based on a three‐level hybrid parallel programming model, including message passing for inter‐SMP node communication, loop directives for intra‐SMP node parallelization and vectorization for each processing element (PE). Simple 3D elastic linear problems with more than $10^8$ degrees of freedom have been solved by $3\times3$ block ICCG(0) with additive Schwarz domain decomposition and PDJDS/CM‐RCM reordering on 16 SMP nodes of a Hitachi SR8000 parallel computer, achieving a performance of 20 Gflops. The PDJDS/CM‐RCM reordering method provides excellent vector and parallel performance in SMP nodes, and is essential for parallelization of forward/backward substitution in IC/ILU factorization with global data dependency. The method developed was also tested on an NEC SX‐4 and attained 969 Mflops (48.5% of peak performance) using a single processor. The additive Schwarz domain decomposition method provides robustness for the GeoFEM parallel iterative solvers with localized preconditioning. Copyright © 2002 John Wiley & Sons, Ltd.

Parallel Iterative Solvers with Localized ILU Preconditioning for Unstructured Grids on Workstation Clusters

Incomplete Lower-Upper (0) (ILU(O)) factorization is a very effective preconditioning method of iterative solvers for large-scale linear sparse systems in scientific and engineering computations. However, this method requires global data dependency, which is not ideal for parallel computations in which locality is of utmost importance. In this paper, the localized ILU(O) preconditioning method is implemented in various types of iterative solvers. This method provides data locality and good parallelization on each processor. The performance of the developed system was evaluated on a workstation cluster using MPI. In 1997, the Science and Technology Agency of Japan (STA) began a five-year project to develop the Earth Simulator. Both hardware and software for various types of global earth simulation are to be developed under this project. The present study was conducted as part of the research on software for solid earth simulation. This simulation code, named GeoFEM, solves crust deformation, mantle convection, seismic wave propagation, etc., using the finite element method.

PARALLELIZATION OF A CLASS OF IMPLICIT FINITE DIFFERENCE SCHEMES IN COMPUTATIONAL FLUID DYNAMICS

Implicit finite difference schemes are often the preferred numerical methods in computational fluid dynamics, requiring less stringent stability bounds than the explicit schemes. Each iteration in an implicit scheme, however, involves global data dependencies in the form of second and higher order recurrences. Efficient parallel implementations of such methods, therefore, are more difficult and can be non-intuitive. Moreover, in practical applications, some sections of the computations are explicit while other sections are implicit in nature. Developing techniques that extract maximum parallelism simultaneously from all sections of an application is considerably harder than extracting parallelism from just an implicit section or an explicit section of the computations. In this paper, we consider issues in the parallelization of techniques that are used for solving Euler and thin-layer Navier-Stokes equations and that require, as a part of the computation, solving large linear systems in the form of block tri-diagonal and/or scalar penta-diagonal matrices. We focus our attention on three-dimensional cases and present schemes that minimize the total execution time when implemented on a message passing system. We describe various partitioning and scheduling strategies for alleviating the effects of the global data dependencies. Analyses of the computation, the communication, and the memory requirements of these methods are presented. The ARC-3D code, developed at NASA Ames, is used as an example application. Performance of the proposed methods is verified on the Victor multiprocessor system, a message passing architecture developed at the IBM T.J. Watson Research Center.