This thesis presents and justifies a framework for programming real-time signal processing systems. The framework extends the existing "block-diagram" programming model; it has three components: a very high-level textual language, a visual language, and the dataflow process network model of computation. The dataflow process network model, although widely-used, lacks a formal description, and I provide a semantics for it. The formal work leads into a new form of actor. Having established the semantics of dataflow processes, the functional language Haskell is layered above this model, providing powerful features---notably polymorphism, higher-order functions, and algebraic program transformation---absent in block-diagram systems. A visual equivalent notation for Haskell, Visual Haskell, ensures that this power does not exclude the "intuitive" appeal of visual interfaces; with some intelligent layout and suggestive icons, a Visual Haskell program can be made to look very like a block dia...

The parallel functional programming language Eden was specially designed to be implemented in a distributed setting. In a previous paper [3] we presented an operational specification of DREAM, the distributed abstract machine for Eden. In this paper we go a step further and present the imperative code generated for Eden expressions and how this code interact with the distributed RunTime System (RTS) for Eden. This translation is done in two steps: first Eden is translated into PEARL (Parallel Eden Abstract Reduction Language), the parallel functional language of DREAM, and then PEARL expressions are translated into imperative code.

Introduction An important recent idea in software technology for distributed-memory multicomputers is the use of annotations to control data partitioning and placement, relying on a compiler to infer the necessary process placement and communications. We have been developing a declarative language for controlling data partitioning and placement in functional programs, called Caliban. It is interesting because the annotation language builds on the power of the functional language, allowing the user to re-use code developed for the computational part of the problem when expressing how it should be distributed across a parallel computer. The key to doing this is partial evaluation, that is symbolically executing the program until the annotation is in its primitive form, and the partitioning is clear. While this work was developed primarily in the context of parallel functional programming, there is the interesting prospect of applying it to the problem of controlling the distribu

This paper considers parallel program development based on functional mutually recursive specifications. The development yields a communication structure linking an arbitrary fixed number of processors and an SPMD program executable on the structure. There are two steps in the development process: first, a parallel functional implementation is obtained through formal transformations in the Bird-Meertens formalism; it is then systematically transformed into an imperative target program with message passing. The approach is illustrated with a divide-and-conquer algorithm for numerical twodimensional sparse grid integration. The optimization of the target program and the results of experimental performance measurements on a 64-transputer network under OS Parix are presented. 1 Introduction We take the following approach to parallelization: we try to identify certain standard patterns of high-level functional specifications and to associate equivalent parallel programs to them...

This thesis presents and justi es a framework for programming real-time signal process-ing systems. The framework extends the existing \block-diagram " programming model� it has three components: a very high-level textual language, a visual language, and the data ow process network model of computation. The data ow process network model, although widely-used, lacks a formal description, and I provide a semantics for it. The formal work leads into a new form of actor. Having established the semantics of data ow processes, the functional language Haskell is layered above this model, providing powerful features|notably polymorphism, higher-order func-tions, and algebraic program transformation|absent in block-diagram systems. A visual equivalent notation for Haskell, Visual Haskell, ensures that this power does not exclude the \intuitive " appeal of visual interfaces � with some intelligent layout and suggestive icons, a Visual Haskell program can be made to look very like ablock diagram program. Finally, the functional language is used to further extend data ow process networks, by simulating timed and dynamically-varying networks.

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

This document describes an implementation of Caliban, the front-end language for the Fast compiler. It shows the transformations used to translate the annotated source language to standard Haskell \Gamma augmented with a parallel primitive. 1 Introduction One of the goals of the Fast project was to produce a functional language system for developing parallel programs for distributed-memory parallel computers. The approach is based on utilising a state-of-the-art optimising compiler for a sequential language and adding a sublanguage to allow partitioning and process placement of an application. The target architecture is a distributed-memory multiprocessor, in particular a Meiko Transputer Surface. This document describes how the Caliban phases of the Fast compiler are implemented. It gives details of the Caliban annotation language itself, the way this annotation language is integrated with the Haskell \Gamma front end, and how program transformations translate a Caliban program i...

The paper explores the application of a lazy functional language, Haskell, to a series of grid-based scientific problems---solution of the Poisson equation and Monte Carlo simulation of two theoretical models from statistical and particle physics. The implementations introduce certain abstractions of grid topology, making extensive use of the polymorphic features of Haskell. Updating is expressed naturally through use of infinite lists, exploiting the laziness of the language. Evolution of systems is represented by arrays of interacting streams. 1 Introduction Lazy functional languages have not, to date, made an enormous impact in scientific computing. Partly, this has to do with performance---codes written in these languages often run an order of magnitude slower than imperative codes, which limits their appeal for numbercrunching production codes 1 . Apart from that, there is a suspicion that programming without assignments or side-effects is difficult, or restrictive. Evidently, ...