S. Matsuoka and S. Kawai. Using tuple space communication in distributed object-oriented languages. In Proceedings of the 3rd ACM Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA '88), pages 276--284, 1988.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....work, Kimura proposed the Transaction Network [19] a visual language in which the traditional places and transitions appearing in Petri nets have been replaced by databases and transactions, respectively. Recently, we became aware of several other groups working on similar kinds of languages [4, 24]. We use the term shared dataspace to refer to the general class of models and languages in which the principal means of communication is a common, content addressable data structure. Because the investigation of shared dataspace languages is still in its early stages, the body of knowledge ....

S. Matsuoka and S. Kawai. Using tuple space communication in distributed object-oriented languages. In Proceedings of the 1988.

.... is used in goals (but of course, each of these systems also have specific features which are not accounted for in LinLog) It leads to an actors model of computation [2, 32] where multiple independent agents perform concurrent tasks, communicating via a shared blackboard [28] or tuple space [17, 24]. In [6] we propose a more refined notion of blackboard (called forum ) which exploits not only the connective , but also , in goals. It provides a notion of locality for the operations of consumption and production of messages in the blackboard. Interaction nets [22] also provide a model ....

A. Matsuoka and S. Kawai. Using tuple space communication in distributed object oriented languages. In Proc. of OOPSLA'88, San Diego, Ca, U.S.A., 1988.

....We have seen how forum based communication, which lies at the basis of the computational model for LO presented here, provides a refinement of blackboard based communication [10] in terms of local consumption. Proposals for a more local form of blackboard based communication were also presented in [19] in a non logical setting, sharing our same intent of making use of blackboards in the context of object oriented programming. 7] provides instead a logical version of blackboard based communication in its standard global interpretation. LO can also be seen as an instance of Concurrent ....

A. Matsuoka and S. Kawai. Using tuple space communication in distributed object oriented languages. In Proc. of OOPSLA'88, San Diego, Ca, U.S.A., 1988.

....and thus keeps referential transparency within user processes. However, it does not support time varying behaviors or indeed any notion of time at all. The Linda architecture has been well studied and widely used with languages like C [CGMS94] extensions of Pascal and object oriented languages [MK88], but has never been integrated with Haskell. Lastly, the whole idea of efficiently partitioning a problem such as a web server or an online auction into its constituent components to be run in parallel on different processors has been addressed both in the functional and declarative domains ....

S. Matsuoka and S. Kawai. Using tuple space communication in distributed objectoriented languages. In Proceedings of OOPSLA'88, ACM SIGPLAN Notices, volume 23, November 1988.

....a language, and make distributed programming look simple. 1. 2 Publish Subscribe Motivated by the observation that RPC is not always the best solution, the integration of alternative distributed interaction styles, like asynchronous RPC (e.g. 65, 43] or the tuple space [28] paradigm (e.g. [45]) with a language have also been studied. More recently, Oki et al. 50] have pointed out the existence of many distributed event based applications for which a publish subscribe interaction style is very appealing, thanks to its strong decoupling of participants in (1) time (participants don t ....

....Support There have been a series of attempts to transform the structured form of tuples to an object form, mainly by extending the exact type equivalence for tuple elements in Linda to the notion of subtyping. While early approaches to integrating the tuple space with an object language like [45] (for Smalltalk) promoted tuples as sets of objects, later approaches, like [55] C ) or [37] Objective Linda) considered tuples, just like events in our case, as single first class citizens, and added some form of content based matching based on templates. Very recently, callback mechanisms ....

S. Matsuoka and S. Kawai. Using Tuple Space Communication in Distributed Object-Oriented Languages. In 3rd ACM Conference on Object-Oriented Programming Systems, Languages and Applications, 1988.

....UCM Completion and Infrastructure Components The Designer UCM shown in Figure 2 does not describe the communication infrastructure between different communicating processes. Communication infrastructure might consist of protocol stacks, middleware, etc. Here, it was decided to use a tuple space [10] communication mechanism. Other communications such as protocol stacks are needed but will not be shown here, for simplicity of explanation. The tuple space communications is provided by a server task, which handles and stores messages. Party A Figure 3 Completion of Figure 2 with Tuple Space ....

S. Kawai and S. Matsuoka., "Using Tuple Space Communication in Distributed Object Oriented Languages", Proc. of the OOPSLA '88, pages 276-283, 1988.

.... while in Multiple Tuple Spaces an agent can react, with a transition, to the received tuples (temporal decoupling) An existing proposal of integration of these two paradigms defines a new communication model where tuple spaces are dynamically created objects that communicate by sending tuples [11]. However, there is no concrete example of a programming language nspired by this model. 8.3 Actors The computational model that we present in this paper shares many characteristics with the Actors model. An actor is a computational agent which has a mail address and a behavior. Actors ....

S. Kawai and S. Matsuoka. Using Tuple Space Communication in Distributed ObjectOriented Languages. Proc. of the OOPSLA '88, pages 276-283, 1988.

....increasing knowledge base; on the other hand, Linda allows communication objects (tuples) to be removed from the tuple space. Additional work in this direction includes adding types to tuple spaces for safety, using objects instead of tuples and making tuple spaces rst class entities [20, 25, 31]. In contrast to these approaches, the hierarchical model of actor coordination that we present is based purely on communication which requires the sender to explicitly name the target of a message. Our use of the term coordination is di erent: following Wegner, we de ne coordination as ....

S. Matsuoka and S. Kawai. Using tuple space communication in distributed object-oriented languages. In ACM Conference Proceedings, Object Oriented Programming Languages, Systems and Applications, pages 276-284, San Diego, CA, 1988.

.... language [12] Later Carriero and Gelernter distilled the model down to a few basic operations and packaged these in language neutral libraries [13] The result is a remarkably elegant programming model for parallel and distributed applications which has been embedded into many languages [8, 21, 20, 18, 22]. Linda consists of only four operations, out, eval, rd and in, defined over a shared memory called a tuple space. Two predicate forms, inp and rdp, are not considered here. A succinct description of these operations (taking liberties with syntax) is given here: outhtuplei Non blocking write of ....

S. Matsouka and S. Kawai. Using Tuple Space Communication in Distributed Object Oriented Languages. In Proc. ACM Object Oriented Programming, Systems, Languages and Applications (OOPSLA 88), 1988.

....highlight shortcomings of the shared space model. The model works well when all processes with access to the shared space have been designed carefully and are well behaved. Unfortunately, mistakes are easily made the simplest example being reading an entry which is part of another protocol [27, 18] and nothing prevents malicious processes from spying or even corrupting the data exchanged over the common space. Moreover, denial of service attacks can easily be mounted by flooding the space with requests. In this paper we present a coordination model, called the Secure Object Space model ....

....this can only be done using encryption algorithms, even for agents executing within the same JVM which is too inefficient for generalized use. Apart from Java, the shared space paradigm, usually in its Linda variant, has been integrated into several languages, C, Prolog [8] C [21] SmallTalk [18] and Eiffel [16] Interestingly, the papers that treat object oriented languages have not considered the security issues posed by inheritance and user defined matching. 7 Conclusions In this paper, we have considered coordination support for independent and mistrusting software components that ....

S. Matsouka and S. Kawai. Using Tuple Space Communication in Distributed Object Oriented Languages. In Proc. ACM Object Oriented Programming, Systems, Languages and Applications (OOPSLA 88), 1988.

.... and message passing computational models are not mutually excluding each other [3] As an example, object oriented parallel programming environments, whose computational model defines a message passing scenario without any shared resource, can greatly benefit of the presence of shared memory [4]. However, the physical implementation of a shared memory presents problems [5] it introduces a centralisation point that limits the system scalability, becomes the bottleneck when the system size increases. A promising solution, not to avoid the use of a global interaction space, is represented ....

S. Matsuoka, S. Kawai, "Using Tuple Space Communication in Distributed Object-Oriented Languages", OOPSLA '88 Conference Proceedings, San Diego (CA), Sept. 1988.

....latter to become the basis of object interaction in the presence of hererogeneous systems. Furthermore, it removes all implementation details from the realization of agent interaction and hence applies this idea from sequential programming to agent interaction in concurrent systems. The work in [7, 12, 13] proposes hierarchies of nested tuples spaces by introducing tuple spaces as first class entities of the model. All of them introduce names (or references) to tuple spaces, whereas [12] additionally introduces relative references by a special reference called the context which denotes the tuple ....

....In Objective Linda, we have to specify the type of object we wish to receive, so we have to pass an object of the corresponding class to the in and rd operations anyway. So it is an obvious idea to pass the matching predicates inside this object, too. This resembles a concept introduced in [13] where in and rd operations are performed by putting a so called reader object into the object space. In our case, a reader object would be an object of the type to be matched and the state of which contains all necessary information to parameterize the function (e.g. called) match which becomes ....

Satoshi Matsuoka and Satoru Kawai. Using Tuple Space Communication in Distributed Object-Oriented Languages. In ACM Conference Procedings, Object Oriented Programming Systems, Languages and Applications, San Diego California, pages 276--284, 1988.

....tuple. Elements specified by type and value are called actuals whereas typed placeholders (without a value) are called formals . The obvious similarity between tuples and the record structure of object implementations has led to early adaptations of the Linda model to object oriented languages [17, 23]. In these systems, language level objects are stored in shared data spaces and are retrieved using template objects which specify actuals and formals. This straightforward adaptation allows to use the Linda model from within object oriented languages. But because object matching is based on the ....

....still has to know what kind of data is available. This setting degrades anonymity of communication and is most likely to be the main obstacle concerning general consensus about a suitable model with multiple data spaces. One possible approach for introducing multiple data spaces is presented in [23]. Here, object spaces are simply first class objects. They must hence be known by producers and consumers. This approach comes close to message passing and immediately leads to problems with dangling references if applied to open systems. As an alternative to object space references, the work in ....

Satoshi Matsuoka and Satoru Kawai. Using Tuple Space Communication in Distributed Object-Oriented Languages. In ACM Conference Proceedings, Object Oriented Programming Systems, Languages and Applications, San Diego California, pages 276--284, 1988.

....the encapsulated data. ffl Introspective method calls (calls to self ) are explicitly disallowed. 2.3.8 Tuple Spaces Instead of message passing, an alternative method for communication between objects in an object oriented language is via the use of tuple spaces. This approach was considered in (Matsuoka and Kawai, 1988) which also discussed the changes required for object oriented language when using tuple spaces. An example language which uses tuple spaces is Kitara (Guffick and Blair, 1992) From the use of tuples for communication, it is a simple extension to the use of active objects and the use of tuples ....

Matsuoka, S. and Kawai, S. (1988). Using Tuple Space Communications in Distributed Object--Oriented Languages, ACM SIGPLAN Notices -- Proceedings of OOPSLA'88 23(11): 276--284.

....and C templates allow us to achieve many of the capabilities of a Linda compiler using just a standard C compiler, without introducing new syntax or changing the semantics of the programming language. The Linda model can easily be integrated into an object oriented programming language [15]. Linda implementations for Eiffel [13] and Java [9] require the user to explicitly create objects of class Tuple. In C Linda [5] a precompiler is required to translate new syntax into C . Our Blossom system neither needs explicit creation of objects of class Tuple, nor does it use a ....

Matsuoka, S., and Kawai, S. Using Tuple-Space Communication in Distributed Object-Oriented Architectures. Proceedings ACM Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA) 23, 11 (1988), 276-- 284.

....space, it must be specified which is the environment assumed for variables in the code that it executes. ffl Syntax and semantics of operations for multiple tuple spaces (in the original Linda definition only one tuple space is allowed; a natural extension consists of releasing this constraint [29, 35]) In short, we can define a coordination model describing three concepts: the coordinating entities, the coordination medium, and the coordinating rules. In a classic view the coordinating entities are processes and messages; here however we are more liberal, and allow several kind of entities: ....

S. Matsuoka and S. Kawai. Using tuple-space communication in distributed object-oriented architectures. In Proc. Conf. OOPSLA, volume 23:11 of ACM SIGPLAN Notices, pages 276--284, November 1988.

....fields) into the space without having to worry about the identity and locality of the receivers. Receivers can inspect or remove tuples from this space by specifying a template tuple. The reception occurs when a match for the template tuple is found. Communication through tuple space is used in [42] in the context of distributed object oriented languages. Oki et al. 48] use a variant of the Linda approach, called anonymous communication, where one field of each tuple is the subject field, and reception is based on the matching of the subject fields. Similar to the original approach, ....

S. Matsuoka and S. Kawai. Using tuple space communication in distributed object-oriented languages. SIGPLAN Notices, 23(11):276--284, 1988.

....it from the tuple space. There are currently two ways of achieving parallelism in an object oriented programming language using Linda. One is to add Linda constructs to an existing object oriented language [Jell90] Another is to transform the basic tuple space model to support object orientation [Mats88]. Our approach is a novel one in the way it uses the base tuple space model. We transform the object oriented program code (i.e. in CORAL) to denotational code. Then, semantics preserving transformations are performed on this intermediate code to identify the parts of the program that can run in ....

Matsuoka, S., Kawai, S., "Using Tuple Space Communications in Distributed Object-Oriented Languages," OOPSLA '88 ACM Conference on ObjectOriented Programming Systems, Languages and Applications, Sep. 1988, pp. 276-284.

....every object to be eval uated must be represented by a special heir of a common superclass which defines a method called evaluate, executed whenever an object of class h is subject to eval. Obviously, Eiffel Linda is not language independent. Linda and Concurrent Smalltalk The work presented in [43] goes even further with introducing objects into the Linda model. First, it treats tuples as objects, as Eiffel Linda does. Second, it eliminates asymmetries in the original Linda communication scheme. In order to make tuple space communication symmetrical, both senders and receivers put tuples ....

....the latter to become the basis of object interaction in the presence of heterogeneous systems. Furthermore, it removes all implementation details from the realization of agent interaction and hence applies this idea from sequential programming to agent interaction in parallel systems. The work in [28, 38, 43] proposes hierarchies of nested tuples spaces by introducing tu12 ple spaces as first class entities of the model. All of them introduce names (or references) to tuple spaces, whereas [38] additionally introduces relative references by a special reference called the context which denotes the ....

S. Matsuoka and S. Kawai. Using Tuple Space Communication in Distributed Object-- Oriented Languages. In ACM Conference Proceedings, Object Oriented Programming Systems, Languages and Applications, San Diego California, pages 276--284, 1988.

....coordinate cooperating parallel computations. Computations communicate by generating new data objects, called tuples, and writing them in a shared data structure, called the tuple space, which plays the role of an associative memory. This model has been adapted for use in object oriented programs [27][8] without addressing security issues. Not only do all problems of shared variables apply to generative communication, but there are issues related to accounting. Existing designs do not allow any form of resource accounting over tuple space resource usage. 4.3 Datagrams Datagrams are ....

....tuples on the behalf of a computation. Charging computations for processing time is straightforward as tuples are passive while in the object space. This means that unlike other proposals, matching is kept simple, in particular we do not invoke methods on the tuples or their components [27]. The memory used by each computation is equal to the size of all of its tuples still in the object space. The ownership of a tuple changes when it is input by another computation. Issues such as expiration policies for old tuples and tuple garbage collection are currently being investigated. 6 ....

S. Matsuoka and S. Kawai. Using tuple space communication in distributed object-oriented languages. In OOPSLA'88 Proceedings, pages 276---284, Sept. 1988.

.... out that inheritance and synchronization constraints in concurrent object systems often conflict with each other[2, 4, 16] Some have gone so far as not adopting inheritance in their languages[2, 21, 23, 24] or employed a flexible communication mechanism independent of the inheritance hierarchy[13]. Several proposals[5, 6, 9, 12, 15, 19] have been made in the past for controlling the anomaly arising from their simultaneous incorporation into OOCP languages. However, we can show for many of such proposals that the anomaly in inheritance occurs where re definitions of all relevant parent ....

Satoshi Matsuoka and Satoru Kawai. Using tuple space communication in distributed object-oriented languages. In Proceedings of the 1988 Conference on OOPSLA, volume 23(11), pages 276--283. ACM SIGPLAN, ACM, Sep. 1988.

.... such languages are ABCL 1[42, 41] and CSSA[29] There are also languages that extends existing sequential OO languages with explicit message reception statements in order to achieve inter object concurrency, such as Concurrent C [15] Buhr et al. s extension to C [10] or Tuple Space Smalltalk[22]. For these languages, however, the messages explicitly received are not processed via the normal method dispatch mechanism of the base language. As a result, inheritance and communication are totally separated from the beginning, causing heavy breakage of encapsulation. 3.1.3 Path Expressions ....

Satoshi Matsuoka and Satoru Kawai. Using Tuple Space communication in distributed objectoriented languages. In Proceedings of OOPSLA'88, volume 23, pages 276--283. SIGPLAN Notices, ACM Press, September 1988.

No context found.

S. Matsuoka and S. Kawai. Using tuple space communication in distributed object-oriented languages. In Proceedings of the 3rd ACM Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA '88), pages 276--284, 1988.

No context found.

S. Kawai and S. Matsuoka., "Using Tuple Space Communication in Distributed Object Oriented Languages," Proc. of the OOPSLA '88, pages 276-283, 1988.

No context found.

#26# S. Matsuoka and S. Kawai. Using tuple-space communication in distributed object-oriented architectures. In Proceedings of the ACM Conference

First 50 documents

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC