Six implementations of different lazy functional languages are compared using a common benchmark of a dozen medium-sized programs. The experiments that were carried out two years ago have been repeated to chart progress in the development of these compilers. The results have been extended to include all three major Haskell compilers. Over the last two years, the Glasgow Haskell compiler has been improved considerably. The other compilers have also been improved, but to a lesser extent. The Yale Haskell compiler is slower than the Glasgow and Chalmers Haskell compilers. The compilation speed of the Clean compiler is still unrivalled. Another extension is a comparison of results on different architectures so as to look at architectural influences on the benchmarking procedure. A high-end architecture should be avoided for benchmarking activities, as its behaviour is uneven. It is better to use a midrange machine if possible. 1 Introduction In the previous benchmark paper [10], which wi...

The aim of this paper is two-fold; first, we develop an interprocedural register allocation algorithm, an extended variant of Briggs' optimistic graph colouring. We use interprocedural coalescing as an elegant way to achieve a custom-made calling convention for each function. We add a restricted, and cheap, form of live range splitting in a way that is particularly useful for call intensive languages. Second, we apply our interprocedural register allocation algorithm to code generated from a lazy functional language. In doing this we use a monadic intermediate code, well suited for analysis and program transformation. We use program transformation techniques and the result of an abstract interpretation analysis on the intermediate code to eliminate all unknown control flow in the program. This will improve the chances of the register allocator to produce good results. Preliminary measurements show that we are able to eliminate up to 95% of all stack references compared to the Chalmers ...

Current implementation techniques for functional languages differ considerably from those for logic languages. This complicates the development of flexible and efficient abstract machines that can be used for the compilation of declarative languages combining concepts of functional and logic programming. We propose an abstract machine, called the JUMP-machine, which systematically integrates the operational concepts needed to implement the functional and logic programming paradigm. The use of a tagless representation for heap objects, which originates from the Spineless Tagless G-machine, supports the integration of different concepts. In this paper, we provide a functional logic kernel language and show how to translate it into the abstract machine language of the JUMP-machine. Furthermore, we define the operational semantics of the machine language formally and discuss the mapping of the abstract machine to concrete machine architectures. We tested the approach by writing a compiler for the functional logic language GTML. The obtained performance results indicate that the proposed method allows to implement functional logic languages efficiently.

The research presented in this thesis is about the design and implementation of Naira, a parallel, parallelising compiler for a rich, purely functional programming language. The source language of the compiler is a subset of Haskell 1.2. The front end of Naira is written entirely in the Haskell subset being compiled. Naira has been successfully parallelised and it is the largest successfully parallelised Haskell program having achieved good absolute speedups on a network of SUN workstations. Having the same basic structure as other production compilers of functional languages, Naira's parallelisation technology should carry forward to other functional language compilers. The back end of Naira is written in C and generates parallel code in the C language which is envisioned to be run on distributed-memory machines. The code generator is based on a novel compilation scheme specified using a restricted form of Milner's ß-calculus which achieves asynchronous communication. We present the f...

this paper is on writing parallel programs, we will not say more about programming in Miranda. 5 Tools and annotations for parallelism

The FAST compiler is a backend for compilers of lazy functional languages. There are two versions of the compiler: one that takes a rather simple lazy functional language as input and a second that accepts a language similar to Miranda. On output the compiler produces a set of macro calls that are normally turned into a C program by one of the code generators that have been developed for FAST. Such a C program must be compiled by a C compiler and linked with the appropriate runtime library to form an executable. This document decsribes how to use the FAST compiler. Familiarity with functional languages and their implementation methods is required to make full use of this document. 1 Introduction The FAST (Functional programming on ArrayS of Transputers) project team at Southampton has developed an optimising compiler for a lazy functional language on a single processor [6]. This document describes how to use the compiler. The compiler accepts on input a language called Intermediate th...

In this paper we will show how to embed functional concepts in an imperative host language in a natural way. This is achieved by interpreting functional programs as specifications of imperative programs. We will introduce a refined notion of laziness, which allows us to interpret lazy computations as special constructors, which encapsulate the suspended computation. Even higher-order concepts can be represented efficiently, if we restrict the possibility to use partial applications. Essentially, we disallow the use of sequences of partial applications as hidden data structures. By considering a setting in which the unit of translation is a module, this approach is the key to an integration of the functional programming paradigm and the imperative programming paradigm on a module level. Functional components of the resulting hybrid module architectures may use and may be used by imperative components without need for special interlanguage interfaces. Beside the `best of both worlds', this concept ooeers the possibility to migrate `module by module' from purely imperative systems to hybrid systems and to do rapid prototyping using functional modules. Experimental results with a prototype version of a translator will show that we can compete with traditional functional languages like Haskell.

A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and medium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and RISC and VLIW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic building block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state. 1 Introduction Functional programming is founded on the lambda calculus, which is a mathematical theory that provides a sound basis for work on reduction machines [5]. This is p...

. To deepen our quantitative understanding of the performance of lazy evaluation, we have studied the cache behaviour of a benchmark of functional programs. The compiler, based on the G-machine style of graph reduction, has been modified to insert monitoring code into the executable that records instruction and data references at run time. The resulting address trace is used to drive a cache simulator that computes statistics like miss rates and traffic ratios. A number of experiments with different cache parameters (size, associativity, etc.) shows that the benchmark programs have a strong spatial locality in their memory references. This is caused by the heap allocation strategy that allocates nodes by advancing a pointer through the heap, generating new addresses. Therefore the initialisation of new heap nodes results in cache misses, which dominate performance. Comparisons with results of other functional language implementations confirm this behaviour 1 Introduction Recently, com...

Abstract not found