Locality, causality and continuations

Concurrency and distribution are topics exacerbated by the omnipresence of Internet. Although many languages address these topics, few offer a real opportunity to control and coordinate widely spread dynamic computations. This paper presents such a language and its prominent features. Besides explaining the software architecture of the implementation (based on objects and generic functions), it also presents an original coherency protocol for shared mutable variables. We first recall, in Section 1, the main features of our Scheme-based, concurrent, distributed and computation-oriented language already presented in more details and examples in [QD93]. Section 2 explains how to systematically implement a concurrent and distributed interpreter for that language, using a set of program transformations combining Abstract Continuation Passing Style (ACPS) and Object-Oriented Lifting. The originality of this implementation is that it chiefly uses objects and generic functions in a style that allows to concentrate the problems related to concurrency and migration of computations into the sole discriminating behavior of generic functions. ACPS is not only used to reify continuations but also to enforce locality of computations in presence of distal objects. In Section 3, we propose a new (to our knowledge) protocol to manage shared mutable variables. This protocol enhances [MSRN92], does not require atomic broadcast, tolerates short communication breakdowns and uses bounded circular clocks. This result comes from the use of a distributed GC (which allows us to maintain an approximation of Global Virtual Time) and from the exploitation of causality as stated by continuations. To give a continuation a value (and a store) clearly expresses that the computations that are present in the continuation causally depend on the invoker of the continuation. Finally the computation-orientation of our language and mainly the ability to control groups of threads, concurrently running on multiple sites for the completion of the evaluation of a single expression, is shortly sketched in Section 4. As usual, related works and conclusions end this paper.

[1]  Maurice Herlihy,et al.  Linearizability: a correctness condition for concurrent objects , 1990, TOPL.

[2]  Andrew W. Appel,et al.  Compiling with Continuations , 1991 .

[3]  Henri E. Bal,et al.  Orca: A Language For Parallel Programming of Distributed Systems , 1992, IEEE Trans. Software Eng..

[4]  François Morain,et al.  Distributed Primality Proving and the Primality of (23539+1)/3 , 1991, EUROCRYPT.

[5]  Julian Padget,et al.  An Overview of EULISP , 1993, LISP and Symbolic Computation.

[6]  Phil Kearns,et al.  Bounding sequence numbers in distributed systems: a general approach , 1990, Proceedings.,10th International Conference on Distributed Computing Systems.

[7]  Thomas W. Christopher,et al.  Reference count garbage collection , 1984, Softw. Pract. Exp..

[8]  Geoffrey M. Brown Asynchronous multicaches , 1990, Distributed Computing.

[9]  D. A. Moon,et al.  Common lisp object system specification , 1988, SIGP.

[10]  David R. Jefferson,et al.  Virtual time , 1985, ICPP.

[11]  Matthias Felleisen,et al.  Abstract continuations: a mathematical semantics for handling full jumps , 1988, LISP and Functional Programming.

[12]  Randy B. Osborne Speculative computation in multilisp , 1990, LISP and Functional Programming.

[13]  Richard J. LeBlanc,et al.  Distributed garbage collection , 1987, PLDI.

[14]  Richard P. Gabriel,et al.  Qlisp: An Interim Report , 1989, Workshop on Parallel Lisp.

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

[16]  Gerard Tel,et al.  The derivation of distributed termination detection algorithms from garbage collection schemes , 1991, TOPL.

[17]  Christian Queinnec Continuation conscious compilation , 1993, LIPO.

[18]  Colin J. Fidge,et al.  Timestamps in Message-Passing Systems That Preserve the Partial Ordering , 1988 .

[19]  David De Roure,et al.  Design of a Concurrent and Distributed Language , 1992, Parallel Symbolic Computing.

[20]  Christian Queinnec A Concurrent and Distributed Extension of Scheme , 1992, PARLE.

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

[22]  Christian Queinnec,et al.  Sharing Mutable Objects and Controlling Groups of Tasks in a Concurrent and Distributed Language , 1994, Theory and Practice of Parallel Programming.

[23]  Christian Queinnec,et al.  Garbage collecting the world , 1992, POPL '92.

[24]  Michel Raynal,et al.  Communication efficient distributed shared memories , 1992 .

[25]  John Hughes A Distributed Garbage Collection Algorithm , 1985, FPCA.

[26]  José M. Piquer Indirect Reference Counting: A Distributed Garbage Collection Algorithm , 1991, PARLE.

[27]  Gerald J. Sussman,et al.  Design of a LISP-based microprocessor , 1980, CACM.

[28]  Luis Mateu An Efficient Implementation for Coroutines , 1992, IWMM.

[29]  Frann Cois Morain,et al.  DISTRIBUTED PRIMALITY PROVING AND THE PRIMALITY OF , 1990 .

[30]  John C. Reynolds,et al.  Definitional Interpreters for Higher-Order Programming Languages , 1972, ACM '72.

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

[32]  Christian Queinnec,et al.  PolyScheme : a Semantics for a Concurrent Scheme , 1990 .

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

[34]  Julian Padget,et al.  An overview ofEuLisp , 1993 .

[35]  Mitchell Wand,et al.  Essentials of programming languages , 2008 .

[36]  Bruno Achauer,et al.  Implementation of Distributed Trellis , 1993, ECOOP.

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

[38]  Daniel G. Bobrow,et al.  Common lisp object system specification , 1988, SIGP.

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

[40]  Robert H. Halstead,et al.  New Ideas in Parallel Lisp: Language Design, Implementation, and Programming Tools , 1989, Workshop on Parallel Lisp.