Eddy Fromentin

On the Fly Testing of Regular Patterns in Distributed Computations

A class of properties of distributed computations is described and an algorithm which detects them is presented. This class of properties called regular patterns allows the user to specify an expected (or unwanted) behavior of a computation as sequences of relevant events (or as sequences of local predicates that must be successively verified). The sequences are defined by a finite state automaton (hence the name regular patterns) A computation verifies the property if and only if one of its causal paths matches a sequence.

A Unified Framework for the Specification and Run-time Detection of Dynamic Properties in Distributed Computations

To a large extent, the dependability of complex distributed programs relies on our ability to effectively test and debug their executions. Such an activity requires that we be able to specify dynamic properties that the distributed computation must (or must not) exhibit, and that we be able to construct algorithms to detect these properties at run time. In this paper we formulate dynamic property specification and detection as instances of the language recognition problem. Considering boolean predicates on states of the computation as an alphabet, dynamic property specification is akin to defining a language over this alphabet. Detecting a property, on the other hand, is akin to recognizing at run time if the sentence produced by a distributed execution belongs to the language. This formal language-oriented view not only unifies a large body of work on distributed debugging and property detection, it also leads to simple and efficient detection algorithms. We give examples for the case of properties that can be specified as regular grammars through finite automata.

On-the-fly analysis of distributed computations

At some abstraction level a distributed computation can be modeled as a partial order on a set of observable events. This paper presents an analysis technique which can be superimposed on distributed computations to analyze the structure of control flows terminating at observable events. A general algorithm working on the longest control flows of distributed computations is introduced. Moreover it is shown how this algorithm can be simplified according to the position of observable events with respect to communication events.

On classes of problems in asynchronous distributed systems with process crashes

This paper is on classes of problems encountered in asynchronous distributed systems in which processes can crash but links are reliable. The hardness of a problem is defined with respect to the difficulty to solve it despite failures: a problem is easy if it can be solved in presence of failures, otherwise it is hard. Three classes of problems are defined: F, NF and NFC. F is the class of easy problems, namely, those that can be solved in presence of failures (e.g., reliable broadcast). The class NF includes harder problems, namely, the ones that can be solved in a non-faulty system (e.g., consensus). The class NFC (NF-complete) is a subset of NF that includes the problems that are the most difficult to solve in presence of failures. It is shown that the terminating reliable broadcast problem, the non-blocking atomic commitment problem and the construction of a perfect failure detector (problem P) are equivalent problems and belong to NFC. Moreover the consensus problem is not in NFC. The paper presents a general reduction protocol that reduces any problem of NF to P. This shows that P is a problem that lies at the core of distributed fault-tolerance.

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>>

Characterizing and detecting the set of global states seen by all observers of a distributed computation

A consistent observation of a given distributed computation is a sequence of global states that could be produced by executing that computation on a monoprocessor system. Therefore a distributed execution generally accepts several consistent observations. This paper concentrates on what all these observations have in common. An abstraction called common global state is defined. A necessary and sufficient condition characterizing such states is given. A monitor-based algorithm that detects them is also presented and proved correct. Previous works on detection of unstable properties of distributed computations are revisited and explained with this abstraction. Moreover other uses of such particular states are sketched.

Local states in distributed computations: a few relations and formulas

If events produced by processes of a distributed computation are generally supposed to be instantaneous, it is not the case for local states generated by these events. Due to message exchanges and synchronization local states have some duration. This paper defines notions about local states such as weak precedence, strong precedence, weak concurrency and strong concurrency. Moreover a few formulas based on vector clocks, and consequently usable in an operational context, are introduced to decide about relations between local states. These relations and formulas can be used either to debug, test or analyze distributed programs (especially for global properties detection) or to define consistent checkpoints.

Expressing and detecting control flow properties of distributed computations

Properties of distributed computations can be either on their global states or on their control flows. This paper addresses control flow properties. It first presents a simple yet powerful logic for expressing general properties on control flows, seen as sequences of local states. Among other properties, we can express invariance, sequential properties (20 satisfy such a property a control flow must match a pattern described as a word on some alphabet) and non-sequential properties (these properties are on several control flows at the same time). A decentralized detection algorithm for properties described by this logic is then presented. This algorithm, surprisingly simple despite the power of the logic, observes the underlying distributed computation, does not alter its control flows and uses message tags to carry detection-related information.