DOCSLIB.ORG

The Principle of Commitment Ordering, Or Guaranteeing Serializability in a Heterogeneous Environment of Multiple Autonomous Resource Managers Using Atomic Commitment

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
The Principle of Commitment Ordering, Or Guaranteeing Serializability in a Heterogeneous Environment of Multiple Autonomous Resource Managers Using Atomic Commitment The Principle of Commitment Ordering, or Guaranteeing Serializability in a Heterogeneous Environment of Multiple Autonomous Resource Managers Using Atomic Commitment Yoav Raz Digital Equipment Corporation, 151 Taylor St. (TAYI), Littleton, Ma 01460 Abstract I Introduction Commitment Ordering (CO) is a serializability con- Distributed transaction management services are in- cept, that allows global serializability to be effec- tended to provide coordination for transactionsthat span tively achieved across multiple autonomous Re- multiple resource managers (RMs). source Managers (RMs). The RMs may use A RM is a software component that managesresources different (any) concurrency control mechanisms. under transactions’ control. A resource is any medium Thus, CO provides a solution for the long standing with well defined states that are being modified and re- global serializability problem. RM autonomy means trieved while obeying transaction’s (“ah or nothing”) se- that no concurrency control information is shared mantics (atomicity). This means that effects of failed with other entities, except Atomic Commitment transactions are undone, which requires that resources’ (AC) protocol (e.g. Two Phase Commitment - 2PC) statesbe recoverable (i.e. if a resource is modified by a messages. CO is a necessary condition for guaran- transaction, the state it had when the transaction started teeing global serializability across autonomous can be restoredbefore the transaction ends). A resource RMs. CO generalizes the popular Strong-Strict Two is typically (but not necessarily) a data item. The scope Phase Locking concept (S-S2PL; “release locks of any specific resource(e.g. granularity units, versions, applied on behalf of a transaction only after the or replications) is defined as a part of a RM’s semantics. transaction has ended”). While S-S2PL is subject Examples of resource managers are database systems to deadlocks, CO exhibits deadlock-free executions (DBSs), queue managers,cache managers,some types when implemented as nonblocking (optimistic) of managemententities/objects (e.g. see [EMA], [OSI- concurrency control mechanisms. SMO]) etc. A RM may impose a certain property of the generated transaction histories (transaction event schedules) to guarantee correctnessand certain levels of fault toler- Permission IO copy withoti fee all or part of this material is granted ance. However, the global history, i.e. the combined his- provided that copies are MI ma& or dislributed for direct commercial tory of all the RMs involved, does not necessarilyinherit advantage, the VLDB copyright notice and the ti!le of the publication and its dale appear, and nolice ir given thal copying is by permission such a property even if it is provided by all the RMs. of the Very Large Database Endowment. To copy olherwise, or IO re- The serializability (SER) property is an example. pubbh, requires a fee and/or special permission from the endowment. Serializability is the most commonly accepted general criterion for the correctnessof concurrent transactions Proceedings of the 18th VLDB Conference (e.g. see [Bern 871, [Papa 863, and supported in most Vancouver, British Columbia, Canada 1992 RMs. When transactions involve more than one RM, 292 this property may be violated in general, unless special guarantees global serializability is Strong Strict Two measuresare taken, or certain conditions exist to guar- Phase Locking (S-S2PL; “release locks issued on behalf antee it. This issue is dealt with, for example, in [Brei of a transaction only after the transaction has ended”). 901, [Brei 911, [Elma 871, [Geor 911, [Glig 851, [Litw This fact has been known for several years, and has been 891 and rPu 881. [Weih 891 deals with the relationships the major correctnessfoundation for distributed transac- between local and global serializability in the frarne- tions. Various technical documents about distributed work of abstract data types. Achieving global transaction management (e.g. [OSI-CCR]) have men- serializability with reasonable performance, especially tioned it. The observation that local S-S2PL guarantees across RMs that implement different concurrency con- global serializability appears explicitly at least in vu trol mechanisms,has been considered a difficult prob- 881, [Brei 901 and [Brei 9112.The disadvantageof this lem (e.g. [Shet 901, [Silb 913). approachis that all the RMs involved have to implement S-S2PL based concurrency control, even if other types Global serializability can be guaranteed,in principle, by are preferablefor someRMs. several methods if the RMs involved share relevant concurrency control information. Timestamp Ordering In this paper we examine the relationships between his- (TO) is an example (e.g. [Bern 871, borne 901). If all tories of individual RMs and the global history that the RMs involved support TO-based concurrency con- comprises them, and generalize the above observation. trol and share the same timestamps,then the entire sys- We define a history property named Commitment Or- tem can exhibit a coherent behavior basedon TO, which dering (CO), and show that guaranteeing it is a neces- guaranteesglobal serializability. However, this technol- sary and sufficient condition for guaranteeing global ogy requires a certain RM synchronization as well as serializability under the conditions of RM autonomy. timestamp propagation, and is currently unavailable in CO can be implemented as standalone serializability heterogeneousenvironments. Another known method, mechanismsas well as being incorporated with other based on locking, allows RM autonomy. We define a concurrency control mechanisms.Since CO can be en- RM to be autonomous if it does not share any resources forced solely by controlling the order of transactions’ and concurrency control information (e.g. timestamps) commit events, it can be combined with any other with another entity (external to the RM), and is being concurrency control mechanism without affecting the coordinated (at the nonapplication level’) solely via mechanism’s resource accessscheduling strategy. This Atomic Commitment (AC) protocols (to achieve global allows selecting and optimizing concurrency control for atomicity). Most systems that support distributed trans- each RM according to the nature of transactions in- action services provide AC protocols and related inter- volved. Enforcing CO does not require aborting more faces. These protocols guaranteeatomicity even in the transactionsthan those needed to be aborted for global presence of certain types of recoverable failures. It serializability violation prevention, which is determined means that either a distributed transaction is committed, exclusively by the resource accessorders, and is inde- i.e. its effects on all the resourcesinvolved becomeper- pendent of the commit orders. S-S2PL basedRMs pro- manent, or it is aborted (rolled back), i.e. its effects on vide CO already, since S-S2PL is a special caseof CO. all the resourcesare undone. The most commonly used In summary, serializability of transaction histories atomic commitment protocols are variants of the Two across (any) different RM types, which may use differ- Phase Commitment protocol (2PC - [Gray 781, [Lamp ent concurrency control mechanismsbut provide the CO 761). Examples are Digital Equipment Corporation’s property, is guaranteedwithout any global coordination Distributed Transaction Manager - DECdtm ([DEC- or services but AC. Thus, the CO solution is fully dis- dun]), Logical Unit Type 6.2 of International Business tributed. Machines Corporation ([LU6.2]), and the IS0 - OS1 standard for Distributed Transaction Processing ([OSI- Section 2 is an overview and reformulation of DTP]). A well known local (i.e. local to each RM) serializability theory, which provides the foundation for concurrency control mechanism that together with AC analyzing CO. Section 3 defines CO and describes its ‘Typically, a RM is unaware of any resource state dependency with states of resources external to the RM, implied by applica- tions. This is also true in the cases where RMs are coordinataed by multi-database systems, which provide applications with integrated views of resources. 2 [Brei 911 uses the term rigorousness for S-S2PL. [Brei 911 also redefines CO (naming it strong recoverabifify) and uses it to show that applying S-S2PL locally guarantees global serializability. No algorithm for enforcing CO (beyond SS2PL) is given there. 293 properties. Section 4 examines CO schedulersand pre- The events of interest are the following2: sents generic CO algorithms. Section 5 deals with multi l The operation of reading a resource; ri[x] denotes RM histories, atomic commitment, and relationships be- that transaction Ti has retrieved (read) the (partial) tween local and global properties. Section 6 shows that stateof the resourcex. CO is exactly the property required to guaranteeglobal serializability across autonomous RMs. Section 7 pro- l The operation of writing a resource; wi[x] means vides a conclusion. This paper is an abridged version of that transaction Ti has modified (written) the state [Raz 903. of the resourcex. Ending a transaction; ei means that Ti has ended (has been either committed or aborted) and will not 2 Histories and their properties - introduce any further operations. an overview A transactionobeys the following transaction rules (axi- oms): This section summarizesand reformulates known con- l TRl cepts and results of concurrency control theory (seealso A transactionTi has exactly a single event
Load more

Recommended publications
  • An Efficient Concurrency Control Technique for Mobile Database Environment by Md
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Global Journal of Computer Science and Technology (GJCST) Global Journal of Computer Science and Technology Software & Data Engineering Volume 13 Issue 2 Version 1.0 Year 2013 Type: Double Blind Peer Reviewed International Research Journal Publisher: Global Journals Inc. (USA) Online ISSN: 0975-4172 & Print ISSN: 0975-4350 An Efficient Concurrency Control Technique for Mobile Database Environment By Md. Anisur Rahman Dhaka University of Engineering & Technology Gazipur, Bangladesh Abstract - Day by day, wireless networking technology and mobile computing devices are becoming more popular for their mobility as well as great functionality. Now it is an extremely growing demand to process mobile transactions in mobile databases that allow mobile users to access and operate data anytime and anywhere, irrespective of their physical positions. Information is shared among multiple clients and can be modified by each client independently. However, for the assurance of timely access and correct results in concurrent mobile transactions, concurrency control techniques (CCT) happen to be very difficult. Due to the properties of Mobile databases e.g. inadequate bandwidth, small processing capability, unreliable communication, mobility etc. existing mobile database CCTs cannot employ effectively. With the client-server model, applying common classic pessimistic techniques of concurrency control (like 2PL) in mobile database leads to long duration Blocking and increasing waiting time of transactions. Because of high rate of aborting transactions, optimistic techniques aren`t appropriate in mobile database as well. This paper discusses the issues that need to be addressed when designing a CCT technique for Mobile databases, analyses the existing scheme of CCT and justify their performance limitations.
    [Show full text]
  • ACID Compliant Distributed Key-Value Store
    ACID Compliant Distributed Key-Value Store #1 #2 #3 Lakshmi Narasimhan Seshan ,​ Rajesh Jalisatgi ,​ Vijaeendra Simha G A # ​ ​ ​ ​1l​ [email protected] # ​2r​ [email protected] #3v​ [email protected] Abstract thought that would be easier to implement. All Built a fault-tolerant and strongly-consistent key/value storage components run http and grpc endpoints. Http endpoints service using the existing RAFT implementation. Add ACID are for debugging/configuration. Grpc Endpoints are transaction capability to the service using a 2PC variant. Build used for communication between components. on the raftexample[1] (available as part of etcd) to add atomic Replica Manager (RM): RM is the service discovery transactions. This supports sharding of keys and concurrent transactions on sharded KV Store. By Implementing a part of the system. RM is initiated with each of the transactional distributed KV store, we gain working knowledge Replica Servers available in the system. Users have to of different protocols and complexities to make it work together. instantiate the RM with the number of shards that the user wants the key to be split into. Currently we cannot Keywords— ACID, Key-Value, 2PC, sharding, 2PL Transaction dynamically change while RM is running. New Replica ​ ​ Servers cannot be added or removed from once RM is I. INTRODUCTION ​ up and running. However Replica Servers can go down Distributed KV stores have become a norm with the and come back and RM can detect this. Each Shard advent of microservices architecture and the NoSql Leader updates the information to RM, while the DTM revolution. Initially KV Store discarded ACID properties leader updates its information to the RM.
    [Show full text]
  • Lecture 15: March 28 15.1 Overview 15.2 Transactions
    CMPSCI 677 Distributed and Operating Systems Spring 2019 Lecture 15: March 28 Lecturer: Prashant Shenoy 15.1 Overview This section covers the following topics: Distributed Transactions: ACID Properties, Concurrency Control, Serializability, Two-Phase Locking 15.2 Transactions Transactions are used widely in databases as they provide atomicity (all or nothing property). Atomicity is the property in which operations inside a transaction all execute successfully or none of the operations execute. Thus, if a process crashes during a transaction, all operations that happened during that transaction must be undone. Transactions are usually implemented using locks. Without locks there would be interleaving of operations from two transactions, causing overwrites and inconsistencies. It has to look like all instructions/operations of one transaction are executed at once, while ensuring other external instructions/operations are not executing at the same time. This is especially important in real-world applications such as banking applications. 15.2.1 ACID: Most transaction systems will provide the following properties • Atomicity: All or nothing (all instructions execute or none; cannot have some instructions execute and some do not) • Consistency: Transaction takes system from one consistent (valid) state to another • Isolated: Transaction executes as if it is the only transaction in the system. Ensures that the concurrent execution of transactions results in a system state that would be obtained if transactions were executed sequentially (serializability).
    [Show full text]
  • A View-Based Approach to Relaxing Global Serializability in Multidatabase Systems
    Purdue University Purdue e-Pubs Department of Computer Science Technical Reports Department of Computer Science 1993 A View-Based Approach to Relaxing Global Serializability in Multidatabase Systems Aidong Zhang Evaggelia Pitoura Bharat K. Bhargava Purdue University, [email protected] Report Number: 93-082 Zhang, Aidong; Pitoura, Evaggelia; and Bhargava, Bharat K., "A View-Based Approach to Relaxing Global Serializability in Multidatabase Systems" (1993). Department of Computer Science Technical Reports. Paper 1095. https://docs.lib.purdue.edu/cstech/1095 This document has been made available through Purdue e-Pubs, a service of the Purdue University Libraries. Please contact [email protected] for additional information. A VIEW-BASED APPROACH TO RELAXING GLOBAL SERIALIZABILITY IN MULTIDATABASE SYSTEMS Aldong Zhang Evaggelia PitOUI'3 Bharat Bh:Jrgava CSD TR-9J.082 December 1993 (Revised March 1994) A View-Based Approach to Relaxing Global Serializability in Multidatabase Systems Aidong Zhang, Evaggelia Pitoura, and Bharat K Bhargava Department of Computer Science Purdue University West Lafayette, IN 47907 USA Abstract In this paper, we propose a new approach to ensuring the correctness of non­ serializable executions. The approach is based on relating transaction views of the database to the integrity constraints of the system. Drawing upon this approach, we de­ velop a new correctness criterion for multidatabase concurrency control. This criterion, caUed view-based two-level serializability, relaxes global serializabitity in multidatabase systems while respecting the autonomy of local database systems. No additional re­ strictions other than serializallility are imposed on local database systems. 1 Introduction A Illultidataba.-<;e system (MDBS) is a higher-level confederation of a nWllber of pre-existing autonomolls and possibly heterogeneous database systems.
    [Show full text]
  • Concurrency Control Basics
    Outline l Introduction/problems, l definitions Introduction/ (transaction, history, conflict, equivalence, Problems serializability, ...), Definitions l locking. Chapter 2: Locking Concurrency Control Basics Klemens Böhm Distributed Data Management: Concurrency Control Basics – 1 Klemens Böhm Distributed Data Management: Concurrency Control Basics – 2 Atomicity, Isolation Synchronisation, Distributed (1) l Transactional guarantees – l Essential feature of databases: in particular, atomicity and isolation. Many users can access the same data concurrently – be it read, be it write. Introduction/ l Atomicity Introduction/ Problems Problems u Example, „bank scenario“: l Consistency must be guaranteed – Definitions Definitions task of synchronization component. Locking Number Person Balance Locking Klemens 5000 l Multi-user mode shall be hidden from users as far as possible: concurrent processing Gunter 200 of requests shall be transparent, u Money transfer – two elementary operations. ‚illusion‘ of being the only user. – debit(Klemens, 500), – credit(Gunter, 500). l Isolation – can be explained with this example, too. l Transactions. Klemens Böhm Distributed Data Management: Concurrency Control Basics – 3 Klemens Böhm Distributed Data Management: Concurrency Control Basics – 4 Synchronisation, Distributed (2) Synchronization in General l Serial execution of application programs Uncontrolled non-serial execution u achieves that illusion leads to other problems, notably inconsistency: l Introduction/ without any synchronization effort, Introduction/
    [Show full text]
  • Distributed Transactions
    Distributed Systems 600.437 Distributed Transactions Department of Computer Science The Johns Hopkins University Yair Amir Fall 16/ Lecture 6 1 Distributed Transactions Lecture 6 Further reading: Concurrency Control and Recovery in Database Systems P. A. Bernstein, V. Hadzilacos, and N. Goodman, Addison Wesley. 1987. Transaction Processing: Concepts and Techniques Jim Gray & Andreas Reuter, Morgan Kaufmann Publishers, 1993. Yair Amir Fall 16/ Lecture 6 2 Transaction Processing System Clients Messages to TPS outside world Real actions (firing a missile) Database Yair Amir Fall 16/ Lecture 6 3 Basic Definition Transaction - a collection of operations on the physical and abstract application state, with the following properties: • Atomicity. • Consistency. • Isolation. • Durability. The ACID properties of a transaction. Yair Amir Fall 16/ Lecture 6 4 Atomicity Changes to the state are atomic: - A jump from the initial state to the result state without any observable intermediate state. - All or nothing ( Commit / Abort ) semantics. - Changes include: - Database changes. - Messages to outside world. - Actions on transducers. (testable / untestable) Yair Amir Fall 16/ Lecture 6 5 Consistency - The transaction is a correct transformation of the state. This means that the transaction is a correct program. Yair Amir Fall 16/ Lecture 6 6 Isolation Even though transactions execute concurrently, it appears to the outside observer as if they execute in some serial order. Isolation is required to guarantee consistent input, which is needed for a consistent program to provide consistent output. Yair Amir Fall 16/ Lecture 6 7 Durability - Once a transaction completes successfully (commits), its changes to the state survive failures (what is the failure model ? ).
    [Show full text]
  • Effective Technique for Optimizing Timestamp Ordering in Read- Write/Write-Write Operations
    International Research Journal of Engineering and Technology (IRJET) e-ISSN: 2395-0056 Volume: 06 Issue: 09 | Sep 2019 www.irjet.net p-ISSN: 2395-0072 Effective Technique for Optimizing Timestamp Ordering in Read- Write/Write-Write Operations Obi, Uchenna M1, Nwokorie, Euphemia C2, Enwerem, Udochukwu C3, Iwuchukwu, Vitalis C4 1Lecturer, Department of Computer Science, Federal University of Technology, Owerri, Nigeria 2Senior Lecturer, Department of Computer Science, Federal University of Technology, Owerri, Nigeria 3Lecturer, Department of Computer Science, Federal University of Technology, Owerri, Nigeria 4Lecturer, Department of Computer Science, Federal University of Technology, Owerri, Nigeria ---------------------------------------------------------------------***---------------------------------------------------------------------- Abstract - In recent times, the use of big data has been the measures, these are: read-write (RW) synchronization and trending technology, most enterprises tend to adopt large write-write (WW) synchronization. databases, but the inherent problem is how to ensure serializability in concurrent transactions that may want to Concurrency control techniques are employed for managing access the data in the database so as to maintain its data concurrent access of transactions on a particular data item integrity and not to compromise it. The aim of this research is by ensuring serializable executions or to avoid interference to develop an efficient Timestamp Ordering algorithm and among transactions and thereby helps in avoiding errors and model in conflicting operations in read-write/write-write data maintain consistency of the database. Various concurrency synchronization. In read-write synchronization, one of the control techniques have been developed by different operations to perform is read while the other is write researchers and these techniques are distinct and unique in operation.
    [Show full text]
  • On Ordering Transaction Commit
    On Ordering Transaction Commit Mohamed M. Saad Roberto Palmieri Binoy Ravindran Virginia Tech msaad, robertop, binoy @vt.edu { } Complete Commit Execute Abstract Ordering In this poster paper, we briefly introduce an effective solution to Time address the problem of committing transactions enforcing a pre- α defined order. To do that, we overview the design of two algorithms γ that deploy a cooperative transaction execution that circumvents the δ transaction isolation constraint in favor of propagating written val- β ues among conflicting transactions. A preliminary implementation shows that even in the presence of data conflicts, the proposed al- gorithms outperform other competitors, significantly. Categories and Subject Descriptors D.1.3 [Software]: Concur- rent Programming; H.2.4 [Systems]: Transaction processing (a) BS 4 Thr. (b) BS 8 Thr. (c) FH Commit (d) FH Complete Keywords Transactional Memory, Commitment Ordering Figure 1: ACO using Blocking/Stall (BS) and Freeze/Hold (FH) 1. Introduction semantics (of the parallel code) that is equivalent to the original Transactional Memory (TM) [5] is an easy abstraction to program (sequential) code. Regarding the latter, SMR-based transactional concurrent applications. Its integration into main-stream compilers systems order transactions (totally or partially) before their execu- and programming languages such as GCC and C++ gives TM, tion to guarantee that a state always evolves on several computing respectively, accessibility and concreteness. nodes, consistently. To do that, usually a consensus protocol is em- In this poster paper we provide the design of two TM implemen- ployed (e.g., Paxos [6]), which establishes a common order among tations that commit transactions enforcing an order defined prior to transactions.
    [Show full text]
  • Serializability, Not Serial: Concurrency Control and Availability in Multi-Datacenter Datastores
    Serializability, not Serial: Concurrency Control and Availability in Multi-Datacenter Datastores Stacy Patterson1 Aaron J. Elmore2 Faisal Nawab2 Divyakant Agrawal2 Amr El Abbadi2 1Department of Electrical Engineering 2Department of Computer Science Technion - Israel Institute of Technology University of California, Santa Barbara Haifa, 32000, Israel Santa Barbara, CA 93106 [email protected] faelmore,nawab,agrawal,[email protected] ABSTRACT create applications within the eventual consistency model We present a framework for concurrency control and avail- [21]. Many cloud providers then introduced support for ability in multi-datacenter datastores. While we consider atomic access to individual data items, in essence, provid- Google's Megastore as our motivating example, we define ing strong consistency guarantees. This consistency level general abstractions for key components, making our solu- has become a standard feature that is offered in most cloud tion extensible to any system that satisfies the abstraction datastore implementations, including BigTable, SimpleDB, properties. We first develop and analyze a transaction man- and Apache HBase [17]. Strong consistency of single data agement and replication protocol based on a straightforward items is sufficient for many applications. However, if several implementation of the Paxos algorithm. Our investigation data items must be updated atomically, the burden to imple- reveals that this protocol acts as a concurrency prevention ment this atomic action in a scalable, fault tolerant manner mechanism rather than a concurrency control mechanism. lies with the software developer. Several recent works have We then propose an enhanced protocol called Paxos with addressed the problem of implementing ACID transactions Combination and Promotion (Paxos-CP) that provides true in cloud datastores [3, 11, 12], and, while full transaction transaction concurrency while requiring the same per in- support remains a scalability challenge, these works demon- stance message complexity as the basic Paxos protocol.
    [Show full text]
  • A Study of the Availability and Serializability in a Distributed Database System
    A STUDY OF THE AVAILABILITY AND SERIALIZABILITY IN A DISTRIBUTED DATABASE SYSTEM David Wai-Lok Cheung B.Sc., Chinese University of Hong Kong, 1971 M.Sc., Simon Fraser University, 1985 A THESIS SUBMI'ITED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHLLOSOPHY , in the School of Computing Science 0 David Wai-Lok Cheung 1988 SIMON FRASER UNIVERSITY January 1988 All rights reserved. This thesis may not be reproduced in whole or in part, by photocopy or other means, without permission of the author. 1 APPROVAL Name: David Wai-Lok Cheung Degree: Doctor of Philosophy Title of Thesis: A Study of the Availability and Serializability in a Distributed Database System Examining Committee: Chairperson: Dr. Binay Bhattacharya Senior Supervisor: Dr. TikoJameda WJ ru p v Dr. Arthur Lee Liestman Dr. Wo-Shun Luk Dr. Jia-Wei Han External Examiner: Toshihide Ibaraki Department of Applied Mathematics and Physics Kyoto University, Japan Bate Approved: January 15, 1988 PARTIAL COPYRIGHT LICENSE I hereby grant to Simon Fraser University the right to lend my thesis, project or extended essay (the title of which is shown below) to users of the Simon Fraser University Library, and to make partial or single copies only for such users or in response to a request from the library of any other university, or other educational institution, on its own behalf or for one of its users. I further agree that permission for multiple copying of this work for scholarly purposes may be granted by me or the Dean of Graduate Studies. It is understood that copying or publication of this work for financial gain shall not be allowed without my written permission, T it l e of Thes i s/Project/Extended Essay Author: (signature) ( name (date) ABSTRACT Replication of data objects enhances the reliability and availability of a distributed database system.
    [Show full text]
  • An Alternative Model to Overcoming Two Phase Commit Blocking Problem
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by International Journal of Computer (IJC - Global Society of Scientific Research and... International Journal of Computer (IJC) ISSN 2307-4523 (Print & Online) © Global Society of Scientific Research and Researchers http://ijcjournal.org/ An Alternative Model to Overcoming Two Phase Commit Blocking Problem Hassan Jafar Sheikh Salaha*, Dr. Richard M. Rimirub , Dr. Michael W. Kimwelec a,b,cComputer Science, Jomo Kenyatta University of Agriculture and Technology Kenya aEmail: [email protected] bEmail: [email protected] cEmail: [email protected] Abstract In distributed transactions, the atomicity requirement of the atomic commitment protocol should be preserved. The two phased commit protocol algorithm is widely used to ensure that transactions in distributed environment are atomic. However, a main drawback was attributed to the algorithm, which is a blocking problem. The system will get in stuck when participating sites or the coordinator itself crashes. To address this problem a number of algorithms related to 2PC protocol were proposed such as back up coordinator and a technique whereby the algorithm passes through 3PC during failure. However, both algorithms face limitations such as multiple site and backup coordinator failures. Therefore, we proposed an alternative model to overcoming the blocking problem in combined form. The algorithm was simulated using Britonix transaction manager (BTM) using Eclipse IDE and MYSQL. In this paper, we assessed the performance of the alternative model and found that this algorithm handled site and coordinator failures in distributed transactions using hybridization (combination of two algorithms) with minimal communication messages.
    [Show full text]
  • Transaction Management in the R* Distributed Database Management System
    Transaction Management in the R* Distributed Database Management System C. MOHAN, B. LINDSAY, and R. OBERMARCK IBM Almaden Research Center This paper deals with the transaction management aspects of the R* distributed database system. It concentrates primarily on the description of the R* commit protocols, Presumed Abort (PA) and Presumed Commit (PC). PA and PC are extensions of the well-known, two-phase (2P) commit protocol. PA is optimized for read-only transactions and a class of multisite update transactions, and PC is optimized for other classes of multisite update transactions. The optimizations result in reduced intersite message traffic and log writes, and, consequently, a better response time. The paper also discusses R*‘s approach toward distributed deadlock detection and resolution. Categories and Subject Descriptors: C.2.4 [Computer-Communication Networks]: Distributed Systems-distributed datahes; D.4.1 [Operating Systems]: Process Management-concurrency; deadlocks, syndvonization; D.4.7 [Operating Systems]: Organization and Design-distributed sys- tems; D.4.5 [Operating Systems]: Reliability--fault tolerance; H.2.0 [Database Management]: General-concurrency control; H.2.2 [Database Management]: ‘Physical Design-recouery and restart; H.2.4 [Database Management]: Systems-ditributed systems; transactionprocessing; H.2.7 [Database Management]: Database Administration-logging and recouery General Terms: Algorithms, Design, Reliability Additional Key Words and Phrases: Commit protocols, deadlock victim selection 1. INTRODUCTION R* is an experimental, distributed database management system (DDBMS) developed and operational at the IBM San Jose Research Laboratory (now renamed the IBM Almaden Research Center) 118, 201. In a distributed database system, the actions of a transaction (an atomic unit of consistency and recovery [13]) may occur at more than one site.
    [Show full text]