Showing papers on "Concurrency control published in 1984"

An algorithm for concurrency control and recovery in replicated distributed databases

Abstract: In a one-copy distributed database, each data item is stored at exactly one site. In a replicated database, some data items may be stored at multiple sites. The main motivation is improved reliability: by storing important data at multiple sites, the DBS can operate even though some sites have failed.This paper describes an algorithm for handling replicated data, which allows users to operate on data so long as one copy is “available.” A copy is “available” when (i) its site is up, and (ii) the copy is not out-of-date because of an earlier crash.The algorithm handles clean, detectable site failures, but not Byzantine failures or network partitions.

Computation and communication in R*: a distributed database manager

Abstract: This article presents and discusses the computation and communication model used by R*, a prototype distributed database management system. An R* computation consists of a tree of processes connected by virtual circuit communication paths. The process management and communication protocols used by R* enable the system to provide reliable, distributed transactions while maintaining adequate levels of performance. Of particular interest is the use of processes in R* to retain user context from one transaction to another, in order to improve the system performance and recovery characteristics.

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 trade-off.

The Performance of Concurrency Control Algorithms for Database Management Systems

Abstract: This paper describes a study of the performance of centralized concurrency control algorithms. An algorithm-independent simulation framework was developed in order to support comparative studies of various concurrency control algorithms. We describe this framework in detail and present performance results which were obtained for what we believe to be a representative cross-section of the many proposed algorithms. The basic algorithms studied include four locking algorithms. two timestamp algorithms. and one optimistic algorithm. Also. we briefly summarize studies of several multiple version algorithms and several hierarchical algorithms. We show that. in general, locking algorithms provide the best performance.

Integration of Time Versions into a Relational Database System

Abstract: New application areas for database systems, such as office automation and CAD/CAM will require to support not only access to the current data, as is done in current database systems, but also to previous instances of the data (versions). This means that time version support is needed. This paper presents the design considerations for a database system currently under implementation, that integrates time version support as a normal database function. It is shown that many subtle issues, such as choice of a suitable timestamp, how to store history data in a compact form, how to integrate version management into update processing, recovery, concurrency control, etc., have to be considered together to obtain an optimal design.

A distributed algorithm for generalized deadlock detection

Abstract: An efficient distributed algorithm to detect deadlocks in distributed and dynamically changing systems is presented. In our model, processes can request any N available resources from a pool of size M. This is a generalization of the well-known AND-OR request model. The algorithm is incrementally derived and proven correct. Its communication, computational, and space complexity compares favorably with those of previously known distributed AND-OR deadlock detection algorithms.

Simulated Performance of a Reduction-Based Multiprocessor

Abstract: Multiprocessinig systems have the potential for increasing system speed over what is now offered by device technology. They must provide the meains of generating work for the processors, getting the work to processors, and coherently collecting the results from the processors. For most applications, they should also enisure the repeat-ability of behavior, i.e., determinacy, speed-independence, or elimination of \"critical races.\" 1-6 Determinacy can be destroyed, for example, by permitting-in separate, coni-current processes statements such as \"v: = x + 1\" and \"ift x = 0 then else. .\", which share a commoin variable. Here, there may be a critical race, in that more thani one global outcome is possible, depeindinig on execu-tioIn order. But by basinig a multiprocessiing system on functional languages, we can avoid such dangers. Our concerin is the coInstructionl of multiprocessors that canl be programmed in a logically transparenit tashion. In other words, the prograninier should Inot be aware of pro-grammning a multiprocessor versus a unipiocessor, except for optlmlzling perfornmanice oi-a specific coIItiguratioIn. This means that the progi-amimler should not have to set up processes explicitly to achieve concurrent processinig, nor be conicerned with synchronizing such processes. Programs expressed in functional languages possess a fair anmount of implicit concurrenicy. The conceptual ex-ecutioin of a tunctional programn is based purely oIn the evaluation of expressions, not on the assignmeint of values to rmemory cells. Accordingly, there can be no \"side ef-fects\" of one function on another, which ensures deter-miniacy; a program gives the samle results regardless of the physical aspects of communicatioin betweenI processors or the number of processors involved in its execution. These languages seenm to be ideal tor the programming of multi-processors when distinction between them and uniproces-sors is undesirable. Functional languages also have other conceptual advantages that have beeni discussed elsewhere.79 To demonstrate how a tunctional language provides tor concurrent execution, consider an expression such as max[subexpressioin-1, subexpression-2] wherce ttax is the usual nunmeric mlaximunm tunction (or any other function which requires both of its arguments). A concurrent execution model carries out three important aspects: (1) Spawning of tasks to evaluate the two subexpres-sions concurrently; (2) Synchronizatioin to deterimiine that both subevalua-tions are complete; and (3) Evaluation of the maxiimiuiim, once completioin is established. Obviously, only the third of these aspects would be found in a sequential implementation; the first two are implicit in a conicurrent functional implemneintation. In contrast, the specitication of these mechanical …

Replication methods for abstract data types

Abstract: Replication can enhance the availability of data in a distributed system. This thesis introduces a new method for managing replicated data. We propose new techniques to address four problems associated with replication: (i) the representation and manipulation of replicated data, (ii) concurrency control, (iii) on-the-fly reconfiguration, and (iv) enhancing availability in the presence of partitions. Unlike many methods that support replication only for uninterpreted files, our method makes use of type-specific properties of objects (such as sets, queues, or directories) to provide more effective replication. Associated with each operation of the data type is a set of quorums, which are collections of sites whose cooperation suffices to execute the operation. An analysis of the algebraic structure of the data type is used to derive a set of constraints on quorum intersections. Any choice of quorums that satisfies these constraints yields a correct implementation, and it can be shown that no smaller set of constraints guarantees correctness. By taking advantage of type-specific properties in a general and systematic way, our method can realize a wider range of availability properties, more concurrency, more flexible reconfiguration, and better tolerance of partitions than existing replication methods.

Serializability by Locking

Abstract: The power of locking as a primitive for controlling concurrency in database systems is examined. It is accepted that the concurrent execution (or schedule) of different transactions must be serializable; that is, it must behave like a serial schedule, one in which the transactions run one at a time. It is shown that locking cannot achieve the full power of serializability. An exact characterization of the schedules that can be produced if locking is used to control concurrency is given for two versions of serializability. In the first one, state serializability, only the effect of the schedule on the database is taken into account. In the second one, view serializability, the view of the data received by the transactions is also taken into account. The author shows that it is possible to determine efficiently whether the transactions in a given set can be permitted to run safely by themselves without the need of any control while ensuring view serializability, although the problem is np-complete in the case of state serializability. 20 references.

Architectural Issues of Transaction Management in Multi-Layered Systems

Abstract: The internal structure of current data b;lse systems is ideally characterized by a hierarchy of multiple layers. Each layer offers certain specific objects and operations on its interface. Within this framework we investigate the transaction management aspects I It is shown that the System R kind of concurrency control can be generalized and an appropriate recovery method can be found by introducing a type of open nested transactions which are strongly tied to architectural layers. Especially. our approach includes application-specific levels on top of a data base kernel system. Up to now, most of the preprocessor solutions for so-called “non-standard” applications that have been proposed simply ignore aspects of concurrency control and recovery. We sketch different possibilities to realize transaction management in such a layered environment. 1, lntrodution and RB Two different directions of evolution in data base systems may be observed. On the one hand, the performance for commercial applications should be increased still further (/Ba83/) . On the other hand, data base systems of the next generation are expected to support so-called ‘non-standard” applications such as CAD or office automation ( /HR83b/, /SchP82/) . Permiwion to copy without fee all or part of this material is gmnted provided that the cop&s ore not made or distributed for direct commercial advantage, the VLDB copyright not&e and the title of the publication and its date appear, and notice is given that copying is by permission of the Very Large Dora Bose Endowment. To copy otherwlrc. or to republish, requires a fee and/or special permission from the Endowment. 7 hese two objectives, although different, have something in common. To achieve them It does nor suffice to modify single system components locally, rather the overall architecture of data base systems is affected (/Kie83/. /LSch83/). An important part of the architectural considerations is concerned with transaction management ( /Ba83/, /PrS83/) . Ideally we can look at the structure of modern data base systems as a hierarchy of ‘virtual machines’. Each such ‘machine’ is characterized by the objects and operations which are available at its interface. These are In turn implemented with the help of objects and operations of the layer one lower. Such a multi-layered architecture is described In /HR83a/. A variant of it forms the background df a data base kernel system which we plan to implement (/PSSW84/). One special design feature is that we use a single data model. the so-called NF2-relational model, to describe conceptual as well as internal data structures in a uniform way (/SohS83/). In this model NF2-tuples are the basis of complex structured objects which appear on both the storage structure and access path level and, In the context of “non-standard’ applications. at the user interface. The layered architecture of the projected data base kernel system Is roughly described in the following figure 1. Proceodlngr of the Tenth Intomatlonal Confarenoa on Vary Larga Data Bases. Slngapora, August, 1964

Concurrency control in a dynamic search structure

Abstract: A design of a data structure and efficient algorithms for concurrent manipulations of a dynamic search structure by independent user processes is presented in this paper. The algorithms include updating data, inserting new elements, and deleting elements. The algorithms support a high level of concurrency. Each of the operations listed above requires only constant amount of locking. In order to make the system even more efficient for the user processes, maintenance processes are introduced. The maintenance processes operate independently in the background to reorganize the data structure and “clean up” after the (more urgent) user processes. A proof of correctness of the algorithms is given and some experimental results and extensions are examined.

Site Initialization, Recovery, and Backup in a Distributed Database System

Abstract: Site initialization is the problem of integrating a new site into a running distributed database system (DDBS). Site recovery is the problem of integrating an old site into a DDBS when the site recovers from failure. Site backup is the problem of creating a static backup copy of a database for archival or query purposes. We present an algorithm that solves the site initialization problem. By modifying the algorithm slightly, we get solutions to the other two problems as well. Our algorithm exploits the fact that a correct DDBS must run a serializable concurrency control algorithm. Our algorithm relies on the concurrency control algorithm to handle all intersite synchronization.

Simplifying distributed database systems design by using a broadcast network

Abstract: Atomic broadcast and failure detection are powerful primitives for distributed database systems In the distributed database system LAMBDA, they are provided as network primitives In this paper, we show how atomic broadcast and failure detection simplify transaction commitment, concurrency control, and crash recovery Specifically, we give a simple two-phase non-blocking commit protocol, whereas three phases are required in a point-to-point network We also give a simplified read-one/write-all update algorithm for replicated data and an easily implemented log-based recovery algorithm providing uninterrupted transaction processingThe benefits of performing the atomic broadcast and failure detection at the network level are also discussed Performing these functions at the network level not only simplifies database protocols but also better utilizes the broadcast network fewer messages are transmitted Comparisons between LAMBDA and existing distributed database systems are also made

Transactions on typed objects

Abstract: Transactions simplify the construction of reliable systems by protecting programmers from the effects of concurrency and failures. To date, they have been used primarily in database systems. The limitations of existing strategies for synchronization and recovery constrain the use of transactions in more general environments such as file systems, mail systems, and operating systems. The standard transaction model can be extended by redefining a transaction as a sequence of typed operations on objects that are instances of shared abstract types. This approach allows semantic knowledge about individual types to be used in developing more flexible synchronization and recovery strategies, including ones that sacrifice basic transaction properties such as serializability. The dissertation discusses a method for specifying the synchronization properties of shared abstract types, and an extensible locking technique for their implementation. The dissertation also examines how a shared abstract type's semantics and implementation affect the choice of a recovery technique. Two new log-based algorithms for recovery are also presented. The simpler algorithm is easier to implement, and its resource requirements during recovery are more tightly bounded. The more complex algorithm allows greater concurrency in implementations of shared abstract types. Choosing transactions as a fundamental mechanism for concurrency control and recovery influences the overall structure of a system. The dissertation describes how synchronization and recovery are implemented in TABS, a system being developed at Carnegie-Mellon that provides an object-oriented transaction mechanism on top of an existing operating system kernel. The possibility of systems that incorporate transactions at an even lower level is also discussed.

Distributed Transaction Management in Jasmin

Abstract: In this paper, we describe the architecture of JASMIN, a functionally distributed database machine which uses replicated software modules (DM. RM, IS) to achieve high degrees of throughput. We discuss some issues in distributing data and metadata in JASMIN. We describe our distributed multiversion validation technique along with the two phase commit protocol which we use to achieve concurrency control and crash recovery for data and metadata. The scheme also solves the version consistency problem in the multiprocessor environment.

A Model to Solve Timing-Critical Application Problems in Distributed Computer Systems

Abstract: Today, real-time computer applicationis can require system processing speeds up to hundreds of MIPS. Concurrently, there is a need for short svstem response time, particularly w here timing-critical application (TCA) problenis are concerned. As a way of meeting these system demands, concurrent processing of data items in advanced distributed computer ssystems is rapidly gainiing favor. With the advent of I SI technology, the system designer cani nows feasibly interconnect nuimierous processors and memnorv modules in a network system.t Howesver, without the proper software tool, the incremental increase of network processors may degrade system tlhroughput and fail to pass the system response time requirenmenlt.-4 Why? Because thc unsophisticated software tool usually causes both an unbalanced use of processors ancd anI increase in interprocessor traffic. tJnbalanced proecssor rIisC occurs when many software tasks in one processor cause extra qucueing delay time for task executioin. Heavier interprocessor traffic arises when the highlv data-dependent software tasks locatcd on diffterent processors generate considerable CoImImunication saste upon data transfer. E ft icienqt Lt iliiat ion of dlistributed compurci systenms clemiiands the ollows in e:

Communication Mechanisms for Programming Distributed Systems

Abstract: LSI and VLSI advances have greatly decreased costs for such computer hardware as processors and memories. Now universities and industry are taking advantage of this low-cost technology to research the development of distributed computer systems composed of multiple (cooperating) computers as alternatives to systems based on single computers. However, this new technology brings with it its own communications and synchronization problems. To solve them, system designers must have access to appropriate , well-defined mechanisms for expressing forms of communication and synchronization. This article covers applications-level software-communication mechanisms that have appeared in other literature. It focuses on communication mechanisms explicitly designed for distributed programming, addressing particularly what the various communication mechanisms do, as opposed to how they are implemented, then illustrating-with specific distributed programming examples-how communication mechanisms influence the programming process. However , to begin any discussion of distributed computer systems , their characteristics must be defined. As Stankovic and Van Dam indicate, 3 we can define a distributed processing system as a collection of distributed processing components physically and logically interconnected , possessing a decentralized, system-wide resource 'A more general discussion of software communication mechanisms can be found in Stankovic's paper, which illustrates control flow and data flow comparison of effective communication through procedure calis and messages; 1 Andrew's survey of concepts and notations for concurrent programming provides a detailed discussion on primitives for concurrent programming ,2 which can be considered a superset of distributed programming. control, and executing application programs in a coordinated manner.t Coordination is established by communication and synchronization, which constitute virtual communication among the application processes assigned to the individual processing components. At the applications level, communication and synchronization are said to be virtual because there may or may not be a direct, physical communications channel between the processes. The actual message exchanges occur at a level more primitive than applications-level software. Since memory is not shared, interaction among the processes requires message passing. An interconnection network routes messages from a source process to a destination process, and all in-terprocess interactions map into some actual communication protocols at the network level. Figure 1 illustrates a tEnslow's widely accepted definition characterizes system distribution from three standpoints: hardware, control, and database decentralizaton. 4 Figure 1. A logical view of a distributed computing system's architecture including the distributed communications network, or DCN, and the distributed processing component, or DPC.

Application of an optimistic concurrency control method

Abstract: This paper illustrates the implementation feasibility of an optimistic approach to concurrency control. After reviewing the approach and clarifying the underlying algorithms and assumptions, it is applied to the design of a multi-user version of an existing relational database management system. Two different system architectures for a UNIX -based environment are presented and prototype implementations have been constructed. We also provide some performance statistics on the optimistic approach to concurrency control and compare it with a traditional locking protocol.

Towards a self-adapting centralized concurrency control algorithm

Abstract: We introduce the notion of self-adapting concurrency control algorithms --- concurrency control algorithms that consist of several rw and several ww synchronization techniques, and employ combinations of the techniques in a manner that attains a performance objective. We Consider synchronization techniques that use locking and certification. A general proof method for such algorithms is outlined and applied.

Database Portals: A New Application Program Interface

Abstract: This paper describes the design and proposed implementation of a new application program interface to a database management system. Programs which browse through a database making ad-hoc updates are not well served by conventional embedding of DBMS commands in programming languages. a new embedding is suggested which overcomes all deficiencies. This construct, called a portal, allows a program to request a collection Of tuples at once and supports novel concurrency control schemes.

Managing distributed databases in partitioned networks

Abstract: A distributed database (DDB) is subject to network partitioning; that is, failures may leave sites disconnected. If a DDB with replicated data becomes partitioned, its sites must either suspend activity until the failure is repaired or modify their activities to maintain serializability in spite of the partitioning. Adaptations are either conservative, and guarantee that all activity will be serializable, or optimistic, and may require some transactions to be backed out to establish serializability when the failure is repaired. We consider conservative strategies to be composed of class assignment rules, which allocate transaction classes to partitions, conflict resolution rules, which ensure that the assignments will be serializable, and version assignment rules, which specify the versions of data-items that are read by specific transactions. We show how to extend previously proposed rules for class assignment, that resolving conflicts optimally is NP-complete, and how to assign old versions of data-items to transactions in ways that increase the number of transactions that can be run. We also show how to modify these techniques for use as a concurrency control method in non-partitioned systems to reduce communication overhead. Optimistic strategies do not restrict the transactions that can be run during partitioning, but may require that transactions be backed out when partitions are reconnected. We show that doing this optimally is NP-complete, as are several subproblems. We describe an approximation method for solving the problem with a better than O(n) error bound. We also consider relaxing various constraints of our model. A probabilistic model for predicting the level of conflict is presented and then modified to encompass extensions such as partial database replication.

Optimal Object Allocation in Distributed Computer Systems.

Abstract: 1 Introduction

Data management facilities of an operating system kernel

Abstract: The paper describes the part of a general operating system Kernel supporting data management functions The operating system Kernel can be imbedded into microcode and viewed as an extended hardware interfaceFour Kernel instructions are defined to support data management They provide a powerful basis for the implementation of different kinds of access methods and file systems, including data base systems Advanced transaction processing concepts such as concurrency control, support of backout, commit and a variety of share options are included.

Certification by Intervals of Timestamps in Distributed Database Systems

Abstract: This paper introduces, as an optimistic concurrency control, a new certification method by means of intervals of timestamps, usable in a distributed database system. The main advantage of this method is that it allows a chronological validation order which differs from the serialization one (thus avoiding rejections or delays of transactions which occur in usual certification methods or in classical locking or timestamping ones). The use of the dependency graph permits both classifying this method among existing ones and proving it. 1. INl'RODUCTION Nunerous Concurrency Control Methods (CCMs) for Distributed Data Bases (DDBs) have been proposed so far [Bernstein 811 using either Two-Phase Locking (2PL) or Timestamp Ordering (TO). The main feature of these CCMs is that the serializability test is made for each action (Read or Prewrite) on an object of the base. For this reason, we call these CCMs continuous ones as opposed to certification (also called optimistic) ones, where the Permission to copy without fee all or part of this material iF granted provided that the copies are not made or distributed for direct commcrciot advantage, the VLDB copyright notice and the title of the publication and its date appear, and notice is given that copying is by pe?mLrsion of the VW Large Data Base Endowment. To copy otherwise, or to republish, requires a fee and/or special permission from the Endowment. Proceedings of the Tenth International Conference on Very Large Data Bases. serializability test is only made at the end of the transaction. Usually, continuous CCMs and certification ones are described in totally different ways. Our study offers a unifying view for this classification. Certification methods [Kunq 811, [Haerder 823, [Lausen 821 have been studied mostly for centralized systems. The few proposals adapted to distributed systems [Badal 791, [Schlageter 811, [Bhargava 821 are not convincing due to lack of formal proofs for their desired behavior. We answer that problem by proving a certification method in a distributed system. Serialization relies on the setting among transactions. principles are used control used in CCMs of a serialization order In continuous CCMs two to construct this order. In 2PL methods [Traiger 821, it is dynamically constructed and corresponds to the order into which transactions reach their maximum locking point. The well known drawback of these methods is useless waiting sometimes imposed to transactions and deadlocks which may occur. Deadlock prevention may be applied [Rosenkrantz 783 at the cost of increasing the number of rejections. In basic or multiversions TO CCMs, the order is "static" and relies upon the giving of a unique timestamp to any transaction, thus defining the serialization order. One study [Bayer 821 refines this technique by introducing the notion of a "dynamic" timestamp which avoids useless rejection of a transaction when its first conflict arises, in a very particular CCM. Control by certification allows a dynamic construction of the serialization Singapore, August, 1984

A Scheme for Batch Verification of Integrity Assertions in a Database System

Abstract: A database management system can ensure the semantic integrity of a database via an integrity control subsystem. A technique for implementation of such a subsystem is proposed. After a database is updated by transactions, its integrity must be verified by evaluation of a set of semantic integrity assertions. For evaluation of an integrity assertion a number of database pages need to be transferred from the secondary storage to the fast memory. Since certain pages may be required for evaluation of different integrity assertions, the order of the evaluation of the integrity assertions determines the total number of pages fetched from the secondary storage. Hence, the schedule for the evaluation determines the cost of the database verification process. We show that the search for an optimal schedule is an NP-hard problem. Four approximation algorithms that find suboptimal schedules are proposed. They are based on the utilization of intersections among sets of pages required for the evaluation of different integrity assertions. The theoretical worst case behaviors of these algorithms are studied. Finally, the algorithms are compared via a simulation study to a naive, random order verification approach. The methods proposed for minimizing the costs of the batch integrity verification also apply to other problems that can be abstracted to the directed traveling salesman optimization problem. For example, the methods are applicable to multiple to multiple-query optimization and to concurrency control via the predicate locks.