Skeleton Composition Using Remote Data

Dieterle, Mischa; Horstmeyer, Thomas; Loogen, Rita

doi:10.1007/978-3-642-11503-5_8

Cited by 7 publications

(11 citation statements)

References 6 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…If for example the input lists overlap (e.g. c ′ ( [1,2,3,4], [3,4,5,6])) a simple swap would not fulfill the requirements. We would prefer a result such as ( [1,2,3,3], [4,4,5,6]) and therefore A ′ can not be a permutation of A but we expect that every element a ij from A 1 , .…”

Section: Agglomeration Law For Sorting Networkmentioning

confidence: 99%

An Agglomeration Law for Sorting Networks and its Application in Functional Programming

Schiller¹

2017

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

In this paper we will present a general agglomeration law for sorting networks. Agglomeration is a common technique when designing parallel programmes to control the granularity of the computation thereby finding a better fit between the algorithm and the machine on which the algorithm runs. Usually this is done by grouping smaller tasks and computing them en bloc within one parallel process. In the case of sorting networks this could be done by computing bigger parts of the network with one process. The agglomeration law in this paper pursues a different strategy: The input data is grouped and the algorithm is generalised to work on the agglomerated input while the original structure of the algorithm remains. This will result in a new access opportunity to sorting networks wellsuited for efficient parallelization on modern multicore computers, computer networks or GPGPU programming. Additionally this enables us to use sorting networks as (parallel or distributed) merging stages for arbitrary sorting algorithms, thereby creating new hybrid sorting algorithms with ease. The expressiveness of functional programming languages helps us to apply this law to systematically constructed sorting networks, leading to efficient and easily adaptable sorting algorithms. An application example is given, using the Eden programming language to show the effectiveness of the law. The implementation is compared with different parallel sorting algorithms by runtime behaviour.

show abstract

Section: Agglomeration Law For Sorting Networkmentioning

confidence: 99%

An Agglomeration Law for Sorting Networks and its Application in Functional Programming

Schiller¹

2017

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

show abstract

“…We have measured the performance of an Eden implementation of N -Body based on iteration skeletons (Dieterle et al, 2013). These use the allGather skeleton (Dieterle et al, 2010) to implement the global data exchange. Figure 18 shows the speedups that we obtain with this implementation for a problem size of 20,000 particles.…”

Section: Scalabilitymentioning

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

“…The data transmission occurs automatically from the process that releases the data to the process which uses the handle to fetch the remote data. The remote data feature has the following interface in Eden [20]:…”

Section: The Remote Data Conceptmentioning

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

Skeleton Composition Using Remote Data

Cited by 7 publications

References 6 publications

An Agglomeration Law for Sorting Networks and its Application in Functional Programming

An Agglomeration Law for Sorting Networks and its Application in Functional Programming

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Eden – Parallel Functional Programming with Haskell

Contact Info

Product

Resources

About