Farms, pipes, streams and reforestation: reasoning about structured parallel processes using types and hylomorphisms

Self Cite

Please cite this article as: D. Castro, et al., Automatically deriving cost models for structured parallel processes using hylomorphisms, Future Generation Computer Systems (2017), http://dx.doi.org/10.1016/j.future. 2017.04.035 This is a PDF file of an unedited manuscript that has been accepted for publication. As a service to our customers we are providing this early version of the manuscript. The manuscript will undergo copyediting, typesetting, and review of the resulting proof before it is published in its final form. Please note that during the production process errors may be discovered which could affect the content, and all legal disclaimers that apply to the journal pertain. An operational semantics of a queue language for streaming computations.  An operational semantics of algorithmic skeletons using this queue language.  Derive cost equations for algorithmic skeletons from the operational semantics.  Cost equations for algorithmic skeletons are combined with sized types. AbstractStructured parallelism using nested algorithmic skeletons can greatly ease the task of writing parallel software, since common, but hard-to-debug, problems such as race conditions are eliminated by design. However, choosing the best combination of algorithmic skeletons to yield good parallel speedups for a specific program on a specific parallel architecture is still a difficult problem. This paper uses the unifying notion of hylomorphisms, a general recursion pattern, to make it possible to reason about both the functional correctness properties and the extra-functional timing properties of structured parallel programs. We have previously used hylomorphisms to provide a denotational semantics for skeletons, and proved that a given parallel structure for a program satisfies functional correctness. This paper expands on this theme, providing a simple operational semantics for algorithmic skeletons and a cost semantics that can be automatically derived from that operational semantics. We prove that both semantics are sound with respect to our previously defined denotational semantics. This means that we can now automatically and statically choose a provably optimal parallel structure for a given program with respect to a cost model for a (class of) parallel architecture. By deriving an automatic amortised analysis from our cost model, we can also accurately predict parallel runtimes and speedups.

Section: Derive Eqn Maxmentioning

confidence: 99%

“…We illustrate our approach using the image merge example from [9]. The purpose of the imgMerge function is to mark and then merge pairs of images.…”

Section: Motivating Examplementioning

confidence: 99%

Section: Algorithmic Skeletonsmentioning

confidence: 99%

Section: Type System and Semanticsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Automatically deriving cost models for structured parallel processes using hylomorphisms

Castro

Hammond

Sarkar

et al. 2018

Self Cite

Free the Conqueror! Refactoring divide-and-conquer functions

Kozsik

Tóth

Bozó

2018

Divide-and-conquer algorithms appear in the solution of many computationally intensive problems, and are good candidates for parallelization. A divide-andconquer computation can be expressed in a programming language in many ways. This paper presents a set of small, semantics-preserving code transformations, and a methodology to refactor divide-and-conquer functions in a functional programming language. By applying a sequence of transformations using a refactoring tool, many divide-and-conquer functions can be restructured into a canonical form -which then can be refactored into an instance of a parallel divide-and-conquer pattern. This methodology offers an effective and safe way to parallelize HPC applications.

Finding parallel functional pearls: Automatic parallel recursion scheme detection in Haskell functions via anti-unification

Barwell

Brown

Hammond

2018

Self Cite

Please cite this article as: A.D. Barwell, C. Brown, K. Hammond, Finding parallel functional pearls: Automatic parallel recursion scheme detection in Haskell functions via anti-unification, Future Generation Computer Systems (2017), http://dx. AbstractThis paper describes a new technique for identifying potentially parallelisable code structures in functional programs. Higher-order functions enable simple and easily understood abstractions that can be used to implement a variety of common recursion schemes, such as maps and folds over traversable data structures. Many of these recursion schemes have natural parallel implementations in the form of algorithmic skeletons. This paper presents a technique that detects instances of potentially parallelisable recursion schemes in Haskell 98 functions. Unusually, we exploit anti-unification to expose these recursion schemes from source-level definitions whose structures match a recursion scheme, but which are not necessarily written directly in terms of maps, folds, etc. This allows us to automatically introduce parallelism, without requiring the programmer to structure their code a priori in terms of specific higher-order functions. We have implemented our approach in the Haskell refactoring tool, HaRe, and demonstrated its use on a range of common benchmarking examples. Using our technique, we show that recursion schemes can be easily detected, that parallel implementations can be easily introduced, and that we can achieve real parallel speedups (up to 23.79× the sequential performance on 28 physical cores, or 32.93× the sequential performance with hyper-threading enabled).