New Ideas in Parallel Lisp: Language Design, Implementation, and Programming Tools

A Lisp-based approach is attractive for parallel computing since Lisp languages and systems assume significant clerical burdens, such as storage management. Parallel Lisps thus enable programmers to focus on the new problems introduced by using concurrency. Parallel Lisps now exist that can execute realistic applications with “industrial-strength” performance, but there are applications whose requirements they do not handle elegantly. Recent work has contributed new, elegant ideas in the areas of speculative computation, continuations, exception handling, aggregate data structures, and scheduling. Using these ideas, it should be possible to build “second generation” parallel Lisp systems that are as powerful and elegantly structured as sequential Lisp systems.

[1]  Leslie Lamport,et al.  On-the-fly garbage collection: an exercise in cooperation , 1975, Language Hierarchies and Interfaces.

[2]  Robert H. Halstead,et al.  Exception Handling in Multilisp , 1985, ICPP.

[3]  J. D. Ichbiah,et al.  Preliminary Ada reference manual , 1979, SIGP.

[4]  Robert M. Keller,et al.  Simulated Performance of a Reduction-Based Multiprocessor , 1984, Computer.

[5]  Robert R. Kessler,et al.  An implementation of portable standard LISP on the BBN butterfly , 1988, LFP '88.

[6]  Moses Ma,et al.  Efficient message-based system for concurrent simulation , 1989 .

[7]  Robert R. Kessler,et al.  Concurrent Scheme , 1989, Workshop on Parallel Lisp.

[8]  Takayasu ITO,et al.  A Parallel Lisp Language PaiLisp and Its Kernel Specification , 1989, Workshop on Parallel Lisp.

[9]  Guy L. Steele,et al.  Common Lisp the Language , 1984 .

[10]  Thomas F. Knight.  An architecture for mostly functional languages , 1986, LFP '86.

[11]  Robert H. Halstead,et al.  Mul-T: a high-performance parallel Lisp , 1989, PLDI '89.

[12]  Elizabeth Bradley.  LOGIC SIMULATION ON A MULTIPROCESSOR , 1986 .

[13]  Randy B. Osborne,et al.  Speculative computation in multilisp , 1989, LISP and Functional Programming.

[14]  Albert R. Meyer,et al.  Continuations may be unreasonable , 1988, LISP and Functional Programming.

[15]  James R. Larus,et al.  Restructuring Lisp programs for concurrent execution , 1988, PPoPP 1988.

[16]  Shigeo Sugimoto,et al.  A Multi-Microprocessor System for Concurrent LISP , 1983, ICPP.

[17]  C. S. Wetherell.  Error Data Values in the Data-Flow Language VAL , 1982, TOPL.

[18]  Robert H. Halstead,et al.  Overview of concert multilisp: a multiprocessor symbolic computing system , 1987, CARN.

[19]  Robert H. Halstead,et al.  MULTILISP: a language for concurrent symbolic computation , 1985, TOPL.

[20]  Joseph E. Stoy,et al.  Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory , 1981 .

[21]  W. Daniel Hillis,et al.  Connection Machine Lisp: fine-grained parallel symbolic processing , 1986, LFP '86.

[22]  Carl Hewitt,et al.  The Scientific Community Metaphor , 1988, IEEE Transactions on Systems, Man, and Cybernetics.

[23]  Matthias Felleisen,et al.  Control delimiters and their hierarchies , 1990, LISP Symb. Comput..

[24]  Peter Henderson,et al.  A lazy evaluator , 1976, POPL.

[25]  Robert H. Thomas,et al.  Performance Measurements on a 128-Node Butterfly Parallel Processor , 1985, ICPP.

[26]  Richard P. Gabriel,et al.  Preliminary results with the initial implementation of Qlisp , 1988, LFP '88.

[27]  John Glauert,et al.  SISAL: streams and iteration in a single assignment language. Language reference manual, Version 1. 2. Revision 1 , 1985 .

[28]  Elizabeth Bradley,et al.  Simulating logic circuits: A multiprocessor application , 1987, International Journal of Parallel Programming.

[29]  Jack B. Dennis,et al.  Data Flow Supercomputers , 1980, Computer.

[30]  Alan Snyder,et al.  Exception Handling in CLU , 1979, IEEE Transactions on Software Engineering.

[31]  Robert H. Halstead,et al.  Parallel Symbolic Computing , 1986, Computer.

[32]  Robert H. Halstead,et al.  Lazy task creation: a technique for increasing the granularity of parallel programs , 1990, LISP and Functional Programming.

[33]  David A. Moon,et al.  Garbage collection in a large LISP system , 1984, LFP '84.

[34]  James S. Miller,et al.  Garbage Collection in MultiScheme , 1989, Workshop on Parallel Lisp.

[35]  Edward J. Krall,et al.  A case study of parallel execution of a rule-based expert system , 2005, International Journal of Parallel Programming.

[36]  Richard P. Gabriel,et al.  Qlisp: parallel processing in Lisp , 1989, IEEE Software.

[37]  T. L. Anderson.  THE DESIGN OF A MULTIPROCESSOR DEVELOPMENT SYSTEM , 1982 .

[38]  Robert H. Halstead.  An assessment of multilisp: Lessons from experience , 2005, International Journal of Parallel Programming.

[39]  Jr. Robert H. Halsatead.  Parallel computing using Multilisp , 1988 .

[40]  Kai Hwang,et al.  Parallel processing for supercomputers and artificial intelligence , 1989 .

[41]  Gerald J. Sussman,et al.  Structure and interpretation of computer programs , 1985, Proceedings of the IEEE.

[42]  W. Daniel Hillis,et al.  Data parallel algorithms , 1986, CACM.

[43]  Donald C. Allen,et al.  Recent Developments in Butterfly™ Lisp , 1987, AAAI.

[44]  David K. Gifford,et al.  Polymorphic effect systems , 1988, POPL '88.

[45]  William D. Clinger,et al.  Implementation strategies for continuations , 1988, LFP '88.

[46]  P. R. Nuth.  COMMUNICATION PATTERNS IN A SYMBOLIC MULTIPROCESSOR , 1987 .

[47]  Daniel P. Friedman,et al.  Aspects of Applicative Programming for Parallel Processing , 1978, IEEE Transactions on Computers.

[48]  Williams Ludwell Harrison,et al.  The interprocedural analysis and automatic parallelization of Scheme programs , 1990, LISP Symb. Comput..

[49]  Daniel Weise,et al.  Continuing into the future: on the interaction of futures and first-class continuations , 1990, LISP and Functional Programming.

[50]  Thomas J. LeBlanc,et al.  Debugging Parallel Programs with Instant Replay , 1987, IEEE Transactions on Computers.

[51]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[52]  Richard P. Gabriel,et al.  Qlisp: experience and new directions , 1988, PPoPP 1988.

[53]  Charles L. Forgy,et al.  Rete: A Fast Algorithm for the Many Patterns/Many Objects Match Problem , 1982, Artif. Intell..

[54]  Mark Horowitz,et al.  An evaluation of directory schemes for cache coherence , 1998, ISCA '98.

[55]  R. R. Halstead,et al.  Concert: design of a multiprocessor development system , 1986, ISCA 1986.

[56]  Carl Hewitt,et al.  The incremental garbage collection of processes , 1977 .

[57]  M. Katz.  PARATRAN: A TRANSPARENT, TRANSACTION BASED RUNTIME MECHANISM FOR PARALLEL EXECUTION OF SCHEME , 1989 .

[58]  H. G. Baker,et al.  ACTOR SYSTEMS FOR REAL-TIME COMPUTATION , 1978 .

[59]  Paul Hudak,et al.  ORBIT: an optimizing compiler for scheme , 1986, SIGPLAN '86.

[60]  John ffitch,et al.  The Bath concurrent LISP machine , 1983, EUROCAL.

[61]  Matthias Felleisen,et al.  The theory and practice of first-class prompts , 1988, POPL '88.

[62]  Richard P. Gabriel,et al.  Performance and evaluation of Lisp systems , 1985 .

[63]  D. A. Turner,et al.  A new implementation technique for applicative languages , 1979, Softw. Pract. Exp..

[64]  Robert Hieb,et al.  Continuations and concurrency , 1990, PPOPP '90.

[65]  Slocum Miller James,et al.  Multischeme : a parallel processing system based on MIT scheme , 1987 .

[66]  Ian Watson,et al.  The Manchester prototype dataflow computer , 1985, CACM.

[67]  John B. Goodenough,et al.  Exception handling: issues and a proposed notation , 1975, CACM.