Generative communication in Linda

Reviewer: Jerzy J. A. Klaczak

There are three separate topics of discussion in this paper: the generative interprocess communication concept, its implementation, and examples of its use. Generative communication is a brand new model; it is the generalization of ports in PROLOG-like style (roughly speaking). It assumes the existence of an environment called Tuple Space (TS). This implies two (orthogonal) properties: time- and space(name)-uncoupling of communicating processes. It also allows structured naming and nondeterminism. The simple rules for tuple manipulations result in creating a Name Space (an analogon of the Address Space in sequential computing). A message (tuple) sent by a process to TS is equally accessible to all processes being bound to no one. The concept is then wrapped up with some CSP-like flesh to become a language named Linda. There is, unfortunately, no possibility of directing a tuple to a specified receiver only (anyone can produce or consume tuples instead of an assumed interlocutor). There are also no name locality and nested scope rules. The remedy is to force the first field of every tuple to carry unique sender IDs (required anyway), which are hierarchically built. The termination of a program containing the repetitive-or statement ( C 2*[s1 &vbm0; . . . &vbm0; sn]) will also be a problem. The example part, occupying half of the paper, has no particular theme. Gelernter illustrates that Linda doesn't sacrifice expressiveness for the sake of simplicity. We can simulate remote procedure calls or a CSP-like rendezvous, as well as 1-way or 2-way naming. It is easy to construct interrupt handler, content addressable memory, shared global variables, dynamic process creation, idle node allocation, a watchdog, etc. There are also “usual” applications: disk-head scheduler and 2-phase locking (although the deadlock-detection algorithm in Appendix 4.1 has a bug). The author order the examples, surprisingly, according to Linda's tools used. Individual examples are nevertheless compared to other distributed languages (DPLs). A scheme for implementing dynamic global TS is explored last, with attention also paid to files and reliability (yet handshake protocol contradicts with time-uncoupling). It is valid for an even-dimensioned hypercube multiprocessor. The problem remains open for a general network. The implementation described was dismantled due to “unsophisticated hardware.” I do believe that the concept is suitable also to less intricate networks. Overall, this is an up-to-date research paper which is a must for both the theoretician and the constructor of DPLs. A high level of distributed computation maturity is a necessity; however, the necessary references to particular DPLs, other aspects of Linda, and issues in distributed processing are given. The depth of details varies from chapter to chapter, but the exposition is clear. The most attractive feature, of course, is the generative communication. Is it a language__?__ As far as this paper is concerned, no. It is a concept, general enough to be incorporated into any DPL. The paper introduces questions for further study, but doesn't answer them. It is not, contrary to the author, the C-language of DPLs; but it can become the BASIC. This is certainly the path I should like to follow, and continue.