Least fixpoints as meanings of recursive definitions.

Higher order functional programs constantly allocate objects dynamically. These objects are typically cons cells, closures, and records and are generally allocated in the heap and reclaimed later by some garbage collection process. This paper describes a compile time analysis, called escape analysis, for determining the lifetime of dynamically created objects in higher order functional programs, and describes optimizations that can be performed, based on the analysis, to improve storage allocation and reclamation of such objects. In particular, our analysis can be applied to programs manipulating lists, in which case optimizations can be performed to allow whole cons cells in spines of lists to be either reclaimed at once or reused without incurring any garbage collection overhead. In a previous paper on escape analysis [10], we had left open the problem of performing escape analysis on lists. Escape analysis simply determines when the argument (or some part of the argument) to a func...

Interpretation over Finite Domains) Philip Wadler Programming Research Group Oxford University Recent work shows that lazy functional languages can be compiled to run on conventional architectures with very good speed [Johnsson 84, PeytonJones 86]. Strictness analysis is one way to make such implementations even faster. This is because when an argument to a function is known to be strict then one may evaluate the argument directly rather than build a data structure to be evaluated later. One of the most promising techniques of strictness analysis is by abstract interpretation [Mycroft 83], which recently has been extended to include higher-order functions [Burn et al 85, Hudak and Young 85, 86] and polymorphism [Abramsky 85]. One of the remaining problems of great interest is whether this method can be extended to non-flat domains. Accordingly, strictness analysis on non-flat domains has received a great deal of attention [Hughes 85, Karlsson 85, Kieburtz 85]. Unfortunately, the wor...

Abstract not found

We describe a logic for reasoning about higher-order strictness properties of typed lambda terms. The logic arises from axiomatising the inclusion order on certain closed subsets of domains. The axiomatisation of the lattice of strictness properties is shown to be sound and complete, and we then give a program logic for assigning properties to terms. This places work on strictness analysis via type inference on a firm theoretical foundation. We then use proof theoretic techniques to show how the derivable strictness properties of different instances of polymorphically typed terms are related. 1

Implementations of lazy evaluation for non-strict functional languages usually involve the notion of a delayed representation of the value of an expression, which we call a thunk. We present several techniques for implementing thunks and formalize a class of optimizations that reduce both the space and time overhead of these techniques. The optimizations depend on a compile-time inferencing strategy called path analysis, a generalization of strictness analysis that uncovers order-of-evaluation information. Although the techniques in this paper are focused on the compilation of a non-strict functional language for a conventional architecture, they are directly applicable to most of the virtual machines commonly used for implementing such languages. The same techniques also apply to other forms of delayed evaluation such as futures and promises. 1

ion for PCF Motivated by the full completeness results, it became of compelling interest to re-examine perhaps the best-known "open problem" in the semantics of programming languages, namely the "Full Abstraction problem for PCF", using the new tools provided by game semantics. 2 PCF is a higher-order functional programming language; modulo issues of the parameterpassing strategies, it forms a fragment of any programming language with higher-order procedures (which includes any reasonably expressive object-oriented language). The aspect of the Full Abstraction problem I personally found most interesting was: to construct a syntax-independent model in which every element is the denotation of some program (note the analogy with full completeness, whose definition had in turn been motivated in part by this aspect of full abstraction). This is not how the problem was originally formulated, but by "general abstract nonsense", given such a model one can always quotient it to get a fully ab...

This thesis is focused on improving execution time and precision of scalable pointer analysis. Such an analysis statically determines the targets of all pointer variables in a program. We formulate the analysis as a directed graph problem, where the solution can be obtained by a computation similar, in many ways, to transitive closure. As with transitive closure, identifying strongly connected components and transitive edges offers significant gains. However, our problem differs as the computation can result in new edges being added to the graph and, hence, dynamic algorithms are needed to efficiently identify these structures. Thus, pointer analysis has often been likened to the dynamic transitive closure problem. Two new algorithms for dynamically maintaining the topological order of a directed graph are presented. The first is a unit change algorithm, meaning the solution must be recomputed immediately following an edge insertion. While this has a marginally inferior worse-case time bound, compared with a previous solution, it is far simpler to implement and has fewer restrictions. For these reasons, we find it to be faster in practice and provide an experimental study over random graphs to support this. Our second is a batch algorithm, meaning the solution can be updated after

The major question examined by this paper is whether sufficient fine-grain 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 head-strictness 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...

Abstract. This paper proves correctness of Nöcker’s method of strictness analysis, implemented for Clean, which is an effective way for strictness analysis in lazy functional languages based on their operational semantics. We improve upon the work of Clark, Hankin and Hunt, which addresses correctness of the abstract reduction rules. Our method also addresses the cycle detection rules, which are the main strength of Nöcker’s strictness analysis. We reformulate Nöcker’s strictness analysis algorithm in a higherorder lambda-calculus with case, constructors, letrec, and a nondeterministic choice operator ⊕ used as a union operator. Furthermore, the calculus is expressive enough to represent abstract constants like Top or Inf. The operational semantics is a small-step semantics and equality of expressions is defined by a contextual semantics that observes termination of expressions. The correctness of several reductions is proved using a context lemma and complete sets of forking and commuting diagrams.