TIL: A type-directed optimizing compiler for ML

ACM SIGPLAN Notices

Volumn 39, Issue 4, 2004, Pages 556-567

  Tarditi, D ^a   Morrisett, G ^a   Cheng, P ^a   Stone, C ^a   Harper, R ^a   Lee, P ^a  

^a Carnegie Mellon University   (United States)

Author keywords

[No Author keywords available]

Indexed keywords

COMPILER OPTIMIZATION; GARBAGE COLLECTION; LOOP OPTIMIZATION; POLYMORPHISM;

BENCHMARKING; COMPUTER PROGRAMMING LANGUAGES; DATA REDUCTION; FUNCTIONS; INVARIANCE; OPTIMIZATION; RECURSIVE FUNCTIONS; STORAGE ALLOCATION (COMPUTER);

PROGRAM COMPILERS;

EID: 3142685432     PISSN: 03621340     EISSN: None     Source Type: Journal    
DOI: None     Document Type: Conference Paper

References (49)

1. Shail Aditya, Christine Flood, and James Hicks. Garbage collection for strongly-typed languages using run-time type reconstruction. In LFP '94 [30], pages 12-23.
2. Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman. Compilers: Principles, Techniques, and Tools. Addison-Wesley Publishing Company, 1986.
3. Andrew Appel. A critique of Standard ML. Journal of Functional Programming, 3(4):391-429, October 1993.
4. Andrew W. Appel. Runtime tags aren't necessary. Lisp and Symbolic Computation, (2):153-162, 1989.
5. Andrew W. Appel. Compiling with Continuations. Cambridge University Press, 1992.
6. Andrew W. Appel, James S. Mattson, and David Tarditi. A lexical analyzer generator for Standard ML. Distributed with Standard ML of New Jersey, 1989.
7. Edoardo Biagioni, Robert Harper, Peter Lee, and Brian Milnes. Signatures for a network protocol stack: A systems application of Standard ML. In LFP '94 [30], pages 55-64.
8. Lars Birkedal, Nick Rothwell, Mads Tofte, and David N. Turner. The ML Kit, Version 1. Technical Report 93/14, DIKU, 1993.
9. Guy B. Blelloch. NESL: A nested data-parallel language (version 2.6). Technical Report CMU-CS-93-129, School of Computer Science, Carnegie Mellon University, April 1993.
10. Hans-Juergen Boehm. Space-efficient conservative garbage collection. In PLDI '93 [36], pages 197-206.
11. P. Branquart and J. Lewi. A scheme for storage allocation and garbage collection for Algol-68. In Algol-68 Implementation. North-Holland Publishing Company, Amsterdam, 1970.
12. Dianne Ellen Britton. Heap storage management for the programming language Pascal. Master's thesis, University of Arizona, 1975.
13. Fred C. Chow. Minimizing register usage penalty at procedure calls. In Proceedings of the ACM SIGPLAN '88 Conference on Programming Language Design and Implementation, pages 85-94, Atlanta, Georgia, June 1988. ACM.
14. A. Demers, M. Weiser, B. Hayes, H. Boehm, D. Bobrow, and S. Shenker. Combining generational and conservative garbage collection: Framework and implementations. In Conference Record of the 17th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, San Francisco, California, January 1990. ACM.
15. Amer Diwan, Eliot Moss, and Richard Hudson. Compiler support for garbage collection in a statically typed language. In Proceedings of the ACM SIGPLAN '92 Conference on Programming Language Design and Implementation, pages 273-282, San Francisco, CA, June 1992. ACM.
16. Amer Diwan, David Tarditi, and Eliot Moss. Memory-System Performance of Programs with Intensive Heap Allocation. Transactions on Computer Systems, August 1995.
17. K. Ekanadham and Arvind. SIMPLE: An exercise in future scientific programming. Technical Report Computation Structures Group Memo 273, MIT, Cambridge, MA, July 1987. Simultaneously published as IBM/T. J. Watson Research Center Research Report 12686, Yorktown Heights, NY.
18. K. Ekanadham and Arvind. SIMPLE: An exercise in future scientific programming. Technical Report Computation Structures Group Memo 273, MIT, Cambridge, MA, July 1987. Simultaneously published as IBM/T. J. Watson Research Center Research Report 12686, Yorktown Heights, NY.
19. Cormac Flanagan, Amr Sabry, Bruce F. Duba, and Matthias Felleisen. The essence of compiling with continuations. In PLDI '93 [36], pages 237-247.
20. Benjamin Goldberg. Tag-free garbage collection in strongly typed programming languages. In Proceedings of the ACM SIGPLAN '91 Conference on Programming Language Design and Implementation, pages 165-176, Toronto, Canada, June 1991. ACM.
21. Benjamin Goldberg and Michael Gloger. Polymorphic type reconstruction for garbage collection without tags. In Proceedings of the 1992 ACM Conference on Lisp and Functional Programming, pages 53-65, San Francisco, California, June 1992. ACM.
22. Cordelia Hall, Simon L. Peyton Jones, and Patrick M. Sansom. Unboxing using specialisation. In D. Turner K. Hammond, P.M. Sandom, editor, Functional Programming, 1994, Springer-Verlag, 1995.
23. Robert Harper and Mark Lillibridge. A type-theoretic approach to higher-order modules with sharing. In POPL '94 [37], pages 123-137.
24. Robert Harper and Greg Morrisett. Compiling polymorphism using intensional type analysis. In Conference Record of the 22nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 130-141, San Francisco, California, January 1995. ACM.
25. Fritz Henglein and Jesper Jørgensen. Formally optimal boxing. In POPL '94 [37], pages 213-226.
26. M.P. Jones. Partial evaluation for dictionary-free overloading. Research Report YALEU/DCS/RR-959, Yale University, New Haven, Connecticut, USA, April 1993.
27. Simon Peyton Jones and John Launchbury. Unboxed values as first-class citizens. In Proceedings of the Conference on Functional Programming and Computer Architecture, volume 523 of Lecture Notes on Computer Science, pages 636-666. ACM, Springer-Verlag, 1991.
28. David Kranz, Richard Kelsey, Jonathan Rees, Paul Hudak, James Philbin, and Norman Adams. ORBIT: An Optimizing Compiler for Scheme. In Proceedings of the SIGPLAN '86 Symposium on Compiler Construction, pages 219-233, Palo Alto, California, June 1986. ACM.
29. Xavier Leroy. Unboxed objects and polymorphic typing. In Conference Record of the 19th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 177-188, Albuquerque, NM, January 1992. ACM.
30. Xavier Leroy. Manifest types, modules, and separate compilation. In POPL '94 [37], pages 109-122.
31. Proceedings of the 1994 ACM Conference on Lisp and Functional Programming, Orlando, Florida, June 1994. ACM.
32. Robin Milner, Mads Tofte, and Robert Harper. The Definition of Standard ML. MIT Press, 1990.
33. Y. Minamide, G. Morrisett, and R. Harper. Typed closure conversion. In Conference Record of the 23rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, St. Petersburg, Florida, January 1996. ACM.
34. Greg Morrisett. Compiling with Types. PhD thesis, School of Computer Science, Carnegie Mellon University, Pittsburgh, PA, December 1995. Published as Technical Report CMU-CS-95-226.
35. Greg Morrisett, Matthias Felleisen, and Robert Harper. Abstract models of memory management. In ACM Conference on Functional Programming and Computer Architecture, pages 66-77, La Jolla, June 1995.
36. R. Morrison, A. Dearle, R. C. H. Connor, and A. L. Brown. An ad hoc approach to the implementation of polymorphism. ACM Transactions on Programming Languages and Systems, 13(3):342-371, July 1991.
37. Proceedings of the ACM SIGPLAN '93 Conference on Programming Language Design and Implementation, Albuquerque, New Mexico, June 1993. ACM.
38. Conference Record of the 21st Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Portland, Oregon, January 1994. ACM.
39. Eigil Rosager Poulsen. Representation analysis for efficient implementation of polymorphism. Technical report, Department of Computer Science (diku), University of Copenhagen, April 1993. Master Dissertation.
40. Chris Reade. Elements of Functional Programming. Addison-wesley, Reading, Massachusetts, 1989.
41. Manual Serrano and Pierre Weis. 1+1 = 1: an optimizing Caml compiler. Technical Report 2264, Inria, June 1994.
42. Zhong Shao. Compiling Standard ML for Efficient Execution on Modern Machines. PhD thesis, Princeton University, Princeton, New Jersey, November 1994.
43. Zhong Shao and Andrew W. Appel. A type-based compiler for Standard ML. In Proceedings of the ACM SIGPLAN '95 Conference on Programming Language Design and Implementation, pages 116-129, La Jolla, California, June 1994. ACM.
44. Peter Steenkiste. Advanced register allocation. In. Peter Lee, editor, Topics in Advanced Language Implementation. MIT Press, 1990.
45. Bjarne Stroustrup. The C++ Programming Language, 2nd Edition. Addison-Wesley, 1991.
46. David R. Tarditi. Optimizing ML. PhD thesis, School of Computer Science, Carnegie Mellon University, 1996. Forthcoming.
47. Andrew Tolmach. Tag-free garbage collection using explicit type parameters. In LFP '94 [30], pages 1-11.
48. Kevin G. Waugh, Patrick McAndrew, and Greg Michaelson. Parallel implementations from function prototypes: a case study. Technical Report Computer Science 90/4, Heriot-Watt University, Edinburgh, August 1990.
49. P.L. Wodon. Methods of garbage collection for Algol-68. In Algol-88 Implementation. North-Holland Publishing Company, Amsterdam, 1970.