Gaétan Hains

A calculus of functional BSP programs

Abstract An extension of the λ -calculus called BS λ is introduced as a formal basis for functional languages expressing bulk synchronous parallel algorithms. A confluence result is shown. The application of the calculus is illustrated by examples of program proofs and the associated notion of parallel reduction. The reduction process is interpreted in the BSP cost model.

A conservative scheme for parallel interval narrowing

Abstract An efficient parallel interval narrowing algorithm for solving numerical problems is designed, implemented and tested. Differences with the corresponding sequential algorithm are clearly stated. The algorithms performance is analyzed in the Bulk-Synchronous Parallel (BSP) cost model which suggests speed-ups on high-bandwidth architectures. Experimental results on a massively parallel machine Cray T3E-1200 validate the model and show the parallel algorithms efficiency as well as its limitations.

An efficient equi-semi-join algorithm for distributed architectures

Semi-joins is the most used technique to optimize the treatment of complex relational queries on distributed architectures. However the overcost related to semi-joins computation can be very high due to data skew and to the high cost of communication in distributed architectures. In this paper we present a parallel equi-semi-join algorithm for shared nothing machines. The performance of this algorithm is analyzed using the BSP cost model and is proved to have asymptotic optimal complexity and perfect load balancing even for highly skewed data. This guarantees unlimited scalability in all situations for this key algorithm.

A Skew-insensitive Algorithm for Join and Multi-join Operations on Shared Nothing Machines

Join is an expensive and frequently used operation whose parallelization is highly desirable. However effectiveness of parallel joins depends on the ability to evenly divide load among processors. Data skew can have a disastrous effect on performance. Although many skew-handling algorithms have been proposed they remain generally inefficient in the case of multi-joins due to join product skew, costly and unnecessary redistribution and communication costs. A parallel join algorithm called fa_join has been introduced in an earlier paper with deterministic and near-perfect balancing properties. Despite its advantages, fa_join is sensitive to the correlation of the attribute value distributions in both relations. We present here an improved version of the algorithm called Sfa_join with a symmetric treatment of both relations. Its predictably low join-product and attribute-value skew makes it suitable for repeated use in multi-join operations. Its performance is analyzed theoretically and experimentally, to confirm its linear speed-up and its superiority over fa_join.

An Efficient Scalable Parallel View Maintenance Algorithm for Shared Nothing Multi-processor Machines

The problem of maintenance of materialized views has been the object of increased research activity recently mainly because of applications related to data warehousing. Many sequential view maintenance algorithms are developed in the literature. If the view is defined by a relational expression involving join operators, the cost of re-evaluating the view even incrementally may be unacceptable. Moreover, when views are materialized, parallelism can greatly increase processing power as necessary for view maintenance. n nIn this paper, we present a new parallel join algorithm by partial duplication of data and a new parallel view maintenance algorithm where views can involve multi-joins. The performances of these algorithms are analyzed using the scalable and portable BSP1 cost model which predicts a near-linear speedup.

A Generic Cost Model for Concurrent and Data-parallel Meta-computing

The CCS (Calculus of Communicating System) process algebra is a well-known formal model of synchronization and communication, useful for the analysis of safety and liveness in protocols or distributed programs, and in more recent works their security properties. BSP (Bulk-synchronous parallelism) is an algorithm- and programming model of data-parallel computation. It is useful for the design, analysis and programming of scalable parallel algorithms. Many current evolutions require the integration of distributed- and parallel programming: grid systems for sharing resources across the Internet, secure and reliable global access to parallel computer systems, geographic distribution of confidential data on randomly accessible systems, etc. Such software services must provide guarantees of safety, liveness, and security together with scalable and reliable performance. Formal models are therefore needed to combine parallel performance and concurrent behavior. With this goal in mind, we propose here an integration of BSP with CCS semantics, generalize its cost (performance) model and sketch its application to scheduling problems in meta-computing.

A bulk-synchronous parallel process algebra

The calculus of communicating systems (CCS) process algebra is a well-known formal model of synchronization and communication. It is used for the analysis of safety and liveness in protocols or distributed programs. In more recent work, it is used for the analysis of security properties. Bulk-synchronous parallelism (BSP) is an algorithm and programming model of data-parallel computation. It is useful for the design, analysis and programming of scalable parallel algorithms. Many current evolutions require the integration of distributed and parallel programming: grid systems for sharing resources across the Internet, secure and reliable global access to parallel computer systems, geographic distribution of confidential data on randomly accessible systems, etc. Such software services must provide guarantees of safety, liveness, security together with scalable and reliable performance. Formal models are therefore needed to combine parallel performance and concurrent behavior. With this goal in mind, we propose here an integration of BSP with CCS semantics, generalize its cost (performance) model and sketch its application to scheduling problems in meta-computing.

Implementation of Data-Parallel Skeletons: A Case Study Using a Coarse-Grained Hierarchical Model

Writing parallel programs is known to be notoriously difficult. Often programmers do not want to reason about message-passing algorithms and only want to combine existing high-level patterns to produce their parallel program. This is the algorithmic skeletons approach to parallel programming. It improves reliability and clarity of source code. But skeletons can be insufficient when complicated communication schemes are needed. Expressing skeletons in a more general and low level language in the form of a library seems to be a good compromise between simplicity and expressive power. In this article, we present a coarsed-grained implementation using a hierarchical model of a set of data-parallel skeletons. Programming experiments and benchmarks complete the article.

Concrete data structures and functional parallel programming

A framework is presented for designing parallel programming languages whose semantics is functional and where communications are explicit. To this end, Brookes and Geva’s generalized concrete data structures are specialized with a notion of explicit data layout to yield a CCC of distributed structures called arrays. Arrays’ symmetric replicated structures, suggested by the data-parallel SPMD paradigm, are found to be incompatible with sum types. We then outline a functional language with explicitly distributed (monomorphic) concrete types, including higher-order, sum and recursive ones. In this language, programs can be as large as the network and can observe communication events in other programs. Such =exibility is missing from current data-parallel languages and amounts to a fusion with their so-called annotations, directives or meta-languages. c 2001 Elsevier Science B.V. All rights reserved.

Functional Parallel Programming with Explicit Processes: Beyond SPMD

Parallel programming languages tend to waste algorithmic expressiveness to avoid deadlocks, non-determinism and the general complexity of concurrent languages. As a result, most of them dont specify data placement so that performance is unpredictable as a function of the source program (it depends on the language implementation, not its semantics). The BSP paradigm [7] demonstrates that explicit processor locations and explicit communications remove this uncertainty at the cost of a restricted programming style. We propose a solution to this dilemma by combining the events of process algebras and explicit processor locations of BSP with a higher-order functional language. The resulting language, CDS*, is derived from Berry and Curiens sequential language CDS0 and realizes Brookes and Gevas theory of deterministic parallel functions.