From (sequential) Haskell to (parallel) Eden: An implementation point of view

Breitinger, Silvia; Klusik, Ulrike; Loogen, Rita

doi:10.1007/bfb0056623

Cited by 12 publications

(7 citation statements)

References 10 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The DREAM runtime system (Breitinger et al, 1998;Klusik et al, 1999) was the first working implementation of Eden. It was originally implemented by adapting the GUM implementation to comply with the the DREAM abstract machine model (Breitinger et al, 1997).…”

Section: Implementations Of Gph and Edenmentioning

confidence: 99%

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Berthold

Loidl²,

Hammond

2016

J. Funct. Prog.

View full text Add to dashboard Cite

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 a portable and high-level shared-nothing implementation 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. * Corresponding author. Reported work performed while at the University of Copenhagen (DIKU).

show abstract

Section: Implementations Of Gph and Edenmentioning

confidence: 99%

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Berthold

Loidl²,

Hammond

2016

J. Funct. Prog.

View full text Add to dashboard Cite

show abstract

“…In principle, it shares its parallel runtime system (PRTS) with Glasgow parallel Haskell [58] but due to the disjoint address spaces of its processes does not need to implement a virtual shared memory and global garbage collection in contrast to GpH. In the following, we abstract from low-level implementation details like graph reduction and thread management which are explained elsewhere [47,58,14,34] and describe Eden's implementation on top of the module This module provides primitive monadic operations which are used to implement the Eden constructs on a higher-level of abstraction [10]. …”

Section: Behind the Scenes: Eden's Implementationmentioning

confidence: 99%

Eden – Parallel Functional Programming with Haskell

Loogen

2012

Central European Functional Programming School

Self Cite

View full text Add to dashboard Cite

Abstract. Eden is a parallel functional programming language which extends Haskell with constructs for the definition and instantiation of parallel processes. Processes evaluate function applications remotely in parallel. The programmer has control over process granularity, data distribution, communication topology, and evaluation site, but need not manage synchronisation and data exchange between processes. The latter are performed by the parallel runtime system through implicit communication channels, transparent to the programmer. Common and sophisticated parallel communication patterns and topologies, so-called algorithmic skeletons, are provided as higher-order functions in a user-extensible skeleton library written in Eden. Eden is geared toward distributed settings, i.e. processes do not share any data, but can equally well be used on multicore systems. This tutorial gives an up-to-date introduction into Eden's programming methodology based on algorithmic skeletons, its language constructs, and its layered implementation on top of the Glasgow Haskell compiler.

show abstract

“…The primitive operations implement basic actions which have to be performed directly in the runtime system of the underlying sequential compiler GHC 3 . In the Eden module, every primitive operation is wrapped in In the following, we abstract from low-level implementation details like graph reduction and thread management which are well-understood and explained elsewhere [12,19,2]. Instead we focus on coordination aspects, in particular process abstractions and process instantiations and their implementation in the Eden module.…”

Section: A Layered Implementation Of Coordinationmentioning

confidence: 99%

“…By embedding Eden's syntax into Haskell, we could use the frontend of the compiler without any changes. The bulk of the extensions lies in the back end of the compiler and the RTS [2,7]. Kernel parts of the parallel functional RTS, like thread and memory management, are shared with GUM, the implementation of GpH [19].…”

Section: Introductionmentioning

confidence: 99%

High-Level Process Control in Eden

Berthold

Klusik

Loogen

et al. 2003

Euro-Par 2003 Parallel Processing

Self Cite

View full text Add to dashboard Cite

Abstract. High-level control of parallel process behaviour simplifies the development of parallel software substantially by freeing the programmer from low-level process management and coordination details. The latter are handled by a sophisticated runtime system which controls program execution. In this paper we look behind the scenes and show how the enormous gap between high-level parallel language constructs and their low-level implementation has been bridged in the implementation of the parallel functional language Eden. The main idea has been to implement the process control in a functional language and to restrict the extensions of the low-level runtime system to a few selected primitive operations.

show abstract

From (sequential) Haskell to (parallel) Eden: An implementation point of view

Cited by 12 publications

References 10 publications

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Eden – Parallel Functional Programming with Haskell

High-Level Process Control in Eden

Contact Info

Product

Resources

About