Showing papers on "Concurrency control published in 1982"

On extending the functions of a relational database system

Abstract: Relational database systems are attracting great interest from potential users outside the traditional areas in which such systems have been employed. Features of modern relational systems such as powerful query facilities, data and device independence, concurrency control, and recovery are useful in applications such as engineering design, office automation, and graphics. However, such applications place demands on the system that it must be extended to handle. This paper identifies three of these demands: storing non-coded information of arbitrary length within the database, dealing with aggregate objects as a unit, and improving support for interactive access. Additions to System R, a prototypical relational system, are introduced to satisfy these demands: long fields, for storing non-coded data, and complex objects, which declare the semantic relationships among data items and provide a means for adequately supporting interactive access.

Load Balancing in Distributed Systems

Abstract: In a distributed computing system made up of different types of processors each processor in the system may have different performance and reliability characteristics. In order to take advantage of this diversity of processing power, a modular distributed program should have its modules assigned in such a way that the applicable system performance index, such as execution time or cost, is optimized. This paper describes an algorithm for making an optimal module to processor assignment for a given performance criteria. We first propose a computational model to characterize distributed programs, consisting of tasks and an operational precedence relationship. This model alows us to describe probabilistic branching as well as concurrent execution in a distributed program. The computational model along with a set of seven program descriptors completely specifies a model for dynamic execution of a program on a distributed system. The optimal task to processor assignment is found by an algorithm based on results in Markov decision theory. The algorithm given in this paper is completely general and applicable to N-processor systems.

Distributed deadlock detection algorithm

Abstract: We propose an algorithm for detecting deadlocks among transactions running concurrently in a distributed processing network (i.e., a distributed database system). The proposed algorithm is a distributed deadlock detection algorithm. A proof of the correctness of the distributed portion of the algorithm is given, followed by an example of the algorithm in operation. The performance characteristics of the algorithm are also presented.

A Quorum-Based Commit Protocol

Abstract: Herein, we propose a commit protocol and an associated recovery protocol that is resilient to site failures, lost messages, and network partitioning. The protocols do not require that a failure be correctly identified or even detected. The only potential effect of undetected failures is a degradation in performance. The protocols use a weighted voting scheme that supports an arbitrary degree of data replication (including none) and allows unilaterally aborts by any site. This last property facilitates the integration of these protocols with concurrency control protocols. Both protocols are centralized protocols with low message overhead.

The implementation of an integrated concurrency control and recovery scheme

Abstract: This paper describes the implementation level design of an integrated concurrency control and recovery scheme based on the maintenance of multiple versions of data objects in a database. The concurrency control mechanism enhances parallelism by eliminating interference between retrieval and update transactions. The recovery mechanism permits efficient transaction and system recovery by keeping before-images of data objects at the page (block) level. This paper addresses the key technical problems in the implementation of such an integrated scheme. We present an efficient garbage collection algorithm for reclaiming storage space used by old versions of data objects that will no longer be accessed. We also propose an on-line backup algorithm that will permit the backup procedure to run in parallel with regular transactions. This integrated concurrency control and recovery scheme is being implemented in the LDM: the local database manager component of a distributed database management system, now being developed by Computer Corporation of America, that will support the ADAPLEX database application programming language [Chan81a, Smith81].

Transactions and consistency in distributed database systems

Abstract: The concepts of transaction and of data consistency are defined for a distributed system. The cases of partitioned data, where fragments of a file are stored at multiple nodes, and replicated data, where a file is replicated at several nodes, are discussed. It is argued that the distribution and replication of data should be transparent to the programs which use the data. That is, the programming interface should provide location transparency, replica transparency, concurrency transparency, and failure transparency. Techniques for providing such transparencies are abstracted and discussed.By extending the notions of system schedule and system clock to handle multiple nodes, it is shown that a distributed system can be modeled as a single sequential execution sequence. This model is then used to discuss simple techniques for implementing the various forms of transparency.

The time relational model

Abstract: Existing data base management systems (DBMSs) allow users to operate upon the latest (committed) data base state. However, many real world applications require storing and accessing historical information. Furthermore, there are no provisions in current DBMSs for the distinction between the physical time a given data item is entered, and the time period to which it pertains. Many data base updates in real applications are either "retroactive", i.e., their effectiveness takes place sometime in the past, or "proactive", i.e., their effectiveness will take place sometime in the future. The Time-Relational Model is an architecture which integrates comprehensive time processing capabilities into the Relational Model of data bases for managing changes of data values, data manipulation rules, and data structure. However, those who are not concerned about Time in their particular applications may perceive this model as a regular relational model. A fundamental concept is the time-view of data and transaction programs. Its major objective is to automatically and dynamically provide multiple and complete data base views reflecting different points in time, including all system components that may change over time. The time-view theorem provides necessary and sufficient conditions for achieving any desirable, dynamic time-view. The time-consistency theorem states the conditions for which a given computation can be reproduced again and again in the face of data base changes over time. The basic relational algebra operators are extended to include the time-view concept, resulting in the time relational algebra. An implementation architecture is developed which demonstrates the feasibility of such model. The central idea is to gain more functions and solutions based on the presence of time related information and, thus, spread the overall operational and implementation cost across multiple sources. Recovery Manager and Concurrency Control Procedures are developed. The recovery manager uses only the data itself for its own operation rather, than a logging facility; there is no need for a locking mechanism to provide each user with an appropriate isolation level from other concurrent users. A real-life case study is described based on the Informatics Inc. Manufacturing Planning System - PRODUCTION-IV.

Achieving Distributed Termination without Freezing

Abstract: An efficient algorithm for achieving distributed termination without introducing new communicaton channels and without delaying the basic computations ("freezing") is presented. The algorithm is related to the methodology of designing distributed programs where the programmer is relieved from the problem of distributed termination. An informal correctness proof and complexity analysis are included.

A New Method for Concurrency in B-Trees

Abstract: In this paper we study the problem of supporting concurrent operations in B-trees and their variants. A survey of previous work is given and two basic types of solutions to this problem are identified. A new solution with a greater degree of concurrency is proposed. As solutions are surveyed or presented we identify useful techniques which have wider applicability. In particular, we introduce the technique of side-branching in our new solution.

On concurrency control by multiple versions

Abstract: We examine the problem of concurrency control when the database management system supports multiple versions of the data. We characterize the limit of the parallelism achievable by the multiversion approach and demonstrate the resulting space-parallelism tradeoff.

Protocols for Deadlock Detection in Distributed Database Systems

Abstract: In distributed databases, deadlocks may occur due to conflicts in data file lockings A system is in a deadlock if and only if there is a directed cycle in its demand graph. However, due to the inherent communication delay in a distributed system, it is not easy to construct a consistent demand graph for a distributed system. In this paper, three deadlock detection protocols are discussed. The first protocol uses two communication phases. The second protocol uses a single communication phase. Based on the second protocol, a one-phase hierarchical deadlock detection protocol is developed.

Design of concurrency controls for transaction processing systems

Abstract: : A complete transaction processing system was developed for Cm*, a distributed multi-microprocessor. This system used a concurrency control in which all functions required by the paradigm were available, and the concurrency control used a policy module implementing a number of policies, any of which could be chosen at run-time. The record manager of this system supported a simple relational view of the database, with one or more B-tree indexes for each relation. The record manager was replicated, and copies of versions of shared data objects were cached. The usefulness of the design framework was illustrated by the fact that the record manager, the most complex subsystem, was earlier developed on a completely different centralized system, and required only minor modifications to be used in this system. Experiments were performed with varying numbers of processors, and with various policies. For this system, the effect of waiting due to locking proved to be negligible, and so locking policies generally gave the best performance. This result may not apply to other systems, though: as an example of one of many possible differences, in this system individual processors were not multiprogrammed. However, using a concurrency control policy module, it is easy to investigate many different concurrency controls on any system, as demonstrated by these experiments.

Reliability issues for fully replicated distributed databases

Abstract: Reliability is commonly considered to be one of the main advantages of distributed databases, but there are problems that must be overcome before it can be achieved. Exactly what is reliability? There are many types of failures, and we should know which types the system will be protected against. It is also necessary to define how the system will react to those failures. A considerable number of special protocols must be implemented with great care in order to realize the desired level of reliability. The purpose of this article is to discuss the design alternatives and problems that must be solved in order to make a completely replicated distributed database reliable. A distributed database is completely replicated if a copy of the value of any data item is stored at every node (or site) in the system. A completely replicated distributed database is a special case of a general distributed database, and there are several reasons for studying the reliability issues in this limited context: (1) Complete replication simplifies the problems. Making a distributed database reliable is not a simple matter, so as a first step we can try to understand a simplified specific case. (2) Replicated data is the key to making data available after failures, so we will actually be concentrating on the critical component of distributed databases. (3) Transaction processing (with no failures) in a completely replicated distributed database is well understood and a good number of papers have been written on the subject. 1-5 Most of the research for reliable distributed databases has been performed in the context of particular transaction processing algorithms. (There are exceptions, however .6'7) This means that only the alternatives best suited to the transaction processing algorithm are considered. In this article this will be avoided by not advocating a particular transaction processing algorithm. A person designing a reliable distributed database is faced with a set of choices. Here these choices are divided into seven broad categories and each category will be discussed in one of the following sections. For each choice that must be made by the designer, I will attempt to give the major alternatives available and then list the implications of these alternatives. Many of the mechanisms for reliable distributed databases that we will discuss have been presented in the literature. I would like to caution the reader that my division of choices is somewhat arbitrary and that the …

Concurrency control performance issues

Abstract: Concurrency control methods are studied in two contexts: centralized and distributed database management systems. Models to study the performance of the many algorithms that have been proposed to keep databases consistent are presented. For the centralized case of heuristic analytical model is solved iteratively and results concerning optimal granularity are derived. A proof that for all reasonable systems the iteration converges is given. Additionally, a simple test that determines whether the point of convergence is unique is provided. Previous studies of the performance of concurrency control mechanisms in distributed database management systems have not considered workload characteristics or system constraints. These factors are incorporated into a framework that enables an easier choice of concurrency control algorithm for a distributed database management system. Finally, two distributed algorithms are compared using a simulation model and the effect of various system and workload parameters are investigated.

Concurrency control in database systems: A step towards the integration of optimistic methods and locking

Abstract: The traditional approach to concurrency control is based on locking. Recently, new methods have been presented called optimistic methods. These methods are well suited in situations where the likelihood of conflicting actions is rather small. Otherwise locking should be used. Typically in database systems it is not known in advance what kind of transactions are to be processed. Therefore what is really needed are methods which combine the benefits of optimistic methods and locking. This paper is a first step in this direction.

Why control of the concurrency level in distributed systems is more fundamental than deadlock management

Abstract: Over the past years, stress has been put on global deadlock processing in distributed database management systems. This paper presents the main results of evaluation studies which were intended to provide clues for the choice of a concurrency control mechanism for the SCOT project. The relationship between deadlock management algorithm and concurrency level is exhibited. Their respective influence on system performance is studied in the light of simulations of several concurrency control techniques. A good algorithm for concurrency control is that which controls the concurrency level while solving, as a side effect, the deadlock question.

Distributed deadlock detection in distributed database systems

Abstract: Deadlock detection in distributed database systems is very complicated and difficult to handle because of the distributed nature of the system and the communication delay of the network. Many detection algorithms have been proposed in the past, but most of them have been shown to be incorrect and inefficient. Designing an applicable algorithm is still worthy of intensive study. In this thesis, a distributed deadlock detection algorithm is proposed. Checking a cycle in a graph, called an "RTR" graph, is used to detect a deadlock state. The inter-communication scheme of the algorithm generates and propagates "reaching" messages in order to update the RTR graphs at other sites. The reaching message is a fixed-size message containing a transaction node, a resource node and a timestamp. Timestamps are also attached to the graph edges in order to avoid false deadlocks. A deadlock recovery approach is also proposed to break deadlock after it is detected. A minimum cost policy and a "polling" synchronization scheme are used in the algorithm in order to break the detected deadlock state with a minimum communication cost. A message generation scheme based on transaction ordering has been applied to the proposed deadlock detection algorithm to reduce the number of reaching messages transmitted and increase the efficiency of the deadlock detection. For a deadlock state with n transactions involved, this algorithm needs half the number of reaching messages of the original algorithm in the worst case. The proposed algorithm has been shown to be correct and more efficient compared to previously proposed algorithms. It has been shown that the reaching message generation scheme of the algorithm will ensure the detection of all possible deadlocks, and the comparison of timestamps in graph edges and messages will prevent false deadlocks. A simulator in PATH PASCAL has been written during the design of the algorithm for testing correctness and improving performance. Four network sites with I/O channels to the virtual network model have been simulated.

A theorem in database concurrency control

Abstract: Consider two straight-line programs a and b, and let h be a set of sequences of steps of a and b, possibly interleaved, but each containing all steps of a and b in the right order. A necessary and sufficient condition is given for h to be realisable as the set of all sequences of steps which are legal under some insertion of lock-unlock steps between the steps of a and b. 13 references.

Freedom from Deadlock of Safe Locking Policies

Abstract: The usual method for preserving the consistency of a database when accessed (read and updated) concurrently by several transactions, is by locking the transactions according to some locking policy; a locking policy that guarantees the preservation of consistency of the database is called safe. Furthermore, if no deadlocks can arise the policy is called deadlock-free. In this paper we are concerned with the freedom from deadlock of safe locking policies. We show that a simple extension of the DAG policy of [Y] is the most general safe and deadlock-free policy for a pair of transactions. We prove however, that it is NP-complete to test whether a set of transactions is not deadlock-free even for the simplest kind of transactions, those that are two-phase locked [E]. We show that for the natural class of safe locking policies, the L-policies, studied in [Y], freedom from deadlock is determined only by the order in which entities are accessed by the transactions and not by the way in which safety is ensured. A...

File allocation in a distributed database

Abstract: A File allocation problem is studied in this paper. The problem formulated is to minimize transmission cost where the constraints are the number of files and the number of copies. The transmission cost also reflects concurrency control cost which is essential in a distributed database system. It is demonstrated that an optimal solution can be found by transforming this problem to a network flow problem.

Deadlock freedom using edge locks

Abstract: We define a series of locking protocols for database systems that all have three main features: freedom from deadlock, multiple granularity, and support for general collections of locking primitives. A rooted directed acyclic graph is used to represent multiple granularities, as in System R. Deadlock freedom is guaranteed by extending the System R protocol to require locks on edges of the graph in addition to the locks required on nodes.

Performance evaluation of a two-phase commit based protocol for DDBs

Abstract: Many concurrency control algorithms for distributed database management systems have been proposed in the last few years, but little has been done to analyse their performance. This paper presents the specification of a concurrency control algorithm based on the two-phase commit protocol for DDBs. The results of a complete performance analysis based on an analytic model are presented and discussed.

An optimal algorithm for testing for safety and detecting deadlocks in locked transaction systems

Abstract: Various notions are introduced for the closure of a set of rectilinearly oriented rectangles on the plane. Optimal algorithms are presented for computing the closures. These algorithms imply optimal solutions to several problems related to database concurrency control.

Compatibility and commutativity in non-two-phase locking protocols

Abstract: Research on concurrency control mechanisms for database systems has had as a primary goal the discovery of techniques for allowing increased levels of concurrent execution of transactions. In this paper, we study this problem in the context of non-two-phase locking protocols which are defined for data bases in which a directed acyclic graph structure is superimposed on the data items. We introduce a new lock mode, called INV, with properties fundamentally different from locking modes previously studied and show how this allows increased concurrency. Through the introduction of the INV mode of locking we have enunciated a new principle of the theory of data base concurrency control. This principle involves the separation of the effects of the commutativity and compatibility of data manipulation operations. We then examine how the introduction of such a lock mode affects the occurrence of deadlocks in a system. Certain conditions under which deadlock-freedom is maintained are identified, and simple methods for removing deadlocks in other situations are presented.

Is distributed locking harder

Abstract: We examine the problem of determining whether a set of locked transactions, accessing a distributed database, is guaranteed to produce only serializable schedules. For a pair of transactions we prove that this concurrency control problem (which is polynomially solvable for centralized databases) is in general coNP-complete. We employ a new graph-theoretic technique and provide an efficient test for the special case of databases distributed between two sites only.