Distributed Termination Detection Research Articles

The derivation of distributed termination detection algorithms from garbage collection schemes

It is shown that the termination detection problem for distributed computations can be modeled as an instance of the garbage collection problem. Consequently, algorithms for the termination detection problem are obtained by applying transformations to garbage collection algorithms. The transformation can be applied to collectors of the “mark-and-sweep” type as well as to reference-counting protocol of Lermen and Maurer, the weighted-reference-counting protocol, the local-reference-counting protocol, and Ben-Ari's mark-and-sweep collector into termination detection algorithms. Known termination detection algorithms as well as new variants are obtained.

Development of a class of distributed termination detection algorithms

Accessing and updating information in a self organizing data structure in a distributed environment requires execution of various distributed algorithms. Design of such algorithms is often facilitated by the use of a distributed termination detection algorithm superimposed on top of another distributed algorithm. The problem of distributed termination detection is considered, and message counting is introduced as an effective technique in designing such algorithms. A class of efficient algorithms, based on the idea of message counting, for this problem is presented. After termination has occurred, it is detected within a small number of message communications. These algorithms do not require the FIFO (first in, first out) property for the communication lines. Assumptions regarding the connectivity of the processes are simple. The algorithms are incrementally developed, i.e. a succession of algorithms leading to the final algorithms is presented.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Paradigms for process interaction in distributed programs

Distributed computations are concurrent programs in which processes communicate by message passing. Such programs typically execute on network architectures such as networks of workstations or distributed memory parallel machines (i.e., multicomputers such as hypercubes). Several paradigms—examples or models—for process interaction in distributed computations are described. These include networks of filters, clients, and servers, heartbeat algorithms, probe/echo algorithms, broadcast algorithms, token-passing algorithms, decentralized servers, and bags of tasks. These paradigms are appliable to numerous practical problems. They are illustrated by solving problems, including parallel sorting, file servers, computing the topology of a network, distributed termination detection, replicated databases, and parallel adaptive quadrature. Solutions to all problems are derived in a step-wise fashion from a general specification of the problem to a concrete solution. The derivations illustrate techniques for developing distributed algorithms.

Application of three-valued logic for distributed termination detection

In this paper a three-valued logic method is used as a tool to design and proof the correctness of an algorithm for distributed termination detection. Dijkstra et al. proposed an algorithm that was based on the assumption of zero delay in the communication channels, where a token and a two-color rule were used to detect termination. Similar to Dijkstra's algorithm we have developed an algorithm for distributed systems that does not rely on any clock synchronization scheme. Moreover, it uses a communication channel model that is non-FIFO with finite delay message transmission. This algorithm uses two auxiliary message types, called token and control messages, in addition to the regular messages that are used for computation. Auxiliary messages travel in a Hamiltonian path, however, regular messages travel in any arbitrary path between the sender and receiver of the message. For developing and proving the termination detection algorithm, multiple tokens and control messages are used together with a three-valued logic scheme with the values 0, 1 2 and 1 representing colors black, gray and white, respectively.

Distributed termination detection with counters

Our purpose is to present a termination detection algorithm that uses counters instead of probing. The counters are used to record information about the number of passive machines in the neighbourhood of each machine.

A message-optimal algorithm for distributed termination detection

Termination detection is among the important problems in distributed processing systems. Several algorithms have been proposed to solve the problem. However, these solutions are inefficient in terms of the number of messages used in the worst case. Chandy and Misra have shown that a lower bound on the message complexity of the termination detection problem is the number of messages used by the underlying computation. We establish a new lower bound on the message complexity of the termination detection problem and present a new algorithm for the termination detection problem which achieves these lower bounds simultaneously.

A generalized framework for deriving ring based termination detection algorithms

A generalized prototype protocol framework has been developed for designing ring based symmetric distributed termination detection algorithms. Then, based upon the framework, the derivation of a class of such algorithms, employing uni-directional control communication around a ring, has been discussed.

Reliable protocols for distributed termination detection

The problem of detecting termination in a network which has at most one faulty node is considered and several message-efficient protocols are presented. The protocols are then extended to multiple node failures. The network is assumed to be connected in spite of the failures. The protocols are being implemented on a network of SUN workstations.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A fully distributed termination detection scheme

A fully distributed scheme for detecting the termination of distributed computations is proposed. The proposed scheme avoids a predesigned detector, and makes no assumption about the connection topology of the processes.

The derivation of graph marking algorithms from distributed termination detection protocols

We show that on-the-fly garbage collection algorithms can be obtained by transforming distributed termination detection protocols. Virtually all known on-the-fly garbage collecting algorithms are obtained by applying the transformation. The approach leads to a novel and insightful derivation of, e.g., the concurrent garbage collection algorithms of Dijkstra et al. and of Hudak and Keller. The approach also leads to several new, highly parallel algorithms for concurrent garbage collection. We also analyze a garbage collecting system due to Hughes from our current perspective.

Algorithms for distributed termination detection

The termination problem for distributed computations is analyzed in the general context of asynchronous communication. In the underlying computational model it is assumed that messages take an arbitrary but finite time and do not necessarily obey the FIFO rule. Time diagrams are used as a graphic means of representing the overall communication scheme, giving a clear insight into the difficulties involved (e.g., lack of global state or time, inconsistent time cuts) and suggesting possible solutions.

Inheritance on processes, exemplified on distributed termination detection

A multiple inheritance mechanism on processes is designed and presented within the framework of a small object oriented language. Processes are described in classes, and the different action parts of a process inherited from different classes are executed in a coroutine-like style called alternation. The inheritance mechanism is a useful tool for factorizing the description of common aspects of processes. This is demonstrated within the domain of distributed programming by using the inheritance mechanism to factorize the description of distributed termination detection algorithms from the description of the distributed main computations for which termination is to be detected. A clear separation of concerns is obtained, and arbitrary combinations of termination detection algorithms and main computations can be formed. The same termination detection classes can also be used for more general purposes within distributed programming, such as detecting termination of each phase in a multi-phase main computation.

Repeated snapshots in distributed systems with synchronous communications and their implementation in CSP

A new version of the Snapshot Algorithm of Chandy and Lamport (1985) is presented. It considers synchronous communications and partially ordered semantics and allows for repeated snapshots. Its implementation in the language CSP is described: it is symmetric, generic and bounded in storage. It yields a symmetric and generic solution to the ‘Distributed Termination Detection’ problem of Francez.

Distributed termination detection algorithm for distributed computations

A fully distributed and symmetric algorithm for solving the distributed termination problem is presented along with its correctness arguments. The algorithm does not make use of time-stamps and clock-synchronization and is very simple.

Inheritance Used to Factorize: Distributed Termination Detection Algorithms

&lt;p&gt;A multiple inheritance mechanism on processes is introduced. Processes are described in classes, and the different action parts of a process inherited from different classes are executed in a coroutine-like style called alternation.&lt;/p&gt;&lt;p&gt;The inheritance mechanism is a useful tool for factorizing the description of common aspects of processes. This is demonstrated within the domain of distributed programming by using the inheritance mechanism to factorize the description of distributed termination detection algorithms from the description of the distributed main computations for which termination is to be detected.&lt;/p&gt;&lt;p&gt;The factorization is obtained by programming the termination detection algorithms in separate classes. The main computations are programmed in classes that use appropriate termination detection classes as superclasses. A clear separation of concerns is obtained, and arbitrary combinations of termination detection algorithms and main computations can be formed.&lt;/p&gt;