: This lecture considers the optimisation of functional programming languages (particularly `lazy' languages) based on `strictness analysis'. Such optimisations alter evaluation order to allow more efficient translation into von Neumann architecture or to increase the parallelism in a sequentially specified system (such as that implied by lazysemantics) . Keywords: Functional languages, lazy evaluation, eager evaluation, strictness analysis, abstract interpretation. 1 Functional Languages The term `functional' as applied to programming languages has been used to apply to a number of related but different models of computation. As used here it will refer to purely functional languages, characterised by a complete lack of side-effects and a very direct relationship with the -calculus. This rules out languages such as ML and Lisp which, although emphasising the status of functions in the construction of programming and containing well-understood pure subsets, include forms of assignmen...

Interpretation versus Demand Propagation Wadler [1987] uses abstract interpretation over a four-point 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 above-mentioned 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.

Explicit parallelism greatly complicates the program semantics, especially if concurrent activities are allowed to interact with each other through shared variables. Existing compiler analysis and optimization techniques for sequential programs must be carefully examined before they can be safely applied to parallel programs. In this paper, we present a general framework for analyzing programs with cobegin parallelism, which is based on state space exploration. Reducing the explosion of state space is necessary to make compile-time analysis feasible. This state space explosion problem is relieved first by eliminating redundant interleaving, through the stubborn set theory. Then, abstract interpretation techniques are employed which provide systematic methods for folding related states for further state space reduction. With this framework, we have developed static analysis for obtaining program properties, such as side effects, data dependences, and object lifetimes. The information ob...

interpretation is sometimes unfairly seen as a rather specialised subject. Semantics in static analysis Domain theory has been used to formulate and validate many static analyses, particularly for functional languages [2, 1, 4]. Analyses of properties such as strictness, binding-time or totality are often not merely validated by such a semantics, but are formulated right from the start in semantic terms; domain-theoretic concepts, such as projections, can naturally suggest program analysis techniques [4]. More sophisticated semantic concepts, such as parametricity [1], initiality, fibrations [4] and higher-dimensional automata, have also been used in static analysis. Operational, rather than denotational, semantics are now often used as the basis for static analyses: see, for example, [6, 8]. Although static analysis sometimes uses moderately sophisticated ideas from the semantics community, this is comparatively rare -- more often static analysis develops its own theory on top of fai...

We have developed a software tool called Z1 by which one can quickly achieve an accurate yet affordable program analysis. The user writes an analysis specification and sets a parameter for a desired cost-accuracy tradeoff. The tool then creates an executable analyzer that has the specified performance balance. Z1 has been used for developing both conventional and non-conventional flow analyses. These analyses were for programs written in C, FORTRAN, and Standard ML, without restriction upon the programs treated. We present experimental data showing the performances of Z1 for analyzing C, FORTRAN, and Standard ML programs. Index Terms: data flow analysis, abstract interpretation, global program analysis, collecting analysis, lattice, projection Correspondence: Kwangkeun Yi, kwang@research.att.com AT&T Bell Laboratories, Rm 2A-421, Murray Hill, NJ 07974, USA. A preliminary version of this paper appeared in the Proceedings of the 20th ACM SIGPLAN-SIGACT Symposium on Principles of Prog...

We present an inference system for translating programs in a PCF-like source language into a variant of Moggi's computational lambda calculus. This translation combines a simple strictness analysis with its associated optimising transformations into a single system. The correctness of the translation is established using a logical relation between the denotational semantics of the source and target languages. 1 Introduction 1.1 Background Strictness analysis of lazy functional programs has been studied extensively during the the last 15 years or so, usually with the justification that the results of the analysis can be used in an optimising compiler [Myc81, BHA86, Ben92]. There has, however, been surprisingly little serious work on just how the results of strictness analysis can be used as the basis for optimising transformations. This is probably because it turns out to be rather more difficult to express and justify these optimisations than one might at first imagine. Roughly speak...

A new construction of a finite set of strictness properties for any lazy algebraic datatype is presented. The construction is based on the categorical view of the solutions to the recursive domain equations associated with such types as initial algebras. We then show how the initial algebra induction principle can be used to reason about the entailment relation on the chosen collection of properties. We examine the lattice of properties given by our construction for the type nlist of lazy lists of natural numbers and give proof rules which extend the conjunctive strictness logic of [2] to a language including the type nlist. 1