The Paderborn University BSP (PUB) library is a C communication library based on the BSP model. The basic library supports buffered as well as unbuffered non-blocking communication between any pair of processors and a mechanism for synchronizing the processors in a barrier style. In addition, PUB provides non-blocking collective communication operations on arbitrary subsets of processors, the ability to partition the processors into independent groups that execute asynchronously from each other, and a zero-cost synchronization mechanism. Furthermore, some techniques used in the implementation of the PUB library deviate significantly from the techniques used in other BSP libraries.

The Paderborn University BSP (PUB) library

The Bulk-Synchronous Parallel (BSP) model was proposed by Valiant as a model for general-purpose parallel computation. The objective of the model is to allow the design of parallel programs that can be executed efficiently on a variety of architectures. While many theoretical arguments in support of the BSP model have been presented, the degree to which the model can be efficiently utilized on existing parallel machines remains unclear. To explore this question, we implemented s small library of BSP functions, called the Green BSP library, on several parallel platfotms. We also created a number of parallel applications based on this library. Here, we report on the performance of six of these applications on three different parallel platforms. Our preliminary results suggest that the BSP model can be used to develop efficient and portable programs for a range of machines and applications.

Towards efficiency and portability: programming with the BSP model

A quantitative comparison of the BSP and LogP models for parallel computation is developed. Very efficient cross simulations between the two models are derived, showing their substantial equivalence for algorithmic design guided by asymptotic analysis. It is also shown that the two models can be implemented with similar performance on most point-to-point networks. In conclusion, within the limits of our analysis that is mainly of asymptotic nature, BSP and LogP can be viewed as closely related variants within the bandwidth-latency framework for modeling parallel computation. BSP seems somewhat preferable due to greater simplicity and portability, and slightly greater power.

BSP vs LogP

We present parallel algorithms for union, intersection and
difference on ordered sets using random balanced binary
trees (treaps [26]). For two sets of size n and m (m ≤ n) the
algorithms run in expected O(mlg(n=m)) work and O(lg n)
depth (parallel time) on an EREW PRAM with scan operations
(implying O(lg2 n) depth on a plain EREW PRAM).
As with the sequential algorithms on treaps for insertion
and deletion, the main advantage of our algorithms are their
simplicity. In fact, our algorithms for set operations seem
simpler than previous sequential algorithms with the same
work bounds, and might therefore also be useful in a sequential
context. To analyze the effectiveness of the algorithms
we implemented both sequential and parallel versions of the
algorithms and ran several experiments on them. Our parallel
implementation uses the Cilk [5] shared memory runtime
system on a 16 processor SGI Power Challenge and a
6 processor Sun Ultra Enterprise 3000. It shows reasonable
speedup: 6.3 to 6.8 speedup on 8 processors of the SGI, and
4.1 to 4.4 speedup on 5 processors of the Sun.

/pdf/fast-set-operations-using-treaps-1uu817m35m.pdf

Fast set operations using treaps

There has been a great deal of interest recently in the development of general-purpose bridging models for parallel computation. Models such as the BSP and LogP have been proposed as more realistic alternatives to the widely-used PRAM model. The BSP and LogP models imply a rather different style for designing algorithms when compared to the PRAM model. Indeed, while many consider data parallelism as a convenient style, and the shared-memory abstraction as an easy-to-use platform, the bandwidth limitations of current machines have diverted much attention to message-passing and distributed-memory models (such as the BSP and LogP) that account more properly for these limitations. In this paper we consider the question of whether a shared-memory model can serve as an effective bridging model for parallel computation. In particular, can a shared-memory model be as effective as, say, the BSP? As a candidate for a bridging model, we introduce the Queuing Shared Memory (QSM) model, which accounts for limited communication bandwidth while still providing a simple shared-memory abstraction. We substantiate the ability of the QSM to serve as a bridging model by providing a simple work-preserving emulation of the QSM on both the BSP, and on a related model, the (d,x)-BSP. We present evidence that the features of the QSM are essential to its effectiveness as a bridging model. In addition, we describe scenarios in which the high-level QSM more accurately models certain machines than the more detailed BSP and LogP models. Finally, we present algorithmic results for the QSM, as well as general strategies for mapping algorithms designed for the BSP or PRAM models onto the QSM model. Our main conclusion is that shared-memory models can potentially serve as viable alternatives to existing message-passing, distributed-memory bridging models.

/pdf/can-shared-memory-model-serve-as-a-bridging-model-for-1ara76yu2g.pdf

Can shared-memory model serve as a bridging model for parallel computation?

In this paper we design and analyse parallel algorithms with the goal to get exact bounds on their speed-ups on real machines. For this purpose we define an extension of Valiant's BSP model, BSP*, that rewards blockwise communication, and uses Valiant's notion of c-optimality. Intuitively a c-optimal parallel algorithm for p processors achieves speed-up close to p/c. We consider the Multisearch problem: Assume a strip in 2D to be partitioned into m segments. Given n query points in the strip, the task is to locate, for each query, its segment. For m ≤ n we present a deterministic BSP* algorithm that is 1-optimal, if n = Ω(p log2p). For m > n, we present a randomized BSP* algorithm that is (1 + δ)-optimal for arbitrary δ>0, m ≤ 2p and n=Ω(p log2p). Both results hold for a wide range of BSP* parameters where the range becomes larger with growing input sizes m and n. We further report on implementation work in progress. Previous parallel algorithms for Multisearch were far away from being c-optimal in our model and do not consider blockwise communication.

Truly efficient parallel algorithms: 1-optimal multisearch for an extension of the BSP model

Truly Efficient Parallel Algorithms: c-Optimal Multisearch for an Extension of the BSP Model (Extended Abstract)

Fully Dynamic Search Trees for an Extension of the BSP Model* Armin Baumker and Wolfgang Dittrich {abk, dittrich}(~uni-paderborn.de Department of Mathematics and Computer and Heinz Nixdorf Institute University of Paderborn D-33095 Paderborn, Germany Science We present parallel algorithms that maintain a 2-3 tree under insertions and deletions. The algorithms are designed for an extension of Valiant’s BSP model, BSP*, that and reduction of the overhead involved in communicant ion. The BSP*-model is introduced by Baumker et al. in [2]. Our analysis of the data structure goes beyond standard asymptotic analysis: We use Valiant’s notion of c-optimalit y. Intuitively c-optimal algorithms tend to speedup p/c with growing input size (p denotes the number of processors), where the communication time is asymptotically smaller than the computation time. Our first approach allows l-optimal searching and amortized c-optimal insertion and deletion for a small constant c. The second one allows 2-optimal searching, and c-optimal deletion and insertion for a small constant c. Both results hold with probability 1 – o(1) for wide ranges of BSP*parameters, where the ranges become larger with growing input sizes, The first approach allows much larger ranges. Further, both approaches are memory efficient, their total amount of memory used is proportional to the size m of the set being stored. Our results improve previous results by supporting a fully dynamic search tree rather than a static one, and by significantly reducing the communication time. Further our algorithms use blockwise communication.

Fully dynamic search trees for an extension of the BSP model

The Deterministic Complexity of Parallel Multisearch (Extended Abstract)

Given m ordered segments that form a partition of some universe (e.g., a 2D strip), the multisearch problem consists of determining, for a set of n query points in the universe, the segments they belong to. We present the first parallel deterministic scheme that efficiently solves the problem in the case m ≥ n. The scheme is designed on the BSP model, a variant of Valiant's BSP that rewards blockwise communication, and uses a suitable redundant representation of the data. Both computation and communication complexities are studied as functions of the redundancy. In particular, it is shown that optimal speed-up can be achieved using logarithmic redundancy. We also prove a lower bound on the communication requirements of any multisearch scheme realized on a distributed memory machine.

Armin Bäumker

Papers

Truly efficient parallel algorithms: 1-optimal multisearch for an extension of the BSP model

Truly Efficient Parallel Algorithms: c-Optimal Multisearch for an Extension of the BSP Model (Extended Abstract)

Fully dynamic search trees for an extension of the BSP model

The Deterministic Complexity of Parallel Multisearch (Extended Abstract)

The deterministic complexity of parallel multisearch