Noël Plouzeau

Detecting atomic sequences of predicates in distributed computations

This paper deals with a class of unstable non-monotonic global predicates, called herein atomic sequences of predicates. Such global predicates are defined for distributed programs built with message-passing communication only (no shared memory) and they describe global properties by causal composition of local predicates augmented with atomicity constraints. These constraints specify forbidden properties, whose occurrence invalidate causal sequences. This paper defines formally these atomic sequences of predicates, proposes a distributed algorithm to detect their occurrences and gives a sketch of a proof of correctness of this algorithm.

A distributed algorithm for mutual exclusion in an arbitrary network

A distributed algorithm for mutual exclusion is presented. No particular assumptions on the network topology are required, except connectivity; the communication graph may be arbitrary. The processes communicate by using messages only and there is no global controller. Furthermore, no process needs to know or learn the global network topology. In that sense, the algorithm is more general than the mutual exclusion algorithms which make use of an a priori knowledge of the network topology (for example either ring or complete network). A proof of the correctness of the algorithm is provided. The algorithms complexity is examined by evaluating the number of messages required for the mutual exclusion protocol.

Detection of stable properties in distributed applications

When evaluated to true, a stable property remains true forever. Such a stable property may characterize important states of a computation. This is the case of deadlocked or terminated computations. In this paper we expose a general algorithm for the distributed detection of stable properties in distributed applications or systems. This distributed algorithm deals with every stable property of a fairly general class : in this sense the algorithm is generic. This was achieved using a methodical approach, with a strong distinction between the computation and control activities in the problem. Moreover, the detection method used by the algorithm is based on an observational mechanism,

Research: Debugging tool for distributed Estelle programs

This paper discusses design and implementation issues for a distributed debugger, called EREBUS, which fits in a programming environment for distributed programs written in Estelle, an ISO-normalized language. Problems pertaining to execution replays of distributed programs are discussed in detail, and performance of the prototype debugger is exhibited.

An introduction to the analysis and debug of distributed computations

Distributed programs are much more difficult to design, understand and implement than sequential or parallel ones. This is mainly due to the uncertainty created by the asynchrony inherent to distributed machines. So appropriate concepts and tools have to be devised to help the programmer of distributed applications in his task. This paper is motivated by the practical problem called distributed debugging. It presents concepts and tools that help the programmer to analyze distributed executions. Two basic problems are addressed: replay of a distributed execution (how to reproduce an equivalent execution despite of asynchrony) and the detection of a stable or unstable property of a distributed execution. Concepts and tools presented are fundamental when designing an environment for distributed program development. This paper is essentially a survey presenting a state of the art in replay mechanisms and detection of unstable properties on global states of distributed executions.<<ETX>>

On-the-fly replay: a practical paradigm and its implementation for distributed debugging

This paper presents a practical paradigm, called on-the-fly replay. This paradigm consists of running a distributed program twice at the same time: an original computation is running in a regular fashion, which also includes steps of making non-deterministic choices; this execution is driving a twin execution, whose non-deterministic choices do not have to be evaluated (since they are taken from the original computation). This paradigm has several interesting uses. Among them, distributed debugging is particularly noteworthy. The integration of this paradigm into a distributed debugging facility, called EREBUS, is described. This implementation was run on a distributed memory parallel machine (Intel Hypercube iPSC2) and experimental results are described, that demonstrate the advantage of this paradigm.<<ETX>>