An implementation of static functional process networks

Cox, Stuart; Huang, Shell-Ying; Liu, Junxian; Taylor, Frank

doi:10.1007/3-540-55599-4_107

Cited by 7 publications

(2 citation statements)

References 8 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…It is therefore of great importance that the compiler used in our experiments should perform well. We have adopted the compiler developed for the FAST project (Cox et al, 1992), and although comparing compilers is difficult, we are confident that the system is competitive with the state of the art (Hartel and Langendoen, 1993). It also, conveniently, generates C, making generated code very easy to instrument and modify.…”

Section: Compiler and Run-time Systemmentioning

confidence: 99%

Pipelined functional tree accesses and updates: scheduling, synchronization, caching and coherence

Bennett

Paterson

2001

J. Funct. Prog.

View full text Add to dashboard Cite

This paper is an exploration of the parallel graph reduction approach to parallel functional programming, illustrated by a particular example: pipelined, dynamically-scheduled implementation of search, updates and read-modify-write transactions on an in-store binary search tree. We use program transformation, execution-driven simulation and analytical modelling to expose the maximum potential parallelism, the minimum communication and synchronisation overheads, and to control the overall space requirement. We begin with a lazy functional program specifying a series of transactions on a binary tree, each involving several searches and updates, in a side-effect-free fashion. Transformation of the source code produces a formulation of the program with greater locality and larger grain size than can be achieved using naive parallelization methods, and we show that, with care, these tasks can be scheduled effectively. Even with a workload using random keys, significant spatial locality is found, and we evaluate a modified cache coherency protocol which avoids false sharing so that large cache lines can be used to minimise the number of messages required. As expected with a pipeline, the application should reach a steady state as soon as the first transaction is completed. However, if the network latency is too large, the rate of completion lags behind the rate at which work is admitted, and internal queues grow without bound. We determine the conditions under which this occurs, and show how it can be avoided while maximising speedup.

show abstract

Section: Compiler and Run-time Systemmentioning

confidence: 99%

Pipelined functional tree accesses and updates: scheduling, synchronization, caching and coherence

Bennett

Paterson

2001

J. Funct. Prog.

View full text Add to dashboard Cite

show abstract

“…The paradigm used in each case is one of interacting parallel processes, modelled by lazy lists (streams) representing the output of the processes. Partly this choice can be attributed to the source of funding for this work-the FAST project aims to provide a parallel implementation of annotated functional programs written in essentially this style (Cox et al, 1992). Apart from that, the style comes naturally and is quite efficient in a lazy language, especially for algorithms with some 'locality of reference'.…”

Section: Introductionmentioning

confidence: 99%

Some lattice-based scientific problems, expressed in Haskell

Carpenter

Glaser

1996

J. Funct. Prog.

View full text Add to dashboard Cite

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.

show abstract