Catálogo de publicaciones - libros

We present a calculus inspired by whose main features are: explicit process distribution and node interconnections, remote operations, process mobility and asynchronous communication through distributed tuple spaces. We first introduce a basic language where connections are reliable and immutable; then, we enrich it with two more advanced features for global computing, i.e. and . In each setting, we use our formalisms to specify some non-trivial global computing applications and exploit the semantic theory based on an observational equivalence to equationally establish properties of the considered case-studies.

To support the fault tolerance of mobile computing systems, many checkpointing coordination and message logging schemes have been proposed. However, due to the mobility of mobile hosts, coordination and control of these schemes are quite complicate and have the possibility of inefficiency. In this paper, a fault-tolerance scheme based on mobile agents is proposed. In the proposed scheme, a set of mobile and stationary agents are used to trace and maintain the recovery information for the mobile host. The mobile agents properly trace the mobile host and manage the suitable distance between the recovery information and the mobile host. Also, the migration of the recovery information of the mobile host can be performed asynchronously with the hand-off of the mobile host and hence the fault-tolerance service by mobile agents dose not incur any unnecessary hand-off delay.

Architectural descriptions can provide support for a formal representation of the structure and the overall behavior of software systems, which is suitable for an early assessment of the system properties as well as for the automated generation of code. The problem addressed in this paper is to what extent the properties verified at the architectural level can be preserved during the code generation process for multithreaded programs. In order to limit the human intervention, we propose to separate the thread synchronization management from the thread behavior translation. While a completely automated and architecture-driven approach can guarantee the correct thread coordination, we show that only a partial translation based on stubs is possible for the behavior of the threads, with the preservation of the architectural properties depending on the way in which the stubs are filled in.

Reactive programming has been added to the traditional Linda programming style in order to deal with the dynamic aspects of those applications in which it is important to observe modifications of the environment which occur quickly. Reactive programming is embedded in shared data spaces by defining the entities and the corresponding that usually are processes possibly executing coordination primitives. Typical observable entities are the presence in the space of a datum (state-based) or the execution of a particular primitive (event-based). In this paper we consider different models of reaction execution adopted in the coordination literature so far, namely the model (used e.g. in MARS [3], TuCSoN [8] and LIME [9]) and the execution model (considered e.g. in JavaSpaces [13 ], TSpaces [14] and WCL [11]). Prioritized reactions are usually implemented at server-side as during their execution no other coordination primitives can take place; reactions, more suited when reactions are executed at client-side, are executed in parallel with the other processes in the system (thus other coordination primitives can interleave with the reactions). Using a process algebraic setting we perform a rigorous investigation of the relative advantages and disadvantages of these two models for reaction execution.

We present a framework for modelling heterogeneous distributed systems using graph transformations in the Synchronized Hyperedge Replacement approach, which describes complex evolutions by synchronizing local rules. In order to deal with heterogeneity, we consider different synchronization algebras for different communication channels. The main technical point is the interaction between synchronization algebras and name mobility in the -calculus style. The power of our approach is shown through a few examples.

Composition of a concurrent system out of components involves coordination of their mutual interactions. In component-based construction, this coordination becomes the responsibility of the glue-code language and its underlying run-time middle-ware. Reo offers an expressive glue-language for construction of coordinating component connectors out of primitive channels. In this paper we consider the problem of synthesizing Reo coordination code from a specification of a behavior as a relation on scheduled-data streams. The specification is given as a constraint automaton that describes the desired input/output behavior at the ports of the components. The main contribution in this paper is an algorithm that generates Reo code from a given constraint automaton.

A simple and effective way of coordinating distributed, mobile, and parallel applications is to use a virtual shared memory (VSM), such as a Linda tuple-space. In this paper, we propose a new kind of VSM, called a . Each element in the VSM is a value with an associated tag, and values are read or removed from the VSM by matching the tag. Tagged sets exhibit three properties useful for VSMs:

This paper motivates our approach, sketches its basic theory, and places it in the context of other data management strategies.

Tuple centres allow for dynamic programming of the coordination media: coordination laws are expressed and enforced as the behaviour specification of tuple centres, and can change over time. Since time is essential in a large number of coordination problems and patterns (involving timeouts, obligations, commitments), coordination laws should be expressive enough to capture and govern time-related issues.

Along this line, in this paper we discuss how tuple centres and the ReSpecT language for programming logic tuple centres can be extended to catch with time, and to support the definition and enforcement of time-aware coordination policies. Some examples are provided to demonstrate the expressiveness of the ReSpecT language to model timed coordination primitives and laws.

In a Service Oriented Architecture (SOA), services may need to dynamically discover non-functional properties of possible other services to cooperate with. Among these non-functional properties, transactional support is particularly relevant to enable coordination. In this paper we model the transactional support of Web services in a machine readable format (using OWL-S); in our model transactional support can be defined as negotiable thus requiring a run time multi step interaction among services to agree on the supported transaction type. We use the Business Transaction Protocol (BTP), a distributed transaction protocol, to carry out this negotiation. Specifically, we use an implementation of the bidding negotiation in BTP with the asynchronous pi calculus in order to provide a formal framework for these coordination issues.