Constantinos J. Siniolakis

Deterministic sorting and randomized median finding on the BSP model

We present new BSP algorithms for deterministic sorting and rmdomized median finding. We sort n general keys by using a partitioning scheme that achieves the requirements of efficiency (one-optimality) and insensitivity against data skew (the accuracy of the splitting keys depends solely on the step distance, which can be adapted to meet the worstcase requirements of our application). Although we employ sampling in order to realize efficiency, we can give a precise worst-case estimation of the maximum imbalance which might occur. We also investigate optimal randomized BSP algorithms for the problem of finding the median of n elements that require, with high-probability, 3rz/(2p) + o(n/p) number of comparisons, for a wide range of values of n and p. Experimental results for the two algorithms are also presented

EFFICIENT DETERMINISTIC SORTING ON THE BSP MODEL

We present a new algorithm for deterministic sorting on the Bulk-Synchronous Parallel (BSP) model of computation. We sort n keys using a partitioning scheme that achieves the requirements of efficiency (one-optimality) and insensitivity against initial key distribution. Although we employ sampling to realize efficiency, we give a precise worst-case estimation of the maximum imbalance which might occur. The algorithm is one-optimal for a wide range of the BSP parameters in the sense that its speedup on p processors is asymptotically (1 - o(1))p.

A randomized sorting algorithm on the BSP model

The authors present a new randomized sorting algorithm on the bulk-synchronous parallel (BSP) model. The algorithm improves upon the parallel slack of previous algorithms to achieve optimality. Tighter probabilistic bounds are also established. It uses sample sorting and utilizes recently introduced search algorithms for a class of data structures on the BSP model. Moreover the methods are within a 1+o(1) multiplicative factor of the respective sequential methods in terms of speedup for a wide range of the BSP parameters.

Architecture independent parallel selection with applications to parallel priority queues

We present a randomized selection algorithm whose performance is analyzed in an architecture independent way on the bulk-synchronous parallel (BSP) model of computation along with an application of this algorithm to dynamic data structures, namely parallel priority queues. We show that our algorithms improve previous results upon both the communication requirements and the amount of parallel slack required to achieve optimal performance. We also establish that optimality to within small multiplicative constant factors can be achieved for a wide range of parallel machines. While these algorithms are fairly simple themselves, descriptions of their performance in terms of the BSP parameters is somewhat involved; the main reward of quantifying these complications is that it allows transportable software to be written for parallel machines that fit the model.

Communication Efficient Data Structures on the BSP Model with Applications in Computational Geometry

The implementation of data structures on distributed memory models, like the Bulk-Synchronous Parallel (BSP), rather than shared memory ones, like the PRAM, offers a serious challenge. In this paper we undertake the architecture independent study of the communication and synchronization requirements of searching “ordered h-level graphs”, which include most of the standard data structures. We propose n-way search as a general tool for the design, analysis, and implementation of BSP algorithms. This technique allows elegant high-level design and analysis of algorithms, using data structures similar to that of sequential models. Our methods are within a 1 + o(1) factor of the respective sequential methods. An application to computational geometry is also presented.

Merging on the BSP model

Abstract The design of complex parallel algorithms relies heavily on a set of primitive operations. In this work, we examine the problem of merging two sorted sequences in an architecture independent setting. We derive parallel algorithms that can be used on a variety of parallel machines and whose performance can be reliably predicted if these algorithms are analyzed under the bulk-synchronous parallel (BSP) model. While our algorithms are fairly simple themselves, description of their performance in terms of the BSP parameters is somewhat complicated. The main reward for quantifying these complications, is that it enables parallel software to be written once and for all that can be migrated efficiently among a variety of parallel platforms. The optimal merging algorithm presented in this work achieves asymptotically optimal parallel efficiency compared to any optimal sequential merging algorithm.

Portable and architecture independent parallel performance tuning using BSP

A call-graph profiling tool has been designed and implemented to analyse the efficiency of programs written in BSPlib, This tool highlights computation and communication imbalance in parallel programs, exposing portions of program code which are amenable to improvement.A unique feature of this profiler is that it uses the bulk synchronous parallel cost model, thus providing a mechanism for portable and architecture-independent parallel performance tuning. In order to test the capabilities of the model on a real-world example, the performance characteristics of an SQL query processing application are investigated on a number of different parallel architectures.

Portable and architecture independent parallel performance tuning using a call-graph profiling tool

The paper describes a post mortem call graph profiling tool that analyses trace information generated during the execution of BSPlib programs. The purpose of the tool is to expose imbalance in either computation or communication, and to highlight portions of code that are amenable to improvement. Unlike other profiling tools, the profile information guides optimisation in an architecture independent way. From an ease of use perspective, the amount of information displayed when visualising a profile for a parallel program is no more complex than that of a sequential program.

An experimental study of BSP sorting algorithms

The bulk-synchronous parallel (BSP) model of computation has been proposed as a unifying and bridging model for the design, analysis and implementation of parallel algorithms that are both scalable and portable among diverse parallel machines. The authors implement, using the Oxford BSP Toolset, BSPlib, a number of BSP deterministic and randomized sorting algorithms on a variety of parallel systems, including the SGI Power Challenge and the CRAY T3D. The experimental results illustrate the efficiency, portability and reusability of the algorithms across such diverse hardware platforms, and reinforce their claim that the BSP model can be used as a kind of programming paradigm.

PRAM programming: theory vs. practice

We investigate the practical viability of PRAM programming within the BSP framework. We argue that there is a necessity for PRAM computations in situations where the problem exhibits poor data locality. We introduce a C++ PRAM simulator that is built on top of the Oxford BSP Toolset, BSPlib, and provide a succinct PRAM language. Our approach achieves simplicity of programming over direct-mode BSP programming for reasonable overhead cost. We objectively compare optimized BSP algorithms with PRAM algorithms implemented with our library and provide encouraging experimental results for the latter style of programming.