Fast non-blocking atomic commit: an inherent trade-off

Abstract. Consensus is the most basic agreement problem encountered in faulttolerant distributed computing: each process proposes a value and non-faulty processes must agree on the same value, which has to be one of the proposed values. While this problem is impossible to solve in asynchronous systems prone to process crash failures, it can be solved in synchronous (round-based) systems where all but one process might crash in any execution. It is well-known that (t + 1) rounds are necessary and sufficient in the worst case execution scenario for the processes to decide and stop executing, where t < n is a system parameter denoting the maximum number of allowed process crashes and n denotes the number of processes in the system. Early decision and stopping considers the case where f < t processes actually crash, f not being known by processes. It has been shown that the number of rounds that have to be executed in the worst case is then min(f + 2, t + 1). Following Castañeda, Gonczarowski and Moses (DISC 2014), the paper shows that this value is an upper bound attained only in worst execution scenarios. To this end, it investigates a sequence of three early deciding/stopping predicates P1 = Pcount, P2 = P dif and P3 = P pref0 , of increasing power, which differ in the information obtained by the processes from the actual failure, communication and data pattern. It is shown that each predicate Pi is better than the previous one Pi−1, i ∈ {2, 3}, in the sense that there are executions where Pi allows processes to reach a decision earlier than Pi−1, while Pi−1 never allows a process to decide earlier than Pi. Moreover, P3 = P pref0 is an unbeatable predicate in the sense that it cannot be strictly improved: if there is an early deciding/stopping predicate P that improves the decision time of a process with respect to P pref0 in a given execution, then there is at least one execution in which a process decides with P strictly later than with P pref0 .

show abstract

“…A similar result was observed for the non-blocking atomic commit problem in synchronous systems ( [8], see also Chap. 10 in [19]).…”

Section: Proof Of Item (D)supporting

confidence: 83%

“…If one of them votes no, they must abort their local computations. It is shown in [8] that there is no algorithm that, whatever the decision (abort or commit), is fast in all executions: a fast algorithm for commit cannot be fast for abort, and vice versa.…”

Section: Proof Of Item (D)mentioning

confidence: 99%

Early Decision and Stopping in Synchronous Consensus: A Predicate-Based Guided Tour

Castañeda¹,

Moses

Raynal

et al. 2017

Lecture Notes in Computer Science

View full text Add to dashboard Cite

show abstract

“…Complexity results. The most closely related works to ours are (a) Dwork and Skeen's lower bound on the number of messages [17,25,26] and (b) Charron-Bost and Schiper's bound on the number of rounds [39] (of which the tightness was shown by Dutta et al [42]). Both works focus on synchronous NBAC, while our study is for an arbitrary (asynchronous) system as well as an arbitrary combination of properties of NBAC.…”

Section: Complexity Of Commit Protocolsmentioning

confidence: 71%

“…In other words, for any synchronous NBAC protocol, before any process decides, two send phases and one receive phase are necessary. (The tight two-round protocol of [42] needs at least two message delays and thus does not help to get such a picture. )…”

Section: Complexity Of Commit Protocolsmentioning

confidence: 99%

How Fast can a Distributed Transaction Commit?

Guerraoui

Wang

2017

Proceedings of the 36th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems

View full text Add to dashboard Cite

The atomic commit problem lies at the heart of distributed database systems. The problem consists for a set of processes (database nodes) to agree on whether to commit or abort a transaction (agreement property). The commit decision can only be taken if all processes are initially willing to commit the transaction, and this decision must be taken if all processes are willing to commit and there is no failure (validity property). An atomic commit protocol is said to be non-blocking if every correct process (a database node that does not fail) eventually reaches a decision (commit or abort) even if there are failures elsewhere in the distributed database system (termination property).Surprisingly, despite the importance of the atomic commit problem, little is known about its complexity. In this paper, we present, for the first time, a systematic study on the time and message complexity of the problem. We measure complexity in the executions that are considered the most frequent in practice, i.e., failure-free, with all processes willing to commit. In other words, we measure how fast a transaction can commit. Through our systematic study, we close many open questions like the complexity of synchronous non-blocking atomic commit. We also present optimal protocols which may be of independent interest. In particular, we present an effective protocol which solves what we call indulgent atomic commit that tolerates practical distributed database systems which are synchronous "most of the time".

show abstract

“…Let us remark that very recently, Dutta, Guerraoui and Pochon in [DGP04] investigate the time-complexity of the NB-AC problem in a synchronous environment. They propose ad-hoc protocols that either fast abort or fast commit a transaction when no processes crash.…”

Section: Introductionmentioning

confidence: 99%

Generating Fast Atomic Commit from Hyperfast Consensus

Greve

Narzul

2005

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. This work introduces a highly modular derivation of fast non-blocking atomic commit protocols. Modularity is achieved by the use of consensus protocols as completely independent services. Fast decision is obtained by the use of consensus protocols that decide in one communication step in good scenarios. Two original non-blocking atomic commit protocols are presented. One of the presented protocols outperforms existing equivalent solutions that are based on the use of failure detectors. In the presence of a low resiliency rate, f ≤ 1, it behaves as the classical 2PC and 3PC, exhibiting the same message complexities. In the general case, when one considers the number of tolerated crashes as f < n/2, it exhibits a complexity of 2nf + 3n point to point messages. The best known algorithm exhibits a complexity of 4nf + 3n point to point messages.

show abstract

Fast non-blocking atomic commit: an inherent trade-off

Cited by 6 publications

References 3 publications

Early Decision and Stopping in Synchronous Consensus: A Predicate-Based Guided Tour

Early Decision and Stopping in Synchronous Consensus: A Predicate-Based Guided Tour

How Fast can a Distributed Transaction Commit?

Generating Fast Atomic Commit from Hyperfast Consensus

Contact Info

Product

Resources

About