Distributed implementations of programming languages with implicit parallelism hold out the prospect that the parallel programs are immediately scalable. This paper presents some of the results of our part of Esprit 415, in which we considered the implementation of lazy functional programming languages on distributed architectures. A compiler and abstract machine were designed to achieve this goal. The abstract parallel machine was formally specified, using Miranda 1 . Each instruction of the abstract machine was then implemented as a macro in the Transputer Assembler. Although macro expansion of the code results in non-optimal code generation, use of the Miranda specification makes it possible to validate the compiler before the Transputer code is generated. The hardware currently available consists of five T800--25's, each board having 16M bytes of memory. Benchmark timings using this hardware are given. In spite of the straight forward code-generation, the resulting system compar...

Plotkin, in his seminal article Call-by-name, call-by-value and the λ-calculus, formalized evaluation strategies and simulations using operational semantics and continuations. In particular, he showed how call-by-name evaluation could be simulated under call-by-value evaluation and vice versa. Since Algol 60, however, call-by-name is both implemented and simulated with thunks rather than with continuations. We recast

. This paper examines the transformation of call-by-need terms into continuation -passing style (CPS). It begins by presenting a simple transformation of call-by-need terms into program graphs and a reducer for such graphs. From this, an informal derivation is carried out, resulting in a translation from terms into self-reducing program graphs, where the graphs are represented as CPS terms involving storage operations. Though informal, the derivation proceeds in simple steps, and the resulting translation is taken to be our canonical CPS transformation for call-by-need terms. In order to define the CPS transformation more formally, two alternative presentations are given. The first takes the form of a continuation semantics for the call-by-need language. The second presentation follows Danvy and Hatcliff 's two-stage decomposition of the call-by-name CPS transformation, resulting in a similar two-stage CPS transformation for call-by-need. Finally, a number of practical matters are...

: Call-by-name can be simulated in a call-by-value setting using "thunks" (i.e., parameterless procedures) or continuation-passing-style (CPS). In this paper we uncover a relationship between the two simulations. We prove that the call-by-value CPS transformation Cv , when applied to a term T (t) which simulates call-by-name using thunks, yields a term identical to the call-by-name CPS transformation Cn applied directly to t (modulo renaming): Cv ffi T j Cn This result sheds new light on the call-by-name CPS transformation --- it can be factored into two conceptually distinct steps: ffl the suspension of argument evaluation (captured in T ); ffl the sequentialization of function application to give the usual tail-calls of CPS terms (captured in Cv ). Keywords: -calculus, call-by-name, call-by-value, continuation-passing style transformation. 1. Introduction Among many possible implementations of call-by-name in Algol 60, one still stands the test of time: Ingerman's "thunks" [8]. A...

The article presents an algorithm for the destructive update optimization in first-order lazy functional languages. The main component of the method is a new static analysis of the order of evaluation of expressions which, compared to other published work, has a much lower complexity and is not restricted to pure lazy evaluation. The other component, which we call reduction to variables, is a method of detecting the variables which denote locations where the result of an expression might be stored. Starting with the operational semantics of the language, we introduce some markers for the values in the basic domain. By appropriately choosing the set of markers M and the method of propagating them during evaluation, we can extract some property of the evaluation in which an expression can participate in by looking at the marker of its value. We define then an equivalent denotational semantics and derive the above analyses, in an uniform way, by abstract interpretation over a subdomain of...

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...

We describe the design, implementation, and use of a machinecertified framework for correct compilation and execution of programs in garbage-collected languages. Our framework extends Leroy’s Coq-certified Compcert compiler and Cminor intermediate language. We add: (i) a new intermediate language, GCminor, that includes primitives for allocating memory in a garbage-collected heap and for specifying GC roots; (ii) a precise, low-level specification for a Cminor library for garbage collection; and (iii) a proven semantics-preserving translation from GCminor to Cminor plus the GC library. GCminor neatly encapsulates the interface between mutator and collector code, while remaining simple and flexible enough to be used with a wide variety of source languages and collector styles. Front ends targeting GCminor can be implemented using any compiler technology and any desired degree of verification, including full semantics preservation, type preservation, or informal trust. As an example application of our framework, we describe a compiler for Haskell that translates the Glasgow Haskell Compiler’s Core intermediate language to GCminor. To support a simple but useful memory safety argument for this compiler, the front end uses a novel combination of type preservation and runtime checks, which is of independent interest.

. Strictness analysis (at least for flat domains) is well understood. For a few years the main concern was efficiency, since the standard analysis was shown to be exponential in the worst case [9]. Thus lots of research evolved to find efficient average-case algorithms. In Yale Haskell we have implemented a strictness analyzer that computes fixpoints via symbolic manipulation of boolean functions. This extremely simple approach also is extremely fast -- the strictness analysis phase of our compiler typically takes about 1% of the overall compilation time. 1 Introduction The goal of strictness analysis is to determine, for every function in a program, the parameters in which it is strict. Strictness information is crucial to the implementation of a non-strict language such as Haskell, since conventional machines are best suited to strict, or eager evaluation. Knowing that a function is strict in a given argument allows one to evaluate that argument eargerly and thus avoid creating dela...

One of the major overheads in implementing functional languages is the storage management overhead due to dynamic allocation and automatic reclamation of indefinite-extent storage. This dissertation investigates the problems of statically inferring lifetime information about dynamically-allocated objects in higher-order polymorphic functional languages, both strict and non-strict, and of applying that information to reduce the storage management overhead. We have developed a set of compile-time semantic analyses for a higher-order, monomorphic, strict functional language based on denotational semantics and abstract interpretation. They are 1) escape analysis, which provides information about the relative lifetimes of objects such as arguments and local objects defin...

control structures................................................................. 3 3.2. Lazy data structures .......................................................................................... 4 3.2.1. Non-strict CONS cells ....................................................................... 4 3.2.2. Streams ............................................................................................. 5 4. Why lazy evaluation is not implemented in imperative languages ....................................... 8 4.1. Referential transparency.................................................................................... 9 4.2. Implementation ................................................................................................. 9 5. The signal processing model in an imperative language...................................................... 10 5.1. Code framework................................................................................................ 11 5.2....