This paper discusses detection of global predicates in a distributed program. A run of a distributed program results in a set of sequential traces, one for each process. These traces may be combined to form many global sequences consistent with the single run of the program. A strong global predicate is true in a run if it is true for all global sequences consistent with the run. We present algorithms which detect if the given strong global predicate became true in a run of a distributed program. 1 Introduction Detection of global predicates is a fundamental problem in distributed computing. It arises in the designing, debugging and testing of distributed programs. Global predicates can be classified into two types - stable and unstable. A stable predicate is one which never turns false once it becomes true. An unstable predicate is one without such a property. Its value may alternate between true and false. Detection of stable predicates has been addressed in the literature by means ...

The problem of checking the correctness of distributed computations arises when debugging distributed algorithms, and more generally when testing protocols or distributed applications. For that purpose, one describes the expected behavior (or suspected errors) by a global property: for example, a predicate on process variables, or the set of admissible orderings on observable events. The problem is to check whether this property is satisfied or not during the execution. A relevant model for this study is the partial order of message causality and the associated state graph, called "lattice of consistent cuts". In this paper, we propose a general approach to trace checking, based on partial order theory.

This paper is dedicated to the on--line computation of the lattice of maximal antichains, say g MA(P ) = (MA(P ); MA(P ) ), of a finite poset e P = (P; P ). This on--line computation fulfills what we call the linear extension hypothesis, that is when the ordering of the incoming vertices of e P follows a linear extension of e P . Beside its theoretical interest, this abstraction of the lattice of antichains of a poset has structural properties which give it interesting practical behaviours. Particularly this lattice of maximal antichains seems interesting for testing distributed computations, domain where the lattice of antichains is going to be widely used. The on--line algorithm we propose for this computation has a run time complexity in O((jP j +! 2 (P ))!(P )jMA(P )j) which strictly improves the previous off--line algorithms.

this paper, we consider properties that can be encoded as general Boolean predicates over global system states. We introduce two global predicate classes called simple sequences and

The domain of a global function is the set of all global states of an execution of a distributed program. We show how to monitor a program in order to determine if there exists a global state in which the sum x 1 +x 2 + : : : +xN exceeds some constant K, where x i is defined in process i. We examine the cases where x i is an integer variable and where x i is a boolean variable. For both cases we provide algorithms, prove their correctness and analyze their complexity. 1 Introduction As a distributed program executes, each process proceeds through a sequence of local states. The set S of all local states is partially ordered by Lamport's happens before relation[Lam78], denoted by !. A global state is a subset of S in which no two elements are ordered by !. Given a global state c of some execution, it is impossible to determine if c actually occurred in an execution. However, it is known that c is consistent with some global state that did occur in the execution [CL85, Mat89]. In ot...

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 (to 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).

Vector clocks are the appropriate mechanism to track causality among the events produced by a distributed computation. Traditional implementations of vector clocks require application messages to piggyback a vector of n integers (where n is the number of processes). This paper considers the tracking of the causality relation on a subset of events (namely, the events that are defined as “relevant ” from the application point of view). It first proposes simple and efficient implementations of vector clocks where the size of message timestamps can be less than n, in a context where communication channels are not required to be FIFO, and where there is no a priori information on the connectivity of the communication graph or the communication pattern. Then, it presents a protocol that provides a correct timestamping of the relevant events in presence of the following constraint: a message timestamp can piggyback at most b event identifiers (where b is a predefined constant, 1 ≤ b ≤ n). To ensure this constraint, processes can be forced to produce additional “null ” relevant events. Finally, the paper presents and proves correct a protocol that tracks (on-thefly and without the help of an external observer) the immediate predecessors of each relevant event. This set of protocols defines a suite of protocols that, in addition to their efficiency, provides a comprehensive view of causality tracking in distributed systems.

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.

: In this paper, we present a concurrency measure that is especially adapted to distributed programs that exhibit regular run-time behaviours. Such programs are frequently obtained by automatic parallelization of sequential code. This measure is based on the antichain lattice of the partial order that models the distributed execution under consideration. We show under which condition the measure is computable on an infinite execution which is the repetition of a finite pattern. The measure can then be computed by considering only a bounded number of patterns, this bound being at most the number of processors. Key-words: Concurrency measure, Automated parallelization, Antichain lattice, Labeled partial orders, Regular executions. (R'esum'e : tsvp) This work was partially supported by the project Trace of the French Minist`ere de l'Enseignement Sup'erieur et de la Recherche. E-mail adress of the authors: fnameg@irisa.fr LFCS, JCMB, King's Buildings, The University of Edinburgh, Edinb...

: We describe in this paper a Parallel Observable virtual Machine (POM), which provides a homogeneous interface upon the communication kernels of parallel architectures. POM was designed so as to be ported easily and efficiently on numerous parallel platforms. It provides sophisticated features for observing distributed executions. Key-words: Distributed memory parallel computers, virtual machine, communication library, observation, traces (R'esum'e : tsvp) guidec@irisa.fr maheo@irisa.fr Unite de recherche INRIA Rennes IRISA, Campus universitaire de Beaulieu, 35042 RENNES Cedex (France) Telephone : (33) 99 84 71 00 -- Telecopie : (33) 99 84 71 POM : une machine parall`ele virtuelle incorporant des m'ecanismes d'observation R'esum'e : Nous d'ecrivons dans cet article une machine parall`ele virtuelle observable, la POM. Celle-ci offre une interface homog`ene au dessus des syst`emes de communication des architectures parall`eles. Elle a 'et'e con¸cue en vue d'un portage ais'e et ...