Hostname: page-component-586b7cd67f-2brh9 Total loading time: 0 Render date: 2024-11-23T19:22:55.847Z Has data issue: false hasContentIssue false
  • English
  • Français

Implementing the evaluation transformer model of reduction on parallel machines

Part of: JFP Research Articles

Published online by Cambridge University Press:  07 November 2008

G. L. Burn
G. L. Burn
Affiliation:
Department of Computing, Imperial College of Science, Technology and Medicine, London SW7 2BZ, UK
Rights & Permissions [Opens in a new window]

Abstract

Core share and HTML view are not available for this content. However, as you have access to this content, a full PDF is available via the ‘Save PDF’ action button.

The evaluation transformer model of reduction generalizes lazy evaluation in two ways: it can start the evaluation of expressions before their first use, and it can evaluate expressions further than weak head normal form. Moreover, the amount of evaluation required of an argument to a function may depend on the amount of evaluation required of the function application. It is a suitable candidate model for implementing lazy functional languages on parallel machines.

In this paper we explore the implementation of lazy functional languages on parallel machines, both shared and distributed memory architectures, using the evaluation transformer model of reduction. We will see that the same code can be produced for both styles of architecture, and the definition of the instruction set is virtually the same for each style. The essential difference is that a distributed memory architecture has one extra node type for non-local pointers, and instructions which involve the value of such nodes need their definitions extended to cover this new type of node.

To make our presentation accessible, we base our description on a variant of the well-known G-machine, an abstract machine for executing lazy functional programs.

Type
Articles
Information
Journal of Functional Programming , Volume 1 , Issue 3 , July 1991 , pp. 329 - 366
Copyright
Copyright © Cambridge University Press 1991

References

Augustsson, L. 1987 a. Compiling Lazy Functional Languages, Part II. PhD thesis, Chalmers Tekniska Högskola, Göteborg, Sweden.Google Scholar
Augustsson, L. 1987 b. A parallel G-machine. Technical Report PMG53, Department of Computer Science, Chalmers University of Technology, Göteborg, Sweden.Google Scholar
Augustsson, L. and Johnsson, T. 1989. The 〈v, G〉-machine: an abstract machine for parallel graph reduction. In MacQueen, D. B. (editor), Proceedings of the Functional Programming Languages and Computer Architecture Conference, pp. 202–213. ACM.Google Scholar
Bevan, D. I. 1987. Distributed garbage collection using reference counting. In de Bakker, J. W., Nijman, A. J. and Treleaven, P. C. (editors), PARLE (Parallel Architectures and Languages Europe), volume 2, pp. 176–187. In volume 259 of Lecture Notes in Computer Science, Springer-Verlag.CrossRefGoogle Scholar
Bevan, D. I., Burn, G. L., Karia, R. J. and Robson, J. D. 1989. Design principles of a distributed memory architecture for parallel graph reduction. The Computer Journal, 32(5): 461–469 (Oct.).CrossRefGoogle Scholar
Bird, R. J. and Wadler, P. L. 1988. An Introduction to Functional Programming, Prentice-Hall.Google Scholar
Bloss, A., Hudak, P. and Young, J. 1988. Code optimisations for lazy evaluation, Lisp and Symbolic Computation: An International Journal, 1(2): 147–164.CrossRefGoogle Scholar
Burn, G. L. 1987. Abstract Interpretation and the Parallel Evaluation of Functional Languages. PhD thesis, Imperial College, University of London (March).Google Scholar
Burn, G. L. 1988 a. Developing a distributed memory architecture for parallel graph reduction. In Proc. CONPAR 88, Manchester, UK (12–16 September).Google Scholar
Burn, G. L. 1988 b. A shared memory parallel G-machine based on the evaluation transformer model of computation. In Proc. Workshop on the Implementation of Lazy Functional Languages, pp. 301–330, Göteborg, Sweden (5–8 September).Google Scholar
Burn, G. L. 1990. Using projection analysis in compiling lazy functional programs. In Proc. 1990 ACM Conference on Lisp and Functional Programming, pp. 227–241, Nice, France(27–29 June).Google Scholar
Burn, G. L. 1991. Lazy Functional Languages: Abstract Interpretation and Compilation, Research Monographs in Parallel and Distributed Computing, Pitman (to appear).Google Scholar
Burn, G. L., Peyton Jones, S. L. and Robson, J. D. 1988. The spineless G-machine. In Proc. 1988 ACM Symposium on Lisp and Functional Programming, pp. 244–258, Snowbird, Utah (July).CrossRefGoogle Scholar
Dijkstra, E. W. 1965. Cooperating sequential processes. Technical report, Technological University, Eindhoven, The Netherlands. (Reprinted in Genuys, F. (ed.), Programming Languages, pp. 43–112, Academic press, New York, 1968.)Google Scholar
Eager, D. L., Lazowska, E. D. and Zahorjan, J. 1986. Adaptive load sharing in homogeneous distributed systems. IEEE Trans. Software Engineering, 12(5): 662–675 (May).CrossRefGoogle Scholar
Fairbairn, J. and Wray, S. C. 1986. Code generation techniques for functional languages. In Proc. ACM Conference on Lisp and Functional Programming, pp. 94–104, Cambridge, MA.CrossRefGoogle Scholar
Fairbairn, J. and Wray, S. C. 1987. TIM: A simple, lazy abstract machine to execute super-combinators. In Kahn, G. (editor), Proc. Functional Programming Languages and Computer Architecture Conference, pp. 34–45. In volume 274 of Lecture Notes in Computer Science, Springer-Verlag.CrossRefGoogle Scholar
Hankin, C. L., Burn, G. L. and Peyton Jones, S. L. 1986. A safe approach to parallel combinator reduction (extended abstract). In Proc. ESOP 86 (European Symposium on Programming), pp. 99–110, Saabrucken, FRG (March).CrossRefGoogle Scholar
Hankin, C. L., Burn, G. L. and Peyton Jones, S. L. 1988. A safe approach to parallel combinator reduction. Theoretical Computer Science, 56: 17–36.CrossRefGoogle Scholar
Hartel, P. H. 1988. Performance Analysis of Storage Management in Combinator Graph Reduction. PhD thesis, Computing Science Department, University of Amsterdam.Google Scholar
Hudak, P. and Goldberg, B. 1985. Serial combinators: ‘optimal’ grains of parallelism. In Jouannaud, J. -P. (editor), Proc. Functional Programming Languages and Computer Architecture Conference, pp. 382–399. Springer-Verlag.CrossRefGoogle Scholar
Hunt, S. 1989. Frontiers and open sets in abstract interpretation. In Proc. Conference on Functional Programming Languages and Computer Architecture,Imperial College,London(11–13 September).CrossRefGoogle Scholar
Johnsson, T. 1983. The G-machine. An abstract machine for graph reduction. In Declarative Programming Workshop, pp. 1–20. University College London (April).Google Scholar
Johnsson, T. 1987. Compiling Lazy Functional Languages. PhD thesis, Chalmers Tekniska Högskola, Göteborg, Sweden.Google Scholar
Kingdon, J., Lester, D. R. and Burn, G. L. 1991. A transputer-based HDG-machine. The Computer Journal (special issue on Parallelism). To appear.Google Scholar
Lester, D. R. 1989 a. An efficient distributed garbage collection algorithm. In Odijk, E., Rem, M. and Syre, J. -C. (editors), PARLE (Parallel Architectures and Languages Europe), volume 1, pp. 207–223 (12–16 June). In volume 258 of Lecture Notes in Computer Science, Springer-Verlag.CrossRefGoogle Scholar
Lester, D. R. 1989 b. Stacklessness: compiling recursion for a distributed architecture. In Conf. Functional Programming Languages and Computer Architecture, pp. 116–128, London, UK (11–13 September).Google Scholar
Lester, D. R. and Burn, G. L. 1990. An executable specification of the HDG-Machine. In Workshop on Massive Parallelism: Hardware, Programming and Applications, Amalfi, Italy (9–15 October).Google Scholar
Loogen, R., Kuchen, H., Indermark, K. and Damm, W. 1989. Distributed implementation of programmed graph reduction. In Odijk, E., Rem, M. and Syre, J. -C. (editors), Proc. PARLE 89, volume 1, pp. 136–157. Eindhoven, The Netherlands (12–16 June). In volume 258 of Lecture Notes in Computer Science, Springer-Verlag.Google Scholar
Nocker, E. and Plasmeyer, R. 1986. Combinator reduction on a parallel G-machine. Technical report, Dept. of Computer Science, University of Nijmegen, The Netherlands.Google Scholar
Partridge, A. 1991. Dynamic Aspects of Distributed Graph Reduction. PhD thesis, Department of Electrical Engineering and Computer Science, University of Tasmania (in preparation).Google Scholar
Peyton Jones, S. L. 1987. The Implementation of Functional Programming Languages. Prentice-Hall.Google Scholar
Peyton Jones, S. L., Clack, C. and Salkild, J. 1989. High-performance parallel graph reduction. In Odijk, E., Rem, M. and Syre, J. -C. (editors), Proc PARLE 89, volume 1, pp. 193–206. Eindhoven, The Netherlands (12–16 June). In volume 258 of Lecture Notes in Computer Science, Springer-Verlag.Google Scholar
Peyton Jones, S. L. and Salkild, J. 1989. The Spineless Tagless G-Machine. In MacQueen, D. B. (editor), Proc. Functional Programming Languages and Computer Architecture Conference, pp. 184–201. ACM (11–13 September).CrossRefGoogle Scholar
Raber, M., Remmel, T., Hoffman, E., Maurer, D., Muller, F., Oberhauser, H. -G. and Wilhelm, R. 1987 a. Compiled graph reduction on a processor network. Technical report, Universitat des Saarlandes, Saarbrucken, FRG.Google Scholar
Raber, M., Remmel, T., Maurer, D., Muller, F., Oberhauser, H. -G. and Wilhelm, R. 1987 b. A concept for a parallel G-machine. Report SFB 124-C1, Universitate des Saarlandes, Saarbrucken, FRG.Google Scholar
Traub, K. R. 1989. Sequential Implementation of Lenient Programming Languages. PhD thesis, Laboratory of Computer Science, MIT (September).Google Scholar
Turner, D. A. 1985. Miranda: a non-strict functional language with polymorphic types. In Jouannaud, J. -P. (editor), Proc. Functional Programming Languages and Computer Architecture Conference, pp. 1–16. Springer-Verlag. In volume 201 of Lecture Notes in Computer Science, Springer-Verlag.CrossRefGoogle Scholar
Turner, D. A. 1986. An overview of Miranda. SIGPLAN Notices (December).CrossRefGoogle Scholar
Valiant, L. G. 1988. General purpose parallel architectures. In van Leeuwen, J. (editor), Handbook of Theoretical Computer Science. North Holland.Google Scholar
Wadler, P. and Hughes, R. J. M. 1987. Projections for strictness analysis. In Kahn, G. (editor), Proc. Functional Programming Languages and Computer Architecture Conference, pp. 385–407. In volume 274 of Lecture Notes in Computer Science, Springer-Verlag.CrossRefGoogle Scholar
Watson, P. and Watson, I. 1987. An efficient garbage collection scheme for parallel computer architectures. In de Bakker, J. W., Nijman, A. J. and Treleaven, P. C. (editors), PARLE Parallel Architectures and Languages Europe, volume 2., pp. 432–443. Eindhoven, The Netherlands (June). In volume 259 of Lecture Notes in Computer Science, Springer-Verlag.CrossRefGoogle Scholar
Submit a response

Discussions

No Discussions have been published for this article.