The beeping model is an extremely restrictive broadcast communication model that relies only on carrier sensing. In this model, we solve the deterministic leader election problem with an asymptotically optimal round complexity. Using this result, we obtain an asymptotically optimal randomized leader election algorithm for anonymous networks, as well as improved algorithms for symmetry-breaking and communication primitives. The techniques that we introduce give a new insight as to how local constraints on the exchangeable messages can result in efficient algorithms, when dealing with the beeping model.
{"title":"Brief Announcement: Beeping a Time-Optimal Leader Election","authors":"Fabien Dufoulon, J. Burman, J. Beauquier","doi":"10.1145/3212734.3212779","DOIUrl":"https://doi.org/10.1145/3212734.3212779","url":null,"abstract":"The beeping model is an extremely restrictive broadcast communication model that relies only on carrier sensing. In this model, we solve the deterministic leader election problem with an asymptotically optimal round complexity. Using this result, we obtain an asymptotically optimal randomized leader election algorithm for anonymous networks, as well as improved algorithms for symmetry-breaking and communication primitives. The techniques that we introduce give a new insight as to how local constraints on the exchangeable messages can result in efficient algorithms, when dealing with the beeping model.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116566316","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Y. Afek, I. Keidar, B. Patt-Shamir, S. Rajsbaum, U. Schmid, G. Taubenfeld
The Dijkstra Prize Committee has decided to grant the 2018 Edsger W. Dijkstra Prize in Distributed Computing to Bowen Alpern and Fred B. Schneider for their paper: B. Alpern, F.B. Schneider: Defining liveness, published in Information Processing Letters 21(4), October 1985, pages 181-185. The Prize is awarded for outstanding papers on the principles of distributed computing, whose significance and impact on the theory and/or practice of distributed computing have been evident for at least a decade. Concurrent and distributed algorithms today are characterized in terms of safety ("bad things" don't happen) and liveness ("good things" do happen). This seminal paper is what gave semantic legitimacy to that decomposition. Safety and liveness for concurrent programs had been suggested earlier by Lamport, but liveness was only formally defined for the first time in the winning paper, where it was accompanied by a compelling justification - that every (what we today call a) "trace property" is the conjunction of a safety and a liveness property. The liveness definition and accompanying decomposition theorem thus establish that safety and liveness are not only intuitively appealing but are also formally orthogonal. As a consequence, they constitute the basic building blocks of all (trace) properties and thus underly a substantial number of papers that appeared at PODC and DISC so far. Moreover, subsequent work has shown that invariants suffice for verifying safety properties and that variant functions on well-founded domains are suitable for verifying liveness properties. So, of the possible ways to decompose properties, the decomposition into safety and liveness provides the added value of also suggesting approaches for verifying each property. Further evidence of the importance of this work is that its topological characterizations and decomposition proof have since been scaled-up to safety and liveness hyperproperties, which express confidentiality and other important correctness concerns that trace properties cannot.
Dijkstra奖委员会决定将2018年Edsger W. Dijkstra分布式计算奖授予Bowen Alpern和Fred B. Schneider，以表彰他们的论文:B. Alpern, F.B. Schneider:定义活度，发表在信息处理快报21(4)，1985年10月，第181-185页。该奖项颁发给关于分布式计算原理的杰出论文，这些论文对分布式计算的理论和/或实践的重要性和影响至少在十年内是显而易见的。当今并发和分布式算法的特点是安全性(“坏事”不会发生)和活动性(“好事”会发生)。这篇开创性的论文为这种分解提供了语义上的合法性。Lamport早前就提出了并发程序的安全性和活动性，但活动性只是在获奖论文中才第一次被正式定义，并伴随着一个令人信服的理由——每一个(我们今天称之为a)“迹性”是安全和活性的结合。活度定义和相应的分解定理由此确立了安全性和活度不仅在直观上吸引人，而且在形式上是正交的。因此，它们构成了所有(跟踪)属性的基本构建块，因此是迄今为止在PODC和DISC上发表的大量论文的基础。此外，随后的工作表明，不变量足以验证安全性质，并且在良好建立的域上的变函数适合验证活性性质。因此，在分解属性的可能方法中，将属性分解为安全性和活动性提供了附加价值，也提供了验证每个属性的方法建议。这项工作的重要性的进一步证据是，它的拓扑表征和分解证明已经扩展到安全性和活跃性超性质，这表达了机密性和其他重要的正确性关注，而跟踪性质不能。
{"title":"2018 Edsger W. Dijkstra Prize in Distributed Computing","authors":"Y. Afek, I. Keidar, B. Patt-Shamir, S. Rajsbaum, U. Schmid, G. Taubenfeld","doi":"10.1145/3212734.3232540","DOIUrl":"https://doi.org/10.1145/3212734.3232540","url":null,"abstract":"The Dijkstra Prize Committee has decided to grant the 2018 Edsger W. Dijkstra Prize in Distributed Computing to Bowen Alpern and Fred B. Schneider for their paper: B. Alpern, F.B. Schneider: Defining liveness, published in Information Processing Letters 21(4), October 1985, pages 181-185. The Prize is awarded for outstanding papers on the principles of distributed computing, whose significance and impact on the theory and/or practice of distributed computing have been evident for at least a decade. Concurrent and distributed algorithms today are characterized in terms of safety (\"bad things\" don't happen) and liveness (\"good things\" do happen). This seminal paper is what gave semantic legitimacy to that decomposition. Safety and liveness for concurrent programs had been suggested earlier by Lamport, but liveness was only formally defined for the first time in the winning paper, where it was accompanied by a compelling justification - that every (what we today call a) \"trace property\" is the conjunction of a safety and a liveness property. The liveness definition and accompanying decomposition theorem thus establish that safety and liveness are not only intuitively appealing but are also formally orthogonal. As a consequence, they constitute the basic building blocks of all (trace) properties and thus underly a substantial number of papers that appeared at PODC and DISC so far. Moreover, subsequent work has shown that invariants suffice for verifying safety properties and that variant functions on well-founded domains are suitable for verifying liveness properties. So, of the possible ways to decompose properties, the decomposition into safety and liveness provides the added value of also suggesting approaches for verifying each property. Further evidence of the importance of this work is that its topological characterizations and decomposition proof have since been scaled-up to safety and liveness hyperproperties, which express confidentiality and other important correctness concerns that trace properties cannot.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127296485","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Recoverable mutual exclusion (RME) is a variation on the classic mutual exclusion (ME) problem that allows processes to crash and recover. The time complexity of RME algorithms is quantified in the same way as for ME, namely by counting remote memory references -- expensive memory operations that traverse the processor-to-memory interconnect. Prior work has established that the RMR complexity of the RME problem for n processes is Θ(log n) for the class of algorithms that use read/write registers and single-word comparison primitives such as Compare-And-Swap (Golab and Ramaraju 2016), O(log n / log log n) for the class of algorithms that use read/write registers and additional single-word read-modify-primitives such as Fetch-And-Store (Golab and Hendler 2017), and Θ(1) for the class of algorithms that use read/write registers and specialized double-word read-modify-write primitives (Golab and Hendler 2017). These complexity bounds hold in a model of computation where processes may fail independently, and where a process that fails while accessing the mutex is required to recover eventually. This body of work leaves open two important questions: (i) what is the tight bound on the RMR complexity of RME for the class of algorithms that use read/write registers and commonly supported single-word read-modify-primitives; and (ii) how is the RMR complexity of RME affected by variations in the failure model? This paper answers both questions partially by showing that RME can be solved using O(1) RMRs per passage in the worst case in a model where failures are system-wide (i.e., all processes crash simultaneously), and processes receive additional information from the environment regarding the occurrence of the failure. The upper bound algorithm we present relies crucially on a novel RMR-efficient barrier that processes use to synchronize recovery actions after each failure. The barrier uses read/write registers and single-word Compare-And-Swap only. Additionally, we present a transformation that can add properties such as critical section re-entry and a strong notion of starvation freedom to any RME algorithm while preserving its asymptotic RMR complexity.
{"title":"Recoverable Mutual Exclusion Under System-Wide Failures","authors":"W. Golab, Danny Hendler","doi":"10.1145/3212734.3212755","DOIUrl":"https://doi.org/10.1145/3212734.3212755","url":null,"abstract":"Recoverable mutual exclusion (RME) is a variation on the classic mutual exclusion (ME) problem that allows processes to crash and recover. The time complexity of RME algorithms is quantified in the same way as for ME, namely by counting remote memory references -- expensive memory operations that traverse the processor-to-memory interconnect. Prior work has established that the RMR complexity of the RME problem for n processes is Θ(log n) for the class of algorithms that use read/write registers and single-word comparison primitives such as Compare-And-Swap (Golab and Ramaraju 2016), O(log n / log log n) for the class of algorithms that use read/write registers and additional single-word read-modify-primitives such as Fetch-And-Store (Golab and Hendler 2017), and Θ(1) for the class of algorithms that use read/write registers and specialized double-word read-modify-write primitives (Golab and Hendler 2017). These complexity bounds hold in a model of computation where processes may fail independently, and where a process that fails while accessing the mutex is required to recover eventually. This body of work leaves open two important questions: (i) what is the tight bound on the RMR complexity of RME for the class of algorithms that use read/write registers and commonly supported single-word read-modify-primitives; and (ii) how is the RMR complexity of RME affected by variations in the failure model? This paper answers both questions partially by showing that RME can be solved using O(1) RMRs per passage in the worst case in a model where failures are system-wide (i.e., all processes crash simultaneously), and processes receive additional information from the environment regarding the occurrence of the failure. The upper bound algorithm we present relies crucially on a novel RMR-efficient barrier that processes use to synchronize recovery actions after each failure. The barrier uses read/write registers and single-word Compare-And-Swap only. Additionally, we present a transformation that can add properties such as critical section re-entry and a strong notion of starvation freedom to any RME algorithm while preserving its asymptotic RMR complexity.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115880445","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Since the early days of the shared memory model for distributed computing, researchers have sought a simple and precise characterization of an object's ability to implement other objects in a wait-free manner. The first candidate for such a characterization was the object's consensus number [14]. But a characterization based on consensus numbers is not precise: there are pairs of objects with the same consensus number that are not equivalent (i.e., one cannot be implemented by instances of the other and registers). This was first shown for non-deterministic objects [24] and much later for deterministic objects as well [2]. A more recent candidate for such a characterization is the object's set agreement power [10]. In PODC 2017, it was shown that this characterization is also not precise: there are two objects with the same set agreement power that are not equivalent [6]. One of these two objects, however, is non-deterministic. So this left open one remaining final question: when restricted to deterministic objects, does the set agreement power of an object fully characterize its ability to implement other objects? More precisely: are any two deterministic objects with the same set agreement power equivalent? In this paper, we show the answer is again no. In fact, we prove the following stronger result: every level n ≥ 2 of Herlihy's consensus hierarchy [14] contains two deterministic objects with the same set agreement power that are not equivalent (i.e., one of these two objects cannot be implemented using instances of the other and registers). We also leverage the above result and a result in [12] to show that in any system with n > 2 processes, there is a deterministic wait-free object that is not equivalent to any wait-free task.
{"title":"On the Classification of Deterministic Objects via Set Agreement Power","authors":"D. Y. C. Chan, V. Hadzilacos, S. Toueg","doi":"10.1145/3212734.3212775","DOIUrl":"https://doi.org/10.1145/3212734.3212775","url":null,"abstract":"Since the early days of the shared memory model for distributed computing, researchers have sought a simple and precise characterization of an object's ability to implement other objects in a wait-free manner. The first candidate for such a characterization was the object's consensus number [14]. But a characterization based on consensus numbers is not precise: there are pairs of objects with the same consensus number that are not equivalent (i.e., one cannot be implemented by instances of the other and registers). This was first shown for non-deterministic objects [24] and much later for deterministic objects as well [2]. A more recent candidate for such a characterization is the object's set agreement power [10]. In PODC 2017, it was shown that this characterization is also not precise: there are two objects with the same set agreement power that are not equivalent [6]. One of these two objects, however, is non-deterministic. So this left open one remaining final question: when restricted to deterministic objects, does the set agreement power of an object fully characterize its ability to implement other objects? More precisely: are any two deterministic objects with the same set agreement power equivalent? In this paper, we show the answer is again no. In fact, we prove the following stronger result: every level n ≥ 2 of Herlihy's consensus hierarchy [14] contains two deterministic objects with the same set agreement power that are not equivalent (i.e., one of these two objects cannot be implemented using instances of the other and registers). We also leverage the above result and a result in [12] to show that in any system with n > 2 processes, there is a deterministic wait-free object that is not equivalent to any wait-free task.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116645362","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
In this paper, we consider two fundamental problems in secure distributed computing, namely Asynchronous Byzantine Agreement (ABA) and Asynchronous Secure Multi-party Computation (ASMPC). Our focus is on the honest majority setting, involving a set of n mutually distrusting parties, t of which can be under the control of a computationally bounded Byzantine adversary Adv, where t < n/2. It is well known that in the cryptographic setting where the parties have access to a public-key infrastructure (PKI) set-up and are connected by pair-wise channels, both ABA and ASMPC requires t n/3. However, Clement et al. (PODC 2012) and Backes et al. (PODC 2014) showed that it is possible to design computationally-secure ABA and ASMPC protocols respectively, even with t < n/2, provided the parties are available with a transferrable non-equivocation mechanism. Non-equivocation is a message authentication mechanism, which prevents a corrupt sender from sending conflicting messages to different parties. The transferability of the mechanism enables a receiver to verifiably transfer any authenticated statement to other parties, on behalf of the sender. In this paper, we revisit the work of Clement et al. and Backes et al. and show the following: 1. If n łeq 3t, then it is impossible to achieve the traditional notion of validity by any ABA protocol, which demands that if the inputs of all honest parties are same, say x, then all honest parties should output x at the end of the protocol. Moreover, this holds even if the parties are equipped with a transferrable non-equivocation mechanism. 2. The input phase of the ASMPC protocol of Backes et al (and hence the overall ASMPC protocol) may never terminate for the honest parties. The input phase runs an asynchronous primitive called Agreement on a Common Subset (ACS), which allows the honest parties to agree upon a common subset of n - t parties who provide their inputs for the computation. The ACS primitive runs n parallel instances of an ABA protocol, where the ith instance is to decide whether the ith party has provided its input. We show that since the underlying ABA instances does not satisfy the validity condition, the ACS primitive may never terminate for the honest parties; this results in the honest parties waiting indefinitely to identify the set of n - t input providers.
本文研究了安全分布式计算中的两个基本问题，即异步拜占庭协议(ABA)和异步安全多方计算(ASMPC)。我们的重点是诚实多数设置，涉及一组n个互不信任的各方，其中t可以在计算有限的拜占庭对手Adv的控制下，其中t < n/2。众所周知，在加密设置中，各方可以访问公钥基础设施(PKI)设置并通过成对通道连接，ABA和ASMPC都需要t n/3。然而，Clement等人(PODC 2012)和Backes等人(PODC 2014)表明，即使在t < n/2的情况下，只要各方具有可转移的非模棱两可机制，也可以分别设计计算安全的ABA和ASMPC协议。非模棱两可是一种消息身份验证机制，它可以防止损坏的发送方向不同方发送冲突的消息。该机制的可转移性使接收方能够代表发送方将任何经过验证的声明以可验证的方式传输给其他方。在本文中，我们回顾了Clement et al.和Backes et al.的工作，并展示了以下内容:如果n łeq 3t，则不可能通过任何ABA协议实现传统的有效性概念，这要求如果所有诚实方的输入相同，例如x，则所有诚实方应在协议结束时输出x。此外，即使各方配备了可转让的不含糊其词机制，这一点也成立。2. Backes等人的ASMPC协议的输入阶段(因此整个ASMPC协议)可能永远不会为诚实方终止。输入阶段运行一个称为公共子集协议(ACS)的异步原语，它允许诚实的各方就n - t个为计算提供输入的各方的公共子集达成一致。ACS原语运行n个ABA协议的并行实例，其中第i个实例决定第i方是否提供了其输入。我们证明，由于底层的ABA实例不满足有效性条件，对于诚实的双方，ACS原语可能永远不会终止;这导致诚实的各方无限期地等待来识别n个输入提供者的集合。
{"title":"Brief Announcement: Asynchronous Secure Distributed Computing with Transferrable Non-equivocation Revisited","authors":"Rishabh Bhadauria, Ashish Choudhury","doi":"10.1145/3212734.3212777","DOIUrl":"https://doi.org/10.1145/3212734.3212777","url":null,"abstract":"In this paper, we consider two fundamental problems in secure distributed computing, namely Asynchronous Byzantine Agreement (ABA) and Asynchronous Secure Multi-party Computation (ASMPC). Our focus is on the honest majority setting, involving a set of n mutually distrusting parties, t of which can be under the control of a computationally bounded Byzantine adversary Adv, where t < n/2. It is well known that in the cryptographic setting where the parties have access to a public-key infrastructure (PKI) set-up and are connected by pair-wise channels, both ABA and ASMPC requires t n/3. However, Clement et al. (PODC 2012) and Backes et al. (PODC 2014) showed that it is possible to design computationally-secure ABA and ASMPC protocols respectively, even with t < n/2, provided the parties are available with a transferrable non-equivocation mechanism. Non-equivocation is a message authentication mechanism, which prevents a corrupt sender from sending conflicting messages to different parties. The transferability of the mechanism enables a receiver to verifiably transfer any authenticated statement to other parties, on behalf of the sender. In this paper, we revisit the work of Clement et al. and Backes et al. and show the following: 1. If n łeq 3t, then it is impossible to achieve the traditional notion of validity by any ABA protocol, which demands that if the inputs of all honest parties are same, say x, then all honest parties should output x at the end of the protocol. Moreover, this holds even if the parties are equipped with a transferrable non-equivocation mechanism. 2. The input phase of the ASMPC protocol of Backes et al (and hence the overall ASMPC protocol) may never terminate for the honest parties. The input phase runs an asynchronous primitive called Agreement on a Common Subset (ACS), which allows the honest parties to agree upon a common subset of n - t parties who provide their inputs for the computation. The ACS primitive runs n parallel instances of an ABA protocol, where the ith instance is to decide whether the ith party has provided its input. We show that since the underlying ABA instances does not satisfy the validity condition, the ACS primitive may never terminate for the honest parties; this results in the honest parties waiting indefinitely to identify the set of n - t input providers.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126565583","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The area of machine learning has made considerable progress over the past decade, enabled by the widespread availability of large datasets, as well as by improved algorithms and models. Given the large computational demands of machine learning workloads, parallelism, implemented either through single-node concurrency or through multi-node distribution, has been a third key ingredient to advances in machine learning. The goal of this tutorial is to provide the audience with an overview of standard distribution techniques in machine learning, with an eye towards the intriguing trade-offs between synchronization and communication costs of distributed machine learning algorithms, on the one hand, and their convergence, on the other.The tutorial will focus on parallelization strategies for the fundamental stochastic gradient descent (SGD) algorithm, which is a key tool when training machine learning models, from classical instances such as linear regression, to state-of-the-art neural network architectures. The tutorial will describe the guarantees provided by this algorithm in the sequential case, and then move on to cover both shared-memory and message-passing parallelization strategies, together with the guarantees they provide, and corresponding trade-offs. The presentation will conclude with a broad overview of ongoing research in distributed and concurrent machine learning. The tutorial will assume no prior knowledge beyond familiarity with basic concepts in algebra and analysis.
{"title":"A Brief Tutorial on Distributed and Concurrent Machine Learning","authors":"Dan Alistarh","doi":"10.1145/3212734.3212798","DOIUrl":"https://doi.org/10.1145/3212734.3212798","url":null,"abstract":"The area of machine learning has made considerable progress over the past decade, enabled by the widespread availability of large datasets, as well as by improved algorithms and models. Given the large computational demands of machine learning workloads, parallelism, implemented either through single-node concurrency or through multi-node distribution, has been a third key ingredient to advances in machine learning. The goal of this tutorial is to provide the audience with an overview of standard distribution techniques in machine learning, with an eye towards the intriguing trade-offs between synchronization and communication costs of distributed machine learning algorithms, on the one hand, and their convergence, on the other.The tutorial will focus on parallelization strategies for the fundamental stochastic gradient descent (SGD) algorithm, which is a key tool when training machine learning models, from classical instances such as linear regression, to state-of-the-art neural network architectures. The tutorial will describe the guarantees provided by this algorithm in the sequential case, and then move on to cover both shared-memory and message-passing parallelization strategies, together with the guarantees they provide, and corresponding trade-offs. The presentation will conclude with a broad overview of ongoing research in distributed and concurrent machine learning. The tutorial will assume no prior knowledge beyond familiarity with basic concepts in algebra and analysis.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129686174","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The problem of Byzantine Agreement (BA) is of interest to both distributed computing and cryptography community. Following well-known results from the distributed computing literature, BA problem in the asynchronous network setting encounters inevitable non-termination issues. The impasse is overcome via randomization that allows construction of BA protocols in two flavours of termination guarantee - with overwhelming probability and with probability one. The latter type termed as almost-surely terminating BAs are the focus of this paper. An eluding problem in the domain of almost-surely terminating BAs is achieving a constant expected running time. Our work makes progress in this direction. In a setting with n parties and an adversary with unbounded computing power controlling at most t parties in Byzantine fashion, we present two asynchronous almost-surely terminating BA protocols: With the optimal resilience of t < n3 , our first protocol runs for expected O(n) time. The existing protocols in the same setting either runs for expected O(n2) time (Abraham et al, PODC 2008) or requires exponential computing power from the honest parties (Wang, CoRR 2015). In terms of communication complexity, our construction outperforms all the known constructions that offer almost-surely terminating feature. With the resilience of t < n/3+ε for any ε > 0, our second protocol runs for expected O( 1 ε ) time. The expected running time of our protocol turns constant when ε is a constant fraction. The known constructions with constant expected running time either require ε to be at least 1 (Feldman-Micali, STOC 1988), implying t < n/4, or calls for exponential computing power from the honest parties (Wang, CoRR 2015). We follow the traditional route of building BA via common coin protocol that in turn reduces to asynchronous verifiable secretsharing (AVSS). Our constructions are built on a variant of AVSS that is termed as shunning. A shunning AVSS fails to offer the properties of AVSS when the corrupt parties strike, but allows the honest parties to locally detect and shun a set of corrupt parties for any future communication. Our shunning AVSS with t < n/3 and t < n 3+ε guarantee Ω(n) and respectively Ω(εt 2) conflicts to be revealed when failure occurs. Turning this shunning AVSS to a common coin protocol constitutes another contribution of our paper.
{"title":"Almost-Surely Terminating Asynchronous Byzantine Agreement Revisited","authors":"Laasya Bangalore, Ashish Choudhury, A. Patra","doi":"10.1145/3212734.3212735","DOIUrl":"https://doi.org/10.1145/3212734.3212735","url":null,"abstract":"The problem of Byzantine Agreement (BA) is of interest to both distributed computing and cryptography community. Following well-known results from the distributed computing literature, BA problem in the asynchronous network setting encounters inevitable non-termination issues. The impasse is overcome via randomization that allows construction of BA protocols in two flavours of termination guarantee - with overwhelming probability and with probability one. The latter type termed as almost-surely terminating BAs are the focus of this paper. An eluding problem in the domain of almost-surely terminating BAs is achieving a constant expected running time. Our work makes progress in this direction. In a setting with n parties and an adversary with unbounded computing power controlling at most t parties in Byzantine fashion, we present two asynchronous almost-surely terminating BA protocols: With the optimal resilience of t < n3 , our first protocol runs for expected O(n) time. The existing protocols in the same setting either runs for expected O(n2) time (Abraham et al, PODC 2008) or requires exponential computing power from the honest parties (Wang, CoRR 2015). In terms of communication complexity, our construction outperforms all the known constructions that offer almost-surely terminating feature. With the resilience of t < n/3+ε for any ε > 0, our second protocol runs for expected O( 1 ε ) time. The expected running time of our protocol turns constant when ε is a constant fraction. The known constructions with constant expected running time either require ε to be at least 1 (Feldman-Micali, STOC 1988), implying t < n/4, or calls for exponential computing power from the honest parties (Wang, CoRR 2015). We follow the traditional route of building BA via common coin protocol that in turn reduces to asynchronous verifiable secretsharing (AVSS). Our constructions are built on a variant of AVSS that is termed as shunning. A shunning AVSS fails to offer the properties of AVSS when the corrupt parties strike, but allows the honest parties to locally detect and shun a set of corrupt parties for any future communication. Our shunning AVSS with t < n/3 and t < n 3+ε guarantee Ω(n) and respectively Ω(εt 2) conflicts to be revealed when failure occurs. Turning this shunning AVSS to a common coin protocol constitutes another contribution of our paper.","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121822743","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Session details: Session 2D: Consensus","authors":"Chryssis Georgiou","doi":"10.1145/3258702","DOIUrl":"https://doi.org/10.1145/3258702","url":null,"abstract":"","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127152683","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Session details: Session 3A: Congest","authors":"I. Keidar","doi":"10.1145/3258703","DOIUrl":"https://doi.org/10.1145/3258703","url":null,"abstract":"","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128549782","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Session details: Session 3C: Coloring","authors":"M. Halldórsson","doi":"10.1145/3258704","DOIUrl":"https://doi.org/10.1145/3258704","url":null,"abstract":"","PeriodicalId":198284,"journal":{"name":"Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2018-07-23","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130936966","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：