Showing papers on "Concurrency control published in 1997"

An adaptive data replication algorithm

Abstract: This article addresses the performance of distributed database systems. Specifically, we present an algorithm for dynamic replication of an object in distributed systems. The algorithm is adaptive in the sence that it changes the replication scheme of the object i.e., the set of processors at which the object inreplicated) as changes occur in the read-write patern of the object (i.e., the number of reads and writes issued by each processor). The algorithm continuously moves the replication scheme towards an optimal one. We show that the algorithm can be combined with the concurrency control and recovery mechanisms of ta distributed database management system. The performance of the algorithm is analyzed theoretically and experimentally. On the way we provide a lower bound on the performance of any dynamic replication algorith.

Concurrency and recovery in generalized search trees

Abstract: This paper presents general algorithms for concurrency control in tree-based access methods as well as a recovery protocol and a mechanism for ensuring repeatable read. The algorithms are developed in the context of the Generalized Search Tree (GiST) data structure, an index structure supporting an extensible set of queries and data types. Although developed in a GiST context, the algorithms are generally applicable to many tree-based access methods. The concurrency control protocol is based on an extension of the link technique originally developed for B-trees, and completely avoids holding node locks during I/Os. Repeatable read isolation is achieved with a novel combination of predicate locks and two-phase locking of data records. To our knowledge, this is the first time that isolation issues have been addressed outside the context of B-trees. A discussion of the fundamental structural differences between B-trees and more general tree structures like GiSTs explains why the algorithms developed here deviate from their B-tree counterparts. An implementation of GiSTs emulating B-trees in DB2/Common Server is underway.

Floor control for multimedia conferencing and collaboration

Abstract: Floor control allows users of networked multimedia applications to utilize and share resources such as remote devices, distributed data sets, telepointers, or continuous media such as video and audio without access conflicts. Floors are temporary permissions granted dynamically to collaborating users in order to mitigate race conditions and guarantee mutually exclusive resource usage.A general framework for floor control is presented. Collaborative environments are characterized and the requirements for realization of floor control will be identified. The differences to session control, as well as concurrency control and access control are elicited. Based upon a brief taxonomy of collaboration-relevant parameters, system design issues for floor control are discussed. Floor control mechanisms are discerned from service policies and principal architectures of collaborative systems are compared. The structure of control packets and an application programmer's interface are proposed and further implementation aspects are elaborated. User-related aspects such as floor presentation, assignment, and the timely stages of floor-controlled interaction in relation to user-interface design are also presented.

Serialization of concurrent operations in a distributed collaborative environment

Abstract: In a distributed groupware system, objects shared by users are subject to concurrency and real-time constraints. In order to satisfy these, various concurrency control algorithms 141 [ 1 l] have been proposed that exploit the semantic properties of operations. By ordering concurrent operations, they guarantee consistency of the different copies of each object. The drawback of these algorithms is that in some situations they can result in inconsistent copies, a non-respect of user’s intentions, and in the need to undo and redo certain operations. The principle objective of the this paper is to present an algorithm that overcomes these problems. The algorithm is based on the notion of user’s intention, and also on the construction of equivalent histories by exploiting and combining some general semantic properties such as forward/backward transposition. Keywbrds: groupware systems, concurrency control, distributed systems, multi-user editors, operation transposition.

Incremental Organization for Data Recording and Warehousing

Abstract: Data warehouses and recording systems typically have a large continuous stream of incoming data, that must be stored in a manner suitable for future access. Access to stored records is usually based on a key. Organizing the data on disk as the data arrives using standard techniques would result in either (a) one or more I/OS to store each incoming record (to keep the data clustered by the key), which is too expensive when data arrival rates are very high, or (b) many I/OS to locate records for a particular customer (if data is stored clustered by arrival order). We study two techniques, inspired by external sorting algorithms, to store data incrementally as it arrives, simultaneously providing good performance for recording and querying. We present concurrency control and recovery schemes for both techniques. We show the benefits of our techniques both analytically and experimentally.

On the schedulability analysis for distributed hard real-time systems

Abstract: We investigate into the validity of the rate monotonic analysis techniques for distributed hard real time systems. A recent paper has shown that the algorithm developed by K. Tindell and J. Clark (1994) for the analysis of this kind of system was incomplete because it did not test all the possible cases. We prove that the algorithm is valid as it is stated and that it effectively obtains an upper bound for the worst case response times to external events in distributed systems, since the longest response always occurs within the cases that are currently tested by this algorithm. In addition, we extend the analysis technique to determine an upper bound for the local response times of particular actions in a response to an event, thus allowing the definition and verification of local deadlines for elementary actions in distributed systems.

Real-Time Database Systems: Issues and Applications

Abstract: Preface 1 Advances in Real-Time Database Systems Research A Bestavros, et al Section I: Models and Paradigms 2 Requirements and Issues on Real-Time Database Systems Kwei-Jay Lin, F Jahanian 3 Similarity Semantics and Concurrency Control Tei-Wei Kuo, AK Mok 4 Probabilistic Real-Time Data Access with Deadline and Interval Constraints Lei Zhou, et al Section II: Applications and Benchmarks 5 Real-Time Databases: Real-World Requirements D Locke 6 Real-Time Databases in Telecommunications KEE Raatikainen 7 Unbundled RTDBMS Support for WWW-Applications H Branding, AP Buchmann 8 Multimedia Capabilities in Distributed Real-Time Applications S Sen, et al 9 Real-Time Database Benchmark Design for Avionics Systems CS Peng, et al 10 Cost Model Development for a Main Memory Database System S Listgarten, M-A Neimat Section III: Scheduling and Concurrency Control 11 Scheduling Access to Temporal Data in Real-Time Databases Ming Xiong, et al 12 Admission Control and Overload Management for Real-Time Databases A Bestavros, S Nagy 13 Lock-Free Transactions for Real-Time Systems JH Anderson, et al 14 A Worst-Case Behaviour Analysis for Hard Real-Time Transactions Jeongyong Byun, et al 15 Performance Modeling of Real-Time Database Schedulers PDV van der Stok, et al Section IV: Experimental Systems 16 The RTSORAC Real-Time Object-Oriented Database Prototype VF Wolfe, et al 17 Developing a Real-Time DB: The Starbase Experience Young-Kuk Kim, SH Son 18 Refining Timing Constraints of Applications in Deeds J Mellin, et al 19 A Real-Time Database Server in an Agile Manufacturing System SungKil Lee, et al Index

A flow control mechanism to avoid message deadlock in k-ary n-cube networks

Abstract: We propose a flow control algorithm for k-ary n-cube networks which avoids the deadlock problems without using virtual channels. Some basic definitions and theorems are proposed in order to establish the necessary and sufficient conditions to verify that an algorithm is deadlock-free. Our proposal is based on a restriction of the virtual cut-through flow control rather than of the routing algorithm and it can be applied both over central buffers or edge buffers. A minimum free buffer space of two packets is required. The implementation complexity of the router according to Chien's (1993) model, is much easier and faster than using virtual channels. Network simulations considering the router complexity show the performance achieved by this new algorithm. The results display a latency improvement of 20% to 35% compared with the use of virtual channels depending on the load of the network.

Concurrency control protocols for management of replicated data items in a distributed database system

Abstract: The invention provides protocols for managing transactions operating on replicated data items at multiple physical sites in a distributed database system The protocols make use of dynamically changing sets of data items referred to as "virtual sites" and a replication graph or other suitable globally consistent representation of the relationships between the transactions and the virtual sites Illustrative embodiments of the invention include a static global serializability (SGS) protocol, a commit-oriented protocol (COP) and a multiversion optimistic protocol (MOP) The SGS protocol broadcasts the data access set of a given transaction to all physical sites, and applies the Thomas Write Rule (TWR) to write-write conflicts on secondary copies of data items The COP protocol defers testing of the replication graph until a transaction is ready to commit, and each transaction is allowed to proceed at its origination site independently of other transactions that are executing at other sites The MOP protocol uses two versions of each data item to ensure global multiversion serializability The two versions are the current version of the data item, and a "last certified version" of the data item All read-only transactions read the last certified version, and can therefore proceed without delay The protocols ensure global serializability while substantially reducing communication overhead relative to conventional protocols

Concurrency and recovery for index trees

Abstract: Although many suggestions have been made for concurrency in B $^+$-trees, few of these have considered recovery as well. We describe an approach which provides high concurrency while preserving well-formed trees across system crashes. Our approach works for a class of index trees that is a generalization of the B $^{\rm link}$-tree. This class includes some multi-attribute indexes and temporal indexes. Structural changes in an index tree are decomposed into a sequence of atomic actions, each one leaving the tree well-formed and each working on a separate level of the tree. All atomic actions on levels of the tree above the leaf level are independent of database transactions, and so are of short duration. Incomplete structural changes are detected in normal operations and trigger completion.

Bounded Concurrent Time-Stamping

Abstract: We introduce concurrent time-stamping, a paradigm that allows processes to temporally order concurrent events in an asynchronous shared-memory system. Concurrent time-stamp systems are powerful tools for concurrency control, serving as the basis for solutions to coordination problems such as mutual exclusion, $\ell$-exclusion, randomized consensus, and multiwriter multireader atomic registers. Unfortunately, all previously known methods for implementing concurrent time-stamp systems have been theoretically unsatisfying since they require unbounded-size time-stamps---in other words, unbounded-size memory. This work presents the first bounded implementation of a concurrent time-stamp system, providing a modular unbounded-to-bounded transformation of the simple unbounded solutions to problems such as those mentioned above. It allows solutions to two formerly open problems, the bounded-probabilistic-consensus problem of Abrahamson and the fifo-$\ell$-exclusion problem of Fischer, Lynch, Burns and Borodin, and a more efficient construction of multireader multiwriter atomic registers.

Software-based deadlock recovery technique for true fully adaptive routing in wormhole networks

Abstract: In this paper, we take a different approach to handle deadlocks and performance degradation. We propose the use of an injection limitation mechanism that prevents performance degradation near the saturation point and reduces the probability of deadlock to negligible values even when fully adaptive routing is used. We also propose an improved deadlock detection mechanism that only uses local information, detects all the deadlocks, and considerably reduces the probability of false deadlock detection over previous proposals. In the rare case when impending deadlock is detected, our proposed recovery technique absorbs the deadlocked message at the current node and later re-injects it for continued routing towards its destination. Performance evaluation results show that our new approach to deadlock handling is more efficient than previously proposed techniques.

The Architecture of the Dalí Main-Memory Storage Manager

Abstract: Performance needs of many database applications dictate that the entire database be stored in main memory. The dali system is a main memory storage manager designed to provide the persistence, availability and safety guarantees one typically expects from a disk-resident database, while at the same time providing very high performance by virtue of being tuned to support in-memory data. User processes map the entire database into their address space and access data directly, thus avoiding expensive remote procedure calls and buffer manager interactions typical of accesses in disk-resident commercial systems available today. dali recovers the database to a consistent state in the case of system as well as process failures. It also provides unique concurrency control and memory protection features, as well as ordered and unordered index structures. Both object-oriented and relational database management systems have been implemented on top of dali. dali provides access to multiple layers of application programming interface, including its low-level recovery, concurrency control and indexing components as well as its high-level relational component. Finally, various features of dali can be tailored to the needs of an application to achieve high performance–for example, concurrency control and logging can be turned off if not desired, enabling dali to efficiently support applications that require non-persistent memory-resident data to be shared by multiple processes.

Similarity-based load adjustment for real-time data-intensive applications

Abstract: How to exploit application semantics to improve the performance of a real-time data-intensive application has been an active research topic in the past few years. Weaker correctness criteria and semantics-based concurrency control algorithms were proposed to provide more flexibility in reordering read and write events. Distinct from the past work, this paper exploits the tradeoff between data consistency and system workload. The definition of similarity is combined with the idea of transaction skipping to provide a theoretical foundation for reducing the workload of a transaction system. We also propose guidelines to adjust the execution frequencies of a static set of transactions and prove their correctness. The strengths of this work were verified by simulation experiments on an air traffic control example (Peng et al., 1997).

Maximising concurrency and scalability in a consistent, causal, distributed virtual reality system, whilst minimising the effect of network delays

Abstract: The development of large scale virtual reality and simulation systems have been mostly driven by the DIS and HLA standards community. A number of issues are coming to light about the applicability of these standards, in their present state, to the support of general multi-user VR systems. This paper pinpoints four issues that must be readdressed before large scale virtual reality systems become accessible to a larger commercial and public domain: a reduction in the effects of network delays; scalable causal event delivery; update control; and scalable reliable communication. Each of these issues is tackled through a common theme of combining wall clock and causal time-related entity behaviour, knowledge of network delays and prediction of entity behaviour, that together overcome many of the effects of network delays.

Concurrency Control Theory for Deferred Materialized Views

Abstract: We consider concurrency control problems that arise in the presence of materialized views. Consider a database system supporting materialized views to speed up queries. For a range of important applications (e.g. banking, billing, network management), transactions that access materialized views would like to get some consistency guarantees—if a transaction reads a base relation after an update, and then reads a materialized view derived from the base relation, it expects to see the effect of the base update on the materialized view. If a transaction reads two views, it expects that the two views reflect a single consistent database state.

Concurrency control and view notification algorithms for collaborative replicated objects

Abstract: This paper describes algorithms for implementing a high-level programming model for synchronous distributed groupware applications. In this model, several application data objects may be atomically updated, and these objects automatically maintain consistency with their replicas using an optimistic algorithm. Changes to these objects may be optimistically or pessimistically observed by view objects by taking consistent snapshots. The algorithms for both update propagation and view notification are based upon optimistic guess propagation principles, adapted for fast commit by using primary copy replication techniques. The main contribution of the paper is the synthesis of these two algorithmic techniques-guess propagation and primary copy replication-for implementing a framework that is easy to program and is well suited for the needs of groupware applications.

On incremental cache coherency schemes in mobile computing environments

Abstract: Re-examines the cache coherency problem in a mobile computing environment in the context of relational operations (i.e. selection, projection and join). We propose a taxonomy of cache coherency schemes, and as case studies, we pick several schemes for further study. These schemes are novel in several ways. First, they are incremental. Second, they are an integration of (and built on) techniques in view maintenance in centralized systems and cache invalidation in client-server computing environments. We conducted extensive studies based on a simulation model. Our study shows the effectiveness of these algorithms in reducing uplink transmission and average access times. Moreover, the class of algorithms that exploit collaboration between the client and server performs best in most cases. We also study extended versions of this class of algorithms to further cut down on the work performed by the server.

Secure transaction processing in firm real-time database systems

Abstract: Many real-time database applications arise in safety-critical installations and military systems where enforcing security is crucial to the success of the enterprise. A secure real-time database system has to simultaneously satisfy who requirements guarantee data security and minimize the number of missed transaction deadlines. We investigate here the performance implications, in terms of missed deadlines, of guaranteeing security in a real-time database system. In particular, we focus on the concurrency control aspects of this issue.Our main contributions are the following: First, we identify which among the previously proposed real-time concurrency control protocols are capable of providing protection against both direct and indirect (covert channels) means of unauthorized access to data. Second, using a detailed simulation model of a firm-deadline real-time database system, we profile the real-time performance of a representative set of these secure concurrency control protocols. Our experiments show that a prioritized optimistic concurrency control protocol. OPT-WAIT, provides the best overall performance. Third, we propose and evaluate a novel dual approach to secure transaction concurrency control that allows the real-time database system to simultaneously use different concurrency control mechanisms for guaranteeing security and for improving real-time performance. By appropriately choosing these different mechanisms, we have been able to design hybrid concurrency control algorithms that provide even better performance than OPT-WAIT.

Implementing atomic actions in Ada 95

Abstract: Atomic actions are an important dynamic structuring technique that aid the construction of fault-tolerant concurrent systems. Although they were developed some years ago, none of the well-known commercially-available programming languages directly support their use. This paper summarizes software fault tolerance techniques for concurrent systems, evaluates the Ada 95 programming language from the perspective of its support for software fault tolerance, and shows how Ada 95 can be used to implement software fault tolerance techniques. In particular, it shows how packages, protected objects, requeue, exceptions, asynchronous transfer of control, tagged types, and controlled types can be used as building blocks from which to construct atomic actions with forward and backward error recovery, which are resilient to deserter tasks and task abortion.

Cluster architectures and S/390 Parallel Sysplex scalability

Abstract: Supporting high transaction rates and high availability for on-line transaction processing and emerging applications requires systems consisting of multiple computing nodes. We outline various cluster architectures and describe the factors that motivate the S/390® Parallel Sysplex™ architecture and its resulting advantages. We quantify the scalability of the S/390 Parallel Sysplex and show that the transaction rate supported is close to linear as nodes are added to the system. The key facet of the S/390 Parallel Sysplex architecture is the coupling facility. The coupling facility provides for very efficient intertransaction concurrency control, buffer cache coherency control, and shared buffer management, among other functions, that lead to the excellent scalability achieved. It also provides for effective dynamic load balancing, high data buffer hit ratios, and load balancing after a failure.

Class library support for workflow environments and applications

Abstract: Workflow systems are receiving increased attention as they intend to facilitate the operations of enterprises by coordinating and streamlining business activities. The need for automated support and operational models that allow workflow applications to coordinate units of work across multiple servers-according to business defined rules and routes-is becoming critical for the proper management of such activities. In this paper, we describe a Transaction-Oriented Workflow Environment (TOWE) for programming workflow activities. The novelty of our approach resides in the proposed unified abstraction, class libraries, to support workflow activities. The fundamental concept used in the TOWE system is based on the symbiosis of object-oriented programming and interprocess communication concepts. In TOWE, the concurrency abstractions are represented by process objects, active objects acting as processes, which involve asynchronous, location-independent, and application specific process invocations.

Logical and Physical Versioning in Main Memory Databases

Abstract: We present a design for multi-version concurrency control and recovery in a main memory database, and describe logical and physical versioning schemes that allow read-only transactions to execute without obtaining data item locks or system latches. These schemes enable a system to guarantee that updaters will never interfere with read-only transactions, and that read-only transactions will not be delayed as long as the operating system provides them with sufficient cycles. Our contributions include several space saving techniques for the main memory implementation. We extend the T-tree index structure (designed for main-memory databases) to support concurrent access and latch-free traversals, and demonstrate the performance benefits of our extensions. Some of these schemes have been implemented on a widely-used software platform within Bell Labs., and the full scheme is implemented in the Dali main memory storage manager.

From serializable to causal transactions for collaborative applications

Abstract: Services in decentralized distributed systems can be implemented using shared distributed objects When these objects are accessed concurrently, serializability (the traditional consistency criterion) can be used to define their execution behaviour However, this consistency criterion has a major drawback because it imposes strong synchronization constraints on the execution of applications which cannot be met efficiently in decentralized systems In this paper, we examine weaker consistency criteria for computations in which accesses to shared objects are grouped to form transactions The guarantees provided by transactions (eg concurrency and failure atomicity) make them attractive when computations manipulate the state of long-lived objects We explore two new criteria: causal consistency and causal serializability These criteria turn out to be sufficient for a class of applications (eg collaborative applications) and their implementation results in lesser synchronization and hence improved autonomy, availability and performance These criteria are formally defined and protocols implementing them are presented

Efficient optimistic concurrency control and lazy queries for B-trees and other database structures

Abstract: The present invention relates to a system and methods for fine-granularity concurrency control in a parallel database. Very fine granularity (at the level of B-tree records) is implemented in a B-tree. Our method applies to B-trees, B-trees with variable keys, and their applications, such as semantic and object-oriented databases. Our method involves accumulating a transaction and then "optimistically" validating it, while attaining high efficiency with maximum semantic safety. "Lazy queries"--an efficient method for finding the intersection of two large queries--is provided for the system.

Optimism vs. locking: a study of concurrency control for client-server object-oriented databases

Abstract: Many client-server object-oriented database systems (OODBs) run applications at clients and perform all accesses on cached copies of database objects. Moving both data and computation to the clients can improve response time, throughput, and scalability. For applications with good locality of reference, retaining cached state across transaction boundaries can result in further performance and scaling benefits. This thesis examines the question of what concurrency control scheme is best able to realize these potential benefits. It describes a new optimistic concurrency control scheme called AOCC (Adaptive Optimistic Concurrency Control) and compares its performance with that of ACBL (Adaptive-Granularity Callback Locking), the scheme shown to have the best performance in previous studies. Like all optimistic schemes, AOCC synchronizes transactions at the commit point, aborting transactions when synchronization fails; ACBL, like other locking schemes, synchronizes transactions while they execute. Earlier studies concluded that locking is a better choice than optimism for client-server systems. Our research leads to the opposite conclusion. We present the results of simulation experiments showing that AOCC outperforms ACBL across a wide range of system and workload settings. In addition to having better performance, AOCC is simpler than ACBL, and scales better with respect to the number of clients using shared data. The thesis also presents a model that allows us to understand these results. The two major costs associated with locking are the messages that must be exchanged for clients to acquire locks and the cost of waiting for locks held by other clients. The major cost associated with optimism is the need to re-execute aborted transactions. The reason AOCC performs so well (and that previously-studied optimistic schemes did not do well) is that its design allows it to have very low abort and restart costs. Both the model and the insights gained from the performance study should help in the design of future client-server concurrency control schemes.

Applying formal methods to semantic-based decomposition of transactions

Abstract: In some database applications the traditional approach of seerializability, in which transactions appear to execute atomically and in isolation on a consistent database state, fails to satisfy performance requirements. Although many researchers have investigated the process of decomposing transactions into steps to increase concurrency, such research typically focuses on providing algorithms necessary to implement a decomposition supplied by the database application developer and pays relatively little attention to what constitutess a desirable decomposition or how the developer should obtain one. We focus onthe decomposition itself. A decomposition generates proof obligations whose descharge ensures desirable properties with respect to the original collection of transactions. We introduce the notion of semantic histories to formulate and prove the necessary properties, and the notion of successor sets to describe efficiently the correct interleavings of steps. The successor set constraints use information about conflicts between steps so as to take full advantage of conflict serializability at the level of steps. We propose a mechanism based on two-phase locking to generate correct stepwise serializable histories.

Relative performance of preemption-safe locking and non-blocking synchronization on multiprogrammed shared memory multiprocessors

Abstract: Most multiprocessors are multiprogrammed to achieve acceptable response time. Unfortunately inopportune preemption may significantly degrade the performance of synchronized parallel applications. To address this problem, researchers have developed two principal strategies for concurrent, atomic update of shared data structures: (1) preemption safe locking and (2) non blocking (lock free) algorithms. Preemption safe locking requires kernel support. Non blocking algorithms generally require a universal atomic primitive, and are widely regarded as inefficient. We present a comparison of the two alternative strategies, focusing on four simple but important concurrent data structures-stacks, FIFO queues, priority queues and counters-in microbenchmarks and real applications on a 12 processor SGI Challenge multiprocessor. Our results indicate that data structure specific non blocking algorithms, which exist for stacks, FIFO queues and counters, can work extremely well: not only do they outperform preemption safe lock based algorithms on multiprogrammed machines, they also out perform ordinary locks on dedicated machines. At the same time, since general purpose nonblocking techniques do not yet appear to be practical, preemption safe locks remain the preferred alternative for complex data structures: they outperform conventional locks by significant margins on multiprogrammed systems.