In the last few years the use of distributed structured shared memory paradigms for coordination between parallel processes has become common. One of the most well known implementations of this paradigm is the shared tuple space model (as used in Linda). In this paper we describe a new set of primitives for fully distributed coordination of processes and agents using tuple spaces, called the Bonita primitives. The Linda primitives provide synchronous access to tuple spaces, whereas the Bonita primitives provide asynchronous access to tuple spaces. The proposed primitives are able to mimic the Linda primitives, therefore providing the ease of use and expressibility of Linda together with a number of advantages for the coordination of agents or processes in distributed environments. The primitives allow user processes to perform computation concurrently with tuple space accesses, and provide new coordination constructs which lead to more efficient programs. In this paper we present the ...

The distributed tuple space concept, on which the Linda process coordination model is founded, has given rise to several implementations on parallel machines and networks of heterogenous workstations. However, the fundamental techniques used in there systems have remained largely unchanged from the original Linda implementations. This paper describes a novel implementation which, using extensions to the original Linda model and recently developed bulk access primitives for tuple spaces, is able to demonstrate 10 to 70 times speed improvements over the best available commercial system. This is achieved dynamically without any compile time optimisations.

Linda is a co-ordination language that has been used for many years. From our recent work on the model we have found a simple operation that is widely used in many different algorithms which the Linda model is unable to express in a viable fashion. We examine a function which performs the composition of two binary relations. By examining how to implement this in parallel using Linda we demonstrate that the current methods are unacceptable. A more detailed explanation of the problem, which we call the multiple rd problem is then presented, together with some other algorithms which have the same problem. We then show how the addition of a primitive to the Linda model, copy-collect, extends the expressibility of the model to overcome this problem. This work builds on previous work on the addition of another primitive called collect[1]. The parallel composition of two binary relations is then reconsidered using copy-collect and is shown to be more efficient.

We introduce a process algebra containing the coordination primitives of Linda (asynchronous communication via a shared data space, read operation, non-blocking test operators on the shared space). We compare two possible semantics for the output operation: the former, that we call ordered, defines the output as an operation that returns when the message has reached the shared data space; the latter, that we call unordered, returns just after sending the message to the tuple space. The process algebra under the ordered semantics is Turing powerful, as we are able to program any Random Access Machine. The main result of the paper is that the process algebra under the unordered semantics is not Turing powerful. This result is achieved by resorting to a net semantics in terms of contextual nets (P/T nets with inhibitor and read arcs), and showing that there exists a deadlock-preserving simulation of such nets by finite P/T nets, a formalism where termination is decidable. 1 Introduction ...

This paper demonstrates how this "multiple

. This paper describes the parallel language ISETL-LINDA. The language is an extension of ISETL, an imperative language whose main data structure is the set. We extend ISETL by adding a new type of distributed bags, and operations to act on bags which correspond to the LINDA primitives. However, we use a variant of LINDA created at the University of York which replaces the problematic inp and rdp primitives by a single primitive, collect. After describing the language, we give an example of its use with a simple case study. We then describe an implementation across a network of processors, outlining the implementation of distributed bags, and our process spawning mechanism. The language has been implemented on a Meiko Computing Surface. 1 Introduction This paper describes a new language, ISETL-LINDA, and its implementation over a network of transputers. The language itself is similar to another parallel language, ProSet [5]. Both are embeddings of Linda [4] into SETL. Linda is a mode...

This paper demonstrates the need for garbage collection in multiple tuple space distributed open systems, which has Linda as a major icon, and identifies problems involved in incorporating garbage collection into such systems. We concern ourselves with open implementations as the existence of a garbage collector is essential in this environment. The extension of Linda to include multiple tuple spaces has introduced this new problem as processes are now able to create tuple spaces, spawn other processes into these tuple spaces, and store tuples (data) into these tuple spaces, but are unable to delete any of the objects (tuples, tuple spaces and processes) or even decide about their usefulness. In this paper we begin by showing that the main problem in introducing garbage collection into Linda is the lack of sufficient information about the effectiveness of Linda objects. We then describe techniques for maintaining a structure to be used by a garbage collection algorithm of tuple spaces....

Department of Computer Science. 32 200 words This thesis describes the novel features of an extended Linda system, called eLinda. The main contribution of eLinda is the introduction of a powerful and flexible mechanism for expressing the queries used for data retrieval in Linda systems. This provides simplicity for applications that would otherwise need to handle complex retrieval operations explicitly, and enhances efficiency, particularly where the data is distributed across a network. Other extensions introduce support for distributed multimedia resources, and provide additional support for efficient data distribution across a communication network. The enhanced functionality of the eLinda system is described in detail and compared with existing Linda systems, both commercial products and research projects. This is done primarily with an emphasis on the expressiveness

In the last 20 years of research in coordination, researchers were able to demonstrate that distributed languages are made of two distinct parts: a computation and a coordination language. Among a plethora of coordination models (the basis of a coordination language) available today, Linda is perhaps the most successful. Linda advocates that processes should interact solely via associative shared memories called tuple spaces. Linda has developed from a single-tuple-space into a multiple-tuple-space model but the coordination mechanism used was never extended to express the multiple-tuple-space model full potential.

Coordination systems, in particular Linda, have established themselves as important tools for developing applications for open systems such as the Internet. This paper shows how to tackle a forgotten, yet crucial problem in open coordination systems: memory management. As with any system which intends to be of wide use, coordination systems have to address the problems of memory exhaustion since memory is a finite resource. This paper first explores the separation between coordination and computation in order to make it clear that the problem of memory exhaustion in coordination systems cannot be solved using garbage collection schemes implemented at the computation language | a garbage collection scheme must exist in the coordination environment as well. As Linda is arguably the most successful coordination system, this paper will focus on the Linda-like family of systems. By showing how the problem can be tackled in Linda it is expected that a solution for other coordination system could be implemented by adapting the method described.