A customizable substrate for concurrent languages

We describe an approach to implementing a wide-range of concurrency paradigms in high-level (symbolic) programming languages. The focus of our discussion is STING, a dialect of Scheme, that supports lightweight threads of control and virtual processors as first-class objects. Given the significant degree to which the behavior of these objects may be customized, we can easily express a variety of concurrency paradigms and linguistic structures within a common framework without loss of efficiency. Unlike parallel systems that rely on operating system services for managing concurrency, STING implements concurrency management entirely in terms of Scheme objects and procedures. It, therefore, permits users to optimize the runtime behavior of their applications without requiring knowledge of the underlying runtime system. This paper concentrates on (a) the implications of the design for building asynchronous concurrency structures, (b) organizing large-scale concurrent computations, and (c) implementing robust programming environments for symbolic computing.

[1]  Peter Boehler Bishop,et al.  Computer systems with a very large address space and garbage collection , 1977 .

[2]  Mitchell Wand,et al.  Continuation-Based Multiprocessing , 1980, High. Order Symb. Comput..

[3]  Reflection Coefficients,et al.  A. real-time , 1982 .

[4]  Henry Lieberman,et al.  A real-time garbage collector based on the lifetimes of objects , 1983, CACM.

[5]  David Ungar.  Generation scavenging: a nondisruptive high performance storage reclamation algorithm , 1984 .

[6]  John McCarthy,et al.  Queue-based multi-processing LISP , 1984, LFP '84.

[7]  David M. Ungar,et al.  Generation Scavenging: A non-disruptive high performance storage reclamation algorithm , 1984, SDE 1.

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

[9]  William D. Clinger,et al.  Revised3 report on the algorithmic language scheme , 1986, SIGP.

[10]  Paul Hudak.  Para-Functional Programming , 1986, Computer.

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

[12]  Keith L. Clark,et al.  PARLOG: parallel programming in logic , 1986, ACM Trans. Program. Lang. Syst..

[13]  Avadis Tevanian,et al.  MACH threads and the UNIX kernel : the battle for control , 1987 .

[14]  Nicholas Carriero,et al.  How to write parallel programs: a guide to the perplexed , 1989, CSUR.

[15]  Henry M. Levy,et al.  The Performance Implications of Thread Management Alternatives for Shared-Memory Multiprocessors , 1989, IEEE Trans. Computers.

[16]  Vijay A. Saraswat,et al.  Concurrent constraint programming , 1989, POPL '90.

[17]  Andrew A. Chien,et al.  Experience with CST: programming and implementation , 1989, PLDI '89.

[18]  Justin O. Graver,et al.  Multilisp: a Language for Concurrent Symbolic Computation Acm Transactions on Programming Languages and Systems , 1989 .

[19]  Nicholas Carriero,et al.  Linda in context , 1989, CACM.

[20]  Keshav Pingali,et al.  I-structures: data structures for parallel computing , 1986, Graph Reduction.

[21]  Anoop Gupta,et al.  Process control and scheduling issues for multiprogrammed shared-memory multiprocessors , 1989, SOSP '89.

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

[23]  Thomas E. Anderson,et al.  The performance implications of thread management alternatives for shared-memory multiprocessors , 1989, SIGMETRICS '89.

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

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

[26]  David L. Black.  Scheduling support for concurrency and parallelism in the Mach operating system , 1990, Computer.

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

[28]  J. Gregory Morrisett,et al.  Adding threads to Standard ML , 1990 .

[29]  John H. Reppy,et al.  CML: A Higher-Order Concurrent Language , 1991, PLDI.

[30]  Evangelos P. Markatos,et al.  First-class user-level threads , 1991, SOSP '91.

[31]  D. H. Bartley,et al.  Revised4 report on the algorithmic language scheme , 1991, LIPO.

[32]  John H. Reppy,et al.  CML: A higher concurrent language , 1991, PLDI '91.

[33]  Brian N. Bershad,et al.  Scheduler activations: effective kernel support for the user-level management of parallelism , 1991, TOCS.

[34]  Suresh Jagannathan,et al.  A foundation for an efficient multi-threaded scheme system , 1992, LFP '92.