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

Previous studies on safety of program transformations with respect to performance considered two criteria: preserving performance within a constant factor and preserving complexity. However, as the requirement of program transformations used in compilers the former seems too restrictive and the latter seems too loose. We propose a new safety criterion: a program transformation preserves performance within a factor proportional to the size of a source program. This criterion seems natural since several compilation methods have effects on performance proportional to the size of a program. Based on this criterion we have shown that two semantics formalizing the size of stack space are equivalent. We also discuss the connection between this criterion and the properties of local program transformations rewriting parts of a program. 1

This paper presents a global approach to representation analysis based on program-wide data and control flow information. Boxing and unboxing coercions can be placed around any variable occurrence, not only where values are produced and consumed.

Non-determinism may affect the referential transparency of the programs written in Eden: If a nondeterministic expression is evaluated in different processes, the variable it is bound to it will denote possibly different values. It would be desirable to warn the programmer about this situation, or to force the evaluation of such an expression so that all the occurrences of the variable have the same value. Additionally there exist sequential transformations that are incorrect when non-determinism is involved. Such transformations should be applied only to those parts of the program that are sure to be deterministic. In this paper several analyses of different efficiency and power are presented. Several techniques are used: A types annotation system and abstract interpretation. 1 Introduction The parallel-functional language Eden extends the lazy functional language Haskell by syntactic constructs to explicitly define and communicate processes. The three main new concepts are process a...

Abstract. Common subexpression elimination is a well-known compiler optimisation that saves time by avoiding the repetition of the same computation. In lazy functional languages, referential transparency renders the identification of common subexpressions very simple. More common subexpressions can be recognised because they can be of arbitrary type whereas standard common subexpression elimination only shares primitive values. However, because lazy functional languages decouple program structure from data space allocation and control flow, analysing its effects and deciding under which conditions the elimination of a common subexpression is beneficial proves to be quite difficult. We developed and implemented the transformation for the language Haskell by extending the Glasgow Haskell compiler. On real-world programs the transformation showed nearly no effect. The reason is that common subexpressions whose elimination could speed up programs are uncommon in lazy functional languages.

In this paper we demonstrate how to relate the semantics given by the nondeterministic call-by-need calculus FUNDIO [SS03] to Haskell. After introducing new correct program transformations for FUNDIO, we translate the core language used in the Glasgow Haskell Compiler into the FUNDIO language, where the IO construct of FUNDIO corresponds to direct-call IO-actions in Haskell. We sketch the investigations of [Sab03b] where a lot of program transformations performed by the compiler have been shown to be correct w.r.t. the FUNDIO semantics. This enabled us to achieve a FUNDIO-compatible Haskell-compiler, by turning off not yet investigated transformations and the small set of incompatible transformations. With this compiler, Haskell programs which use the extension unsafePerformIO

The Generic Haskell programming language allows functions to be defined by induction on the structure of data types. This gives rise to generic functions which can be applied to values of any conceivable data type. Compiling a Generic Haskell program amounts to generating a Haskell program in which all generic functions have been translated to ordinary Haskell functions. Since the Haskell language only allows functions to be defined on the values of a data type, translating generic functions defined on the structure of data types is not straightforward. The application of a generic function to a value involves specializing the function to the type of its parameter. For every distinct specialization of a generic function in a Generic Haskell program, an ordinary Haskell function is generated in the compilation process. Hence, the compilation of a generic function will typically yield several ordinary functions. The current method that is used to translate specializations is rather unsophisticated.

This article presents how automatic program transformation techniques can be used in a functional language compiler to get significant improvement in the performance of the code generated. The transformations used are simple, but when they are repeatedly applied and interact, they achieve results that often are obtained only through specific and more complex transformations. 1 Introduction The compilation of languages by program transformation has been known and studied for many years [5,4,2]. But the study of program transformation techniques specifically for code improvement has often concentrated on computationally expensive transformations, and quite often the resulting effect of these transformations has been studied on small benchmarks, specially suited to reflect the performance improvements presented by the transformation on ideal circumstances, where it will achieve its best results. In this article we present how program transformation techniques have been used to improve th...

Eden is a parallel extension of Haskell allowing the programmer to explicitly specify which expressions must be evaluated as parallel processes. Eden is implemented by modifying the Glasgow Haskell Compiler (GHC). This decision has saved a lot of work but has also produced some drawbacks: Some optimizing transformations done by GHC are not convenient for Eden, either because they spoil its semantics or because they negatively affect its efficiency. The paper explains how to circumvent these drawbacks and also how to add our own optimizing analysis and transformation steps in order to generate a (correct and) better parallel code.

Modern software applications are growing in complexity and demand very intensive use of data. Therefore, a wide variety of data structures are utilized to facilitate the storage and access to these vast amounts of computed information. Additionally, the need for reliable software design and the development of large applications following the objectoriented paradigm increase the amount of dynamic buffers and redundant accesses to the data stored in these buffers. In this paper, we propose a systematic, design optimization methodology to remove these intermediate dynamic buffers, thereby reducing the memory accesses of the targeted applications without altering the input-output behaviour of the algorithms. The reduction is focused on sequences and is especially relevant for embedded systems, which have limited on-chip communication bandwidth and the energy consumption of the memory subsystem is high, due to the energy consumption associated with each memory access. The effectiveness of the proposed methodology is assessed in a 3D reconstruction multimedia application and shows a significant reduction in memory accesses. In addition, the general trends for memory improvement and the scalability of our approach are supported as well by a parameterized benchmark set. 1