Regular Article
A Cost Calculus for Parallel Functional Programming

https://doi.org/10.1006/jpdc.1995.1089Get rights and content

Abstract

Building a cost calculus for a parallel program development environment is difficult because of the many degrees of freedom available in parallel implementations and because of difficulties with compositionality. We present a strategy for building cost calculi for skeleton-based programming languages which can be used for derivational software development and which deals in a pragmatic way with the difficulties of composition. The approach is illustrated for the Bird-Meertens theory of lists, a parallel functional language with an associated equational transformation system.

References (0)

Cited by (40)

  • Complexity bounds for container functors and comonads

    2018, Information and Computation
    Citation Excerpt :

    By adding a [C3] rewrite rule into the compiler, this situation can be remedied. Various works have provided a cost analysis for algorithmic skeletons in the context of parallel programming e.g. [15,10,22,13], which have similar motivation to this work: reasoning about performance abstractly to inform program optimisation. Riely and Prins prove that the flattening transformation (for nested parallelism) provides an improvement in their costing [20].

  • Automatically deriving cost models for structured parallel processes using hylomorphisms

    2018, Future Generation Computer Systems
    Citation Excerpt :

    In the basic PRAM execution model, basic computations and shared-memory accesses are both assumed to take unit time. Unfortunately, PRAM costs underestimate actual machine execution costs, but in an unpredictable way [41]. The Bulk Synchronous Parallel (BSP) model [44] extends the PRAM model in a more realistic way, introducing a synchronising communication step after each set of computation steps.

  • Performance implications of synchronization structure in parallel programming

    2009, Parallel Computing
    Citation Excerpt :

    The predominant coordination model found in these restricted programming models is nested parallelism (aka Divide & Conquer). Examples include BSP [55] and nested-BSP (e.g., NestStep [36], PUB [9]), approaches based on Skeletons (e.g., SCL [14], Frame [12]), Cilk [7], Satin [44], BMF [50], ASSIST [3], SPC [22], and SPC-XML [29]. In these programming models the parallel constructs have the same restricted semantics as the nested forms of the well-known cobegin--coend primitives [4].

  • An operational semantics for skeletons

    2004, Advances in Parallel Computing
View all citing articles on Scopus
View full text