PAEAN: Portable and Scalable Runtime Support for Parallel Haskell Dialects

Jost Berthold, Hans-Wolfgang Loidl, Kevin Hammond

Research output: Contribution to journalArticle

Abstract

Over time, several competing approaches to parallel Haskell programming have emerged. Different approaches support parallelism at various different scales, ranging from small multicores to massively parallel high-performance computing systems. They also provide varying degrees of control, ranging from completely implicit approaches to ones providing full programmer control. Most current designs assume a shared memory model at the programmer, implementation and hardware levels. This is, however, becoming increasingly divorced from the reality at the hardware level. It also imposes significant unwanted runtime overheads in the form of garbage collection synchronisation etc. What is needed is an easy way to abstract over the implementation and hardware levels, while presenting a simple parallelism model to the programmer.The PAEAN (PArallEl shAred Nothing) runtime system design aims to provide aportable and high-level shared-nothingimplementation platform for parallel Haskell dialects. It abstracts over major issues such as work distribution and data serialisation, consolidating existing, successful designs into a single framework. It also provides an optional virtual shared-memory programming abstraction for (possibly) shared-nothing parallel machines, such as modern multicore/manycore architectures or cluster/cloud computing systems. It builds on, unifies, and extends, existing well-developed support for shared-memory parallelism that is provided by the widely-used GHC Haskell compiler. This paper summarises the state-of-the-art in shared-nothing parallel Haskell implementations, introduces the PAEAN abstractions, shows how they can be used to implement three distinct parallel Haskell dialects, and demonstrates that good scalability can be obtained on recent parallel machines.
Original languageEnglish
Article numbere10
Number of pages39
JournalJournal of Functional Programming
Volume26
DOIs
Publication statusPublished - 13 Jul 2016

Fingerprint

Data storage equipment
Hardware
Parallel programming
Cloud computing
Computer programming
Computer hardware
Scalability
Synchronization
Systems analysis

Cite this

@article{176425cc56a540bc86c1d0d2e8281a29,
title = "PAEAN: Portable and Scalable Runtime Support for Parallel Haskell Dialects",
abstract = "Over time, several competing approaches to parallel Haskell programming have emerged. Different approaches support parallelism at various different scales, ranging from small multicores to massively parallel high-performance computing systems. They also provide varying degrees of control, ranging from completely implicit approaches to ones providing full programmer control. Most current designs assume a shared memory model at the programmer, implementation and hardware levels. This is, however, becoming increasingly divorced from the reality at the hardware level. It also imposes significant unwanted runtime overheads in the form of garbage collection synchronisation etc. What is needed is an easy way to abstract over the implementation and hardware levels, while presenting a simple parallelism model to the programmer.The PAEAN (PArallEl shAred Nothing) runtime system design aims to provide aportable and high-level shared-nothingimplementation platform for parallel Haskell dialects. It abstracts over major issues such as work distribution and data serialisation, consolidating existing, successful designs into a single framework. It also provides an optional virtual shared-memory programming abstraction for (possibly) shared-nothing parallel machines, such as modern multicore/manycore architectures or cluster/cloud computing systems. It builds on, unifies, and extends, existing well-developed support for shared-memory parallelism that is provided by the widely-used GHC Haskell compiler. This paper summarises the state-of-the-art in shared-nothing parallel Haskell implementations, introduces the PAEAN abstractions, shows how they can be used to implement three distinct parallel Haskell dialects, and demonstrates that good scalability can be obtained on recent parallel machines.",
author = "Jost Berthold and Hans-Wolfgang Loidl and Kevin Hammond",
year = "2016",
month = "7",
day = "13",
doi = "10.1017/S0956796816000010",
language = "English",
volume = "26",
journal = "Journal of Functional Programming",
issn = "0956-7968",
publisher = "Cambridge University Press",

}

PAEAN: Portable and Scalable Runtime Support for Parallel Haskell Dialects. / Berthold, Jost; Loidl, Hans-Wolfgang; Hammond, Kevin.

In: Journal of Functional Programming, Vol. 26, e10, 13.07.2016.

Research output: Contribution to journalArticle

TY - JOUR

T1 - PAEAN: Portable and Scalable Runtime Support for Parallel Haskell Dialects

AU - Berthold, Jost

AU - Loidl, Hans-Wolfgang

AU - Hammond, Kevin

PY - 2016/7/13

Y1 - 2016/7/13

N2 - Over time, several competing approaches to parallel Haskell programming have emerged. Different approaches support parallelism at various different scales, ranging from small multicores to massively parallel high-performance computing systems. They also provide varying degrees of control, ranging from completely implicit approaches to ones providing full programmer control. Most current designs assume a shared memory model at the programmer, implementation and hardware levels. This is, however, becoming increasingly divorced from the reality at the hardware level. It also imposes significant unwanted runtime overheads in the form of garbage collection synchronisation etc. What is needed is an easy way to abstract over the implementation and hardware levels, while presenting a simple parallelism model to the programmer.The PAEAN (PArallEl shAred Nothing) runtime system design aims to provide aportable and high-level shared-nothingimplementation platform for parallel Haskell dialects. It abstracts over major issues such as work distribution and data serialisation, consolidating existing, successful designs into a single framework. It also provides an optional virtual shared-memory programming abstraction for (possibly) shared-nothing parallel machines, such as modern multicore/manycore architectures or cluster/cloud computing systems. It builds on, unifies, and extends, existing well-developed support for shared-memory parallelism that is provided by the widely-used GHC Haskell compiler. This paper summarises the state-of-the-art in shared-nothing parallel Haskell implementations, introduces the PAEAN abstractions, shows how they can be used to implement three distinct parallel Haskell dialects, and demonstrates that good scalability can be obtained on recent parallel machines.

AB - Over time, several competing approaches to parallel Haskell programming have emerged. Different approaches support parallelism at various different scales, ranging from small multicores to massively parallel high-performance computing systems. They also provide varying degrees of control, ranging from completely implicit approaches to ones providing full programmer control. Most current designs assume a shared memory model at the programmer, implementation and hardware levels. This is, however, becoming increasingly divorced from the reality at the hardware level. It also imposes significant unwanted runtime overheads in the form of garbage collection synchronisation etc. What is needed is an easy way to abstract over the implementation and hardware levels, while presenting a simple parallelism model to the programmer.The PAEAN (PArallEl shAred Nothing) runtime system design aims to provide aportable and high-level shared-nothingimplementation platform for parallel Haskell dialects. It abstracts over major issues such as work distribution and data serialisation, consolidating existing, successful designs into a single framework. It also provides an optional virtual shared-memory programming abstraction for (possibly) shared-nothing parallel machines, such as modern multicore/manycore architectures or cluster/cloud computing systems. It builds on, unifies, and extends, existing well-developed support for shared-memory parallelism that is provided by the widely-used GHC Haskell compiler. This paper summarises the state-of-the-art in shared-nothing parallel Haskell implementations, introduces the PAEAN abstractions, shows how they can be used to implement three distinct parallel Haskell dialects, and demonstrates that good scalability can be obtained on recent parallel machines.

U2 - 10.1017/S0956796816000010

DO - 10.1017/S0956796816000010

M3 - Article

VL - 26

JO - Journal of Functional Programming

JF - Journal of Functional Programming

SN - 0956-7968

M1 - e10

ER -