Jean-Marie Jacquet

On Timed Coordination Languages

Although very simple and elegant, Linda-style coordination models lack the notion of time, and are therefore not able to precisely model real-life coordination applications, featuring time-outs and soft real-time constraints. This paper aims at introducing time in these models. To that end, we consider two notions of time, relative time and absolute time, and, for each notion, two types of features. On the one hand, with respect to relative time, we describe two extensions: (i) a delay mechanism to postpone the execution of communication primitives, and (ii) explicit deadlines on the validity of tuples and on the duration of suspension of communication operations. On the other hand, for absolute time, we introduce: (iii) a wait primitive capable of waiting till an absolute point of time, and (iv) time intervals, both on tuples in the data store and on communication operations. The resulting four coordination models are analyzed and compared both from the semantics viewpoint and from the implementation viewpoint. Moreover, a few programming examples suggest their practical interest.

On the Expressiveness of Linda-like Concurrent Languages

Abstract We compare the expressiveness of a class of concurrent languages that employ asynchronous communication primitives a la Linda. All the languages considered contain sequential, parallel and choice operators, and they differ from one another in the set of communication primitives used. These primitives include tell , get and ask operations for adding, deleting, and checking for the presence of data in a dataspace shared by a number of concurrent processes, as well as a nask ( n egative ask ) operation for checking for the absence of data in the shared dataspace. We use the notion of modular embedding introduced by De Boer and Palamidessi in [3] to compare the relative expressive power of the languages. A first result is the formalisation of the intuitive separation result stating that the language with get and tell is strictly more expressive than the language with ask and tell operations. An interesting result is that the ability to check for the presence of information ( ask ) does not increase the power of a language containing get and tell operations, whereas the ability to check for the absence of information ( nask ) does increase the power of such a language. Another interesting result shown is that the language containing all the communication primitives considered is strictly more expressive than each of its sub-languages, except for the redundancy of ask .

On the Expressiveness of Coordination Models

A number of different coordination models for specifying inter-process communication and synchronisation rely on a notion of shared dataspace. Many of these models are extensions of the Linda coordination model, which includes operations for adding, deleting and testing the presence/absence of data in a shared dataspace. We compare the expressive power of three classes of coordination models based on shared dataspaces. The first class relies on Lindas communication primitives, while a second class relies on the more general notion of multi-set rewriting (e.g., like Bauhaus Linda or Gamma). Finally, we consider a third class of models featuring communication transactions that consist of sequences of Linda-like operations to be executed atomically (e.g., like in Shared Prolog or PoliS).

On the expressiveness of coordination via shared dataspaces

A number of different coordination models for specifying inter-process communication and synchronisation rely on a notion of shared dataspace. Many of these models are extensions of the Linda coordination model, which includes operations for adding, deleting and testing the presence/absence of data in a shared dataspace.We compare the expressive power of three classes of coordination models based on shared dataspaces. The first class relies on Lindas communication primitives, while a second class relies on the more general notion of multi-set rewriting (e.g., like Bauhaus Linda or Gamma). Finally, we consider a third class of models featuring communication transactions that consist of sequences of Linda-like operations to be executed atomically (e.g., like in Shared Prolog or PoliS).

On the semantics of mLog

Abstract The paper aims at a semantic study of the integration of blackboards in logic programming. To that end, a new logic programming framework involving Linda-like primitives is proposed first. It is dedicated to no particular logic language but rather focuses on the key concepts and control operators. As natural consequences, it subsumes existing concrete proposals [2,4,6] and provides a general framework well-suited for their semantic analysis. Five semantics are described and compared. They range in the operational, declarative and denotational types and are issued both from the logic programming and the imperative traditions. They are composed of two operational semantics, describing respectively the success/failure sets, and various failures, of two declarative semantics, extending the classical Herbrand interpretation and immediate consequence operator, and of one denotational semantics, defined compositionally and on the basis of process-like histories. The mathematical tools mainly used are complete lattices and complete metric spaces.

µ2 Log: Towards Remote Coordination

Modern computing is characterized, among others, by two major facts. On the one hand, methods are needed to master the ever growing complexity of information systems. On the other hand, distributed and open systems allow configurations to change dynamically and thus require tools to allow processes to cooperate, communicate and work in synergy.

On the expressiveness of timed coordination models

Although very simple and elegant, Linda-style coordination models lack the notion of time, and are therefore not able to precisely model real-life coordination applications. Nevertheless, industrial proposals such as TSpaces and JavaSpaces, inspired from Linda, have incorporated time constructs.This paper aims at a systematic study of the introduction of time in coordination models. It builds upon previous work to study in a coherent framework the expressiveness of Linda extended with two notions of time, relative time and absolute time, and, for each notion, two types of features. On the one hand, with respect to relative time, we describe two extensions: (i) a delay mechanism to postpone the execution of communication primitives, and (ii) explicit deadlines on the validity of tuples and on the duration of suspension of communication operations. On the other hand, for absolute time, we introduce: (iii) a wait primitive capable of waiting till an absolute point of time, and (iv) time intervals, both on tuples in the data store and on communication operations.This expressiveness study points out a most expressive language for which an implementation is described, thereby allowing for the implementation of all the languages presented in the paper.

On the Expressiveness of Absolute-Time Coordination Languages

Although very simple and elegant, Linda-style coordination models lack the notion of time, and are therefore not able to precisely model real-life coordination applications. Nevertheless, industrial proposals such as TSpaces and JavaSpaces, inspired from Linda, have incorporated time constructs.

On the Expressiveness of Relative-Timed Coordination Models

Although very simple and elegant, Linda-style coordination models lack the notion of time, and are therefore not able to precisely model real-life coordination applications. Nevertheless, industrial proposals such as TSpaces and JavaSpaces, inspired from Linda, have incorporated time constructs. This paper aims at a systematic study of the introduction of relative time in coordination models. It builds upon previous work to study the expressiveness of Linda, Linda extended with a delay mechanism and Linda primitives extended to support the duration of tuples and of the suspension of communication operations.

A Process Algebra for Synchronous Concurrent Constraint Programming

Concurrent constraint programming is classically based on asynchronous communication via a shared store. This paper presents new version of the ask and tell primitives which features synchronicity. Our approach is based on the idea of telling new information just in the case that a concurrently running process is asking for it.