Showing papers on "Multiversion concurrency control published in 1998"

Detecting concurrency errors in multi-threaded programs

Abstract: A computer implemented method detects concurrency errors in programs. Machine executable images of multiple program threads are instrumented to locate and replace instructions which affect concurrency states of the threads. Concurrency state information is recorded in a memory while the multiple threads are executing. The recorded concurrency state information is analyzed, and inconsistent dynamic concurrency state transitions are reported as concurrency errors.

Design, Implementation, and Performance of the LHAM Log-Structured History Data Access Method

Abstract: Numerous applications such as stock market or medical information systems require that both historical and current data be logically integrated into a temporal database. The underlying access method must support different forms of “time-travel” queries, the migration of old record versions onto inexpensive archive media, and high insert and update rates. This paper introduces a new access method for transaction-time temporal data, called the Logstructured History Data Access Method (LHAM) that meets these demands. The basic principle of LHAM is to partition the data into successive components based on the timestamps of the record versions. Components are assigned to different levels of a storage hierarchy, and incoming data is continuously migrated through the hierarchy. The paper discusses the LHAM concepts, including concurrency control and recovery, our full-fledged LHAM implementation, and experimental performance results based on this implementation. A detailed comparison with the TSB-tree, both analytically and based on experiments with real implementations, shows that LHAM is highly superior in terms of insert performance while query performance is in almost all cases at least as good as for the TSB-tree; in many cases it is much better,

Concurrency control in real-time object-oriented systems: the affected set priority ceiling protocols

Abstract: This paper presents the affected set priority ceiling protocols (ASPCP) for concurrency control in real-time object-oriented systems. These protocols are based on a combination of semantic locking and priority ceiling techniques. This paper shows that the ASPCP protocols provide higher potential concurrency for object-oriented systems than existing priority ceiling protocols, while still bounding priority inversion and preventing deadlock.

A two-version approach for real-time concurrency control and recovery

Abstract: This paper proposes an integrated mechanism for concurrency control and recovery in real-time databases. A two-version approach is used to adjust the serializability of schedules in favor of higher-priority transactions, and, at the same time, to provide a consistent database image at client sites for local processing of read-only transactions. When the database crashes, a consistent database image is used, in return, to efficiently and predictably recover the database from failure. A two-version network-server-based architecture is proposed to support a diskless run-time logging mechanism and an effective write-through procedure.

An effective class hierarchy concurrency control technique in object-oriented database systems

Abstract: In this paper, we present a locking-based concurrency control scheme for object-oriented databases (OODBs). Our scheme deals with class hierarchy which is an important property in OODBs. The existing concurrence controls for a class hierarchy perform well only for specific environments. Our scheme is based on so-called special classes and can be used for any applications with less locking overhead than existing works, for both single inheritance and multiple inheritance. In this study, we show the superiority of our scheme over existing works.

Re-engineering a concurrency simulator

Abstract: SimAda is a concurrency simulator, reengineered from the simulator given in M Ben-Ari, Principles of Concurrent Programming The language was written in Ada 95 to enhance portability and to utilise the structuring constructs of a modern language The concurrency constructs simulated include protected types which are new for Ada 95, as well as the Ada rendezvous Several task scheduling models can be chosen for experimentation SimAda is intended for teaching concurrency, both by running programs and by studying the implementation techniques

Alternative correctness criteria for multiversion concurrency control and its applications in advanced database systems

Abstract: Concurrency control protocols based on multiversions have been used in some commercial transaction processing systems in order to provide both the serializable executions of transactions and a higher degree of concurrency. In the existing protocols based on multiversions, transactions are scheduled so as to read the most recent version of each of data items for serializability. This feature sometimes causes unnecessary blockings of transactions. Thus, it is not desirable in some advanced database systems, which have additional features such as temporal constraints or security requirements. In this paper we first propose alternative correctness criteria, namely FR-serializability, for multiversion concurrency control protocols. Next, we present a new protocol for real-time secure database systems as one application area of the proposed serializability. We also present several examples to illustrate the behavior of the proposed protocol along with performance comparisons with other protocols.

Asynchronous version advancement in a distributed three version database

Abstract: We present an efficient protocol for multi-version concurrency control in distributed databases. The protocol creates no more than three versions of any data item, while guaranteeing that: update transactions never interfere with read-only transactions; the version advancement mechanism is completely asynchronous with (both update and read-only) user transactions; and read-only transactions do not acquire locks and do not write control information into the data items being read. This is an improvement over existing multi-versioning schemes for distributed databases, which either require a potentially unlimited number of versions, or require coordination between version advancement and user transactions. Our protocol can be applied in a centralized system also, where the improvement over existing techniques is in reducing the number of versions from four to three. The proposed protocol is valuable in large applications that currently shut off access to the system while managing version advancement manually, but now have a need for automating this process and providing continuous access to the data.

Event-Based Detection of Concurrency ; CU-CS-860-98

Abstract: Understanding the behavior of a system is crucial in being able to modify, maintain, and improve the system. A particularly difficult aspect of some system behaviors is concur-rency. While there are many techniques to specify intended concurrent behavior, there are few, if any, techniques to capture and model actual concurrent behavior. This paper presents a technique to discover patterns of concurrent behavior from traces of system events. The technique is based on a probabilistic analysis of the event traces. Using met-rics for the number, frequency, and regularity of event occurrences, a determination is made of the likely concurrent behavior being manifested by the system. The technique is useful in a wide variety of software engineering tasks, including architecture discovery, reengineering, user interaction modeling, and software process improvement. The content of the information does not necessarily reflect the position or the policy of the Government and no official endorsement should be inferred.

Concurrency control of large unstructured data

Abstract: Current research projects and database product extensions reflect the importance of unconventional database applications (for example, document processing and computer aided design). Unconventional applications differ from the conventional ones (for example, airline reservation) in the nature of transactions and data. The transactions may be complex, long and involve human interaction. The data includes small, structured objects as well as large, unstructured objects. The unstructured objects are stored in and managed by unstructured database management systems (UDS). UDS employs coarse-granularity locking which limit the concurrency and reduce the throughput of transactions. This paper deals with this problem of coarse-granularity locking at UDS. It proposes and investigates the logical concurrency control (LCC) concept as a solution. In LCC, a software module sits on top of the UDS and offers a higher-level service. This module employs application-domain-specific fine-granularity locking to achieve high concurrency.

Semantic-Based Concurrency Control in Object-Oriented Databases.

Abstract: In this paper, we present a concurrency control mechanism that deals with three important issues in object-oriented databases (OODBs): semantics of methods, nested method invocation and referentially shared object. In our scheme, locks are required for the execution of methods instead of atomic operations. By doing this, we reduce the locking overhead and deadlocks due to lock escalation. Especially, if a method invokes one or more methods on the same object during its execution, our scheme does not incur additional overhead for those invoked methods. Also, we provide a way of automating commutativity of methods. In addition, we further increase concurrency with the use of runtime information.

Two Version Concurrency Control Algorithm with Query Locking for Decision Support

Abstract: In decision supporting environments, a legacy operational system is needed to provide the additional facilities in order to manage the transaction that has the different characteristic from the traditional transaction. The most transactions that are used for decision support have a long-term read operation accessing a considerable portion of database. Therefore, the traditional concurrency control methods that are optimized to the on-line transaction processing cause the serious problem to the transaction management. The long delay of transaction processing cannot be avoided in those methods because of the lock conflict between the read operation of a decision supporting query and the write operation of an OLTP transaction. In this paper, transactions can be classified into two groups in decision supporting environment. One is the query session that consists of only read operations for decision support. The query session does not mind reading a possibly slightly old, but still consistent, version of the database. The other is the OLTP transaction that can have write operations for on-line transaction processing. According to our classification of transactions, we present a concurrency control algorithm that is called ‘Two Version Query Locking (2VQL)’. The 2VQL algorithm prevents a query session from blocking the operation of other transactions. It can be achieved by delaying the refresh process that exchanges old and new versions of an updated data. By our performance evaluation, the 2VQL algorithm is proved to be better than other legacy algorithms in the decision supporting of operational system.

Concurrency - The Fly in the Ointment?

Abstract: Concurrency is a central pillar of the Java programming language, is implicit in the transactional model of computation adopted by most persistent systems, and has been widely studied in the context of orthogonal persistence. We argue that despite the substantial literature on concurrency control and transaction models for orthogonal persistence, a basic question as to the interaction between concurrency and orthogonal persistence has yet to be adequately addressed. The demands of orthogonality appear to place orthogonal persistence at odds with more general approaches to concurrency control. Given its stated objective of providing a ‘complete’ computational environment, the future of the orthogonal persistence vision in general, and persistent Java in particular, will depend, to some extent, on the release of this tension through the realization of new approaches to the integration of concurrency and persistence. This paper addresses both strict transactional and more ‘open’ approaches to managing concurrency in face of persistence, and examines difficulties with each approach. A simple transaction model that relieves some of these difficulties is presented and its limitations briefly examined.

A real-time concurrency control protocol for main-memory database systems+

Abstract: Protocols developed so far for concurrency control in real-time database systems have assumed a dynamic acquisition of data resources as it is impossible to predict which instances of relations will actually be accessed by each transaction. In this papert, we present a new concurrency control protocol for main-memory real-time database systems, which is baaed on predeclaration of data requirements at a relation granularity. When a transaction is submitted, it is possible to detect with simple syntactical means which relations will be accessed by the transaction. Preacquisition of data resources enables the system to execute transactions in a conflict-free manner. The protocol also offers the possibility of determining execution times without the effects of blocking and I/O, thereby allowing us to give guarantees for the execution of high-priority transactions. Through a series of simulation experiments, the protocol is compared against some typical concurrency control protocols proposed recently for real-time database systems. 01998 Elsevier Science Ltd. All rights reserved

Design issues of an efficient distributed database scheduler for telecom

Abstract: We optimize the speed of real-time databases by optimizing the scheduler. The performance of a database is directly linked to the environment it operates in, and we use environment characteristics as guidelines for the optimization. A typical telecom environment is investigated, and characteristics that are relevant to performance are derived. A theoretical study of database scheduler performance is combined with the characteristics of the telecom environment. Design issues are extracted from this combination. It turns out that the scheduler overhead, rather than the concurrency is the most important factor in database performance. With the derived issues in mind, a light-weight optimistic concurrency control (OCC-light) scheduler has been designed. The OCC-light is implemented in the Mnesia database. Experiments were conducted to compare OCC-light against the existing two phase locking (2PL) scheduler. The OCC-light compared favorably to 2PL, as was already suggested by our theoretical study.

Virtual Time Synchronization in Distributed Database Systems Using a Cluster of Workstations

Abstract: Virtual Time is the fundamental concept in optimistic synchronization schemes. In this paper, we investigate the efficiency of a distributed database management system. synchronized by virtual time using a LAN connected collection of SPARCS. To the best of our knowledge, there is little data reporting VT performance in DDBMS. The experimental results are compared with a multiversion timestamp ordering (MVTO) concurrency control method, a widely used technique in distributed databases, and approximately 25–30% reduction in the response time is observed when using the VT synchronization scheme. Our results demonstrate that the VT synchronization approach is a viable alternative concurrency control method for distributed database systems and outpforms MVTO one.