Philippe Mauran

Abstracting Communication to Reason about Distributed Algorithms

In distributed systems, message passing is a low level representation of communication resulting in intricate designs and proofs. This paper presents a new abstraction to express communication: the observation. This notion provides a more concise expression of programs and properties, and consequently is an effective help in understanding and reasoning about distributed algorithms. Observations are formalized in the Unity framework.

Refinement Based Validation of an Algorithm for Detecting Distributed Termination

We present the development and the validation of an algorithm for detecting the termination of diffusing computations. To the best of our knowledge, this is the first one which is based on the maximal paths generated by a diffusing computation. After an informal presentation of the algorithm, we proceed to its rigorous development within the framework of the UNITY formalism and the assistance of the PVS proof system. The correctness of the algorithm is established through a refinement of an abstract model.

THE OBSERVATION: AN ABSTRACT COMMUNICATION MECHANISM

In this paper, we introduce an observation relation as an abstraction of point-to-point communication in distributed architectures. After showing how its semantics and syntax can be embedded within the UNITY approach, we state general observation properties. Finally, we consider the description and the validation of a distributed mutual exclusion algorithm. The relevant aspect of such a validation is the exclusive use of refinements and observations properties for the proof of these refinements.

Tailoring UNITY to Distributed Program Design

As a general framework, UNITY does not offer any specific facility for the design of distributed systems. For such systems, distribution aspects must be represented at a low level, resulting into intricated models and proofs. To provide a more abstract view of distributed systems, we propose two extensions to UNITY. The first one is an observation relation which is integrated in UNITY semantics to provide an abstract communication mechanism. The second one is a mapping operator which accounts for the true parallelism of distributed systems. The paper illustrates, through different examples, how these extensions can be used to help the design of distributed systems in UNITY.

Maximal group membership in ad hoc networks

The notion of Group communication has long been introduced as a core service of distributed systems. More recently, this notion appeared with a somewhat different meaning in the field of mobile ad hoc systems. In this context, we study the group membership problem. After specifying the basic safety properties of such groups and a maximality criterion based on cliques, we propose a group membership algorithm. Lastly, with respect to this criterion, we compare our algorithm with two group membership algorithms for ad hoc environments. Moreover, a formal description in TLA+ has been programmed and verified by model-checking for small networks.

Safe Adaptation of Component Coordination

In the domain of software engineering, the use of software components is now a well established approach. However, it raises problems about the dynamic adaptation of these components to particular users demands. Indeed, these components have been developed with the intent to have a wide range of use, and so they implement functionalities which perhaps do not match precisely enough the demands of specific users. Therefore, we address the adaptation of the coordination between components by means of so-called Moderators. A Moderator is itself a coordination component managing interactions that are described and formalized using Petri nets. More precisely, we study the dynamic adaptation of the coordination rules by means of specific transformations of the Petri nets used to describe a Moderator. Safety properties must be enforced to maintain a consistent cooperation among participants with respect to the requested evolutions of the coordination rules. In particular, an adaptation of the Moderator can be considered safe if it cannot be detected by the participants. We present a computable criterion which enables to check such a satefy property automatically. We illustrate our approach in the context of a computer aided learning system, by adapting the coordination rules for controlling accesses to documents during an examination.

Unity, as a Tool for Reactive Systems Specification and Derivation

The Unity f ormalism provides a unified model for reasoning about reactive programs either synchronous or asynchronous. We outline this fundamental property through the Unity expression of some real time formalisms and languages. Moreover, the choice between synchronicity and asynchronicity may be made in the framework of a top-down design. Lastly, it allows a clean separation between the problem logic and the flow of control. This property is especially signijicant for designing reactive programs.

Supervising distributed black boxes

Software components bring in an interesting alternative to the traditional, centralized, approach to software development. The core idea is indeed to enable the (end) user to build and customize his own application, by assembling pre-existing (“off the shelf”) components. However, picking predefined, off-the-shelf components raises the question of the suitability of these components to a peculiar use. In this setting, the ability to supervise and adapt components appears to be crucial, in order to make the component-oriented approach to software design really effective. The fact that a component is and must remain a black box for its clients makes a significant difference as regards instrumentation, and thus supervision of components. This paper introduces a supervision service fitted for software components. The main features of this service are that: –it proposes an instrumentation protocol that keeps the opacity of components, with respect to their implementation, whilst it allows to instrument components independently from their design. – it facilitates the supervision of components by providing a simple coupling between the components internal control, and the control provided by the user of the component, based on user-specified criteria. This paper motivates the interest of such a supervision service, outlines its implementation, and illustrates its use.

Real time behavior of data in distributed embedded systems

Nowadays, most embedded systems become distributed systems structured as a set of communicating components. Therefore, they display a less deterministic global behavior than centralized systems and their design and analysis must address both computation and communication scheduling in more complex configurations. We propose a modeling framework centered on data. More precisely, the interactions between the data located in components are expressed in terms of a so-called observation relation. This abstraction is a relation between the values taken by two variables, the source and the image, where the image gets past values of the source. We extend this abstraction with time constraints in order to specify and analyze the availability of timely sound values. The formal description of the observation-based computation model is stated using the formalisms of transition systems. Real time is introduced as a dedicated variable. As a first result, this approach allows to focus on specifying time constraints attached to data and to postpone task and communication scheduling matters. At this level of abstraction, the designer has to specify time properties about the timeline of data such as their freshness, stability, latency... As a second result, a verification of the global consistency of the specified system can be automatically performed. A forward or backward approach can be chosen. The verification process can start from either the timed properties (e.g. the period) of data inputs or the timed requirements of data outputs (e.g. the latency). As a third result, communication protocols and task scheduling strategies can be derived as a refinement towards an actual implementation.