Pomset interpretations of parallel functional programs

Hudak, Paul; Anderson, Steven R.

doi:10.1007/3-540-18317-5_14

Cited by 15 publications

(4 citation statements)

References 13 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…both par and seq are idempotent), but are uncertain of the best framework for proving them. One possible starting point is to use partially ordered multisets to provide a theoretical basis for defining evaluation order (Hudak and Anderson, 1987).…”

Section: Future Workmentioning

confidence: 99%

Algorithm + strategy = parallelism

et al. 1998

View full text Add to dashboard Cite

The process of writing large parallel programs is complicated by the need to specify both the parallel behaviour of the program and the algorithm that is to be used to compute its result. This paper introduces evaluation strategies: lazy higher-order functions that control the parallel evaluation of non-strict functional languages. Using evaluation strategies, it is possible to achieve a clean separation between algorithmic and behavioural code. The result is enhanced clarity and shorter parallel programs. Evaluation strategies are a very general concept: this paper shows how they can be used to model a wide range of commonly used programming paradigms, including divide-and-conquer parallelism, pipeline parallelism, producer/consumer parallelism, and data-oriented parallelism. Because they are based on unrestricted higher-order functions, they can also capture irregular parallel structures. Evaluation strategies are not just of theoretical interest: they have evolved out of our experience in parallelising several large-scale parallel applications, where they have proved invaluable in helping to manage the complexities of parallel behaviour. Some of these applications are described in detail here. The largest application we have studied to date, Lolita, is a 40,000 line natural language engineering system. Initial results show that for these programs we can achieve acceptable parallel performance, for relatively little programming effort.

show abstract

Section: Future Workmentioning

confidence: 99%

Algorithm + strategy = parallelism

et al. 1998

View full text Add to dashboard Cite

show abstract

“…First, it is speculatively parallel relative to a call-by-value model (e.g., the PAL model [Blelloch and Greiner 1995;Greiner 1997]), as it allows a function body and argument to be evaluated in parallel when possible, which is consistent with Hudak and Anderson's call-byspeculation [Hudak and Anderson 1987]. Second, it is speculative relative to a call-by-need evaluation, as it at least starts the evaluation of an argument even if it is irrelevant.…”

Section: Related Workmentioning

confidence: 80%

“…Futures, lenient languages, and several implementations of graph reduction for lazy languages all use speculative evaluation (call-by-speculation [Hudak and Anderson 1987]) to expose parallelism. The basic idea of speculative evaluation, in this context, is that the evaluation of a function body can start in parallel with the evaluation of the corresponding function arguments.…”

Section: Introductionmentioning

confidence: 99%

A provably time-efficient parallel implementation of full speculation

Greiner

Blelloch

1999

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

Speculative evaluation, including leniency and futures, is often used to produce high degrees of parallelism. Understanding the performance characteristics of such evaluation, however, requires having a detailed understanding of the implementation. For example, the particular implementation technique used to suspend and reactivate threads can have an asymptotic effect on performance. With the goal of giving the users some understanding of performance without requiring them to understand the implementation, we present a provable implementation bound for a language based on speculative evaluation. The idea is (1) to supply the users with a semantics for a language that defines abstract costs for measuring or analyzing the performance of computations, (2) to supply the users with a mapping of these costs onto runtimes on various machine models, and (3) to describe an implementation strategy of the language and prove that it meets these mappings. For this purpose we consider a simple language based on speculative evaluation. For every computation, the semantics of the language returns a directed acyclic graph (DAG) in which each node represents a unit of computation, and each edge represents a dependence. We then describe an implementation strategy of the language and show that any computation with w work (the number of nodes in the DAG) and d depth (the length of the longest path in the DAG) will run on a p-processor PRAM in O(w/p + d log p) time. The bounds are work efficient (within a constant factor of linear speedup) when there is sufficient parallelism, w/d ≥ p log p. These are the first time bounds we know of for languages with speculative evaluation. The main challenge is in parallelizing the necessary queuing operations on suspended threads.

show abstract

“…Cost semantics were originally developed to reason about the complexity of sequential algorithms [Rosendahl 1989;Sands 1990]. Our cost semantics notation is most closely based on the work of Greiner [1995, 1996], who were in turn inspired by the work of Hudak and Anderson [1987], which used partially ordered multisets to represent dependencies in much the same way as DAGs. This early work focused on fork-join or nested parallelism and was later extended to handle futures by Spoonhower [2009] using the łleft compositionž and edge addition operations we also use in our graphs and graph types.…”

Section: Related Workmentioning

confidence: 99%

Static prediction of parallel computation graphs

Muller

2022

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Many algorithms for analyzing parallel programs, for example to detect deadlocks or data races or to calculate the execution cost, are based on a model variously known as a cost graph, computation graph or dependency graph, which captures the parallel structure of threads in a program. In modern parallel programs, computation graphs are highly dynamic and depend greatly on the program inputs and execution details. As such, most analyses that use these graphs are either dynamic analyses or are specialized static analyses that gather a subset of dependency information for a specific purpose. This paper introduces graph types, which compactly represent all of the graphs that could arise from program execution. Graph types are inferred from a parallel program using a graph type system and inference algorithm, which we present drawing on ideas from Hindley-Milner type inference, affine logic and region type systems. We have implemented the inference algorithm over a subset of OCaml, extended with parallelism primitives, and we demonstrate how graph types can be used to accelerate the development of new graph-based static analyses by presenting proof-of-concept analyses for deadlock detection and cost analysis.

show abstract

Pomset interpretations of parallel functional programs

Cited by 15 publications

References 13 publications

Algorithm + strategy = parallelism

Algorithm + strategy = parallelism

A provably time-efficient parallel implementation of full speculation

Static prediction of parallel computation graphs

Contact Info

Product

Resources

About