On Detecting Global Predicates in Distributed Computations (original) (raw)
Related papers
Detection of strong unstable predicates in distributed programs
IEEE Transactions on Parallel and Distributed Systems, 1996
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.
Detection of weak unstable predicates in distributed programs
IEEE Transactions on Parallel and Distributed Systems, 1994
|This paper discusses detection of global predicates in a distributed program. Earlier algorithms for detection of global predicates proposed by Chandy and Lamport work only for stable predicates. A predicate is stable if it does not turn false once it becomes true. Our algorithms detect even unstable predicates without excessive overhead. In the past, such predicates have been regarded as too dicult to detect. The predicates are speci ed using a logic described formally in this paper. We discuss detection of weak conjunctive predicates which are formed by conjunction of predicates local to processes in the system. Our detection methods will detect if such a predicate is true for any interleaving of events in the system, whether the predicate is stable or not. Also, any predicate which can be reduced to a set of weak conjunctive predicates is detectable. This class of predicates captures many global predicates that are of interest to a programmer. The message complexity of our algorithm is bounded by the number of messages used by the program. The main application of our results are in debugging and testing of distributed programs. Our algorithms have been incorporated in a distributed debugger which runs on a network of Sun Workstations under SunOS.
Efficient detection of a locally stable predicate in a distributed system
Journal of Parallel and Distributed Computing, 2007
We present an efficient approach to detect a locally stable predicate in a distributed computation. Examples of properties that can be formulated as locally stable predicates include termination and deadlock of a subset of processes. Our algorithm does not require application messages to be modified to carry control information (e.g., vector timestamps), nor does it inhibit events (or actions) of the underlying computation. The worst-case message complexity of our algorithm is O(n(m + 1)), where n is the number of processes in the system and m is the number of events executed by the underlying computation. We show that, in practice, its message complexity should be much lower than its worst-case message complexity. The detection latency of our algorithm is O(d) time units, where d is the diameter of communication topology. Our approach also unifies several known algorithms for detecting termination and deadlock. We also show that our algorithm for detecting a locally stable predicate can be used to efficiently detect a stable predicate that is a monotonic function of other locally stable predicates.
Efficient detection of restricted classes of global predicates
Lecture Notes in Computer Science, 1995
We show that the problem of predicate detection in distributed systems is NP-complete. We introduce a class of predicates, linear predicates, such that for any linear predicate B there exists an efficient detection of the least cut satisfying B. The dual of linearity is post-linearity. These properties generalize several known properties of distributed systems, such as the set of consistent cuts forms a lattice, and the WCP and GCP predicate dectection results given in earlier work. We define a more general class of predicates, semi-linear predicates, for which efficient algorithms are known to detect whether a predicate has occurred during an execution of a distributed program. However, these methods may not identify the least such cut. Any stable predicate is an example of a semi-linear predicate. In addition, we show that certain unstable predicates can also be semi-linear, such as mutual exclusion violation. Finally, we show application of max-flow to the predicate detection problem. This result solves a previously open problem in predicate detection, establishing the existence of an efficient algorithm to detect predicates of the form x 1 + x 2 : : : + x N < k where x i are variables on different processes, k is some constant, and N is larger than 2.
Predicate Detection for Parallel Computations with Locking Constraints
2016
The happened-before model (or the poset model) has been widely used for modeling the computations (execution traces) of parallel programs and detecting predicates (user-specified conditions). This model captures potential causality as well as locking constraints among the executed events of computations using Lamport's happened-before relation. The detection of a predicate in a computation is performed by checking if the predicate could become true in any reachable global state of the computation. In this paper, we argue that locking constraints are fundamentally different from potential causality. Hence, a poset is not an appropriate model for debugging purposes when the computations contain locking constraints. We present a model called Locking Poset, or a Loset, that generalizes the poset model for locking constraints. Just as a poset captures possibly an exponential number of total orders, a loset captures possibly an exponential number of posets. Therefore, detecting a pred...
Efficient Detection of Channel Predicates in Distributed Systems
Journal of Parallel and Distributed Computing, 1997
This paper discusses efficient detection of global predicates in a distributed program. Previous work in this area required predicates to be specified as a conjunction of predicates defined on individual processes. Many properties in distributed systems, however, use the state of channels, such as “the channel is empty,” or “there is a token in the channel.” In this paper, we introduce the concept of alinearchannel predicate and provide efficient centralized and distributed algorithms to detect any conjunction of local and linear channel predicates. The class of linear predicates is fairly broad. For example, classic problems such as detection of termination and computation of global virtual time are instances of conjunctions of linear channel predicates. Linear predicates can be functions of the number of messages in the channel, or can be based upon the actual contents of the messages. The main application of our results are in debugging and testing of distributed programs. For these applications it is important to detect thefirststate where some predicate is true. We show that this first state is uniquely defined if and only if linear predicates are used.
Finding missing synchronization in a distributed computation using controlled re-execution
Distributed Computing, 2004
Correct distributed programs are hard to write. Not surprisingly, distributed systems are especially vulnerable to software faults. Testing and debugging is an important way to improve the reliability of distributed systems. A distributed debugger equipped with the mechanism to re-execute the traced computation in a controlled fashion can greatly facilitate the detection and localization of bugs. This approach gives rise to a general problem of predicate control, which takes a computation and a safety property specified on the computation as inputs, and produces a controlled computation, with added synchronization, that maintains the given safety property as output. We devise efficient control algorithms for two classes of useful predicates, namely region predicates and disjunctive predicates. For the former, we prove that the control algorithm is optimal in the sense that it guarantees maximum concurrency possible in the controlled computation. For the latter, we prove that our control algorithm generates the least number of synchronization dependencies and therefore has optimal message-complexity. Furthermore, we provide a necessary and sufficient condition under which it is possible to efficiently compute a minimal controlling synchronization for a general predicate. We also give an algorithm to compute such a synchronization under the condition provided.
Detection of global predicates: Techniques and their limitations
Distributed Computing, 1998
We show that the problem of predicate detection in distributed systems is NP-complete. In the past, efficient algorithms have been developed for special classes of predicates such as stable predicates, observer-independent predicates, and conjunctive predicates. We introduce a class of predicates, semi-linear predicates, which properly contains all of the above classes. We first discuss stable, observer-independent and semi-linear classes of predicates and their relationships with each other. We also study closure properties of these classes with respect to conjunction and disjunction. Finally, we discuss algorithms for detection of predicates in these classes. We provide a non-deterministic, detection algorithm for each class of predicate. We show that each class can be equivalently characterized by the degree of non-determinism present in the algorithm. Stable predicates are defined as those that can be detected by an algorithm with the most nondeterminism. All other classes can be derived by appropriately constraining the non-determinism in this algorithm. keywords: distributed debugging, predicate detection, unstable predicates. £ A preliminary version of this
Deriving distributed algorithms from a general predicate detector
computer software and applications conference, 1995
Designing and debugging distributed systems requires the detection of conditions across the entire system. As an illustration, monitoring the status of an application requires detection of termination, and using virtual time requires the periodic calculation of the global virtual time. The Generalized Conjunctive Predicate (GCP) detector o ers a method to derive detection algorithms for these and other problems based on optimizing the base algorithm.
Global Predicate Detection in Distributed Systems with Small Faults
Lecture Notes in Computer Science, 2007
We study the problem of global predicate detection in presence of permanent and transient failures. We term the transient failures as small faults. We show that it is impossible to detect predicates in an asynchronous distributed system prone to small faults even if nodes are equipped with a powerful device known as failure detector sequencer (denoted by Σ). To redress this impossibility, we introduce a theoretical device, known as a small fault sequencer (denoted by ΣSF), and show that ΣSF is necessary and sufficient for predicate detection. Unfortunately, we also show that ΣSF cannot be implemented even in a synchronous distributed system. Fortunately, however, we show that predicate detection can be achieved with high probability in synchronous systems.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.