Academia.eduAcademia.edu

Outline

Title
Abstract
Figures
References
All Topics
Computer Science
Algorithms and Data Structures

Efficient compilation of lazy evaluation

Profile image of Thomas JohnssonThomas Johnsson

2004, ACM SIGPLAN Notices

https://doi.org/10.1145/989393.989409
visibility

…

description

14 pages

link

1 file

Abstract

This paper describes the principles underlying an efficient implementation of a lazy functional language, compiling to code for ordinary computers. It is based on combinator-like graph reduction: the user defined functions are used as rewrite rules in the graph. Each function is compiled into an instruction sequence for an abstract graph reduction machine, called the G-machine, the code reduces a function application graph to its value. The G-machine instructions are then translated into target code. Speed improvements by almost two orders of magnitude over previous lazy evaluators have been measured; we provide some performance figures.

Figures (9)
In our graph reduction scheme each function defini- tion is compiled into a sequence of G-machine instructions. Each graph rewrite, according to a function definition, is carried out by executing the code for that function. We here illustrate execution of the G-machine with the reduction step (e)-(a) from figure 1. The G-machine state transi- tions are shown in figure 2.
In our graph reduction scheme each function defini- tion is compiled into a sequence of G-machine instructions. Each graph rewrite, according to a function definition, is carried out by executing the code for that function. We here illustrate execution of the G-machine with the reduction step (e)-(a) from figure 1. The G-machine state transi- tions are shown in figure 2.
The execution of this code sequence is shown ir figure 3. The addition is done on a separate stack for basic values, called V, with instructions MKIN‘ and GET for transfering values to and from the graph. PUSHBASIC pushes a basic value constant az the V stack.
The execution of this code sequence is shown ir figure 3. The addition is done on a separate stack for basic values, called V, with instructions MKIN‘ and GET for transfering values to and from the graph. PUSHBASIC pushes a basic value constant az the V stack.
The initial configuration of the machine for a given program is shown in figure 4. The machine starts with an empty output, a code sequence c, for se ; ie) evaluating and printing the start expression e,, an empty pointer stack and an empty basic value stack, an empty graph, an environment Ey containing the compiled code for the functions together with their arity, and an empty dump-
The initial configuration of the machine for a given program is shown in figure 4. The machine starts with an empty output, a code sequence c, for se ; ie) evaluating and printing the start expression e,, an empty pointer stack and an empty basic value stack, an empty graph, an environment Ey containing the compiled code for the functions together with their arity, and an empty dump-
of the stack new points to the m curried arguments of the function, and below them there is a pointer to the apply node which is to be updated with the value of the application. The reason for remaking the stack in this manner is firstly to make the function arguments easily accessible, and secondly to access function arguments and local variables introduced by let and letrec expressions uniformly. Figure 5. Rearrangement of the stack after unwind.
of the stack new points to the m curried arguments of the function, and below them there is a pointer to the apply node which is to be updated with the value of the application. The reason for remaking the stack in this manner is firstly to make the function arguments easily accessible, and secondly to access function arguments and local variables introduced by let and letrec expressions uniformly. Figure 5. Rearrangement of the stack after unwind.
a Further improvements of the G-machine code This section discusses two kinds of improvements of the G-machine code, which is not embodied in the compiler given in the previous section: improved tail recursive behaviour and exploiting the knowledge that a variable has been previously evaluated. Both kinds of improvements are included in our compiler implementation.
a Further improvements of the G-machine code This section discusses two kinds of improvements of the G-machine code, which is not embodied in the compiler given in the previous section: improved tail recursive behaviour and exploiting the knowledge that a variable has been previously evaluated. Both kinds of improvements are included in our compiler implementation.
The new scheme S emits a code sequence to rearrange the stack in the manner shown in figure 8, and then Figure 8. Rearranging the stack for tail calls. a direct jump is performed to the first instruction of f, thus turning tail recursion into loops in the G-machine code. Using this method on our little example above, assuming f only takes one argument, we would get
The new scheme S emits a code sequence to rearrange the stack in the manner shown in figure 8, and then Figure 8. Rearranging the stack for tail calls. a direct jump is performed to the first instruction of f, thus turning tail recursion into loops in the G-machine code. Using this method on our little example above, assuming f only takes one argument, we would get

Related papers

A dataflow implementation technique for lazy typed functional languages
Bill Wadge

This paper presents an efficient alternative to the reduction-based implementations of functional languages. The proposed technique systematically eliminates user-defined functions by appropriately introducing context-manipulation operators in the program. An abstract architecture for executing the resulting code is presented. A performance evaluation indicates that the proposed approach performs considerably well compared to graph-reduction implementations. A novel feature of the technique is that it is a fixed-program machine. As a result, passing unevaluated arguments to functions has little or no overhead. In addition, the technique is suitable for implementation on dataflow architectures. In fact, our approach gives a solution to the dataflow implementation of higher-order functions, which until now were inefficiently implemented using an expensive scheme based on closures.

View PDFchevron_right
Efficient interpretation by transforming data types and patterns to functions
Pieter Koopman

Grana, 2006

This paper describes an efficient interpreter for lazy functional languages like Haskell and Clean. The interpreter is based on the elimination of algebraic data types and pattern-based function definitions by mapping them to functions using a new efficient variant of the Church encoding. The transformation is simple and yields concise code. We illustrate the concepts by showing how to map Haskell and Clean programs to the intermediate language SAPL (Simple Application Programming Language) consisting of pure functions only.

View PDFchevron_right
Code improvement via lazy evaluation
DAVID KOJO HANSON

Information Processing Letters, 1980

View PDFchevron_right
Towards a Safe Partial Evaluation of Lazy Functional Logic Programs
Josep Silva, Salvador Tamarit

2007

Partial Evaluation is a well-known technique for specializing programs w.r.t. a given restriction of their input data. Although partial evaluation has been widely investigated in the context of functional and functional logic languages like Haskell or Curry, current schemes are either overly restrictive or destroy sharing through the specialization process, which may produce incorrect specializations when non-deterministic functions are considered. In this work, we present a new partial evaluation scheme for lazy functional logic programs that preserves sharing through the specialization process and still allows the unfolding of arbitrary functions. Furthermore, our approach ensures that sharing is also preserved across non-deterministic computations.

View PDFchevron_right
Partial evaluation of lazy functional logic programs
Pascual Julian-Iranzo

Artificial Intelligence …, 2003

View PDFchevron_right
A Modern Look at GRIN, an Optimizing Functional Language Back End
Andor Pénzes

Acta Cybernetica

GRIN is short for Graph Reduction Intermediate Notation, a modern back end for lazy functional languages. Most of the currently available compilers for such languages share a common flaw: they can only optimize programs on a per-module basis. The GRIN framework allows for interprocedural whole program analysis, enabling optimizing code transformations across functions and modules as well. Some implementations of GRIN already exist, but most of them were developed only for experimentation purposes. Thus, they either compromise on low-level efficiency or contain ad hoc modifications compared to the original specification. Our goal is to provide a full-fledged implementation of GRIN by combining the currently available best technologies like LLVM, and evaluate the framework's effectiveness by measuring how the optimizer improves the performance of certain programs. We also present some improvements to the already existing components of the framework. Some of these improvements incl...

View PDFchevron_right
Algorithmic debugging for lazy functional languages
Henrik Nilsson

Journal of Functional Programming, 1994

Lazy functional languages have non-strict semantics and are purely declarative, i.e. they support the notion of referential transparency and are devoid of side-effects. Traditional debugging techniques are, however, not suited for lazy functional languages since, computations generally do not take place in the order one might expect. Since algorithmic debugging allows the user to concentrate on the declarative aspects of program semantics, and will semi-automatically find functions containing bugs, we propose to use this technique for debugging lazy functional programs. Because of the non-strict semantics of lazy functional languages, arguments to functions are in general partially evaluated expressions. The user is, however, usually more concerned with the values that these expressions represent. We address this problem by providing the user with a strictified view of the execution trace whenever possible. In this paper, we present an algorithmic debugger for a lazy functional language based on strictification and some experience in using it. A number of problems with the current implementation of the debugger (e.g. too large trace size and too many questions asked) are also discussed and some techniques for overcoming these problems, at least partially, are suggested, the key techniques being immediate strictification and piecemeal tracing.

View PDFchevron_right
Lazy call-by-value evaluation
Bernd Braßel

Sigplan Notices, 2007

Designing debugging tools for lazy functional programming languages is a complex task which is often solved by expensive tracing of lazy computations. We present a new approach in which the information collected as a trace is reduced considerably (kilobytes instead of megabytes). The idea is to collect a kind of step information for a call-by-value interpreter, which can then efficiently reconstruct the computation for debugging/viewing tools, like declarative debugging. We show the correctness of the approach, discuss a proof-of-concept implementation with a declarative debugger as back end and present some benchmarks comparing our new approach with the Haskell debugger Hat.

View PDFchevron_right
A Technique to Build Debugging Tools for Lazy Functional Logic Languages
Bernd Braßel

Electronic Notes in Theoretical Computer Science, 2009

This paper is based on a recently developed technique to build debugging tools for lazy functional programming languages. With this technique it is possible to replay the execution of a lazy program with a strict semantics by recording information of unevaluated expressions. The recorded information is called an oracle and is very compact. Oracles contain the number of strict steps between discarding unevaluated expressions. The technique has already been successfully employed to construct a debugger for lazy functional languages. This paper extends the technique to include also lazy functional logic languages. A debugging tool built with the technique can be downloaded at www-ps.informatik.uni-kiel.de/~bbr.

View PDFchevron_right
Graph Rewriting Semantics for Functional Programming Languages
Sjaak Smetsers

1996

The lambda calculus forms without any question *the* theoretical backbone of functional programming languages. For the design and implementation of the lazy functional language Concurrent Clean we have used a related computational model: Term Graph Rewriting Systems (TGRS's). This paper wraps up our main conclusions after 10 years of experience with graph rewriting semantics for functional programming languages. TGRS's are not a direct extension of the lambda calculus, so one sometimes has to re-establish known theoretical results. But TGRS's are that much closer to the world of functional programming that its use has been proven to be very worthwhile. In TGRS's functions have names, there are constants, pattern matching and one can choose to either share expressions or copy them. Graph reduction very accurately models the essential behaviour of most implementations of functional languages and therefore it forms a good base for reasoning about reduction properties as well as the time and space consumption of functional applications. With uniqueness typing important information can be derived for efficient implementation and for purely functional interfacing with imperative programs.

View PDFchevron_right

References (27)

  1. L. Augustsson. FC manual. Technical Report Memo 13, Programming Methodology Group, Chalmers University of Technology, Göteborg, Sweden, 1982.
  2. L. Augustsson. A Compiler for Lazy ML. In Proceedings of the 1984 ACM Symposium on Lisp and Functional Programming, pages 218-227, Austin, Texas, 1984.
  3. L. Augustsson. Compiling Pattern Matching. In Proceedings 1985 Conference on Functional Programming Languages and Computer Architecture, pages 368-381, Nancy, France, 1985.
  4. L. Augustsson. Compiling Lazy Functional Languages, Part II. PhD thesis, Department of Computer Science, Chalmers University of Technology, Göteborg, Sweden, November 1987.
  5. L. Augustsson. HBC User's Manual. Programming Methodology Group, Department of Computer Sciences, Chalmers, S-412 96
  6. L. Augustsson and T. Johnsson. Parallel Graph Reduction with the n, G -machine. In Proceedings of the 1989 Conference on Functional Languages and Computer Architecture, pages 202-213, London, England, 1989.
  7. L. Augustsson and T. Johnsson. The Chalmers Lazy-ML Compiler. The Computer Journal, 32(2):127-141, 1989.
  8. Lennart Augustsson. Implementing Haskell Overloading. In Proc. 6th Int'l Conf. on Functional Programming Languages and Computer Architecture (FPCA'93), pages 65-73. ACM Press, June 1993.
  9. Urban Boquist. Interprocedural Register Allocation for Lazy Functional Languages. In Proceedings of the 1995 Conference on Functional Programming Languages and Computer Architecture, La Jolla, CA, USA, June 1995.
  10. Urban Boquist. Code Optimisation Techniques for Lazy Functional Languages. PhD thesis, Department of Computing Science, Chalmers University of Technology, S-412 96
  11. Göteborg, Sweden, 1999.
  12. Urban Boquist and Thomas Johnsson. The GRIN Project: A Highly Optimising Back End For Lazy Functional Languages. In Selected papers from the 8th International Workshop on Implementation of Functional Languages, Bad Godesberg, Germany, September 1996. Springer-Verlag, LNCS 1268.
  13. G. Burn, J. Robson, and S. Peyton Jones. The Spineless G-machine. In Proceedings of the 1988 ACM Symposium on Lisp and Functional Programming, Snowbird, Utah, 1988.
  14. J. Fairbairn and S. C. Wray. Code generation techniques for functional languages. In Proceedings of the 1986 ACM Symposium on Lisp and Functional Programming, Cambridge, Mass., 1986.
  15. J. Fairbairn and S. C. Wray. TIM: A simple, lazy abstract machine to execute supercombinators. In Proceedings of the 1987 Conference on Functional Programming Languages and Computer Architecture, Portland, Oregon, September 1987.
  16. R. J. M. Hughes. Super Combinators-A New Implementation Method for Applicative Languages. In Proceedings of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1-10, Pittsburgh, 1982.
  17. R. J. M. Hughes. The Design and Implementation of Programming Languages. PhD thesis, Programming Research Group, Oxford University, July 1983.
  18. T. Johnsson. Code Generation for Lazy Evaluation. Technical Report Memo 22, Programming Methodology Group, Chalmers University of Technology, Göteborg, Sweden, 1981.
  19. T. Johnsson. Ef cient Compilation of Lazy Evaluation. In Proceedings of the SIGPLAN '84 Symposium on Compiler Construction, pages 58-69, Montreal, 1984.
  20. T. Johnsson. Lambda Lifting: Transforming Programs to Recursive Equations. In Proceedings 1985 Conference on Functional Programming Languages and Computer Architecture, Lecture Notes in Computer Science 201, Nancy, France, 1985. Springer Verlag.
  21. T. Johnsson. Code Generation from G-machine code. In Proceedings of the workshop on Graph Reduction, Lecture Notes in Computer Science 279, Santa Fe, September 1986. Springer Verlag.
  22. T. Johnsson. Compiling Lazy Functional Languages. PhD thesis, Department of Computer Sciences, Chalmers University of Technology, Göteborg, Sweden, February 1987.
  23. Mark P. Jones. The implementation of the Gofer functional programming system. Technical Report YALEU/DCS/RR-1030, Department of Computer Science, Yale University, New Haven, Connecticut, USA, May 1994, May 94.
  24. Simon L. Peyton Jones. Implementing lazy functional languages on stock hardware: the spineless tagless g-machine. Journal of Functional Programming, 2(2):127-202, July 1992.
  25. Niklas Röjemo. Highlights from nhc -a space-ef cient Haskell compiler. In Proc. 7th Int'l Conf. on Functional Programming Languages and Computer Architecture (FPCA'95). ACM Press, June 1995.
  26. S. S. Thackar, editor. Selected reprints on Data ow and Reduction Architectures. IEEE Computer Society Press, 1987.
  27. D. A. Turner. A New Implementation Technique for Applicative Languages. Software-Practice and Experience, 9:31-49, 1979.

Related papers

Code optimizations for lazy evaluation
Jonathan Young

Lisp and Symbolic Computation, 1988

Implementations of lazy evaluation for non-strict functional languages usually involve the notion of a delayed representation of the value of an expression, which we call a thunk. We present several techniques for implementing thunks and formalize a class of optimizations that reduce both the space and time overhead of these techniques. The optimizations depend on a compile-time inferencing strategy called path analysis, a generalization of strictness analysis that uncovers order-of-evaluation information. Although the techniques in this paper are focused on the compilation of a non-strict functional language for a conventional architecture, they are directly applicable to most of the virtual machines commonly used for implementing such languages. The same techniques also apply to other forms of delayed evaluation such as futures and promises.

View PDFchevron_right
The Generalized Intensional Transformation for Implementing Lazy Functional Languages
Panos Rondogiannis

The intensional transformation is a promising technique for implementing lazy functional languages based on a demand-driven execution model. Despite its theoretical elegance and its simple and efficient execution model, the intensional transformation suffered, until now, from two main drawbacks: (a) it could only be applied to programs that manipulate primitive data-types, and (b) it could only compile a simple (and rather restricted) class of higher-order functions. In this paper we remedy the above two deficiencies, obtaining a transformation algorithm that is applicable to mainstream lazy functional languages. The proposed transformation initially uses defunctionalization in order to eliminate higher-order functions from the source program. The resulting first-order program is then transformed into a program in a simple tuple-based language. Finally, the original intensional transformation is extended in order to be applicable to the tuple language. The correctness of the generalized transformation is formally established. It is demonstrated that the proposed technique can be used to compile a relatively large subset of Haskell into portable C code whose performance is comparable to existing mainstream implementations.

View PDFchevron_right
A new programming technique for lazy functional languages
Pim van Den Broek

Science of Computer Programming, 1995

In this paper we present a new programming technique for lazy functional programming languages. The technique is embedded in a programming methodology which is based on divide and conquer: the division of problems into subproblems. Such a division will be represented by a call graph.

View PDFchevron_right
Introducing the PilGRIM: A Processor for Executing Lazy Functional Languages
Jan Kuper

Journal of Physics: Conference Series, 2011

Processor designs specialized for functional languages received very little attention in the past 20 years. The potential for exploiting more parallelism and the developments in hardware technology, ask for renewed investigation of this topic. In this paper, we use ideas from modern processor architectures and the state of the art in compilation, to guide the design of our processor, the PilGRIM. We define a high-level instruction set for lazy functional languages and show the processor architecture, that can efficiently execute these instructions.

View PDFchevron_right
Efficient Intensional Implementation for Lazy Functional Languages
Angelos Charalambidis, Panos Rondogiannis

Mathematics in Computer Science, 2008

The intensional transformation is a technique that can be used in order to eliminate higher-order functions from a functional program by introducing appropriate context manipulation operators. The transformation can be applied to a significant class of higher-order programs and results in equivalent zero-order intensional programs that can be executed in a simple demand-driven way. Despite its simplicity, the transformation has never been seriously evaluated with respect to its efficiency and potential. Certain simple implementations of the technique have been performed, but the questions regarding the merits of the method have remained inconclusive. In this paper we demonstrate that the transformation can be efficiently implemented by using what we call lazy activation records, namely activation records in which some entries are filled on-demand. An evaluation of our implementation demonstrates that the technique outperforms some of the most well-known functional programming systems, for the class of programs that can be transformed.

View PDFchevron_right

Related topics

  • Computer Science
  • Functional Programming
  • Lazy Evaluation
  • Graph Reduction
  • Abstract machine
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved