Finite termination of asynchronous iterative algorithms

Includes bibliographical references (p. 17-18).Supported by an AT&T Bell Laboratories GRPW Fellowship. Supported by the NSF. 9300494-DMI Supported by the ARO. DAAL03-92-G-0309Serap A. Savarí, Dimitri P. Bertsekas

Elements of concurrent programming (Third edition)

These lecture notes are intended to introduce the reader to the basic notions of nondeterministic and concurrent programming. We start by giving the operational semantics of a simple deterministic language and the operational semantics of a simple nondeterministic language based on guarded commands. Then we consider concurrent computations based on: (i) vectorization, (ii) shared variables, and (iii) handshaking communications à la CCS (Calculus for Communicating Systems) [16]. We also address the problem of mutual exclusion and for its solution we analyze various techniques such as those based on semaphores, critical regions, conditional critical regions, and monitors. Finally, we study the problem of detecting distributed termination and the problem of the serializability of database transactions. Sections 1, 2, and 6 are based on [16,22]. The material of Sections 3 and 4 is derived from [1,2,4,5,7,8,13,18,20]. Section 5 is based on [10] and is devoted to programming examples written in Java where the reader may see in action some of the basic techniques described in these lecture notes. In Section 7 we closely follow [3]. We would like to thank Dr. Maurizio Proietti for his many suggestions and his encouragement, Prof. Robin Milner and Prof. Matthew Hennessy for introducing me to CCS, Prof. Vijay K. Garg from whose book [10] I learnt concurrent programming in Java, my colleagues at Roma Tor Vergata University for their support and friendship, and my students for their patience and help. Many thanks also to Dr. Gioacchino Onorati and Lorenzo Costantini of the Aracne Publishing Company for their kind and helpful cooperation. Roma, April 2005 In the third edition we have corrected a few mistakes, we have improved Chapter 2, and we have added in the Appendix a Java program for the distributed computation of spanning trees of undirected graphs. Thanks to Dr. Emanuele De Angelis for discovering an error in the presentation of Peterson’s algorithm. Roma, January 200

Causal synchrony in the design of distributed programs

The outcome of any computation is determined by the order of the events in the computation and the state of the component variables of the computation at those events. The level of knowledge that can be obtained about event order and process state influences protocol design and operation. In a centralized system, the presence of a physical clock makes it easy to determine event order. It is a more difficult task in a distributed system because there is normally no global time. Hence, there is no common time reference to be used for ordering events. as a consequence, distributed protocols are often designed without explicit reference to event order. Instead they are based on some approximation of global state. Because global state is also difficult to identify in a distributed system, the resulting protocols are not as efficient or clear as they could be.;We subscribe to Lamport\u27s proposition that the relevant temporal ordering of any two events is determined by their causal relationship and that knowledge of the causal order can be a powerful tool in protocol design. Mattern\u27s vector time can be used to identify the causal order, thereby providing the common frame of reference needed to order events in a distributed computation. In this dissertation we present a consistent methodology for analysis and design of distributed protocols that is based on the causal order and vector time. Using it we can specify conditions which must be met for a protocol to be correct, we can define the axiomatic protocol specifications, and we can structure reasoning about the correctness of the specified protocol. Employing causality as a unifying concept clarifies protocol specifications and correctness arguments because it enables them to be defined purely in terms of local states and local events.;We have successfully applied this methodology to the problems of distributed termination detection, distributed deadlock detection and resolution, and optimistic recovery. In all cases, the causally synchronous protocols we have presented are efficient and demonstrably correct

Deriving distributed garbage collectors from distributed termination algorithms

This thesis concentrates on the derivation of a modularised version of the DMOS distributed garbage collection algorithm and the implementation of this algorithm in a distributed computational environment. DMOS appears to exhibit a unique combination of attractive characteristics for a distributed garbage collector but the original algorithm is known to contain a bug and, previous to this work, lacks a satisfactory, understandable implementation. The relationship between distributed termination detection algorithms and distributed garbage collectors is central to this thesis. A modularised DMOS algorithm is developed using a previously published distributed garbage collector derivation methodology that centres on mapping centralised collection schemes to distributed termination detection algorithms. In examining the utility and suitability of the derivation methodology, a family of six distributed collectors is developed and an extension to the methodology is presented. The research work described in this thesis incorporates the definition and implementation of a distributed computational environment based on the ProcessBase language and a generic definition of a previously unimplemented distributed termination detection algorithm called Task Balancing. The role of distributed termination detection in the DMOS collection mechanisms is defined through a process of step-wise refinement. The implementation of the collector is achieved in two stages; the first stage defines the implementation of two distributed termination mappings with the Task Balancing algorithm; the second stage defines the DMOS collection mechanisms

Distributed Termination Detection For Multiagent Protocols

The research conducted in this thesis is on distributed termination detection in multiagent systems. Agents engage in complex interactions by executing behaviour specifications in the form of protocols. This work presents and experiments with a framework for making termination in a multiagent system explicit. As a side effect, the mechanism can be exploited to aid management of agent interactions, by providing visibility of the interaction process and can be extended to drive multiagent system management tasks such as timely garbage collection. Results from previous attempts to deploy agents systems when scaling up, e.g. Agentcities, have shown and exposed a big gap between theory and practice especially in the reliability and availability of deployed systems. In particular more work needs to be done in the area of supporting agent infrastructures as much as in theoretical agent foundations. There are two aspects to this problem of termination detection in multiagent systems, firstly, the formal verification of behaviour at compile-time and secondly, monitoring and control at run-time. Regarding the former, there has been some work on the ver- 13 ification of agent communication languages. But overall verification is difficult and often requires knowledge of internal states of agents at compile time, and as yet has not been satisfactorily solved to be deployed in real systems. The second, the runtime approach is adopted in here. The research is not about protocol engineering but assumes correct protocols, and protocol specifications to be finite state machine graphs. Given these correct verified protocols, the thesis proposes a number of definitions culminating in identification of minimal information in the form of sub-protocols that agents being autonomous, can make available for the termination detection. An off line procedure for deriving these sub-protocols is then presented. The thesis then considers a termination detection model, and within this model, proposes an conversationmodel encompassing protocol executions, with hierarchical conversations modelled as diffusing computation trees and defines a number of predicates to derive termination in centralised and distributed environments. Algorithms that implement these predicates are sketched and some complexity analysis is performed. The thesis then considers a prototype implementation evaluated over some defined detection delays metric. The evaluation approach is heavily empirical, with an experimental approach adopted to evaluate various configurations of the termination detection mechanism. The evaluation employs robust resampling and bootstrapping methods to analyse and obtain distributions and confidence intervals of the detection delays metric for the termination detection mechanism