Non-faulty Processes Research Articles

A Tight Space Bound for Consensus

In the consensus problem, there are $n$ processes that each has a private input value. Each nonfaulty process must output a single value such that no two processes output different values and the o...

The harmonized consensus protocol in distributed systems

The goal of the consensus protocol is to make all non-faulty processors agree on a common value despite the interference of faulty processors. In the classical consensus problem, each processor can propose an initial-value and obtain a commonly agreed consensus value through message exchange. However, if the initial-value of any processor is shared by only a small number of other processors, this initial-value will not become the consensus value. This is because initial-values once determined cannot be changed in the classical consensus protocol. In this study, we propose a new consensus protocol named harmonized consensus protocol (HCP) to solve this problem. HCP has a mechanism that allows each processor to change its initial-value based on the messages it has collected during message exchange (i.e., PrfRule rules). Hence, it can increase the chances that all processors agree on a consensus value they prefer and accept. Moreover, HCP also has the mechanism for judging the sufficiency of messages collected (i.e., MajChk rule). It terminates message exchange when processors have collected enough messages for obtaining a consensus value. This also means that HCP can reduce the number of rounds of message exchanges and further lower the time and space complexity of reaching consensus. The performance evaluation results confirm that the proposed HCP can deliver a higher preference match rate with lower time and space complexity.

Efficient Reconfiguration Algorithm With Flexible Rerouting Schemes for Constructing 3-D VLSI Subarrays

In this paper, we investigated the technique for improving the reliability of 3-D processor with faults by reconfiguring a 3-D fault-free subarray utilizing as many nonfaulty process elements (PEs) as possible. A novel flexible rerouting scheme is proposed, which makes the PEs can be rerouted or bypassed in three dimensions, hence increasing the number of neighbors of each element to construct a logical array. Under this scheme, an efficient heuristic algorithm is presented to construct a logical array. The experimental results show that the proposed algorithm under flexible rerouting scheme can produce logical arrays with higher harvest from the host arrays with faults for the random fault scenarios, the improvement is by up to 46.47% compared to the state-of-the-arts.

Anonymous obstruction-free (n, k)-set agreement with $$n-k+1$$ n - k + 1 atomic read/write registers

The k-set agreement problem is a generalization of the consensus problem. Namely, assuming that each pro- cess proposes a value, every non-faulty process must decide one of the proposed values, under the constraint that at most k different values are decided. This is a hard problem in the sense that it cannot be solved in a pure read/write asyn- chronous system, in which k or more processes may crash. One way to sidestep this impossibility result consists in weak- ening the termination property, requiring only that a process decides if it executes alone during a long enough period of time. This is the well-known obstruction-freedom progress condition. Consider a system of n anonymous asynchronous processes that communicate through atomic read/write reg- isters, and such that any number of them may crash. This paper addresses and solves the challenging open problem of designing an obstruction-free k-set agreement algorithm with only (n −k +1) atomic registers. From a shared memory cost point of view, our algorithm is the best algorithm known to date, thereby establishing a new upper bound on the number of registers needed to solve this problem. For the consensus case (k = 1), the proposed algorithm is up to an additive factor of 1 close to the best known lower bound. Further, the paper extends this algorithm to obtain an x-obstruction- free solution to the k-set agreement problem that employs (n − k + x) atomic registers (with 1 ≤ x ≤ k < n), as well as a space-optimal solution for the repeated ver- sion of k-set agreement. Using this last extension, we prove that n registers are enough for every colorless task that is obstruction-free solvable with identifiers and any number of registers

Randomized k-set agreement in crash-prone and Byzantine asynchronous systems

k-Set agreement is a central problem of fault-tolerant distributed computing. Considering a set of n processes, where up to t may commit failures, let us assume that each process proposes a value. The problem consists in defining an algorithm such that each non-faulty process decides a value, at most k different values are decided, and the decided values satisfy some context-depending validity condition. Algorithms solving k-set agreement in synchronous message-passing systems have been proposed for different failure models (mainly process crashes, and process Byzantine failures). Differently, k-set agreement cannot be solved in failure-prone asynchronous message-passing systems when t≥k. To circumvent this impossibility an asynchronous system must be enriched with additional computational power.Assuming t≥k, this paper presents two distributed algorithms that solve k-set agreement in asynchronous message-passing systems where up to t processes may commit crash failures (first algorithm) or more severe Byzantine failures (second algorithm). To circumvent k-set agreement impossibility, this article considers that the underlying system is enriched with the computability power provided by randomization. Interestingly, the algorithm that copes with Byzantine failures is signature-free, and ensures that no value proposed only by Byzantine processes can be decided by a non-faulty process. Both algorithms share basic design principles.

Failure detector-Ring Paxos-based atomic broadcast algorithm

An atomic broadcast problem constitutes an essential component in fault-tolerant distributed systems. an atomic broadcast algorithm ensures that all processes deliver the same messages sequence. Many algorithms solving the atomic broadcast problem have been published. Recently, a new Paxos-based atomic broadcast algorithm has been proposed for clustered systems, named Ring Paxos. It inherits many of Paxos characteristics: safe under asynchronous assumptions, live under weak synchronous assumptions, and requires a majority of non-faulty processes to ensure progress. However, the proposed algorithm relies on strong assumptions, and uses the group membership for faults tolerance. Recently, a new failure detector Ring Paxos-based atomic broadcast algorithm (FD-RP) for asynchronous distributed systems have been proposed. It inherits some of Ring Paxos characteristics and uses failure detectors to tolerate failures instead of a membership service. The aim of this paper is to complete the work done in our previous work by evaluating the performance of the FD-RP protocol by simulation and compare it with the Ring Paxos protocol, results show that the proposed protocol performs better than the Ring Paxos protocol in some situation and is recommended in applications with low latencies.

Signature-free asynchronous Byzantine systems: from multivalued to binary consensus with $$t&lt;n/3$$ t &lt; n / 3 , $$O(n^2)$$ O ( n 2 ) messages, and constant time

This paper presents a new algorithm that reduces multivalued consensus to binary consensus in an asynchronous message-passing system made up of n processes where up to t may commit Byzantine failures. This algorithm has the following noteworthy properties: it assumes t < n/3 (and is consequently optimal from a resilience point of view), uses $$O(n^2)$$O(n2) messages, has a constant time complexity, and uses neither signatures nor additional computational power (such as random numbers, failure detectors, additional scheduling assumption, or additional synchrony assumption). The design of this reduction algorithm relies on two new all-to-all communication abstractions. The first one allows the non-faulty processes to reduce the number of proposed values to c, where c is a small constant. The second communication abstraction allows each non-faulty process to compute a set of (proposed) values satisfying the following property: if the set of a non-faulty process is a singleton containing value v, the set of any non-faulty process contains v. Both communication abstractions have an $$O(n^2)$$O(n2) message complexity and a constant time complexity. The reduction of multivalued Byzantine consensus to binary Byzantine consensus is then a simple sequential use of these communication abstractions. To the best of our knowledge, this is the first asynchronous message-passing algorithm that reduces multivalued consensus to binary consensus with $$O(n^2)$$O(n2) messages and constant time complexity (measured with the longest causal chain of messages) in the presence of up to t < n/3 Byzantine processes, and without using cryptography techniques. Moreover, this reduction algorithm uses a single instance of the underlying binary consensus, and tolerates message re-ordering by Byzantine processes.

Universal constructions that ensure disjoint-access parallelism and wait-freedom

A universal construction is a general mechanism for obtaining a concurrent implementation of an object from its sequential code. We show that there is no universal construction that is both disjoint-access parallel (guaranteeing the processes operating on different parts of an implemented object do not interfere with one another) and wait-free (guaranteeing progress for each nonfaulty process when accessing an object). In contrast, we present a universal construction which results in disjoint-access parallel, wait-free implementations of any object provided there is a bound on the number of data items accessed by each operation supported by the object.

Reliable Channels for Systems in the Presence of Byzantine Faults

Consider a distributed system that delivers each message from a process to its destination if the message transmission does not experience any faults and only delivers those sent by a non-faulty system process. Such a system is referred to as a reliable message passing system. A reliable message passing system requires a reliable channel, a communication channel between a pair of processes that always detects a fault in message transmission and each detected fault is an actual fault, to be implemented. In this paper, we first identify the necessary conditions to detect some restricted form of Byzantine Faults in a message passing system where n disjoint paths exist between each pair of endpoints. We consider Byzantine Faults (BF) whose effect is limited to the modification of a message metadata, omission faults, and message replay. We then present a protocol implementing a reliable channel in message passing systems in the presence of n — 1 Byzantine Faults using n disjoint paths between each pair of communication endpoints where the paths with faults are not known apriori. The proposed protocol detects Byzantine Faults, where each detected fault, an actual fault, authenticates message origins, identifies faulty paths and classifies faults in the presence of multiple messages sent by various system processes.

Intrusion-Tolerant Broadcast and Agreement Abstractions in the Presence of Byzantine Processes

A process commits a Byzantine failure when its behavior does not comply with the algorithm it is assumed to execute. Considering asynchronous message-passing systems, this paper presents distributed abstractions, and associated algorithms, that allow non-faulty processes to correctly cooperate, despite the uncertainty created by the net effect of asynchrony and Byzantine failures. These abstractions are broadcast abstractions (namely, no-duplicity broadcast, reliable broadcast, and validated broadcast), and agreement abstraction (namely, consensus). While no-duplicity broadcast and reliable broadcast are well-known one-to-all communication abstractions, validated broadcast is a new all-to-all communication abstraction designed to address agreement problems. After having introduced these abstractions, the paper presents an algorithm implementing validated broadcast on top of reliable broadcast. Then the paper presents two consensus algorithms, which are reductions of multivalued consensus to binary consensus. The first one is a generic algorithm, that can be instantiated with unreliable broadcast or no-duplicity broadcast, while the second is a consensus algorithm based on validated broadcast. Finally, a third algorithm is presented that solves the binary consensus problem. This algorithm is a randomized algorithm based on validated broadcast and a common coin. The presentation of all the abstractions and their algorithms is done incrementally.

Quantum clock synchronization with a single qudit.

Clock synchronization for nonfaulty processes in multiprocess networks is indispensable for a variety of technologies. A reliable system must be able to resynchronize the nonfaulty processes upon some components failing causing the distribution of incorrect or conflicting information in the network. The task of synchronizing such networks is related to Byzantine agreement (BA), which can classically be solved using recursive algorithms if and only if less than one-third of the processes are faulty. Here we introduce a nonrecursive quantum algorithm, based on a quantum solution of the detectable BA, which achieves clock synchronization in the presence of arbitrary many faulty processes by using only a single quantum system.

On Reducing Rollback Propagation Effect of Optimistic Message Logging for Group-Based Distributed Systems

This paper presents a new scalable method to considerably reduce the rollback propagation effect of the conventional optimistic message logging by utilizing positive features of reliable FIFO group communication links. To satisfy this goal, the proposed method forces group members to replicate different receive sequence numbers (RSNs), which they assigned for each identical message to their group respectively, into their volatile memories. As the degree of redundancy of RSNs increases, the possibility of local recovery for each crashed process may significantly be higher. Experimental results show that our method can outperform the previous one in terms of the rollback distance of non-faulty processes with a little normal time overhead.

An Optimal Inherently Stabilizing 2-Neighborhood Crash Resilient Protocol for Secure and Reliable Routing in Hypercube Networks

Many fundamental problems in the area of distributed systems such as security, reliable routing, network survivability and broadening available bandwidth can be addressed through the use of disjoint paths between communication endpoints. Therefore, distributed solutions to the disjoint paths problem are of crucial importance to these fundamental problems. Disjoint paths naturally exist in traditional networks; however, these networks provide no guarantees regarding the presence and the number of available disjoint paths. On the other hand, network topologies structured based on Caley graphs such as hypercube, star networks and their variations possess many desirable properties related to disjoint paths. Therefore, it is anticipated that backbones of future networks will be structured following some Caley graph topologies. In this paper, we present a simple novel stabilizing and inherently stabilizing algorithm to route messages over all node-disjoint paths of optimal length from one non-faulty process to another in at most n+1 rounds in an n-dimensional hypercube network in the presence of crash failures. The proposed algorithm can tolerate up to 2n-⌈log (n+1)⌉ process/link failures in the network and a maximum of ⌊(L-2)/3⌋ process/link failures on each disjoint path, where L is the number of processes on a disjoint path and the distance between any two failed processes/links is at least three. The proposed algorithm tolerates a large number of process and link failures, while delivering all n messages over optimal-length disjoint paths in the presence of maximum permissible process/link failures on each path. This is achieved by a simple uniform distributed algorithm using only local knowledge of failure locations.

Narrowing power vs efficiency in synchronous set agreement: Relationship, algorithms and lower bound

The k -set agreement problem is a generalization of the uniform consensus problem: each process proposes a value, and each non-faulty process has to decide a value such that a decided value is a proposed value, and at most k different values are decided. It has been shown that any algorithm that solves the k -set agreement problem in synchronous systems that can suffer up to t crash failures requires ⌊ t k ⌋ + 1 rounds in the worst case. It has also been shown that it is possible to design early deciding algorithms where no process decides and halts after min ( ⌊ f k ⌋ + 2 , ⌊ t k ⌋ + 1 ) rounds, where f is the number of actual crashes in a run ( 0 ≤ f ≤ t ). This paper explores a new direction to solve the k -set agreement problem in a synchronous system. It considers that the system is enriched with base objects (denoted has [ m , ℓ ] _SA objects) that allow solving the ℓ -set agreement problem in a set of m processes ( m < n ). The paper makes several contributions. It first proposes a synchronous k -set agreement algorithm that benefits from such underlying base objects. This algorithm requires O ( t ℓ m k ) rounds, more precisely, ⌊ t Δ ⌋ + 1 rounds, where Δ = m ⌊ k ℓ ⌋ + ( k mod ℓ ) . The paper then shows that this bound, that involves all the parameters that characterize both the problem ( k ) and its environment ( t , m and ℓ ), is a lower bound. The proof of this lower bound sheds additional light on the deep connection between synchronous efficiency and asynchronous computability. Finally, the paper extends its investigation to the early deciding case. It presents a k -set agreement algorithm that directs the processes to decide and stop by round min ( ⌊ f Δ ⌋ + 2 , ⌊ t Δ ⌋ + 1 ) . These bounds generalize the bounds previously established for solving the k -set agreement problem in pure synchronous systems.

Conditions for Set Agreement with an Application to Synchronous Systems

The k-set agreement problem is a generalization of the consensus problem: considering a system made up of n processes where each process proposes a value, each non-faulty process has to decide a value such that a decided value is a proposed value, and no more than k different values are decided. While this problem cannot be solved in an asynchronous system prone to t process crashes when t ≥ k, it can always be solved in a synchronous system; $$ \left\lfloor {\frac{t}{k}} \right\rfloor + 1 $$ is then a lower bound on the number of rounds (consecutive communication steps) for the non-faulty processes to decide. The condition-based approach has been introduced in the consensus context. Its aim was to both circumvent the consensus impossibility in asynchronous systems, and allow for more efficient consensus algorithms in synchronous systems. This paper addresses the condition-based approach in the context of the k-set agreement problem. It has two main contributions. The first is the definition of a framework that allows defining conditions suited to the k-set agreement problem and the second is a generic synchronous k-set agreement algorithm based on conditions.

Strongly Terminating Early-Stopping k-Set Agreement in Synchronous Systems with General Omission Failures

The k-set agreement problem is a generalization of the consensus problem: considering a system made up of n processes where each process proposes a value, each non-faulty process has to decide a value such that a decided value is a proposed value, and no more than k different values are decided. It has recently be shown that, in the crash failure model, $\min(\lfloor \frac{f}{k}\rfloor+2,\lfloor \frac{t}{k}\rfloor +1)$is a lower bound on the number of rounds for the non-faulty processes to decide (where t is an upper bound on the number of process crashes, and f, 0≤f≤t, the actual number of crashes). This paper considers the k-set agreement problem in synchronous systems where up to t<n/2 processes can experience general omission failures (i.e., a process can crash or omit sending or receiving messages). It first introduces a new property, called strong termination. This property is on the processes that decide. It is satisfied if, not only every non-faulty process, but any process that neither crashes nor commits receive omission failure decides. The paper then presents a k-set agreement protocol that enjoys the following features. First, it is strongly terminating (to our knowledge, it is the first agreement protocol to satisfy this property, whatever the failure model considered). Then, it is early deciding and stopping in the sense that a process that either is non-faulty or commits only send omission failures decides and halts by round $\min(\lfloor \frac{f}{k}\rfloor+2,\lfloor \frac{t}{k}\rfloor +1)$. To our knowledge, this is the first early deciding k-set agreement protocol for the general omission failure model. Moreover, the protocol provides also the following additional early stopping property: a process that commits receive omission failures (and does not crash) executes at most $\min(\lceil \frac{f}{k}\rceil +2,\lfloor \frac{t}{k}\rfloor +1)$rounds. It is worth noticing that the protocol allows each property (strong termination vs early deciding/stopping vs early stopping) not to be obtained at the detriment of the two others. The combination of the fact that $\min(\lfloor \frac{f}{k}\rfloor+2,\lfloor \frac{t}{k}\rfloor +1)$is a lower bound on the number of rounds in the crash failure model, and the very existence of the proposed protocol has two noteworthy consequences. First, it shows that, although the general omission failure model is more severe than the crash failure model, both models have the same lower bound for the non-faulty processes to decide. Second, it shows that, in the general omission failure model, this bound applies also the processes that do not crash and commit only send omission failures.

Active and passive techniques for group size estimation in large-scale and dynamic distributed systems

This paper presents two solutions to a distributed statistic collection problem, called Group Size Estimation. These algorithms are intended for large-scale and dynamic distributed systems such as Grids, peer-to-peer overlays, etc. Each algorithm estimates (both in a one-shot and continuous manner) the number of non-faulty processes present in the global group. The first active scheme samples receipt times of gossip messages, while the second passive scheme calculates the density of process identifiers when hashed to a real interval. Our analysis, trace-driven simulation and deployment on a 33-node Linux cluster study and compare the latencies, scalability, and accuracy of these schemes.

The Time-Complexity of Local Decision in Distributed Agreement

Agreement is at the heart of distributed computing. In its simple form, it requires a set of processes to decide on a common value out of the values they propose. The time-complexity of distributed agreement problems is generally measured in terms of the number of communication rounds needed to achieve a global decision, i.e., for all nonfaulty (correct) processes to reach a decision. This paper studies the time-complexity of local decisions in agreement problems, which we define as the number of communication rounds needed for at least one correct process to decide. We explore bounds for early local decision that depend on the number f of actual failures (that occur in a given run of an algorithm), out of the maximum number t of failures tolerated (by the algorithm). We first consider the synchronous message-passing model where we give tight local decision bounds for three variants of agreement: consensus, uniform consensus, and (nonblocking) atomic commit. We use these results to (1) show that, for consensus, local decision bounds are not compatible with global decision bounds (roughly speaking, they cannot be reached by the same algorithm), and (2) draw the first sharp line between the time-complexity of uniform consensus and atomic commit. Then we consider the eventually synchronous model, where we give tight local decision bounds for synchronous runs of uniform consensus. (In this model, consensus and uniform consensus are similar, atomic commit is impossible, and one cannot bound the number of rounds to reach a decision in nonsynchronous runs of consensus algorithms.) We prove a counterintuitive result that the early local decision bound is the same as the early global decision bound. We also give a matching early deciding consensus algorithm that is significantly better than previous eventually synchronous consensus algorithms.

A weakly-adaptive condition-based consensus algorithm in asynchronous distributed systems

The consensus problem is one of the most fundamental and important problems for designing fault-tolerant distributed systems. In the consensus problem, each process proposes a value, and all non-faulty processes have to agree on a common value that is proposed by a process. Despite of many applications (e.g., atomic broadcast [2, 6], shared object [1, 7], weak atomic commitment [5]), it is known that the consensus problem has no deterministic solution in asynchronous systems subject to only a single crash fault [4]. Thus, to circumvent this impossibility, several approaches, such as partial synchrony [3] and unreliable failure detectors [2], have been proposed. As one of such approaches, the condition-based approach is recently introduced [9]. This approach introduces restriction (called condition) on inputs so that the generally-unsolvable problem can be solved for the restricted set of inputs. In the case of the consensus problem, a condition is defined as a subset of all possible input vectors whose entries correspond to the proposal of each process. The first result of the condition-based approach clarifies the condition for which the uniform consensus can be solved in asynchronous systems subject to crash faults [9]. This result proposed a class of conditions, called t-legal conditions, and proved that the t-legal conditions form the class of necessary and sufficient conditions to solve the consensus in asynchronous systems where at most t process can crash. In general, for smaller number of t, the t-legal conditions become weaker restrictions and can contain more input vectors. An example of such t-legal conditions is the condition Cmax t , proposed in [9]. The condition Cmax t is the set of input vectors where the maximum value in each vector appears at t entries or more in the vector. From the definition, the condition Cmax t is a subset of the condition Cmax t−1 . In this sense, the sizes of sufficient conditions are strongly related to the number of crash faults that the system suffers. That is, the consensus algorithm designed for tolerating a larger number of faults can solve the consensus problem only for a smaller set of input vectors. However, in the system with t crash faults at a maximum, it is not often that t processes actually crashes. In other words, the actual number of crash faults is relatively smaller than the maximum. This observation brings one question as follows: Can we construct the condition-based algorithm that solves the consensus problem for more relaxed conditions than t-legal one when the actual number of crash faults is smaller than t ? In this paper, we investigate this problem by applying the adaptive condition-based approach. In the adaptive condition-based approach, a restriction to input vectors is not represented by a single subset of inputs, but represented by a hierarchical sequence of conditions called a condition sequence. Adaptive condition-based algorithms are instantiated by a condition sequence, and guarantee some property according to the position of input vector in the hierarchy of the given condition sequence (i.e., the execution for the input vector with higher position achieves better property). The first result for the adaptive condition-based approach considers time complexity in the synchronous

Lower bounds for asynchronous consensus

Impossibility results and best-case lower bounds are proved for the number of message delays and the number of processes required to reach agreement in an asynchronous consensus algorithm that tolerates non-Byzantine failures. General algorithms exist that achieve these lower bounds in the normal case, when the response time of non-faulty processes and the transmission delay of messages they send to one another are bounded. Our theorems allow algorithms to do better in certain exceptional cases, and such algorithms are presented. Two of these exceptional algorithms may be of practical interest.