Philippe Quéinnec

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.

Streaming with causality: a practical approach

Highly interactive collaborative streaming applications express the need for causality. Solutions exist but we argue that more work needs to be done especially from a perceptual point of view. The key question is: given the current state of the Internet and the perceptual tolerance of causal desynchronization, does causality make any difference? This paper proposes a practical answer to this question by comparing different solutions. We support this comparison by producing video results for a live streaming scenario on an experimental platform. Further, this paper proposes a novel approach for handling causality in multimedia and shows that it can perform better than Δ-causality, usually considered the best solution.

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.

Cooperative Mobile Agents to Gather Global Information

This paper describes an original approach to writing reactive algorithms on highly dynamic networks. We propose to use randomly mobile agents to gather global information about such networks. In this model, mobility is twofold: nodes move within the network and agents are able to migrate from node to node by following network links as they exist at a given moment in time. We apply this approach to a toy load balancing example. Through simulations, we illustrate the reactivity and convergence properties of the proposed approach. In particular, we emphasize two points: the solution is well adapted to node mobility in so much as its performance increases with the node mobility rate, and agent cooperation can be used effectively in this context to increase performance

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.

Asynchronous Message Orderings Beyond Causality

In the asynchronous setting, distributed behavior is traditionally studied through computa- tions, the Happened-Before posets of events generated by the system. An equivalent perspective considers the linear extensions of the generated computations: each linear extension defines a sequence of events, called an execution. Both perspective were leveraged in the study of asyn- chronous point-to-point message orderings over computations; yet neither allows us to interpret message orderings defined over executions. Can we nevertheless make sense of such an ordering, maybe even use it to understand asynchronicity better? We provide a general answer by defining a topology on the set of executions which captures the fundamental assumptions of asynchronicity. This topology links each message ordering over executions with two sets of computations: its closure, the computations for which at least one linear extension satisfies the predicate; and its interior, the computations for which all linear ex- tensions satisfy it. These sets of computations represent respectively the uncertainty brought by asynchronicity – the computations where the predicate is satisfiable – and the certainty available despite asynchronicity – the computations where the predicate must hold. The paper demon- strates the use of this topological approach by examining closures and interiors of interesting orderings over executions.

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.

Derivation of fault tolerance properties of distributed algorithms

Many distributed algorithms have been designed with more or less well-defined assumptions about the fault tolerance properties they verify. From a formal description of such algorithms, namely the Unity formalism from Misra and Chandy [0], we derive their fault tolerance features in the same formalism as the algorithms themselves. We emphasize that we do not derive new algorithms but only provide a rigorous analysis of the fault tolerance properties of the algorithms, especially with respect to different assumptions about the target architecture.