A definition of and linguistic support for partial quiescence

The global quiescence (GQ) of a distributed computation (or distributed termination detection) is an important problem. Some concurrent programming languages and systems provide GQ detection as a built‐in feature so that programmers do not need to write special synchronization code to detect quiescence. This paper introduces partial quiescence (PQ), which generalizes quiescence detection to a specified part of a distributed computation. PQ is useful, for example, when two independent concurrent computations that both rely on GQ need to be combined into a single program. The paper describes how we have designed and implemented a PQ mechanism within an experimental version of the JR concurrent programming language, and have gained experience with several representative applications. Our early results are promising qualitatively and quantitatively. Copyright © 2007 John Wiley & Sons, Ltd.     

Development of a class of distributed termination detectionalgorithms

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     

Synchronous,asynchronous, and causally ordered communication

Summary.  This article studies characteristic properties of synchronous and asynchronous message communications in distributed systems. Based on the causality relation between events in computations with asynchronous communications, we characterize computations which are realizable with synchronous communications, which respect causal order, or where messages between two processes are always received in the order sent. It is shown that the corresponding computation classes form a strict hierarchy. Furthermore, an axiomatic definition of distributed computations with synchronous communications is given, and it is shown that several informal characterizations of such computations are equivalent when they are formalized appropriately. As an application, we use our results to show that the distributed termination detection algorithm by Dijkstra et al. is correct under a weaker synchrony assumption than originally stated. Received: November 1992/Accepted: July 1995     

Distributed predicate detection in series-parallel systems

This paper addresses the problems of state space decomposition and predicate detection in a distributed computation involving asynchronous messages. We introduce a natural communication dependency which leads to the definition of the communication graph. This abstraction proves to be a useful tool to decompose the state lattice of a distributed computation into simpler structures, known as concurrent intervals. Efficient algorithms have been proposed in the literature to detect special classes of predicates, such as conjunctive predicates and bounded sum predicates. We show that more general classes of predicates can be detected when proper constraints are imposed on the underlying computations. In particular, we introduce a class of predicates, defined as separable predicates, that properly includes the above-mentioned classes. We show that separable predicates can be efficiently detected on distributed computations whose communication graphs satisfy the series-parallel constraint     

A family of optimal termination detection algorithms

An important problem in distributed systems is to detect termination of a distributed computation. A computation is said to have terminated when all processes have become passive and all channels have become empty. In this paper, we present a suite of algorithms for detecting termination of a non-diffusing computation for an arbitrary communication topology under a variety of conditions. All our termination detection algorithms have optimal message complexity. Furthermore, they have optimal detection latency when message processing time is ignored. A preliminary version of the paper first appeared in the 18th Symposium on Distributed Computing (DISC), 2004 [27].     

The Doomsday distributed termination detection protocol

Distributed termination detection (DTD) algorithms are important since they detect globally stable states in distributed computations. Here we introduce a new DTD mechanism, the Doomsday protocol together with its proof of correctness. Doomsday is generic since it forms the basis for a number of new and existing DTD algorithms for which the correctness proof may be reused. The paper describes the Doomsday protocol, provides its formal proof, derives one new DTD algorithm and shows how other hitherto unrelated algorithms, Dijkstra–Scholten, Task Balancing and Credit Recovery, can be derived from the protocol. The paper concludes by examining various properties of the protocol in the context of existing DTD algorithms. This work was supported in part by Visiting Fellowship grant EPSRC GR/R84481/01 “The Doomsday Protocol” and by Australian Research Council ARC Linkage International Grant LX0349049 “Extending a Family of Garbage Collectors”.     

Characterizations of Classes of Graphs Recognizable by Local Computations

This paper investigates the power of local computations on graphs, by considering a classical problem in distributed algorithms, the recognition problem. Formally, we want to compute some topological information on a network of processes, possibly using additional knowledge about the structure of the underlying graph. We propose the notion of recognition with structural knowledge by means of local computations. Then we characterize the graph classes that are recognizable with or without structural knowledge. The characterizations use graph coverings and a distributed enumeration algorithm proposed by A. Mazurkiewicz. Several applications are presented, in particular concerning minor-closed classes of graphs.     

Inheritance of synchronization and recovery properties inAvalon/C++

The authors describe their experience adapting inheritance mechanisms to a new application domain, reliable distributed systems. They give an overview of Avalon/C++, a programming language under development that allows programmers to `customize' the synchronization and fault-tolerance properties of data types by letting them inherit properties such as serializability and crash recovery from a library of basic types. The authors first describe the transaction model used to organize distributed computations and some relevant features of C++, and give an overview of the Avalon/C++ base hierarchy. They then describe in more detail each of the hierarchy's classes and some restrictions on their use that must be obeyed to preserve their semantic intent. An extended example illustrates a directory-type implementation that uses all three of the base classes. Related work is discussed     

A methodology to solve distributed termination problem: A short note

A methodology to solve distributed termination problem is presented. The supporting language constructs are also discussed. The language constructs and the underlying mechanism for writing terminating distributed program can be incorporated in any distributed programming language.     

Asynchronous distributed termination—parallel and symmetric solutions with echo algorithms

The principle of message counting is used to detect termination of distributed computations which consist of processes asynchronously communicating over non-FIFO channels. The solution is symmetric and not based on a predefined communication structure. An efficient variant of the echo algorithm, which dynamically builds a spanning tree, allows a parallel and distributed evaluation of the termination predicate in time proportional to the diameter of the communication graph. Concurrent and repeated initiation of the detection algorithm by different processes is possible at any time without prior synchronization due to a subtle method of collision detection and wave extinction, which can be regarded as a distributed election scheme where the average message complexity increases only logarithmically with the number of concurrent initiators. Control messages have a small length and additional communication links are not required. Only a fixed number of simple variables is needed in every process, global knowledge such as the total number of processes or the structure of the network is not used, making the scheme useful for dynamic systems. Several variations of the basic principle are presented, important issues such as message complexity and fault-tolerance are discussed.     

Termination Detection for Parallel Shortest Path Algorithms

Shortest path computation is required by a large number of applications such as VLSI, transportation, and communication networks. These applications, which are often very complex and have sparse networks, generally use parallel labeling shortest path algorithms. Such algorithms, when implemented on a distributed memory machine, require termination detection methods; these methods consist of some type of synchronization among all processors. Because global synchronization can be costly, it is assumed that the best termination detection methods synchronize as infrequently as possible. The frequency, however, can significantly impact the idle time of parallel labeling shortest path algorithms. In this paper we analyze the impact of this frequency on the performance, in particular the idle time, and identify when low versus high frequency detection is best. The analysis and results indicate that when the size of the subnetwork assigned to processor is small enough so that the computation time is less than or equal to the communication time within an iteration, high frequency termination detection methods should be used. Otherwise, low frequency methods should be used.     

Safe termination detection in an asynchronous distributed system when processes may crash and recover

The termination detection problem involves detecting whether an ongoing distributed computation has ceased all its activities. We investigate the termination detection problem in an asynchronous distributed system under the crash-recovery model. It has been shown that the problem is impossible to solve under the crash-recovery model in general. We identify two conditions under which the termination detection problem can be solved in a safe manner. We also propose algorithms to detect termination under the conditions identified.     

分布式计算中稳定性质的等价类划分

分布式计算中的稳定性质是那些在计算中一旦成立将保持成立的性质，如分布式死锁、分布式终止和分布式废码等，稳定性质检测是分布式计算中计算中的重要问题，常通过构造一致全局系统状态来检测稳定性质。     

一种基于目标检测与词性分析的图像描述算法

针对现有的基于注意力机制的图像描述方法描述内容与图像关联度低的问题,提出一种基于目标检测与词性分析的图像描述算法。该方法在注意力机制的基础上,通过目标检测算法提取图片中的信息,使用带有注意力机制的循环神经网络对提取到的信息进行处理,生成图像描述语句。在生成单词的过程中,算法会预测每个单词的词性,根据不同的词性选择不同的神经网络,从而提升描述语句与原图像的关联度。实验结果表明,在多种客观描述评价标准中,本文算法生成的描述语句相对目前存在的算法均有不同程度提升,同时,在主观评价中也能够更准确流畅地描述图片的内容。     

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.Several efficient algorithms for the solution of the termination problem are presented. They are all based on the idea of message counting but have a number of different characteristics. The methods are discussed and compared with other known solutions.Friedemann Matternreceived the Diploma in computer science from the University of Bonn, West Germany, in 1983.He is now a research scientist in the Department of Computer Science at the University of Kaiserslautern and is currently completing his Ph.D. His primary research interests include distributed algorithms, programming language design, and compiler construction. The author can be reached by electronic mail via mattern @ incas.uucp or mattern % uklirb.uucp @ Germany.csne.This work has been supported by the Deutsche Forschungsgemeinschaft (DFG) as part of the SFB124 research project VLSI-Design and Parallelism     

2DT-FP: A parallel functional programming language on two-dimensional data

We propose a new paradigm for programming multiprocessor systems, 2DT (two-dimensional transformations). 2DT programs are composed of local computations on linear data (columns) and global transformations on 2-dimensional combinations of columns (2D-arrays). Local computations can be expressed in a functional or imperative base language; a typed variant of Backus' FP is chosen for 2DT-FP. The level of abstraction of 2DT makes it suitable for programming a relevant set of algorithms, in general any algorithms, whose data can be easily mapped to 2-dimensional representations. A set of examples tries to prove this claim. An interleaving semantics for 2DT-FP is given, exposing the potential for parallel execution of 2DT-FP programs. The claim is proved that any sequential and thus any parallel execution will deliver the same result. The implementation realized on the Intel Hypercube is described. Supported by the Deutsche Forschungsgemeinschaft, DFG     

Detecting causal relationships in distributed computations: In search of the holy grail

Summary The paper shows that characterizing the causal relationship between significant events is an important but non-trivial aspect for understanding the behavior of distributed programs. An introduction to the notion of causality and its relation to logical time is given; some fundamental results concerning the characterization of causality are presented. Recent work on the detection of causal relationships in distributed computations is surveyed. The issue of observing distributed computations in a causally consistent way and the basic problems of detecting global predicates are discussed. To illustrate the major difficulties, some typical monitoring and debugging approaches are assessed, and it is demonstrated how their feasibility is severely limited by the fundamental problem to master the complexity of causal relationships. Reinhard Schwarz received a diploma in computer science from the University of Kaiserslautern, Germany, in 1990. Since then, he is working as a research assistant at the computer science department. His research interests include debugging and monitoring of distributed systems, runtime support for object-oriented distributed programming, and distributed algorithms. Friedemann Mattern received the diploma in computer science from Bonn University, Germany, and the Ph.D. degree from the University of Kaiserslautern, Germany, in 1983 and 1989, respectively. Since 1991 he is a professor of computer science at the University of Saarland in Saarbrücken, Germany. His current research interests include programming of distributed systems, distributed applications, and distributed algorithms.The work presented in this paper was carried out as part of the PARAWAN project supported by the Bundesministerium für Forschung und Technologie (BMFT)