Customization of first-class tuple-spaces in a higher-order language

  • Suresh Jagannathan
Submitted Presentations
Part of the Lecture Notes in Computer Science book series (LNCS, volume 506)

Abstract

A distributed data structure is an object which permits many producers to augment or modify its contents, and many consumers simultaneously to access its component elements. Synchronization is implicit in data structure access: a process that requests an element which has not yet been generated blocks until a producer creates it.

In this paper, we describe a parallel programming language (called T S) whose fundamental communication device is a significant generalization of the tuple-space distributed data structure found in the Linda coordination language[6]. Our sequential base language is a dialect of Scheme[19].

Beyond the fact that T S is derived by incorporating a tuple-space coordination language into a higher-order computation language (i.e., Scheme), T S differs from other tuple-space languages in two important ways:
  • Tuple-spaces are first-class objects. They may be dynamically created, bound to names, passed as arguments to (or returned as results from) functions, and built into other data structures or tuples.

  • The behavior of tuple-spaces may be customized. A tuple-space are manipulated via a policy closure that specify its operational characteristics. The representation of policy closures take significant advantage of Scheme's support for higher-order functions; there is no fundamental extension to Scheme needed in order to support them.

We argue that first-class customizable tuple-spaces provide an expressive and flexible medium for building parallel programs in higher-order languages.

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. [1]
    Gul Agha. Actors: A Model of Concurrent Computation in Distributed Systems. MIT Press, Cambridge, Mass., 1986.Google Scholar
  2. [2]
    V. Ambriola, P Ciancarini, and M. Danelutto. Design and Distributed Implementation of the Parallel Logic Language Shared Prolog. In Second ACM Symposium on Principles and Practice of Parallel Programming, pages 40–49, March 1990.Google Scholar
  3. [3]
    Pierre America. Inheritance and Subtyping in a Parallel Object-Oriented System. In Proceedings of the ECOOP Conf., pages 234–242, 1987.Google Scholar
  4. [4]
    Arvind, Rishiyur Nikhil, and Keshav Pingali. I-Structures: Data Structures for Parallel Computing. Transactions on Programming Languages and Systems, 11(4):598–632, October 1989.Google Scholar
  5. [5]
    Nick Carriero and David Gelernter. How to Write Parallel Programs: A Guide to the Perplexed. ACM Computing Surveys, 21(3), September 1989.Google Scholar
  6. [6]
    Nick Carriero and David Gelernter. Linda in Context. Communications of the ACM, 32(4):444–458, April 1989.Google Scholar
  7. [7]
    Andrew Chien and W.J. Dally. Concurrent Aggreates (CA). In Second ACM Symposium on Principles and Practice of Parallel Programming, pages 187–197, March 1990.Google Scholar
  8. [8]
    K. Clark and S. Gregory. Parlog: Parallel Programming in Logic. ACM Transactions on Programming Languages and Systems, 8:1–49, 1986.Google Scholar
  9. [9]
    William Cook and Jens Palsberg. A Denotational Semantics of Inheritance and its Correctness. In OOPSLA'89 Conference Proceedings, pages 433–444, 1989. Published as SIGPLAN Notices 24(10), October, 1989.Google Scholar
  10. [10]
    David Gelernter. Multiple Tuple Spaces in Linda. In Proceedings of PARLE '89, volume 2, pages 20–27, 1989.Google Scholar
  11. [11]
    Adele Goldberg and David Robson. Smalltalk-80: The Language and its Implementation. Addison-Wesley Press, Reading, Mass., 1983.Google Scholar
  12. [12]
    Robert Halstead. Multilisp: A Language for Concurrent Symbolic Computation. Transactions on Programming Languages and Systems, 7(4):501–538, October 1985.Google Scholar
  13. [13]
    Waldemar Horwat, Andrew Chien, and William Dally. Experience with CST: Programming and Implementation. In ACM SIGPLAN '89 Conference on Programming Language Design and Implementation, pages 101–109, June 1989.Google Scholar
  14. [14]
    Paul Hudak and Philip Wadler, editors. Report on the Functional Programming Language Haskell. Technical Report YALEU/DCS/RR-666, Yale University, Dept. of Computer Science, December 1989.Google Scholar
  15. [15]
    Suresh Jagannathan. Optimizing Analysis for First-Class Tuple-Spaces. In Third Workshop on Parallel Languages and Compilers, August 1990. Forthcoming from MIT Press.Google Scholar
  16. [16]
    Samuel Kamin. Inheritance in Smalltalk-80: A Denotational Definition. In 15th ACM Symposium on Principles of Programming Languages, pages 80–87, 1988.Google Scholar
  17. [17]
    David Kranz, Robert Halstead, and Eric Mohr. Mul-T: A High Performance Parallel Lisp. In Proceedings of the ACM Symposium on Programming Language Design and Implementation, pages 81–91, June 1989.Google Scholar
  18. [18]
    Henry Lieberman. Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems. In OOPSLA'86 Conference Proceedings, pages 214–223, 1986.Google Scholar
  19. [19]
    Jonathan Rees and editors William Clinger. The Revised3 Report on the Algorithmic Language Scheme. ACM Sigplan Notices, 21(12), 1986.Google Scholar
  20. [20]
    Ehud Shapiro. Concurrent Prolog: A Progress Report. IEEE Computer, 19(8):44–60, August 1986.Google Scholar
  21. [21]
    Ehud Shapiro, editor. Concurrent Prolog: Collected Papers. MIT Press, 1987. Volumes 1 and 2.Google Scholar
  22. [22]
    Brian Smith and J. des Rivières. The Implementation of Procedurally Reflective Languages. In Proceedings of the 1984 Conference on Lisp and Functional Programming, pages 331–347, 1984.Google Scholar
  23. [23]
    David Ungar and Randall Smith. Self: The Power of Simplicity. In OOPSLA'87 Conference Proceedings, pages 227–241, 1987.Google Scholar
  24. [24]
    United States Dept. of Defense. Reference Manual for the ADA Programming Language, 1982.Google Scholar
  25. [25]
    Mitchell Wand and Daniel Friedman. The Mystery of the Tower Revealed: A Non-Reflective Description of the Reflective Tower. In Proceedings of the 1986 Conference on Lisp and Functional Programming, pages 298–307, 1986.Google Scholar
  26. [26]
    A. Yonezawa, E Shibayama, T Takada, and Y. Honda. Object-Oriented Concurrent Programming — Modelling and Programming in an Object-Oriented Concurrent Language, ABCL/1. In Object-Oriented Concurrent Programming, pages 55–89. MIT Press, 1987.Google Scholar

Copyright information

© Springer-Verlag 1991

Authors and Affiliations

  • Suresh Jagannathan
    • 1
  1. 1.NEC Research InstitutePrinceton

Personalised recommendations