Atomic Commitment Protocol Research Articles

Parameterized verification of leader/follower systems via first-order temporal logic

We introduce a framework for the verification of protocols involving a distinguished machine (referred to as a leader) orchestrating the operation of an arbitrary number of identical machines (referred to as followers) in a network. At the core of our framework is a high-level formalism capturing the operation of these types of machines together with their network interactions. We show that this formalism automatically translates to a tractable form of first-order temporal logic. Checking whether a protocol specified in our formalism satisfies a desired property (expressible in temporal logic) then amounts to checking whether the protocol’s translation in first-order temporal logic entails that property. Many different types of protocols used in practice, such as cache coherence, atomic commitment, consensus, and synchronization protocols, fit within our framework. First-order temporal logic also facilitates parameterized verification by enabling us to model such protocols abstractly without referring to individual machines.

Path-Sensitive Atomic Commit

Context: Concurrent objects with asynchronous messaging are an increasingly popular way to structure highly available, high performance, large-scale software systems. To ensure data-consistency and support synchronization between objects such systems often use distributed transactions with Two-Phase Locking (2PL) for concurrency control and Two-Phase commit (2PC) as atomic commitment protocol. Inquiry In highly available, high-throughput systems, such as large banking infrastructure, however, 2PL becomes a bottleneck when objects are highly contended, when an object is queuing a lot of messages because of locking. Approach: In this paper we introduce Path-Sensitive Atomic Commit (PSAC) to address this situation. We start from message handlers (or methods), which are decorated with pre- and post-conditions, describing their guards and effect. Knowledge: This allows the PSAC lock mechanism to check whether the effect of two incoming messages at the same time are independent, and to avoid locking if this is the case. As a result, more messages are directly accepted or rejected, and higher overall throughput is obtained. Grounding: We have implemented PSAC for a state machine-based DSL called Rebel, on top of a runtime based on the Akka actor framework. Our performance evaluation shows that PSAC exhibits the same scalability and latency characteristics as standard 2PL/2PC, and obtains up to 1.8 times median higher throughput in congested scenarios. Importance: We believe PSAC is a step towards enabling organizations to build scalable distributed applications, even if their consistency requirements are not embarrassingly parallel.

Efficient and non-blocking agreement protocols

Large scale distributed databases are designed to support commercial and cloud based applications. The minimal expectation from such systems is that they ensure consistency and reliability in case of node failures. The distributed database guarantees reliability through the use of atomic commitment protocols. Atomic commitment protocols help in ensuring that either all the changes of a transaction are applied or none of them exist. To ensure efficient commitment process, the database community has mainly used the two-phase commit (2PC) protocol. However, the 2PC protocol is blocking under multiple failures. This necessitated the development of non-blocking, three-phase commit (3PC) protocol. However, the database community is still reluctant to use the 3PC protocol, as it acts as a scalability bottleneck in the design of efficient transaction processing systems. In this work, we present EasyCommit protocol which leverages the best of both worlds (2PC and 3PC), that is non-blocking (like 3PC) and requires two phases (like 2PC). EasyCommit achieves these goals by ensuring two key observations: (i) first transmit and then commit, and (ii) message redundancy. We present the design of the EasyCommit protocol and prove that it guarantees both safety and liveness. We also present a detailed evaluation of EC protocol and show that it is nearly as efficient as the 2PC protocol. To cater the needs of geographically large scale distributed systems we also design a topology-aware agreement protocol (Geo-scale EasyCommit) that is non-blocking, safe, live and outperforms 3PC protocol.

Unifying consensus and atomic commitment for effective cloud data management

Data storage in the Cloud needs to be scalable and fault-tolerant. Atomic commitment protocols such as Two Phase Commit (2PC) provide ACID guarantees for transactional access to sharded data and help in achieving scalability. Whereas consensus protocols such as Paxos consistently replicate data across different servers and provide fault tolerance. Cloud based datacenters today typically treat the problems of scalability and fault-tolerance disjointedly. In this work, we propose a unification of these two different paradigms into one framework called Consensus and Commitment (C&C) framework. The C&C framework can model existing and well known data management protocols as well as propose new ones. We demonstrate the advantages of the C&C framework by developing a new atomic commitment protocol, Paxos Atomic Commit (PAC), which integrates commitment with recovery in a Paxos-like manner. We also instantiate commit protocols from the C&C framework catered to different Cloud data management techniques. In particular, we propose a novel protocol, Generalized PAC (G-PAC) that integrates atomic commitment and fault tolerance in a cloud paradigm involving both sharding and replication of data. We compare the performance of G-PAC with a Spanner-like protocol, where 2PC is used at the logical data level and Paxos is used for consistent replication of logical data. The experimental results highlight the benefits of combining consensus along with commitment into a single integrated protocol.

Low-latency multi-datacenter databases using replicated commit

Web service providers have been using NoSQL datastores to provide scalability and availability for globally distributed data at the cost of sacrificing transactional guarantees. Recently, major web service providers like Google have moved towards building storage systems that provide ACID transactional guarantees for globally distributed data. For example, the newly published system, Spanner, uses Two-Phase Commit and Two-Phase Locking to provide atomicity and isolation for globally distributed data, running on top of Paxos to provide fault-tolerant log replication. We show in this paper that it is possible to provide the same ACID transactional guarantees for multi-datacenter databases with fewer cross-datacenter communication trips, compared to replicated logging. Instead of replicating the transactional log, we replicate the commit operation itself, by running Two-Phase Commit multiple times in different datacenters and using Paxos to reach consensus among datacenters as to whether the transaction should commit. Doing so not only replaces several inter-datacenter communication trips with intra-datacenter communication trips, but also allows us to integrate atomic commitment and isolation protocols with consistent replication protocols to further reduce the number of cross-datacenter communication trips needed for consistent replication; for example, by eliminating the need for an election phase in Paxos. We analyze our approach in terms of communication trips to compare it against the log replication approach, then we conduct an extensive experimental study to compare the performance and scalability of both approaches under various multi-datacenter setups.

Managing failures in web services atomic commitment protocols

PurposeWS‐ReliableMessaging specification describes a protocol that allows messages to be delivered reliably between distributed applications in the presence of software component, system, or network failures. However, it ensures reliable communication only in the context of two sites – it does not provide any means for consistent termination of the executions spanning over more than two sites. This paper aims to address this issue.Design/methodology/approachThe paper presents the Reliable WS‐AtomicTransaction protocol, and illustrates its implementation by exploiting WS‐Coordination, which describes an extensible framework for providing protocols that coordinate the actions of distributed applications. The paper also presents the ontology of the log, which is maintained by the Reliable WS‐AtomicTransaction protocol. The ontology is presented in a graphical form and in OWL.FindingsThe introduction of an atomic commitment protocol and its termination protocol increase the reliability of the executions of distributed applications in service‐oriented architectures. On the other hand, it complicates the management of distributed applications as the atomic commitment protocol has to maintain the log that is used by its termination protocol.Originality/valueThe paper presents an atomic commitment protocol and its termination protocol, which is failure resilient and non‐blocking as long as a failed site can communicate with a process that has received sufficient information to know whether the transaction will be committed or aborted. Decreasing the amount of blockings is important because blocking can cause processes to wait for an arbitrarily long period of time.

On performance evaluation and design of atomic commit protocols for mobile transactions

The challenges of wireless and mobile computing environments have attracted the attention of researchers to revisit the conventional transaction paradigm. Indeed, this paradigm is an indispensable asset in modern information systems. The atomicity property of a distributed transaction is ensured with the use of an atomic commit protocol (ACP). Due to their great importance for transaction systems, the recent advances in mobile computing development have renewed the interest in the design of ACPs for mobile systems. The work presented in this paper studies the impact of the various and fluctuant parameters of wireless and mobile systems on a set of ACPs for mobile environment. It highlights performance indices which give orientations to the design of an adaptable approach that supports different atomicity notions satisfying a wide range of applications and environment requirements.

Performance evaluation of Atomic Commit Protocols for mobile transactions

The commitment of a distributed transaction is ensured with the use of an Atomic Commit Protocol (ACP). Due to their great importance for transaction systems, the recent advances in mobile computing development have renewed the interest in the ACPs for mobile transactions. We compare assets of mobile ACPs that have been simulated on the NS-DBsim platform integrating two simulation environments; the NS2 simulator and DBsim a distributed database simulator. NS-DBsim takes into account the various and fluctuant parameters of wireless and mobile systems. The comparison highlights performance indices and orientations to the design of ACPs in mobile wireless environments.

Atomic commitment and resilience in grid database systems

Atomic Commitment Protocol (ACP) is an important part of any distributed transaction. ACPs have been proposed for homogeneous and heterogeneous distributed database management systems (DBMS). ACPs designed for these DBMS do not meet the requirement of Grid databases. Homogeneous DBMS are synchronous and tightly coupled while heterogeneous DBMS, like multi-database systems require a top layer of multi-database management system to manage distributed transactions. These ACPs either become too restrictive or need some changes in participating DBMS, which may not be acceptable in Grid Environment. In this paper, we identify requirements for Grid database systems and then propose an ACP for grid databases, Grid-Atomic Commitment Protocol (Grid-ACP). We then extend Grid-ACP to handle failure of database sites.

The Two-Phase Commitment Protocol in an Extended π-Calculus

We examine extensions to the π-calculus for representing basic elements of distributed systems. In spite of its expressiveness for encoding various programming constructs, some of the phenomena inherent in distributed systems are hard to model in the π-calculus. We consider message loss, sites, timers, site failure and persistence as extensions to the calculus and examine their descriptive power, taking the Two Phase Commit Protocol (2PCP), a basic instance of an atomic commitment protocol, as a testbed. Our extensions enable us to represent the 2PCP under various failure assumptions, as well as to reason about the essential properties of the protocol.

Dictatorial Transaction Processing: Atomic Commitment Without Veto Right

The current standard in governing distributed transaction termination is the so-called Two-Phase Commit protocol (2PC). The first phase of 2PC is a voting phase, where the participants in the transaction are given an ultimate right to abort that transaction. Giving up that veto right from all participants reduces the overhead of the atomic commitment protocol but also imposes some restrictions on the concurrency control and recovery protocols employed by the participants in the transaction. This paper gives, for the first time, a precise abstract specification of the Dictatorial Atomic Commitment (DAC) problem, resulting from removing veto rights from the traditional Atomic Commitment (AC) problem. We characterize transactional systems that are compatible with that specification in terms of necessary and sufficient conditions on concurrency control and recovery protocols, and discuss the practical impacts of those conditions. From this study, we capitalize on existing protocols that solve the DAC problem, and propose a new protocol that broadens the applicability of dictatorial transaction processing in order to meet the requirements of today's distributed environments. We point out interesting performance tradeoffs, and describe the implementation of our protocol in the context of current transactional standards, initially designed with 2PC in mind.

Increasing the Resilience of Distributed and Replicated Database Systems

This paper presents a new atomic commitment protocol,enhanced three phase commit(E3PC), thatalwaysallows a quorum in the system to make progress. Previously suggested quorum-based protocols (e.g., the quorum-basedthree phase commit(3PC) (Skeen, 1982)), allow a quorum to make progress in case of one failure. If failures cascade, however, and the quorum in the system is “lost” (i.e., at a given time no quorum component exists), a quorum can later become connected and still remain blocked. With our protocol, a connected quorum never blocks. E3PC is based on the quorum-based 3PC (Skeen, 1982), and it does not require more time or communication than 3PC. We describe how this protocol can be exploited in a replicated database setting, making the databasealwaysavailable to a majority of the sites.

Performance of a two-phase commit protocol

Distributed database systems are subject to data inconsistency in the presence of failures. In order to coordinate the execution of the subtransactions of a global transaction, it is necessary to commit or abort all these subtransactions to maintain data consistency. Two classes of atomic commitment protocols have been proposed in the literature. The first class, known as fault tolerant protocol, aborts a transaction without checking for alternative solutions. The second, optimistic protocol, ignores the occurrence of errors and assumes that a global transaction commits in most cases. However, this would lead to compensating transactions so as to preserve data consistency, in case the global transaction aborts. In this paper, we study the performance of a Prudent Two-Phase Commit protocol, which in the presence of failures does not abort a transaction needlessly. The prudent protocol gives the transaction a second chance before deciding to abort. This prudent approach prevents a transaction from aborting in case of transient communication error or failure. In this way, it improves system performance and reliability. For the purpose of this study, we simulate a distributed database system. The performance of the simulated distributed system is measured while using the Prudent, Basic, and Optimistic Two-Phase Commit protocols. The performances of such protocols are compared and evaluated according to a number of widely accepted performance metrics. The final performance results are presented with a discussion and interpretation of the graphs generated by the simulation. The results of these simulations confirm the improvement in system performance with the Prudent Two-Phase Commit protocol.

A reliable global atomic commitment protocol for distributed multidatabase systems

Many works on multidatabase transaction processing have been made in the past with the assumption of the absence of failures. This is because it has been shown that correct executions of multidatabase transactions cannot be achieved in the presence of failures without certain tradeoffs. In this paper, we first review the problems of preserving the global atomicity of multidatabase transactions in the presence of failures, while preserving local autonomy. Then, we propose a reliable global atomic commitment protocol that solves those problems. We show that the proposed protocol is correct and guarantees the global atomicity. We also present a practical approach that allows easy integration of existing local database systems into our multidatabase system environment. The most elegant feature of our protocol is that it guarantees global atomicity, even in the presence of failures, while the protocol preserves maximal local autonomy, and does not place any restriction on the multidatabase transactions that are often assumed in the literature.

A reliable global atomic commitment protocol for distributed multidatabase systems

Many works on multidatabase transaction processing have been made in the past with the assumption of the absence of failures. This is because it has been shown that correct executions of multidatabase transactions cannot be achieved in the presence of failures without certain tradeoffs. In this paper, we first review the problems of preserving the global atomicity of multidatabase transactions in the presence of failures, while preserving local autonomy. Then, we propose a reliable global atomic commitment protocol that solves those problems. We show that the proposed protocol is correct and guarantees global atomicity. We also present a practical approach that allows easy integration of existing local data base systems into our multidatabase system environment. The most elegant feature of our protocol is that it guarantees global atomicity even in the presence of failures while the protocol preserves maximal local autonomy, and does not place any restriction on the multidatabase transactions that are often assumed in the literature.

Real-Time Object-Oriented Database Support For Program Stock Trading

Many computer systems that automatically control financial applications are required to handle large amounts of data with timing constraints imposed on the data and on the transactions that access the data. Traditional database technology, however, is not designed to manage perishable (timeconstrained) data of financial applications, such as “current†stock prices and trading volumes in index arbitrage transactions. Furthermore, traditional database systems are not capable of scheduling the time-constrained transactions in financial applications, such as transactions that must be performed within time bounds of guaranteed price quotations. This paper presents a schema model of real-time objectoriented database that addresses these weaknesses and shows how this model can support a form of intelligent program stock trading called index arbitrage. This paper also illustrates the use of a protocol called timed atomic commitment, which is an extension of traditional distributed database atomic commitment protocol, to perform index arbitrage transactions using our real-time object-oriented database model.