Results 1  10
of
12
Algorithm + Strategy = Parallelism
 JOURNAL OF FUNCTIONAL PROGRAMMING
, 1998
"... 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 higherorder functions that control the parallel evaluation of ..."
Abstract

Cited by 56 (19 self)
 Add to MetaCart
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 higherorder functions that control the parallel evaluation of nonstrict 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 divideand conquer, pipeline parallelism, producer/consumer parallelism, and dataoriented parallelism. Because they are based on unrestricted higherorder 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 largescale applications, where they have proved invaluable in helping to manage the complexities of parallel behaviour. These applications are described in detail here. The largest application we have studied to date, Lolita, is a 60,000 line natural language parser. Initial results show that for these applications we can achieve acceptable parallel performance, while incurring minimal overhead for using evaluation strategies.
Compilation of Functional Languages Using Flow Graph Analysis
, 1994
"... syntax, and syntactic and semantic domains of a flow graph Figure 9. Semantic equations Def and Exp of a flow graph The first argument to the functions Def and Exp specifies a set of nodes that represent a flow graph, from which the element(s) of current interest are selected by pattern matching. ..."
Abstract

Cited by 17 (13 self)
 Add to MetaCart
syntax, and syntactic and semantic domains of a flow graph Figure 9. Semantic equations Def and Exp of a flow graph The first argument to the functions Def and Exp specifies a set of nodes that represent a flow graph, from which the element(s) of current interest are selected by pattern matching.
Proving the Correctness of Compiler Optimisations Based on a Global Analysis: A Study of Strictness Analysis
, 1992
"... A substantial amount of work has been devoted to the proof of correctness of various program analyses but much less attention has been paid to the correctness of compiler optimisations based on these analyses. In this paper we tackle the problem in the context of strictness analysis for lazy functio ..."
Abstract

Cited by 15 (3 self)
 Add to MetaCart
A substantial amount of work has been devoted to the proof of correctness of various program analyses but much less attention has been paid to the correctness of compiler optimisations based on these analyses. In this paper we tackle the problem in the context of strictness analysis for lazy functional languages. We show that compiler optimisations based on strictness analysis can be expressed formally in the functional framework using continuations. This formal presentation has two benefits: it allows us to give a rigorous correctness proof of the optimised compiler; and it exposes the various optimisations made possible by a strictness analysis.
The Impact of Laziness on Parallelism and the Limits of Strictness Analysis
 PROCEEDINGS HIGH PERFORMANCE FUNCTIONAL COMPUTING
, 1995
"... The major question examined by this paper is whether sufficient finegrain parallelism can be obtained from programs written in a lazy functional language. To answer this question, we have implemented a prototype compiler based on a novel approach to strictness analysis (called abstract demand propa ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
The major question examined by this paper is whether sufficient finegrain parallelism can be obtained from programs written in a lazy functional language. To answer this question, we have implemented a prototype compiler based on a novel approach to strictness analysis (called abstract demand propagation) and we have compared this implementation strategy (optimized lazy) with other implementations, viz., pure lazy and lenient. Although the optimized lazy implementation improves significantly the efficiency of the resulting programs over the pure lazy approach, it was found that little parallelism can effectively be identified. This remains true even when a new notion of laziness  speculative laziness  is introduced, notion well suited to parallel machines as it based on a parallel notion of headstrictness instead of the traditional sequential one. Our experiments also showed that when a program's result is known to be finite, then strictness analysis can generate almost as mu...
Lazy Type Inference for the Strictness Analysis of Lists
, 1994
"... We present a type inference system for the strictness analysis of lists and we show that it can be used as the basis for an efficient algorithm. The algorithm is as accurate as the usual abstract interpretation technique. One distinctive advantage of this approach is that it is not necessary to impo ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
We present a type inference system for the strictness analysis of lists and we show that it can be used as the basis for an efficient algorithm. The algorithm is as accurate as the usual abstract interpretation technique. One distinctive advantage of this approach is that it is not necessary to impose an abstract domain of a particular depth prior to the analysis: the lazy type algorithm will instead explore the part of a potentially infinite domain required to prove the strictness property. 1 Introduction Simple strictness analysis returns information about the fact that the result of a function application is undefined when some of the arguments are undefined. This information can be used in a compiler for a lazy functional language because the argument of a strict function can be evaluated (up to weak head normal form) and passed by value. However a more sophisticated property might be useful in the presence of lists or other recursive data structures which are pervasive in functio...
Improving Parallel Implementations of Lazy Functional Languages Using Evaluation Transformers
, 1995
"... This report outlines a parallel abstract machine for the implementation of a lazy functional core language. The evaluation transformer model of reduction [1] is used to control the evaluation process. An evaluator space containing parameterised evaluators for structured and polymorphic types is i ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
This report outlines a parallel abstract machine for the implementation of a lazy functional core language. The evaluation transformer model of reduction [1] is used to control the evaluation process. An evaluator space containing parameterised evaluators for structured and polymorphic types is introduced. Using this framework it is possible to handle runtime information about evaluators for arbitrary structured types as well as evaluation transformers for functions over polymorphic types.
Projectionbased Program Analysis
, 1994
"... Projectionbased program analysis techniques are remarkable for their ability togive highly detailed and useful information not obtainable by other methods. The rst proposed projectionbased analysis techniques were those of Wadler and Hughes for strictness analysis, and Launchbury for bindingtime ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Projectionbased program analysis techniques are remarkable for their ability togive highly detailed and useful information not obtainable by other methods. The rst proposed projectionbased analysis techniques were those of Wadler and Hughes for strictness analysis, and Launchbury for bindingtime analysis � both techniques are restricted to analysis of rstorder monomorphic languages. Hughes and Launchbury generalised the strictness analysis technique, and Launchbury the bindingtime analysis technique, to handle polymorphic languages, again restricted to rst order. Other than a general approach to higherorder analysis suggested by Hughes, and an ad hoc implementation of higherorder bindingtime analysis by Mogensen, neither of which had any formal notion of correctness, there has been no successful generalisation to higherorder analysis. We present a complete redevelopment of monomorphic projectionbased program analysis from rst principles, starting by considering the analysis of functions (rather than programs) to establish bounds on the intrinsic power of projectionbased analysis, showing also that projectionbased analysis can capture interesting termination
Fast Strictness Analysis Based on Demand Propagation
 ACM Transactions on Programming Languages and Systems
, 1995
"... Interpretation versus Demand Propagation Wadler [1987] uses abstract interpretation over a fourpoint domain for reasoning about strictness on lists. The four points correspond to undefined list (represented by value 0), infinite lists and lists with some tail undefined (value 1), lists with at lea ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Interpretation versus Demand Propagation Wadler [1987] uses abstract interpretation over a fourpoint domain for reasoning about strictness on lists. The four points correspond to undefined list (represented by value 0), infinite lists and lists with some tail undefined (value 1), lists with at least one head undefined (value 2), and all lists (value 3). Burn's work [Burn 1987] on evaluation transformers also uses abstract interpretation on the abovementioned domain for strictness analysis. He defines four evaluators that correspond to the four points mentioned above in the sense that the ith evaluator will fail to produce an answer when given a list with the abstract value i \Gamma 1.
Efficient Strictness Analysis of Haskell in Haskell Using Abstract Reduction
"... The extraction of strictness information marks an indispensable element of an efficient compilation of lazy functional languages like Haskell. Based on the method of abstract reduction we have developed an efficient strictness analyser for a core language of Haskell. It is completely written i ..."
Abstract
 Add to MetaCart
The extraction of strictness information marks an indispensable element of an efficient compilation of lazy functional languages like Haskell. Based on the method of abstract reduction we have developed an efficient strictness analyser for a core language of Haskell. It is completely written in Haskell and compares favourably with known implementations. The implementation is based on the G # machine, which is an extension of the Gmachine that has been adapted to the needs of abstract reduction.
Measuring the Effectiveness of a Simple Strictness Analyser
 In Functional Programming
, 1993
"... We describe a simple strictness analyser for purelyfunctional programs, show how its results are used to improve programs, and provide measurements of the effects of these improvements. These measurements are given both in terms of overall runtime, and in terms of internal operations such as alloc ..."
Abstract
 Add to MetaCart
We describe a simple strictness analyser for purelyfunctional programs, show how its results are used to improve programs, and provide measurements of the effects of these improvements. These measurements are given both in terms of overall runtime, and in terms of internal operations such as allocations, updates, etc. Despite its simplicity, the analyser handles higherorder functions, and nonflat domains provided they are nonrecursive. Ths paper appears in Functional Programming, Glasgow 1993, ed Hammond and O'Donnell, Springer Workshops in Computer Science, 1993, pp201220. 1 Introduction A lot has been written about strictness analysis for nonstrict functional programs, usually in the hope that the results of the analysis can be used to reduce runtime. On the other hand, few papers present measurements of how well it works in practice. Usually, all that is presented are the runtimes of a variety of (usually small) programs, with and without strictness analysis enabled (eg Sm...