Showing papers on "Multiversion concurrency control published in 2006"

Extending Hardware Transactional Memory to Support Non-busy Waiting and Non-transactional Actions

Abstract: Transactional Memory (TM) is a compelling alternative to locks as a general-purpose concurrency control mechanism, but it is yet unclear whether TM should be implemented as a software or hardware construct. While hardware approaches offer higher performance and can be used in conjunction with legacy languages/code, software approaches are more flexible and currently offer more functionality. In this paper, we try to bridge, in part, the functionality gap between software and hardware TMs by demonstrating how two software TM ideas can be adapted to work in a hardware TM system. Specifically, we demonstrate: 1) a process to efficiently support transaction waiting — both intentional waiting and waiting for a conflicting transaction to complete — by de-scheduling the transacting thread, and 2) the concept of pausing and an implementation of compensation to allow non-idempotent system calls, I/O, and access to high contention data within a long-running transaction. Both mechanisms can be implemented with minimal extensions to an existing hardware TM proposal.

Transaction Time Support Inside a Database Engine

Abstract: Transaction time databases retain and provide access to prior states of a database. An update "inserts" a new record while preserving the old version. Immortal DB builds transaction time database support into a database engine, not in middleware. It supports as of queries returning records current at the specified time. It also supports snapshot isolation concurrency control. Versions are stamped with the "clock times" of their updating transactions. The timestamp order agrees with transaction serialization order. Lazy timestamping propagates timestamps to transaction updates after commit. Versions are kept in an integrated storage structure, with historical versions initially stored with current data. Time-splits of pages permit large histories to be maintained, and enable time based indexing, which is essential for high performance historical queries. Experiments show that Immortal DB introduces little overhead for accessing recent database states while providing access to past states.

JAC: declarative Java concurrency

Abstract: SUMMARY The Java programming language has a low-level concurrency model which is hard to use and does not blend well with inheritance. JAC is an extension of Java that introduces a higher level of concurrency, hiding threads and separating thread synchronization from application logic in a declarative fashion. The emphasis is on limiting the differences between sequential and concurrent code, thus furthering code reuse, and on avoiding inheritance anomalies. This is achieved by taking a middle road between concurrent code on the one hand and complete separation of sequential application logic from concurrency mechanisms on the other. An extensive comparison with related approaches is given for motivating our design decisions. Copyright c � 2005 John Wiley & Sons, Ltd.

Looking ahead in open multithreaded transactions

Abstract: Open multithreaded transactions constitute building blocks that allow a developer to design and structure the execution of complex distributed systems featuring cooperative and competitive concurrency in a reliable way. In this paper we describe an optimization to the standard open multithreaded transaction model that does not impose any participant synchronization when committing a transaction, but still provides the same execution semantics. This optimization - letting participants "look ahead" and continue their execution on the outside of the transaction - makes it possible to speed up the execution of in individual transaction with multiple participants tremendously. The paper describes all technical issues that had to be solved, e.g. adapting concurrency control of transactional objects to be look-ahead aware, adapting joining rules for look-ahead participants, and re-defining exception handling in the presence of look-ahead.

Don’t be a Pessimist: Use Snapshot based Concurrency Control for XML

Abstract: As native XML database systems (e.g., [3, 7, 8]) get increasingly popular, fine-granularity concurrency control becomes imperative in order to allow different clients to concurrently access the same documents. Existing concurrency control approaches for XML are mainly based on locking [2, 3, 4, 6, 5]. However, the experiments of [5] have shown that the locking overhead, especially for read operations, can be tremendous. In this paper, we present two snapshot based concurrency control mechanisms that avoid locking. Instead, transactions access a committed snapshot of the data.

An Efficient Synchronous Collaborative Editing System Employing Dynamic Locking of Varying Granularity in Generalized Document Trees

Abstract: The primary goals in a synchronous collaborative editing system (CES) involve ensuring a high level of concurrent access while maintaining the properties of the CCI model. We revisit the idea of applying lock-based concurrency control algorithms to manage access to a shared document; this research overcomes the traditional problem of reduced concurrent access inherent in pessimistic concurrency control by dynamically managing the size of the portion of document locked based upon user demand, scaling up and down the lock granularity to accommodate user write requests. We present algorithms to efficiently maximize concurrent access while utilizing caching techniques to reduce communication costs. We also discuss how OT and other optimistic concurrency control techniques may be incorporated within our approach ? leveraging best practices of both techniques. We conclude with an analysis of the communication and computational costs of our approach and compare these costs to costs incurred using OT-based concurrency control.

Multithreading with concurrency domains

Abstract: Methods, systems and computer products are provided for partitioning software application components into separate domains called concurrency domains (201 ). Computationally expensive, slow or long-running methods may be deployed into such domains, thus keeping the associated application more responsive to the end user. According to one aspect of the invention, a given concurrency domain (201 ) is a partition of runtime objects (203) for providing synchronization and thread isolation within the partition and for providing concurrency with other such partitions in a data-driven dynamically composed and reconfigured application.

Formal Verification of an Optimistic Concurrency Control Algorithm using SPIN

Abstract: To contribute to the promotion of concurrency controllers for temporal databases, we propose in this paper to formally check the access concurrency control algorithm proposed in [4], using SPIN. This algorithm is based on the optimistic approach and must guarantee strong consistency for transaction time relations. SPIN provides a software model checking with a powerful tool to detect errors. It is an appropriate tool for analyzing the logical consistency of concurrent systems. The main target consists of retrieving and correcting blocking error type, on the one hand, and ensuring the validity of the considered system properties specified by temporal logic formulae, on the other hand.

On Optimistic Concurrency Control for Real-Time Database Systems

Abstract: The performance of database transaction processing system can be profoundly affected by the concurrency control method employed since it is necessary to preserve database integrity in a multi-user environment. In addition to satisfying the consistency requirement as in traditional database system, real-time database systems must also satisfy timing constraints. In this study we present a virtual run policy for the restarted first run optimistic transactions and compare its performance with optimistic concurrency control in firm real-time database system.

JAC: declarative Java concurrency: Research Articles

Abstract: The Java programming language has a low-level concurrency model which is hard to use and does not blend well with inheritance. JAC is an extension of Java that introduces a higher level of concurrency, hiding threads and separating thread synchronization from application logic in a declarative fashion. The emphasis is on limiting the differences between sequential and concurrent code, thus furthering code reuse, and on avoiding inheritance anomalies. This is achieved by taking a middle road between concurrent code on the one hand and complete separation of sequential application logic from concurrency mechanisms on the other. An extensive comparison with related approaches is given for motivating our design decisions. Copyright © 2005 John Wiley & Sons, Ltd.

Index Cache Consistency in Client-Server Database Systems

Abstract: In this paper, we present an enhanced cacheconsistency (concurrency-control and replicamanagement) protocol and B?tree algorithms for clientserver database management systems in which the physical database is organized as a sparse (B?tree) index. We improve the concurrency-control and the callback-locking (for replica-management) protocols by augmenting these protocols with the U-locking protocol. In our cache-consistency protocol, concurrency control and replica management are performed at the page level. Our cache consistency protocol and B?tree algorithms improve concurrency in client-server database system.

The V4DB project - support platform for testing the algorithms used in real-time databases

Abstract: Many applications supported by a database management system are characterized by the requirement of timely access to the underlying database today. It is very difficult to achieve guaranteed real time database services when putting a database into a real-time environment because various components can compete for system resources. Previous research in real-time databases has focused primarily on evolution and evaluation of transaction processing algorithms, priority assignment strategies and concurrency control techniques. But for the most part the research efforts are based only on simulation studies with many parameters defined. Our objective is to design and implement an experimental real-time database system suitable for study of real time transaction processing. The experimental system is implemented as an integrated set of the most important functional parts of a veritable real-time database system. It serves as a support platform for performance evaluation of known and new algorithms of the particular processing components, including CPU scheduling, concurrency control and conflict resolution strategies. Because of the strong interactions among the processed components, proposed system can help us to understand their effect on system performance and to identify the most influencing factors.

An evaluation of concurrency control protocols for web services oriented e-commerce

Abstract: Web services oriented computing is a hot topic for many e-commerce applications recently. It dramatically speeds up the application process and becomes more agile in responding to changing business needs. In this paper, we study the concurrency control problems among interleaved transactions for web services oriented e-commerce. We propose a new method called two-phase locking with adjustable slack time (2PL-AST) based on a high priority mechanism, which resolves the concurrent data access for both real-time and non-real-time support operations. The design issue aims to meet the deadline requirements of real-time transactions and minimize the response time of non-real-time transactions in the web services family at the same time. Experiments are conducted to evaluate the performance under different concurrency control protocols.

Exploiting Concurrency in System-on-Chip Verification

Abstract: System-on-chip (SoC) design paradigm makes design verification a more time-consuming task. Therefore, for simulation-based methods, test quality is extremely important. This paper presents a method that increases the test quality by exploiting the concurrency in a system. The main idea is to generalize the elements of concurrency as transfers and then transform the system into a transfer-resource-graph. The graph can be traversed to produce high-quality tests. To further optimize the test quality in terms of concurrency, we are able to generate event-driven test-programs. This is made possible by modelling transfers as active building blocks.

Concurrency abstractions for programming languages using optimistic protocols

Abstract: Welc, Adam. Ph.D., Purdue University, May, 2006. Concurrency Abstractions for Programming Languages Using Optimistic Protocols. Major Professors: Antony Hosking and Suresh Jagannathan. Concurrency control in modern programming languages is typically managed using mechanisms based on mutual exclusion, such as mutexes or monitors. All such mechanisms share similar properties that make construction of scalable and robust applications a non-trivial task. Implementation of user-defined protocols synchronizing concurrent shared data accesses requires programmers to make careful use of mutual-exclusion locks in order to avoid safety-related problems, such as deadlock or priority inversion. On the other hand, providing a required level of safety may lead to oversynchronization and, as a result, negatively affect the level of achievable concurrency. Transactions are a concurrency control mechanism developed in the context of database systems. Transactions offer a higher level of abstraction than mutual exclusion which simplifies implementation of synchronization protocols. Additionally, in order to increase concurrency, transactions relax restrictions on the interleavings allowed between concurrent data access operations, without compromising safety. This dissertation presents a new approach to managing concurrency in programming languages, drawing its inspiration from optimistic transactions. This alternative way of looking at concurrency management issues is an attempt to improve the current state-ofthe-art both in terms of performance and with respect to software engineering benefits. Three different approaches are presented here: revocable monitors are an attempt to improve traditional mutual exclusion, safe futures propose a new way of thinking about concurrency in a context of imperative programming languages and, finally, transactional

A Relaxed Temporal Consistency Approach for Real-Time Concurrency Control

Abstract: This work presents a real time distributed concurrency control scheme where consistency is relaxed to let reading tasks to run as well as concurrent writing tasks. The algorithm reduces the possibility of deadline missing by increasing the level of concurrency in systems where the proportion for read operations is greater than for write operations. The proposed algorithm is a variant for an existent concurrency control algorithm which is faster in the sense that low time responses are offered by the new algorithm.

An evaluation of concurrency control protocols for web services oriented E-commerce

Abstract: Web services oriented computing is a hot topic for many e-commerce applications recently. It dramatically speeds up the application process and becomes more agile in responding to changing business needs. In this paper, we study the concurrency control problems among interleaved transactions for web services oriented e-commerce. We propose a new method called two-phase locking with adjustable slack time (2PL-AST) based on a high priority mechanism, which resolves the concurrent data access for both real-time and non-real-time support operations. The design issue aims to meet the deadline requirements of real-time transactions and minimize the response time of non-real-time transactions in the web services family at the same time. Experiments are conducted to evaluate the performance under different concurrency control protocols.

Overview of Concurrency Control in Real-time Database Systems

Abstract: Real-time database system derives its concurrency control mechanisms from traditional ones and results of real-time systems.Classifying real-time concurrency control protocols as either conservative(e.g.,locked-based) or optimistic concurrency control protocols,the research analyses mechanisms of the basic 2PL protocol and the OCC protocol as well as 2PL-HP protocol and the PCP protocol which derive from 2PL protocol and the OCC-BC and the WAIT-50 those extend the OCC protocol.Keeping focus on resent work of RTDB systems makes it clear that protocols mixed with the two types or extended from one become more and more popular.The famous RCP protocol and the OCC-DA protocol both get excellent performance in practice.

TPR~*-Tree Concurrency Control Scheme for Spatio-temporal Index in Main Memory Database

Abstract: With the development of location technology,advanced location-based services will increasingly require database technologies capable of tracking the positions of large amounts of continuously moving objects in the following years.TPR~*-tree is a kind of index structure which supports to query the current and future positions of moving objects.TPR~*-tree concurrency control scheme in main memory is presented,which can satisfy to correctly query positions of moving objects.Two most important techniques for implementing scheduler are combined:locking and timestamping technologies which drop conflict and execution time.The scheme improves concurrent efficiency.

A transaction processing model for performance analysis in multilevel-secure database systems

Abstract: Although many concurrency control schemes have been developed, a thorough understanding of their actual performance is not enough. Numerous performance studies in non-secure centralized databases have been done in the past decade. However, their results cannot be directly applied to multilevel-secure databases, since in addition to single-level concurrency control, multilevel-secure databases deal with new problems of convert channel due to read-down conflict operations. Investigating their impact on transaction scheduling is a crucial issue. The concurrency control requirements for tran-saction processing in an MLS/DBMS are different from those in conventional transaction processing systems with respect to inclusion of covert-channel freeness. In particular, there is the need to coordinate transactions at different security levels avoiding both potential covert timing channels and the starvation of transactions at high security levels. Using a secure transaction processing model, we can evaluate the throughput and response time characteristics of multilevel-secure concurrency control schemes under a wide variety of database workloads and system configurations.

Concurrency Control in Distributed Caching.

Abstract: Replication and caching strategies are increasingly being used to improve performance and reduce delays in distributed environments. A query can be answered more quickly by accessing a cached copy than making a database round trip. Numerous techniques have been proposed to achieve caching and replication in various contexts. In our context of flat cluster-based networks, we have observed that none of the schemes prove to be optimal for all scenarios. In this thesis we look at concurrency control techniques for achieving consistency in distributed caching in flat cluster-based networks. We then come up with heuristics to choose some concurrency control mechanisms over others, depending on the parameters such as the number of data requests and the ratio of read to write requests.

Evaluation Metrics for Class Hierarchy in Object-Oriented Databases: Concurrency Control Perspectives

Abstract: Object-oriented databases (OODBs) have been adopted for managing non-standard applications such as computer-aided design (CAD), office document management and many multimedia applications. One of the major characteristics of OODBs is class hierarchy where a subclass is allowed to inherit the definitions defined on its superclasses. In this paper, I present the evaluation metrics for class hierarchy quality in OODBs. These metrics are developed to determine if a concurrency control scheme can achieve good performance or not on a given class hierarchy. I first discuss the existing concurrency control schemes for OODBs. Then I provide evaluation metrics based on structural information and access frequency information in class hierarchies. In order to discuss significance of the proposed performance metrics, an analytical model is developed. Analysis results show that the performance metrics are important factor in concurrency control performance. I consider both single inheritance and multiple inheritance. The proposed metrics can be used to provide guidelines on how to design class hierarchy of an OODB for maximizing the performance of concurrency control technique.

Efficient Concurrency Control for Mobile Real-Time Transactions in Data Broadcast Environments

Abstract: In a wireless data broadcast environment, there is a limited upstream bandwidth from mobile clients to the fixed database server. Traditional concurrency protocols are unsuitable in such an asymmetric communication environment. In this paper, we introduce a concurrency control protocol which integrates optimistic concurrency control and timestamp ordering. A mobile read-only transaction is weak consistent and the serialization graph consisting of all update transactions and a mobile read-only transaction is acyclic. By using this protocol, mobile read-only transactions can execute autonomously and mobile update transactions can detect data conflicts earlier. Extensive simulation experiments are conducted and the result shows that compared with existing concurrency control protocols, more mobile real-time transactions can commit before their deadline expire.

An efficient secure real-time concurrency control protocol

Abstract: Secure real-time databases must simultaneously satisfy two requirements in guaranteeing data security and minimizing the missing deadlines ratio of transactions. However, these two requirements can conflict with each other and achieve one requirement is to sacrifice the other. This paper presents a secure real-time concurrency control protocol based on optimistic method. The concurrency control protocol incorporates security constraints in a real-time optimistic concurrency control protocol and makes a suitable tradeoff between security and real-time requirements by introducing secure influence factor and real-time influence factor. The experimental results show the concurrency control protocol achieves data security without degrading real-time performance significantly.

Concurrency in XML

Abstract: ACID Properties • Atomicity refers to the ability of the DBMS to guarantee that either all of the tasks of a transaction are performed or none of them are. • Consistency refers to the database being in a legal state when the transaction begins and when it ends. • Isolation refers to the ability of the application to make operations in a transaction appear isolated from all other operations. • Durability refers to the guarantee that once the user has been notified of success, the transaction will persist, and not be undone

Formal verification of an access concurrency control algorithm for transaction time relations

Abstract: We propose in this paper to formally check the access concurrency control algorithm proposed in (Bouaziz, 2005). This algorithm is based on the optimistic approach and guarantees strong consistency for the transaction time relations. The specification of our model under PROMELA language allowed us to ensure the feasibility of the validation. We then could, using the SPIN model checkers, avoid errors of blocking type and check safety properties specified by temporal logic formulas.

Combining scheduling and concurrency control of real-time transactions within the MOA architecture

Abstract: This paper presents a multi-class scheduling algorithm for real-time transactions that combine scheduling and concurrency control. It is integrated to MOA, a multi-class overload architecture. The architecture consists of a real-time control layer which provides sophisticated admission control, scheduling and overload management. The proposed algorithm, DBP-CC, allows service differentiation and takes into account resource availability when extracting a transaction. There is no need to execute a concurrency control algorithm afterwards. Simulation results show that DBP-CC can achieve a significant performance even in overload situations.

A Transaction Processing Model for Performance Analysis in Multilevel-Secure Database Systems

Abstract: Although many concurrency control schemes have been developed, a thorough understanding of their actual performance is not enough. Numerous performance studies in non-secure centralized databases have been done in the past decade. However, their results cannot be directly applied to multilevel-secure databases, since in addition to single-level concurrency control, multilevel-secure databases deal with new problems of convert channel due to read-down conflict operations. Investigating their impact on transaction scheduling is a crucial issue. The concurrency control requirements for tran-saction processing in an MLS/DBMS are different from those in conventional transaction processing systems with respect to inclusion of covert-channel freeness. In particular, there is the need to coordinate transactions at different security levels avoiding both potential covert timing channels and the starvation of transactions at high security levels. Using a secure transaction processing model, we can evaluate the throughput and response time characteristics of multilevel-secure concurrency control schemes under a wide variety of database workloads and system configurations.