scispace - formally typeset
Search or ask a question

Showing papers on "Concurrency control published in 1985"


Journal ArticleDOI
TL;DR: Virtual time is a new paradigm for organizing and synchronizing distributed systems which can be applied to such problems as distributed discrete event simulation and distributed database concurrency control.
Abstract: Virtual time is a new paradigm for organizing and synchronizing distributed systems which can be applied to such problems as distributed discrete event simulation and distributed database concurrency control. Virtual time provides a flexible abstraction of real time in much the same way that virtual memory provides an abstraction of real memory. It is implemented using the Time Warp mechanism, a synchronization protocol distinguished by its reliance on lookahead-rollback, and by its implementation of rollback via antimessages.

2,280 citations


Book
01 Jan 1985
TL;DR: The method for implementing nested transactions is novel in that it uses locking for concurrency control and the necessary algorithms for locking, recovery, distributed commitment, and distributed deadlock detection for a nested transaction system are presented.
Abstract: This report addresses the issue of providing software for reliable distributed systems. In particular, we examine how to program a system so that the software continues to work in the face of a variety of failures of parts of the system. The design presented uses the concept of transactions: collections of primitive actions that are indivisible. The indivisibility of transactions insures that consistent results are obtained even when requests are processed concurrently or failures occur during a request. Our design permits transactions to be nested. Nested transactions provide nested universes of synchronization and recovery from failures. The advantages of nested transactions over single-level transactions are that they provide concurrency control within transactions by serializing subtransactions appropriately, and that they permit parts of a transaction to fail without necessarily aborting the entire transaction. The method for implementing nested transactions described in this report is novel in that it uses locking for concurrency control. We present the necessary algorithms for locking, recovery, distributed commitment, and distributed deadlock detection for a nested transaction system. While the design has not been implemented, it has been simulated.

975 citations


Journal ArticleDOI
TL;DR: This paper describes some examples of the stochastic models found useful in the design and analysis of advanced computer and communication systems and discusses concurrency control procedures for databases, dynamic channel assignment for cellular radio, and random access schemes for the control of a broadcast channel.
Abstract: (Read before the Royal Statistical Society at a meeting organized by the Research Section on Wednesday, May 8th, 1985, Professor J. B. Copas in the Chair) SUMMARY This paper describes some examples of the stochastic models found useful in the design and analysis of advanced computer and communication systems. Our major theme might be termed the control of contention. As illustrations of this theme we discuss concurrency control procedures for databases, dynamic channel assignment for cellular radio, and random access schemes for the control of a broadcast channel. We emphasize asymptotic properties of product-form distributions and we present some new results on the stability of acknowledgement based random access schemes. This paper is intended to describe to the Society some examples of the stochastic models found useful in the design and analysis of advanced computer and communication systems. The examples chosen are broadly concerned with what might be termed the control of contention, and an attempt has been made to provide enough of the technical background to motivate the models considered. In Section 2 we describe a probabilistic model, due to Mitra (1985), for conflicts anlong tran- sactions in a database. Such conflicts can arise in distributed computer systems, where to ensure the consistency of a database it is often necessary to forbid the concurrent execution of transactions involving common items: a transaction must then contend with other transactions for access to the items it requires. Mitra (1985) has shown that his model can be used to answer some important design questions concerning concurrency control procedures which use exclusive and non-exclusive locks. Mitra's results are based upon a product-form solution; we indicate how his asymptotic formulae can be extended beyond the range of light traffic and the assumption of an unstructured database. In Section 3 we discuss one of the many interesting problems which arise in connection with cellular radio. Cellular radio makes efficient use of a limited number of radio channels by allowing the repeated reuse of each channel in sufficiently separated spatial regions. The topic we consider is contention between different regions for the use of dynamically assigned channels. Everitt and Macfadyen (1983) have described an analytically tractable method of dynamic channel assign- ment, which they term the maximum packing strategy. Again a product form solution is involved: from this it is easy to obtain asymptotic formulae applicable in light traffic. These formulae establish the advantage of the strategy over a fixed channel assignment for low enough loss pro- babilities, but the advantage disappears as traffic and the number of channels increase. The real potential of dynamic schemes is their ability to cope automatically with traffic intensities which fluctuate in space and time.

372 citations


Journal ArticleDOI
01 Dec 1985
TL;DR: The design of a layered file service for the Amoeba Distributed System is discussed, on top of which various applications can easily be intplemented and provide an interface to the users.
Abstract: The design of a layered file service for the Amoeba Distributed System is discussed, on top of which various applications can easily be intplemented. The bottom layer is formed by the Amoeba Block Services, responsible for implementing stable storage and repficated, highly available disk blocks. The next layer is formed by the Amoeba File Service which provides version management and concurrency control for tree-structured files. On top of this layer, the appficafions, ranging from databases to source code control systems, determine the structure of the file trees and provide an interface to the users.

181 citations


Journal ArticleDOI
01 Dec 1985
TL;DR: A new software architecture for fault-tolerant distributed programs is presented that allows replication to be added transparently and flexibly to existing programs, and integration of the replication mechanisms into current programming languages is accomplished by means of stub compilers.
Abstract: This dissertation presents a new software architecture for fault-tolerant distributed programs. This new architecture allows replication to be added transparently and flexibly to existing programs. Tuning the availability of a replicated program becomes a programming-in-the-large problem that a programmer need address only after the individual modules have been written and verified. The increasing reliance that people place on computer systems makes it essential that those systems remain available. The low cost of computer hardware and the high cost of computer software make replicated distributed programs an attractive solution to the problem of providing fault-tolerant operation. A troupe is a set of replicas of a module, executing on machines that have independent failure modes. Troupes are the building blocks of replicated distributed programs and the key to achieving high availability. Individual members of a troupe do not communicate among themselves, and are unaware of one another''s existence; this property is what distinguishes troupes from other software architectures for fault tolerance. Replicated procedure call is introduced to handle the many- to-many pattern of communication between troupes. Replicated procedure cal is an elegant and powerful way of expressing many distributed algorithms. The semantics of replicated procedure call can be summarized as exactly-once execution at all replicas. An implementation of troupes and replicated procedure call is described. Experiments were conducted to measure the performance of this implementation; an analysis of the results of these experiments is presented. The problem of concurrency control for troupes is examined, and algorithms for replicated atomic transactions are presented as a solution. Binding and reconfiguration mechanisms for replicated distributed programs are described, and the problem of when to replace failed troupe members is analyzed. Several issues relating to programming languages and environments for reliable distributed applications are discussed. Integration of the replication mechanisms into current programming languages is accomplished by means of stub compilers. Four stub compilers are examined, and some lessons learned form them are presented. A language for specifying troupe configurations is described, and the design of a configuration manager, a programming-in-the-large tool for configuring replicated distributed programs, is presented.

160 citations


Journal ArticleDOI
TL;DR: Two new concurrency control methods, called running priority and older or running priority, are shown by the simulation results to perform better than the previously known methods (l)-(3) for relatively large n or large p, in terms of achieving a high effective level of concurrency at a comparatively small cost in wasted work.
Abstract: Given the pairwise probability of conflict p among transactions in a transaction processing system, together with the total number of concurrent transactions n, the effective level of concurrency E(n,p) is defined as the expected number of the n transactions that can run concurrently and actually do useful work. Using a random graph model of concurrency, we show for three general classes of concurrency control methods, examples of which are (1) standard locking, (2) strict priority scheduling, and (3) optimistic methods, that (1) E(n, p) l n(1 - p/2)n-1, (2) E(n, p) l (1 - (1 - p)n)/p, and (3) 1 + ((1 - p)/p)ln(p(n - 1) + 1) l E(n, p) l 1 + (1/p)ln(p(n - 1) + 1). Thus, for fixed p, as n r ∞), (1) E r 0 for standard locking methods, (2) E l 1/p for strict priority scheduling methods, and (3) E r ∞ for optimistic methods. Also found are bounds on E in the case where conflicts are analyzed so as to maximize E.The predictions of the random graph model are confirmed by simulations of an abstract transaction processing system. In practice, though, there is a price to pay for the increased effective level of concurrency of methods (2) and (3): using these methods there is more wasted work (i.e., more steps executed by transactions that are later aborted). In response to this problem, three new concurrency control methods suggested by the random graph model analysis are developed. Two of these, called (a) running priority and (b) older or running priority, are shown by the simulation results to perform better than the previously known methods (l)-(3) for relatively large n or large p, in terms of achieving a high effective level of concurrency at a comparatively small cost in wasted work.

150 citations


Journal ArticleDOI
TL;DR: A unified view of the problems associated with concurrency control and recovery for transaction-oriented multiuser centralized database management systems is taken, and several integrated mechanisms are presented.
Abstract: In spite of the wide variety of concurrency control and recovery mechanisms proposed during the past decade, the behavior and the performance of various concurrency control and recovery mechanisms remain largely not well understood. In addition, although concurrency control and recovery mechanisms are intimately related, the interaction between them has not been adequately explored. In this paper, we take a unified view of the problems associated with concurrency control and recovery for transaction-oriented multiuser centralized database management systems, and we present several integrated mechanisms. We then develop analytical models to study the behavior and compare the performance of these integrated mechanisms, and we present the results of our performance evaluation.

142 citations


Journal ArticleDOI
TL;DR: An efficient scheme for eliminating conflicts between distributed read-only transactions and distributed update transactions, thereby reducing synchronization delays and the recovery from transaction and system failures is greatly simplified and the taking of database dumps also can be accommodated while leaving the database on-line.
Abstract: This paper presents an efficient scheme for eliminating conflicts between distributed read-only transactions and distributed update transactions, thereby reducing synchronization delays. The scheme makes use of a multiversion mechanism in order to guarantee that distributed read-only transactions see semantically consistent snap-shots of the database, that they never have to be rolled-back due to their late arrival at retrieval sites, and that they inflict minimal synchronization delays on concurrent update transactions. Proof that the presented scheme guarantees semantic consistency is provided. Two important by-products of this scheme are that the recovery from transaction and system failures is greatly simplified and the taking of database dumps also can be accommodated while leaving the database on-line.

117 citations


Proceedings ArticleDOI
01 Jun 1985
TL;DR: Until recently concurrency control theory has focussed on one-level systems, but real data base systems go beyond this classlcal view, so a typical schedule acting on two layers would look like:
Abstract: Until recently concurrency control theory has focussed on one-level systems, I. 8. regarding schedules simply as sequences of read and write operatlons on objects of one particular abstractlon level (/Pa79/, /BSW79/). usually pages or tuples. Nevertheless. real data base systems sometlmes go beyond this classlcal view. a well-known eXarI’tple being System R. To Increase concurrency, locking Is applied twice within thls prototype. on tuples until end-of-transactlon and on pages for the scope of each tuple operatlon. Since page locks are released before the commitment of the complete transaction. the approach Is called ‘open nested transactlon’ (/Tr83/) , A typical schedule acting on two layers would look like:

103 citations


Proceedings ArticleDOI
01 May 1985
TL;DR: A “complete” model of a database emlronment is employed to study the performance of three dlfferent approaches to the concurrency control problem under a “arleb of modehng assumptions” and examines how differences m the underlymg assumpnons explam the seemmgl\ contradlctorq performance results.
Abstract: A number of recent studies hale exammed the performance of concurrent\ control algorithms for database management s\stems The results reported to date rather than bemg defimove ha\e tended to be contradIctor> In 011s paper rather than presenting “yet another algorithm performance stud)” we crlbcally mvesngate the assumwons made m the models used m past studies and their Imphcatlons We employ a “complete” model of a database emlronment to study the relatn~e performance of three dlfferent approaches to the concurrency control problem under a \arleb of modehng assumptions We shon how differences m the underlymg assumpnons explam the seemmgl\ contradlctorq performance results We also examine how reahsnc the various assumptions would be for “real” database sqqtems

95 citations


Journal ArticleDOI
TL;DR: An algorithm for detecting deadlocks in a distributed database system and incorporating a post-resolution computation that leaves information characterizing dependence relations of remaining transactions of the deadlock cycle in the system, which will help in detecting and resolving deadlocks which may arise in the future.
Abstract: Deadlock handling is an important component of transaction management in a database system. In this paper, we contribute to the development of techniques for transaction management by presenting an algorithm for detecting deadlocks in a distributed database system. The algorithm uses priorities for transactions to minimize the number of messages initiated for detecting deadlocks. It does not construct any wait-for graph but detects cycles by an edge-chasing method. It does not detect any phantom deadlock (in the absence of failures), and for the resolution of deadlocks it does not need any extra computation. The algorithm also incorporates a post-resolution computation that leaves information characterizing dependence relations of remaining transactions of the deadlock cycle in the system, and this will help in detecting and resolving deadlocks which may arise in the future. An interesting aspect of this algorithm is that it is possible to compute the exact number of messages generated for a given deadlock configuration. The complexity is comparable to the best algorithm reported. We first present a basic algorithm and then extend it to take into account shared and exclusive lock modes, simultaneous acquisition of multiple locks, and nested transactions.

Proceedings Article
21 Aug 1985
TL;DR: A simple concurrency control mechan- ism for B+-trees Databases is presented, based on early split- ting and catenating of nodes during a process, which enable to lock only the current node in the process and its father node, to increase the degree of concurrency relatively to other known mechanisms.
Abstract: A simple concurrency control mechan- ism for B+-trees Databases is intro- duced. It is based on early split- ting and catenating of nodes during a process, which are candidates for such operations later on in that process. These early operations enable to lock only the current node in the process and its father node, and hence to increase the degree of concurrency relatively to other known mechanisms.

Journal ArticleDOI
TL;DR: New analytic models are presented which predict the maximum throughput of locking and optimistic concurrency control algorithms for a centralized database system by making several simplifying assumptions and are shown to have an accuracy considerably better than some previously reported methods.

Journal ArticleDOI
21 Aug 1985
TL;DR: In this paper, the authors describe an algorithm to read entire databases with locking concurrency control allowing multiple readers or an exclusive writer, which runs concurrently with the normal transaction processing (on-the-fly), and locks the en-tities in the database one by one (incremental).
Abstract: We describe an algorithm to read entire databases with locking concurrency control allowing multiple readers or an exclusive writer. The algorithm runs concurrently with the normal transaction processing (on-the-fly), and locks the en-tities in the database one by one (incremental). We prove the algorithm produces consistent pictures of the database. We also show that the algorithm aborts a minimal number of updates in the class of on-the-fly, incremental, consistent algorithms. On-the-fly, incremental algorithms to read entire data- bases consistently can improve system availability and reli- ability. Most existing systems either require the transaction processing to stop, or produce potentially inconsistent re- sults. Our algorithm does not change the database physical design, so it can be adapted to existing systems by expand- ing their lock table. Finally, we extend the algorithm in a straightforward way to read entire distributed databases.

Journal ArticleDOI
TL;DR: This paper presents a theory for proving the correctness of algorithms that manage replicated data, an extension of serializability theory, and uses the theory to give simple correctness proofs for two replicated data algorithms: Gifford's “quorum consensus” algorithm, and Eager and Sevcik's ‘missing writes’ algorithm.

Journal ArticleDOI
TL;DR: An atomk remote procedure call mechanism is implemented which provides users a simple and reliable language primitive and detailed concurrency control and recovery algorithms are given, and illustrated with examples.
Abstract: Remote procedure call (RPC) is a programming primitive that makes building distributed programs easier. Atomicity, whkh implies totality and serializability, has been recognized as an important property to assure consistency in spite of computing node crashes. We have implemented an atomk remote procedure call mechanism which provides users a simple and reliable language primitive. Concurrency is controlled by attaching a call graph path identifier to each message representing a procedure call. Procedures keep their last accepted calling message paths to compare against incoming message paths. Only calls that can be serialized are accepted. Associated states of static variables are saved in backup processors on procedure entry and restored to corresponding variables in case of procedure crash. Detailed concurrency control and recovery algorithms are given, and illustrated with examples.

Journal ArticleDOI
TL;DR: This paper presents a formal treatment of atomicity, and treats serializability and recoverability together together, facilitating the precise analysis of online implementations, and focuses on local properties of components of a system, thus supporting modular design.
Abstract: Maintaining the consistency of long-lived, on-line data is a difficult task, particularly in a distributed system. A variety of researches have suggested atomicity as a fundamental organizational concept for such systems. In this paper we present a formal treatment of atomicity. Our treatment is novel in three respects: First, we treat serializability and recoverability together, facilitating the precise analysis of online implementations. Second, we explore how to analyze user-specified semantic information to achieve greater concurrency. Third, we focus on local properties of components of a system, thus supporting modular design. We present three local properties, verify that they ensure atomicity, and show that they are optimal. Previously published protocols are suboptimal. We show that these differences are the result of fundamental limitations in the model used to analyze those protocols; these limitations are not shared by our model.

Journal ArticleDOI
Alexander Thomasian1
TL;DR: An inexpensive analytic solution method is proposed, also based on hierarchical decomposition, such that the throughput of the computer system is characterized by the number of active transactions (regardless of class), which can be used to determine the effect of granularity of locking on system performance.
Abstract: The performance of transaction processing systems is determined by the contention for hardware as well as software resources (database locks), due to the concurrency control mechanism of the database being accessed by transactions. We consider a transaction processing system with a set of dominant transcation classes. Each class needs to acquire a certain subset of the locks in the database before it can be processed, i.e., predeclared lock requests with static locking. Straightforward application of the decomposition method requires the numerical solution of a two-dimensional Markov chain. Equivalently, a hierarchical simulation method, where the computer system is represented by a composite queue with exponential service rates, can be used to analyze the system. We propose an inexpensive analytic solution method, also based on hierarchical decomposition, such that the throughput of the computer system ic characterized by the number of active transactions (regardless of class). Numerical results are provided to show that the new method is adequately accurate compared to the other two rather costly methods. It can be used to determine the effect of granularity of locking on system performance. The solution method is also applicable to multiresource queueing systems with multiple contention points.

Journal ArticleDOI
TL;DR: This paper has studied these issues with respect to a relational database on a local computer system connected by a multiaccess broadcast bus and a transaction model that integrates the control strategies in concurrency control and query processing is proposed.
Abstract: Concurrency control, distribution design, and query processing are some of the important issues in the design of distributed databases. In this paper, we have studied these issues with respect to a relational database on a local computer system connected by a multiaccess broadcast bus. A broadcast bus allows information to be distributed efficiently, and hence simplifies the solutions to some of these issues. A transaction model that integrates the control strategies in concurrency control and query processing is proposed. In concurrency control, the lock, unlock, and update of data are achieved by a few broadcasts. A dynamic strategy is used in query processing, as less data are transferred when compared to a static strategy. The status information needed in dynamic query processing can be conveniently obtained by broadcasting. Lastly, some NP-hard file placement problems are found to be solvable in polynomial time when updates are broadcast.

Journal ArticleDOI
M.T. Ozsu1
TL;DR: The research has resulted in the development of a formalism, called the Extended Place/Transition Nets (EPTN), which is both descriptively powerful in that it can be used to model various algorithms precisely and succinctly and to communicate them in a clear manner, while at the same time lending itself to be used as a performance evaluation tool.
Abstract: Distributed database systems (DDBS) have received considerable attention in recent years. Being a relatively young research field, there are still many problems associated with DDB systems that need solution. Concurrency control is one of these problems and, probably, the most extensively studied. However, most of the work has concentrated on the development of alternative solutions and the field seems to be ready for some comparative analysis work. This paper reports the results of a performance evaluation study on distributed database concurrency control algorithms. The research has resulted in the development of a formalism, based on Petri nets, for modeling and analysis purposes. The formalism, called the Extended Place/Transition Nets (EPTN), is both descriptively powerful in that it can be used to model various algorithms precisely and succinctly and to communicate them in a clear manner, while at the same time lending itself to be used as a performance evaluation tool. An EPTN simulator is implemented and various algorithms are studied using this tool. This paper describes both the formalism and the performance results that have been obtained.

Journal ArticleDOI
01 Aug 1985
TL;DR: The performance of multiple systems sharing a common data base is analyzed for an architecture with concurrency control using a centralized lock engine and the emphasis is on the methodology, approximate analysis technique and on examining the factors that affect multi-system performance.
Abstract: The performance of multiple systems sharing a common data base is analyzed for an architecture with concurrency control using a centralized lock engine. The workload is based on traces from large mainframe systems running IBM's IMS database management system. Based on IMS lock traces the lock contention probability and data base buffer invalidation effect in a multi-system environment is predicted. Workload parameters are generated for use in event-driven simulation models that examine the overall performance of multi-system data sharing, and to determine the performance impact of various system parameters and design alternatives. While performance results are presented for realistic system parameters, the emphasis is on the methodology, approximate analysis technique and on examining the factors that affect multi-system performance.

Journal ArticleDOI
TL;DR: A probabilistic model for conflicts among transactions in a database is given, allowing two kinds of locks for concurrency control, exclusive and non-exclusive, which yields exact formulas for performance measures, such as mean concurrency and throughput.
Abstract: We give a probabilistic model for conflicts among transactions in a database. We extend recent work (Mitra and Weinberger, J. Assoc. Comput. Mach., 31 (1984), pp. 855–878) by allowing two kinds of locks for concurrency control, exclusive and non-exclusive. Thus read locks allow shared access and are therefore non-exclusive, while write locks are exclusive. An arriving transaction is blocked if it conflicts with any of the transactions already undergoing processing; otherwise, it is accepted for concurrent processing. Our treatment, which has probabilistic, combinatorial and analytic components, yields exact formulas for performance measures, such as mean concurrency and throughput. For large databases special formulas are derived and proven to be asymptotically exact. These formulas are simple and also fit well to the exact formulas. What are non-exclusive locks worth? A succinct answer is given for this important design question.

Journal ArticleDOI
TL;DR: An overview is presented of an approach to distributed database design which emphasizes high availability in the face of network partitions and other communication failures, and a mechanism is proposed, based on alerters and triggers, by which applications can deal with exception conditions which may arise as a consequence of the high-availability architecture.
Abstract: An overview is presented of an approach to distributed database design which emphasizes high availability in the face of network partitions and other communication failures. This approach is appropriate for applications which require continued operation and can tolerate some loss of integrity of the data. Each site presents its users and application programs with the best possible view of the data which it can, based on those updates which it has received so far. Mutual consistency of replicated copies of data is ensured by using time stamps to establish a known total ordering on all updates issued, and by a mechanism which ensures the same final result regardless of the order in which a site actually receives these updates. A mechanism is proposed, based on alerters and triggers, by which applications can deal with exception conditions which may arise as a consequence of the high-availability architecture. A prototype system which demonstrates this approach is near completion.

Proceedings ArticleDOI
25 Mar 1985
TL;DR: In this paper, a new notion of multiversion serializability based on conflicts (MVCSR) was introduced, and discussed its relation with the well known single version conflict serialization (CSR).
Abstract: Multiversion schedulers are now a widely accepted method for enhancing the performance of the concurrency control component of a database. In this paper we introduce a new notion of multiversion serializability (MVSR) based on conflicts (MVCSR), and discuss its relation with the well known single version conflict serializability (CSR). On-line schedulable (OLS) subsets of (MVSR) were defined in Papadimitriou and Kanellakis, ACM Trans. Database Systems 9, No. 1 (1984). We prove there that it is NP-complete to decide whether a set of schedules is OLS. We next introduce the concept of maximal OLS sets, and show that no efficient scheduler can be designed that recognizes maximal subsets of the MVSR or MVCSR schedules.

Journal ArticleDOI
TL;DR: An analytical model is used to estimate the delays in transmission channels of the long haul network supporting the distributed database system, showing that the constant transmission time assumption cannot be justified in many cases, and that the response time is sensitive to the parameters mentioned above.
Abstract: Performance analysis studies of distributed database systems in the past have assumed that the message transmission time between any two nodes of a network is constant. They disregard the effect of communication network parameters such as network traffic, network topology, and capacity of transmission channels. In this paper, an analytical model is used to estimate the delays in transmission channels of the long haul network supporting the distributed database system. The analysis shows that the constant transmission time assumption cannot be justified in many cases, and that the response time is sensitive to the parameters mentioned above. Extensions and performance analysis in the context of interconnection networks are also discussed.

Journal ArticleDOI
TL;DR: This paper performs a systematic study of the consequences of allowing lock conversions in non-two-phase locking protocols, and shows how this leads to increased concurrency and affects deadlock-freedom.
Abstract: A locking protocol is a set of rules governing the manner in which the database entities may be accessed. Such a protocol usually employs several kinds of locks. Most of the previous work in this area has assumed that once a transaction acquires a particular kind of lock on a data item it is not allowed to convert this lock to another kind. In this paper we perform a systematic study of the consequences of allowing lock conversions in non-two-phase locking protocols, and show how this leads to increased concurrency and affects deadlock-freedom. The non-two-phase protocols that we study are the very general guard protocols defined for databases in which a directed acyclic graph structure can be superimposed on the data items. We present very natural generalizations of these protocols, including correctness proofs, and develop deadlock removal methods.

Proceedings Article
01 Jan 1985
TL;DR: The purpose is to devise concurrency control methods that allow the computation of derived information to proceed without interfering with the updating of raw data.
Abstract: In a large integrated database, there often exists an “information hierarchy,” where both raw data and derived data are stored and used together. Therefore, among update transactions, there will often be some that perform only read accesses from a certain (i.e., the “raw” data) portion of the database and write into another (i.e., the “derived” data) portion. A conventional concurrency control algorithm would have treated such transactions as regular update transactions and subjected them to the usual protocols for synchronizing update transactions. In this paper such transactions are examined more closely. The purpose is to devise concurrency control methods that allow the computation of derived information to proceed without interfering with the updating of raw data.The first part of the paper presents a proof method for correctness of concurrency control algorithms in a hierarchically decomposed database. The proof method provides a framework for understanding the intricacies in dealing with hierarchically decomposed databases. The second part of the paper is an application of the proof method to show the correctness of a two-phase-locking- based algorithm, called partitioned two-phase locking, for hierarchically decomposed databases. This algorithm is a natural extension to the Version Pool method proposed previously in the literature.

DOI
01 Jan 1985
TL;DR: This paper proposes two integrated methods for implementing concurrency control and replication for data of abstract type that minimizes constraints on availability and concurrency and uses quorum consensus.
Abstract: Data managed by a distr ibuted program may be subject to consistency and availability requirements that must be satisfied in the presence of concurrency, site crashes, and network partit ions. This paper proposes two integrated methods for implementing concurrency control and replication for data of abstract type. Both methods use quorum consensus. The Consensus Locking method minimizes constraints on availability, and the Consensus Schedul ing method minimizes constraints on concurrency. These methods systematically exploit type-specif ic propert ies of the data to provide better availability and concurrency than methods based on the convent ional read/wr i te classif ication of operat ions. Necessary and suff icient constraints on correct implementations are derived directly from the data type specif icat ion. These constraints reveal that an object cannot be replicated in a way that simultaneously minimizes constraints on both availability and concurrency. C o p y r i g h t © 1985 Maurice Herlihy i' This research was sponsored by the Defense Advanced Research Projects Agency (DOD), ARPA Order No. 3597, monitored by the Air Force Avionics Laboratory Under Contract F33615-81-K-1539 The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Defense Advanced Research Projects Agency or the US Government.

Proceedings ArticleDOI
01 Aug 1985
TL;DR: The comparison of constraints on quorum assignment necessary to maximize concurrency under generalized locking, timestamping, and hybrid concurrency control mechanisms shows that hybrid schemes impose more constraints on availability than timestamping schemes, and locking schemes impose constraints incomparable to those of the others.
Abstract: Most pessimistic mechanisms for implementing atomicity in distributed systems fall into three broad categories: two-phase locking schemes, timestamping schemes, and hybrid schemes employing both locking and timestamps. This paper proposes a new criterion for evaluating these mechanisms: the constraints they impose on the availability of replicated data.A replicated data item is a typed object that provides a set of operations to its clients. A quorum for an operation is any set of sites whose co-operation suffices to execute that operation, and a quorum assignment associates a set of quorums with each operation. Constraints on quorum assignment determine the range of availability properties realizable by a replication method.This paper compares the constraints on quorum assignment necessary to maximize concurrency under generalized locking, timestamping, and hybrid concurrency control mechanisms. This comparison shows that hybrid schemes impose weaker constraints on availability than timestamping schemes, and locking schemes impose constraints incomparable to those of the others. Because hybrid schemes permit more concurrency than locking schemes, these results suggest that hybrid schemes are preferable to the others for ensuring atomicity in highly available and highly concurrent distributed systems.This research was sponsored by the Defense Advanced Research Projects Agecy (DOD), ARPA Order No. 3597, monitored by the Air Force Avionics Laboratory Under Contract F33615-81-K-1539.The views and conclusions contained in this document are those of the authords and should not be interpreted as representing the official policies, either expressed or implied, of the Defense Advanced Research Projects Agency or the US Government.

Proceedings Article
01 Jan 1985
TL;DR: It is shown how the NmergeH extension of a purely functional model permits seriallzable concurrent "primary site" distribution control and preliminary experimental results indicate that a reasonable degree of concurrency is attainable from the functional approach.
Abstract: The application of functional programming concepts to the data representation and query!ng aspects of databases has been discussed by Shipman and Buneman, et al. respectively. We argue the suitability of a function-based approach to additional aspects of database systems, including updating, transaction serialization, and physical distribution and communication. It is shown how the NmergeH extension of a purely functional model permits seriallzable concurrent "primary site" distribution control. We also present preliminary experimental results which indicate that a reasonable degree of concurrency is attainable from the functional approach.