Results 1  10
of
20
Tight bounds for asynchronous randomized consensus
 In STOC ’07: Proceedings of the thirtyninth annual ACM symposium on Theory of computing
, 2007
"... A distributed consensus algorithm allows n processes to reach a common decision value starting from individual inputs. Waitfree consensus, in which a process always terminates within a finite number of its own steps, is impossible in an asynchronous sharedmemory system. However, consensus becomes ..."
Abstract

Cited by 21 (6 self)
 Add to MetaCart
A distributed consensus algorithm allows n processes to reach a common decision value starting from individual inputs. Waitfree consensus, in which a process always terminates within a finite number of its own steps, is impossible in an asynchronous sharedmemory system. However, consensus becomes solvable using randomization when a process only has to terminate with probability 1. Randomized consensus algorithms are typically evaluated by their total step complexity, which is the expected total number of steps taken by all processes. This work proves that the total step complexity of randomized consensus is Θ(n 2) in an asynchronous shared memory system using multiwriter multireader registers. The bound is achieved by improving both the lower and the upper bounds for this problem. In addition to improving upon the best previously known result by a factor of log 2 n, the lower bound features a greatly streamlined proof. Both goals are achieved through restricting attention to a set of layered executions and using an isoperimetric inequality for analyzing their behavior. The matching algorithm decreases the expected total step complexity by a log n factor, by leveraging the multiwriting capability of the shared registers. Its correctness proof is facilitated by viewing each execution of the algorithm as a stochastic process and applying Kolmogorov’s inequality.
Towards optimal and efficient perfectly secure message transmission
 in 4th Theory of Cryptography Conf. (TCC), ser. LNCS LNCS 4392
, 2007
"... ..."
(Show Context)
Robust random number generation for peertopeer systems
, 2007
"... We consider the problem of designing an efficient and robust distributed random number generator for peertopeer systems that is easy to implement and works even if all communication channels are public. A robust random number generator is crucial for avoiding adversarial joinleave attacks on peer ..."
Abstract

Cited by 12 (2 self)
 Add to MetaCart
(Show Context)
We consider the problem of designing an efficient and robust distributed random number generator for peertopeer systems that is easy to implement and works even if all communication channels are public. A robust random number generator is crucial for avoiding adversarial joinleave attacks on peertopeer overlay networks. We show that our new generator together with a lightweight rule recently proposed in [4] for keeping peers welldistributed can keep various structured overlay networks in a robust state even under a constant fraction of adversarial peers.
Transmissionline Theory
 30 [7] , Transmissionline Theory
, 1955
"... We describe an algorithm for Byzantine agreement that is scalable in the sense that each processor sends only Õ(√n) bits, where n is the total number of processors. Our algorithm succeeds with high probability against an adaptive adversary, which can take over processors at any time during the proto ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
(Show Context)
We describe an algorithm for Byzantine agreement that is scalable in the sense that each processor sends only Õ(√n) bits, where n is the total number of processors. Our algorithm succeeds with high probability against an adaptive adversary, which can take over processors at any time during the protocol, up to the point of taking over arbitrarily close to a 1/3 fraction. We assume synchronous communication but a rushing adversary. Moreover, our algorithm works in the presence of flooding: processors controlled by the adversary can send out any number of messages. We assume the existence of private channels between all pairs of processors but make no other cryptographic assumptions. Finally, our algorithm has latency that is polylogarithmic in n. To the best of our knowledge, ours is the first algorithm to solve Byzantine agreement against an adaptive adversary, while requiring o(n 2) total bits of communication.
Fast asynchronous Byzantine agreement and leader election with full information
 In SODA’08
, 2008
"... We resolve two longstanding open problems in distributed computation by showing that both Byzantine agreement and Leader Election can be solved in subexponential time in the asynchronous full information model. Surprisingly, our protocols for both problems run in only polylogarithmic time. We thus ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
(Show Context)
We resolve two longstanding open problems in distributed computation by showing that both Byzantine agreement and Leader Election can be solved in subexponential time in the asynchronous full information model. Surprisingly, our protocols for both problems run in only polylogarithmic time. We thus achieve a better than exponential speedup over previous results for asynchronous Byzantine agreement. In addition, to the best of our knowledge, ours is the first protocol for asynchronous fullinformation leader election. Our protocols work in the full information model with a nonadaptive adversary: the adversary is assumed to control up to a constant fraction of the processors, have unlimited computational power as well as access to all communications, but no access to processors ’ private random bits. The adversary is nonadaptive only in the sense that the corrupted processors must be chosen at the outset. Our protocols run in time that is polylogarithmic in the number of processors, n, and tolerate t < n 6+ɛ faulty processors for any positive constant ɛ. Our protocols are Monte Carlo, succeeding with probability 1 − o(1) for Byzantine agreement, and constant probability for leader election.
From almost everywhere to everywhere: Byzantine agreement with Õ(n 3/2) bits
"... Abstract. We address the problem of designing distributed algorithms for large scale networks that are robust to Byzantine faults. We consider a message passing, full information synchronous model: the adversary is malicious, controls a constant fraction of processors, and can view all messages in a ..."
Abstract

Cited by 8 (5 self)
 Add to MetaCart
Abstract. We address the problem of designing distributed algorithms for large scale networks that are robust to Byzantine faults. We consider a message passing, full information synchronous model: the adversary is malicious, controls a constant fraction of processors, and can view all messages in a round before sending out its own messages for that round. Furthermore, each corrupt processor may send an unlimited number of messages. The only constraint on the adversary is that it must choose its corrupt processors at the start, without knowledge of the processors’ private random bits. To the authors ’ best knowledge, there have been no protocols for such a model that compute Byzantine agreement without alltoall communication, even if private channels or cryptography are assumed, unless corrupt processors ’ messages are limited. In this paper, we give a polylogarithmic time algorithm to agree on a small representative committee of processors using only Õ(n3/2) total bits which succeeds with high probability. This representative set can
Stabilizing consensus with the power of two choices
 In SPAA
, 2011
"... In the standard consensus problem there are n processes with possibly different input values and the goal is to eventually reach a point at which all processes commit to exactly one of these values. We are studying a slight variant of the consensus problem called the stabilizing consensus problem [2 ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
In the standard consensus problem there are n processes with possibly different input values and the goal is to eventually reach a point at which all processes commit to exactly one of these values. We are studying a slight variant of the consensus problem called the stabilizing consensus problem [2]. In this problem, we do not require that each process commits to a final value at some point, but that eventually they arrive at a common, stable value without necessarily being aware of that. This should work irrespective of the states in which the processes are starting. Our main result is a simple randomized algorithm called median rule that, with high probability, just needs O(log m log log n + log n) time and work per process to arrive at an almost stable consensus for any set of m legal values as long as an adversary can corrupt the states of at most √ n processes at any time. Without adversarial involvement, just O(log n) time and work is needed for a stable consensus, with high probability. As a byproduct, we obtain a simple distributed algorithm for approximating the median of n numbers in time O(log m log log n + log n) under adversarial presence.
Locally scalable randomized consensus for synchronous crash failures
 in Proceedings of the 21st ACM Symposium on Parallelism in Algorithms and Architectures (SPAA
, 2009
"... We consider bit communication complexity of binary consensus in synchronous message passing systems with processes prone to crashes. A distributed algorithm is locally scalable when each process contributes to the complexity measure an amount that is polylogarithmic in the size n of the system, and ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
(Show Context)
We consider bit communication complexity of binary consensus in synchronous message passing systems with processes prone to crashes. A distributed algorithm is locally scalable when each process contributes to the complexity measure an amount that is polylogarithmic in the size n of the system, and it is globally scalable when the average contribution per process to the complexity measure is such. We show that consensus can be solved by a randomized algorithm that is locally scalable with respect to both time and bit communication complexities against oblivious adversaries. If a bound t on the number of crashes is a constant fraction of the number n of processes then our randomized consensus solution terminates in the expected O(log n) time while the expected number of bits that each process sends and receives is O(log n). Our solution uses overlay networks with topologies that are explicitly defined and have suitable connectivity and robustness properties related to graph expansion. To compare our results to deterministic consensus solutions, it is known [20] that consensus cannot be solved deterministically by an algorithm that is locally scalable with respect to message complexity and that deterministic solutions globally scalable with respect to bit communication complexity exist for any bound t < n on the number of crashes. We prove a lower bound relating the number of nonfaulty processes needed to obtain a specific message complexity of consensus of a randomized algorithm run against oblivious adversaries.
Load balanced Scalable Byzantine Agreement through Quorum Building, with Full Information
"... Abstract. We address the problem of designing distributed algorithms for large scale networks that are robust to Byzantine faults. We consider a message passing, full information model: the adversary is malicious, controls a constant fraction of processors, and can view all messages in a round befor ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. We address the problem of designing distributed algorithms for large scale networks that are robust to Byzantine faults. We consider a message passing, full information model: the adversary is malicious, controls a constant fraction of processors, and can view all messages in a round before sending out its own messages for that round. Furthermore, each bad processor may send an unlimited number of messages. The only constraint on the adversary is that it must choose its corrupt processors at the start, without knowledge of the processors ’ private random bits. A good quorum is a set of O(log n) processors, which contains a majority of good processors. In this paper, we give a synchronous algorithm which uses polylogarithmic time and Õ( √ n) bits of communication per processor to bring all processors to agreement on a collection of n good quorums, solving Byzantine agreement as well. The collection is balanced in that no processor is in more than O(log n) quorums. This yields the first solution to Byzantine agreement which is both scalable and loadbalanced
The Contest Between Simplicity and Efficiency in Asynchronous Byzantine Agreement
"... In the wake of the decisive impossibility result of Fischer, Lynch, and Paterson for deterministic consensus protocols in the aynchronous model with just one failure, BenOr and Bracha demonstrated that the problem could be solved with randomness, even for Byzantine failures. Both protocols are natu ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
In the wake of the decisive impossibility result of Fischer, Lynch, and Paterson for deterministic consensus protocols in the aynchronous model with just one failure, BenOr and Bracha demonstrated that the problem could be solved with randomness, even for Byzantine failures. Both protocols are natural and intuitive to verify, and Bracha’s achieves optimal resilience. However, the expected running time of these protocols is exponential in general. Recently, Kapron, Kempe, King, Saia, and Sanwalani presented the first efficient Byzantine agreement algorithm in the asynchronous, full information model, running in polylogarithmic time. Their algorithm is Monte Carlo and drastically departs from the simple structure of BenOr and Bracha’s Las Vegas algorithms. In this paper, we begin an investigation of the question: to what extent is this departure necessary? Might there be a much simpler and intuitive Las Vegas protocol that runs in expected polynomial time? We will show that the exponential running time of BenOr and Bracha’s algorithms is no mere accident of their specific details, but rather an unavoidable consequence of their general symmetry and round structure. We define a natural class of “fully symmetric round protocols ” for solving Byzantine agreement in an asynchronous setting and show that any such protocol can be forced to run in expected exponential time by an adversary in the full information model. We assume the adversary controls t Byzantine processors for t = cn, where c is an arbitrary positive constant < 1 3. We view our result as a step toward identifying the level of complexity required for a polynomialtime algorithm in this setting, and also as a guide in the search for new efficient algorithms. 1