Despite recent advances, predicting the performance of functional programs on real machines remains something of a black art. This paper reports on one particularly unexpected set of results where small variations in the dynamic heap settings occasionally gave rise to significant differences in CPU performance. These performance spikes can be traced to the direct-mapped cache of the machine being benchmarked, the widely-used Sun Sparcstation 1. 1. Introduction In spite of the recent growth of interest in performance profiling [ 1, 2, 3, 4 ] , we are still often surprised by the performance of functional programs on real machines. This paper reports on performance results obtained from a trivial functional program, whose performance we believed to be well understood, but which transpired to be rather subtle. 2. Benchmarking a Simple Program Our benchmark program is a simple implementation of the classic Towers of Hanoi function in Haskell. main resps = [AppendChan stdout (hanoi 15 '...

This paper reports on the experimental application of heap profiling to Augustsson and Johnsson's Lazy ML (LML) compiler [1]. Since our implementation of heap profiling is itself based on the LML compiler, this amounts to a boot-strapping exercise. The LML compiler extends to some 16,500 lines of code in almost 200 modules, and is by any standard a large and sophisticated piece of software. As it has been developed over a period of almost a decade, with each successive version outperforming its predecessor, the sort of dramatic improvement obtained for the clausify program is hardly to be expected; but

Profiling tools, which measure and display the dynamic space and time behaviour of programs, are essential for identifying execution bottlenecks. A variety of such tools exist for conventional languages, but almost none for non-strict functional languages. There is a good reason for this: lazy evaluation means that the program is executed in an order which is not immediately apparent from the source code, so it is difficult to relate dynamically-gathered statistics back to the original source. We present a new technique which solves this problem. The framework is general enough to profile both space and time behaviour. Better still, it is cheap to implement, and we describe how to do so in the context of the Spineless Tagless G-machine. 1 Introduction Software engineers writing real applications often need to predict, measure and improve the performance of the parts of their programs. Lazy functional programming environments have typically provided few tools to help this process desp...

Mere academic toys or the tools of the future? Lazy functional programming languages have undoubted attractive properties. This thesis explores their potential, from the programmer's point of view, for implementing interactive and graphical applications to which they do not seem immediately suited. The discussion is centred round two example applications. One is a graphical design program based on an idea of the artist M. C. Escher. The thesis argues that the graphical user interface may be encapsulated in an "interpret " function that when applied by a mouse click to an interface of appropriate type yields the required behaviour. The second example is a monitoring interpreter for a functional language. The idea is that if the mechanics of the reduction are presented at a suitable level of abstraction, this may be used to give insight into what is going on. On the basis of this the programmer might modify the code so that a program runs more efficiently in terms of speed and memory requirements. Problems of displaying the reduction are addressed, and solutions proposed for overcoming these: displaying the graph as a spanning tree, to ensure planarity, with extra leaves