Structured parallel programming

  title={Structured parallel programming},
  author={John Darlington and Munir A. Ghanem and Hing Wing To},
  journal={Proceedings of Workshop on Programming Models for Massively Parallel Computers},
  • J. Darlington, M. Ghanem, H. To
  • Published 20 September 1993
  • Computer Science
  • Proceedings of Workshop on Programming Models for Massively Parallel Computers
Parallel programming is a difficult task involving many complex issues such as resource allocation, and process coordination. We propose a solution to this problem based on the use of a repertoire of parallel algorithmic forms, known as skeletons. The use of skeletons enables the meaning of a parallel program to be separated from its behaviour. Central to this methodology is the use of transformations and performance models. Transformations provide portability and implementation choices, whilst… 

Figures from this paper

Co-ordinating Heterogeneous Parallel Computation
This paper proposes that functional skeletons are used to express resource allocation strategies in heterogeneous high performance computing environments by associating performance models with each skeleton, thus providing a tool for guiding the choice of resource allocation.
The Performance of Parallel Algorithmic Skeletons
The approach is illustrated by examples based on existing special purpose languages for image processing, and is extended to analyse the scalability of skeleton-based applications, using isoeeciency functions.
Profess : A Portable System for Prototyping the Performance ofParallel
The underlying language and basic components of the tool are presented, an initial implementation on the AP1000 parallel machine is described, preliminary results of using the system are discussed and the total time required for executing each implementation is described.
Optimising the parallel behaviour of combinations of program components
  • H. To
  • Computer Science
  • 1995
This thesis explores the problem of optimising combinations of skeletons, where each skeleton may have more than one underlying parallel implementation and a skeleton approach suitable for expressing programs as combinations of skeleton is presented.
Interprocedural optimisation of regular parallel computations at runtime
This thesis concerns techniques for efficient runtime optimisation of regular parallel programs that are built from separate software components, and proposes a delayed evaluation, self-optimising (DESO) library of data-parallel numerical routines that is implemented in a parallel version of the widely used Basic Linear Algebra Subroutines (BLAS) library.
Skeletons, BSP and Performance Portability
The paper claims that an intermediate model embedding the main performance features of the target architecture facilitates performance portability across parallel architectures.
A Lazy, Self-optimizing Parallel Matrix Library
A parallel implementation of a matrix/vector library for C++ for a large distributed-memory multicomputer is described, which aims to get much of the performance of compile-time optimisation, possibly more by using run-time information, while retaining the ease with which a library can be installed and used.
An Experimentation Platform for the Automatic Parallelization of R Programs
The ALCHEMY platform is presented that supports the automatic parallelization of R programs during execution and enables ample experimentation with different approaches to the automatic Parallelization of scripting languages such as R.
A cost analysis for a higher-order parallel programming model
The main contribution of the thesis is the cost model which aims to predict realistic performances and which considers several possible parallel implementations for a given program before selecting a cost-e ective one.
Paper : A Lazy , Self-optimising Parallel Matrix Library
This paper describes a parallel implementation of a matrix/vector library for C++ for a large distributed-memory multicomputer. The library is “self-optimising” by exploiting lazy evaluation:


Parallel Programming Using Skeleton Functions
Performance will be generally poor unless the issue of resource allocation is addressed explicitly, diminishing the advantage of using a functional language in the first place.
Building parallel applications without programming
This approach provides a path to eecient but correct programs by separating the issues of behaviour and meaning, and through the exploitation of the knowledge the authors have about the xed patterns of computation and communication of the skeletons.
Algorithmic Skeletons: Structured Management of Parallel Computation
This book introduces a new approach to the design and implementation of software systems which will help users of large scale parallel systems coordinate many concurrent activities toward a single goal and proposes a selection of independent algorithmic skeletons which describes the structure of a particular style of algorithm.
Functional programming for loosely-coupled multiprocessors
  • P. Kelly
  • Computer Science
    Research monographs in parallel and distributed computing
  • 1989
This book proposes a new high level approach to programming that addresses the pragmatic issue of how a computation is distributed across a machine, based on functional programming and has significant advantages over existing comparable approaches, extending the domain of functional programming to include computer architectures in which communication costs are not negligible.
General Purpose Parallel Architectures
  • L. Valiant
  • Computer Science
    Handbook of Theoretical Computer Science, Volume A: Algorithms and Complexity
  • 1990
Introduction to functional programming
  • R. Bird, P. Wadler
  • Economics
    Prentice Hall International series in computer science
  • 1988
This is a thorough introduction to the fundamental concepts of functional programming that includes a simple, yet coherent treatment of the Haskell class; a calculus of time complexity; and new coverage of monadic input-output.
Practical parallel processing with transputers
It is demonstrated that reconfigurable transputer arrays provide a flexible, powerful and easily programmable approach to parallel processing.
Garbage collection in an uncooperative environment
This approach greatly simplifies the implementation of languages supporting garbage collection and allows conventional compilers to be used with a garbage collector, either as the primary means of storage reclamation, or as a debugging tool.
Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs
A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules; these systems have semantics loosely coupled to states—only one state transition occurs per major computation.